diff --git a/Bukkit/build.gradle b/Bukkit/build.gradle
index 3d0059159..12fc00882 100644
--- a/Bukkit/build.gradle
+++ b/Bukkit/build.gradle
@@ -15,6 +15,7 @@ repositories {
maven { url = "https://ci.ender.zone/plugin/repository/everything/" }
maven { url = "https://mvn.intellectualsites.com/content/repositories/snapshots" }
maven { url = "https://repo.wea-ondara.net/repository/public/" }
+ maven { url = "http://repo.mvdw-software.be/content/groups/public/" }
}
@@ -41,8 +42,10 @@ dependencies {
implementation("net.alpenblock:BungeePerms:4.0-dev-106")
compile("se.hyperver.hyperverse:Core:0.6.0-SNAPSHOT"){ transitive = false }
compile('com.sk89q:squirrelid:1.0.0-SNAPSHOT'){ transitive = false }
+ compile('be.maximvdw:MVdWPlaceholderAPI:2.1.1-SNAPSHOT'){ transitive = false }
// logging
implementation('org.apache.logging.log4j:log4j-slf4j-impl:2.8.1')
+ compile('be.maximvdw:MVdWPlaceholderAPI:3.1.1-SNAPSHOT'){ transitive = false }
}
sourceCompatibility = 1.8
diff --git a/Bukkit/pom.xml b/Bukkit/pom.xml
index b12a2d969..fd966e49c 100644
--- a/Bukkit/pom.xml
+++ b/Bukkit/pom.xml
@@ -90,6 +90,18 @@
+
+ be.maximvdw
+ MVdWPlaceholderAPI
+ 3.1.1-SNAPSHOT
+ compile
+
+
+ *
+ *
+
+
+
com.sk89q.worldedit
worldedit-core
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/BukkitPlatform.java b/Bukkit/src/main/java/com/plotsquared/bukkit/BukkitPlatform.java
index 1b824c3b4..5f7b38502 100644
--- a/Bukkit/src/main/java/com/plotsquared/bukkit/BukkitPlatform.java
+++ b/Bukkit/src/main/java/com/plotsquared/bukkit/BukkitPlatform.java
@@ -36,15 +36,19 @@ import com.plotsquared.bukkit.inject.BackupModule;
import com.plotsquared.bukkit.inject.BukkitModule;
import com.plotsquared.bukkit.inject.PermissionModule;
import com.plotsquared.bukkit.inject.WorldManagerModule;
+import com.plotsquared.bukkit.listener.BlockEventListener;
import com.plotsquared.bukkit.listener.ChunkListener;
+import com.plotsquared.bukkit.listener.EntityEventListener;
import com.plotsquared.bukkit.listener.EntitySpawnListener;
import com.plotsquared.bukkit.listener.PaperListener;
-import com.plotsquared.bukkit.listener.PlayerEvents;
+import com.plotsquared.bukkit.listener.PlayerEventListener;
+import com.plotsquared.bukkit.listener.ProjectileEventListener;
+import com.plotsquared.bukkit.listener.ServerListener;
import com.plotsquared.bukkit.listener.SingleWorldListener;
import com.plotsquared.bukkit.listener.WorldEvents;
import com.plotsquared.bukkit.placeholder.PlaceholderFormatter;
-import com.plotsquared.bukkit.placeholder.Placeholders;
import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.bukkit.placeholder.PAPIPlaceholders;
import com.plotsquared.bukkit.player.BukkitPlayerManager;
import com.plotsquared.bukkit.util.BukkitChatManager;
import com.plotsquared.bukkit.util.BukkitUtil;
@@ -309,7 +313,11 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
}
if (Settings.Enabled_Components.EVENTS) {
- getServer().getPluginManager().registerEvents(getInjector().getInstance(PlayerEvents.class), this);
+ getServer().getPluginManager().registerEvents(getInjector().getInstance(PlayerEventListener.class), this);
+ getServer().getPluginManager().registerEvents(getInjector().getInstance(BlockEventListener.class), this);
+ getServer().getPluginManager().registerEvents(getInjector().getInstance(EntityEventListener.class), this);
+ getServer().getPluginManager().registerEvents(getInjector().getInstance(ProjectileEventListener.class), this);
+ getServer().getPluginManager().registerEvents(getInjector().getInstance(ServerListener.class), this);
getServer().getPluginManager().registerEvents(getInjector().getInstance(EntitySpawnListener.class), this);
if (PaperLib.isPaper() && Settings.Paper_Components.PAPER_LISTENERS) {
getServer().getPluginManager().registerEvents(getInjector().getInstance(PaperListener.class), this);
@@ -488,7 +496,7 @@ public final class BukkitPlatform extends JavaPlugin implements Listener, PlotPl
}
if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
- injector.getInstance(Placeholders.class).register();
+ injector.getInstance(PAPIPlaceholders.class).register();
if (Settings.Enabled_Components.EXTERNAL_PLACEHOLDERS) {
ChatFormatter.formatters.add(getInjector().getInstance(PlaceholderFormatter.class));
}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/BlockEventListener.java b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/BlockEventListener.java
new file mode 100644
index 000000000..82a01d765
--- /dev/null
+++ b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/BlockEventListener.java
@@ -0,0 +1,1018 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.database.DBFunc;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.flag.implementations.BlockBurnFlag;
+import com.plotsquared.core.plot.flag.implementations.BlockIgnitionFlag;
+import com.plotsquared.core.plot.flag.implementations.BreakFlag;
+import com.plotsquared.core.plot.flag.implementations.CoralDryFlag;
+import com.plotsquared.core.plot.flag.implementations.DisablePhysicsFlag;
+import com.plotsquared.core.plot.flag.implementations.DoneFlag;
+import com.plotsquared.core.plot.flag.implementations.ExplosionFlag;
+import com.plotsquared.core.plot.flag.implementations.GrassGrowFlag;
+import com.plotsquared.core.plot.flag.implementations.IceFormFlag;
+import com.plotsquared.core.plot.flag.implementations.IceMeltFlag;
+import com.plotsquared.core.plot.flag.implementations.InstabreakFlag;
+import com.plotsquared.core.plot.flag.implementations.KelpGrowFlag;
+import com.plotsquared.core.plot.flag.implementations.LiquidFlowFlag;
+import com.plotsquared.core.plot.flag.implementations.MycelGrowFlag;
+import com.plotsquared.core.plot.flag.implementations.PlaceFlag;
+import com.plotsquared.core.plot.flag.implementations.RedstoneFlag;
+import com.plotsquared.core.plot.flag.implementations.SnowFormFlag;
+import com.plotsquared.core.plot.flag.implementations.SnowMeltFlag;
+import com.plotsquared.core.plot.flag.implementations.SoilDryFlag;
+import com.plotsquared.core.plot.flag.implementations.VineGrowFlag;
+import com.plotsquared.core.plot.flag.types.BlockTypeWrapper;
+import com.plotsquared.core.plot.world.PlotAreaManager;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.Permissions;
+import com.plotsquared.core.util.task.TaskManager;
+import com.plotsquared.core.util.task.TaskTime;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.world.block.BlockType;
+import org.bukkit.Bukkit;
+import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.block.data.BlockData;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.Fireball;
+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;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockBurnEvent;
+import org.bukkit.event.block.BlockDamageEvent;
+import org.bukkit.event.block.BlockDispenseEvent;
+import org.bukkit.event.block.BlockExplodeEvent;
+import org.bukkit.event.block.BlockFadeEvent;
+import org.bukkit.event.block.BlockFormEvent;
+import org.bukkit.event.block.BlockFromToEvent;
+import org.bukkit.event.block.BlockGrowEvent;
+import org.bukkit.event.block.BlockIgniteEvent;
+import org.bukkit.event.block.BlockPhysicsEvent;
+import org.bukkit.event.block.BlockPistonExtendEvent;
+import org.bukkit.event.block.BlockPistonRetractEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.block.BlockRedstoneEvent;
+import org.bukkit.event.block.BlockSpreadEvent;
+import org.bukkit.event.block.EntityBlockFormEvent;
+import org.bukkit.event.world.StructureGrowEvent;
+import org.bukkit.material.Directional;
+import org.bukkit.projectiles.BlockProjectileSource;
+import org.bukkit.util.Vector;
+
+import javax.annotation.Nonnull;
+import javax.inject.Inject;
+import java.util.Iterator;
+import java.util.List;
+import java.util.Objects;
+import java.util.UUID;
+
+@SuppressWarnings("unused")
+public class BlockEventListener implements Listener {
+
+ private final PlotAreaManager plotAreaManager;
+ private final WorldEdit worldEdit;
+
+ @Inject public BlockEventListener(@Nonnull final PlotAreaManager plotAreaManager, @Nonnull final WorldEdit worldEdit) {
+ this.plotAreaManager = plotAreaManager;
+ this.worldEdit = worldEdit;
+ }
+
+ public static void sendBlockChange(final org.bukkit.Location bloc, final BlockData data) {
+ TaskManager.runTaskLater(() -> {
+ String world = bloc.getWorld().getName();
+ int x = bloc.getBlockX();
+ int z = bloc.getBlockZ();
+ int distance = Bukkit.getViewDistance() * 16;
+
+ for (final PlotPlayer player : PlotSquared.platform().getPlayerManager().getPlayers()) {
+ Location location = player.getLocation();
+ if (location.getWorldName().equals(world)) {
+ if (16 * Math.abs(location.getX() - x) / 16 > distance || 16 * Math.abs(location.getZ() - z) / 16 > distance) {
+ continue;
+ }
+ ((BukkitPlayer) player).player.sendBlockChange(bloc, data);
+ }
+ }
+ }, TaskTime.ticks(3L));
+ }
+
+ @EventHandler public void onRedstoneEvent(BlockRedstoneEvent event) {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = location.getOwnedPlot();
+ if (plot == null) {
+ if (area.isRoadFlags() && !area.getRoadFlag(RedstoneFlag.class)) {
+ event.setNewCurrent(0);
+ }
+ return;
+ }
+ if (!plot.getFlag(RedstoneFlag.class)) {
+ event.setNewCurrent(0);
+ plot.debug("Redstone event was cancelled because redstone = false");
+ return;
+ }
+ if (Settings.Redstone.DISABLE_OFFLINE) {
+ boolean disable = false;
+ if (!plot.getOwner().equals(DBFunc.SERVER)) {
+ if (plot.isMerged()) {
+ disable = true;
+ for (UUID owner : plot.getOwners()) {
+ if (PlotSquared.platform().getPlayerManager().getPlayerIfExists(owner) != null) {
+ disable = false;
+ break;
+ }
+ }
+ } else {
+ disable = PlotSquared.platform().getPlayerManager().getPlayerIfExists(plot.getOwnerAbs()) == null;
+ }
+ }
+ if (disable) {
+ for (UUID trusted : plot.getTrusted()) {
+ if (PlotSquared.platform().getPlayerManager().getPlayerIfExists(trusted) != null) {
+ disable = false;
+ break;
+ }
+ }
+ if (disable) {
+ event.setNewCurrent(0);
+ plot.debug("Redstone event was cancelled because no trusted player was in the plot");
+ return;
+ }
+ }
+ }
+ if (Settings.Redstone.DISABLE_UNOCCUPIED) {
+ for (final PlotPlayer player : PlotSquared.platform().getPlayerManager().getPlayers()) {
+ if (plot.equals(player.getCurrentPlot())) {
+ return;
+ }
+ }
+ event.setNewCurrent(0);
+ }
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST) public void onPhysicsEvent(BlockPhysicsEvent event) {
+ switch (event.getChangedType()) {
+ case COMPARATOR: {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ if (location.isPlotArea()) {
+ return;
+ }
+ Plot plot = location.getOwnedPlotAbs();
+ if (plot == null) {
+ return;
+ }
+ if (!plot.getFlag(RedstoneFlag.class)) {
+ event.setCancelled(true);
+ plot.debug("Prevented comparator update because redstone = false");
+ }
+ return;
+ }
+ case ANVIL:
+ case DRAGON_EGG:
+ case GRAVEL:
+ case SAND:
+ case TURTLE_EGG:
+ case TURTLE_HELMET:
+ case TURTLE_SPAWN_EGG: {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getOwnedPlotAbs(location);
+ if (plot == null) {
+ return;
+ }
+ if (plot.getFlag(DisablePhysicsFlag.class)) {
+ event.setCancelled(true);
+ plot.debug("Prevented block physics because disable-physics = true");
+ }
+ return;
+ }
+ default:
+ if (Settings.Redstone.DETECT_INVALID_EDGE_PISTONS) {
+ Block block = event.getBlock();
+ switch (block.getType()) {
+ case PISTON:
+ case STICKY_PISTON:
+ org.bukkit.block.data.Directional piston = (org.bukkit.block.data.Directional) block.getBlockData();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getOwnedPlotAbs(location);
+ if (plot == null) {
+ return;
+ }
+ switch (piston.getFacing()) {
+ case EAST:
+ location = location.add(1, 0, 0);
+ break;
+ case SOUTH:
+ location = location.add(-1, 0, 0);
+ break;
+ case WEST:
+ location = location.add(0, 0, 1);
+ break;
+ case NORTH:
+ location = location.add(0, 0, -1);
+ break;
+ }
+ Plot newPlot = area.getOwnedPlotAbs(location);
+ if (!plot.equals(newPlot)) {
+ event.setCancelled(true);
+ plot.debug("Prevented piston update because of invalid edge piston detection");
+ return;
+ }
+ }
+ }
+ break;
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void blockCreate(BlockPlaceEvent event) {
+ Location location = BukkitUtil.adapt(event.getBlock().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Player player = event.getPlayer();
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ Plot plot = area.getPlot(location);
+ if (plot != null) {
+ if ((location.getY() > area.getMaxBuildHeight() || location.getY() < area.getMinBuildHeight()) && !Permissions
+ .hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {
+ event.setCancelled(true);
+ MainUtil.sendMessage(pp, Captions.HEIGHT_LIMIT.getTranslated().replace("{limit}", String.valueOf(area.getMaxBuildHeight())));
+ }
+ if (!plot.hasOwner()) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_UNOWNED)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_UNOWNED);
+ event.setCancelled(true);
+ return;
+ }
+ } else if (!plot.isAdded(pp.getUUID())) {
+ List place = plot.getFlag(PlaceFlag.class);
+ if (place != null) {
+ Block block = event.getBlock();
+ if (place.contains(BlockTypeWrapper.get(BukkitAdapter.asBlockType(block.getType())))) {
+ return;
+ }
+ }
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ event.setCancelled(true);
+ plot.debug(player.getName() + " could not place " + event.getBlock().getType() + " because of the place flag");
+ return;
+ }
+ } else if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ event.setCancelled(true);
+ return;
+ }
+ }
+ if (plot.getFlag(DisablePhysicsFlag.class)) {
+ Block block = event.getBlockPlaced();
+ if (block.getType().hasGravity()) {
+ sendBlockChange(block.getLocation(), block.getBlockData());
+ plot.debug(event.getBlock().getType() + " did not fall because of disable-physics = true");
+ }
+ }
+ } else if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_ROAD)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_ROAD);
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.LOWEST) public void blockDestroy(BlockBreakEvent event) {
+ Player player = event.getPlayer();
+ Location location = BukkitUtil.adapt(event.getBlock().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getPlot(location);
+ if (plot != null) {
+ BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
+ if (event.getBlock().getY() == 0) {
+ if (!Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_GROUNDLEVEL)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_DESTROY_GROUNDLEVEL);
+ event.setCancelled(true);
+ return;
+ }
+ } else if ((location.getY() > area.getMaxBuildHeight() || location.getY() < area.getMinBuildHeight()) && !Permissions
+ .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {
+ event.setCancelled(true);
+ MainUtil.sendMessage(plotPlayer, Captions.HEIGHT_LIMIT.getTranslated().replace("{limit}", String.valueOf(area.getMaxBuildHeight())));
+ }
+ if (!plot.hasOwner()) {
+ if (!Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_UNOWNED, true)) {
+ event.setCancelled(true);
+ }
+ return;
+ }
+ if (!plot.isAdded(plotPlayer.getUUID())) {
+ List destroy = plot.getFlag(BreakFlag.class);
+ Block block = event.getBlock();
+ final BlockType blockType = BukkitAdapter.asBlockType(block.getType());
+ for (final BlockTypeWrapper blockTypeWrapper : destroy) {
+ if (blockTypeWrapper.accepts(blockType)) {
+ return;
+ }
+ }
+ if (Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_OTHER)) {
+ return;
+ }
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_DESTROY_OTHER);
+ event.setCancelled(true);
+ } else if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
+ if (!Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ event.setCancelled(true);
+ return;
+ }
+ }
+ return;
+ }
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ if (Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_DESTROY_ROAD)) {
+ return;
+ }
+ if (this.worldEdit != null && pp.getAttribute("worldedit")) {
+ if (player.getInventory().getItemInMainHand().getType() == Material.getMaterial(this.worldEdit.getConfiguration().wandItem)) {
+ return;
+ }
+ }
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_DESTROY_ROAD);
+ event.setCancelled(true);
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBlockSpread(BlockSpreadEvent event) {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ if (location.isPlotRoad()) {
+ event.setCancelled(true);
+ return;
+ }
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getOwnedPlot(location);
+ if (plot == null) {
+ return;
+ }
+ switch (event.getSource().getType()) {
+ case GRASS_BLOCK:
+ if (!plot.getFlag(GrassGrowFlag.class)) {
+ plot.debug("Grass could not grow because grass-grow = false");
+ event.setCancelled(true);
+ }
+ break;
+ case MYCELIUM:
+ if (!plot.getFlag(MycelGrowFlag.class)) {
+ plot.debug("Mycelium could not grow because mycel-grow = false");
+ event.setCancelled(true);
+ }
+ break;
+ case VINE:
+ if (!plot.getFlag(VineGrowFlag.class)) {
+ plot.debug("Vine could not grow because vine-grow = false");
+ event.setCancelled(true);
+ }
+ break;
+ case KELP:
+ if (!plot.getFlag(KelpGrowFlag.class)) {
+ plot.debug("Kelp could not grow because kelp-grow = false");
+ event.setCancelled(true);
+ }
+ break;
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBlockForm(BlockFormEvent event) {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ if (location.isPlotRoad()) {
+ event.setCancelled(true);
+ return;
+ }
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getOwnedPlot(location);
+ if (plot == null) {
+ return;
+ }
+ switch (event.getNewState().getType()) {
+ case SNOW:
+ case SNOW_BLOCK:
+ if (!plot.getFlag(SnowFormFlag.class)) {
+ plot.debug("Snow could not form because snow-form = false");
+ event.setCancelled(true);
+ }
+ return;
+ case ICE:
+ case FROSTED_ICE:
+ case PACKED_ICE:
+ if (!plot.getFlag(IceFormFlag.class)) {
+ plot.debug("Ice could not form because ice-form = false");
+ event.setCancelled(true);
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onEntityBlockForm(EntityBlockFormEvent event) {
+ String world = event.getBlock().getWorld().getName();
+ if (!this.plotAreaManager.hasPlotArea(world)) {
+ return;
+ }
+ Location location = BukkitUtil.adapt(event.getBlock().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getOwnedPlot(location);
+ if (plot == null) {
+ event.setCancelled(true);
+ return;
+ }
+ Entity entity = event.getEntity();
+ if (entity instanceof Player) {
+ Player player = (Player) entity;
+ if (!plot.hasOwner()) {
+ BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
+ if (plot.getFlag(IceFormFlag.class)) {
+ plot.debug("Ice could not be formed because ice-form = false");
+ return;
+ }
+ event.setCancelled(true);
+ return;
+ }
+ BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
+ if (!plot.isAdded(plotPlayer.getUUID())) {
+ if (plot.getFlag(IceFormFlag.class)) {
+ plot.debug("Ice could not be formed because ice-form = false");
+ return;
+ }
+ event.setCancelled(true);
+ return;
+ }
+ return;
+ }
+ if (!plot.getFlag(IceFormFlag.class)) {
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBlockDamage(BlockDamageEvent event) {
+ Player player = event.getPlayer();
+ Location location = BukkitUtil.adapt(event.getBlock().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ if (player.getGameMode() != GameMode.SURVIVAL) {
+ return;
+ }
+ Plot plot = area.getPlot(location);
+ if (plot != null) {
+ if (plot.getFlag(InstabreakFlag.class)) {
+ Block block = event.getBlock();
+ BlockBreakEvent call = new BlockBreakEvent(block, player);
+ Bukkit.getServer().getPluginManager().callEvent(call);
+ if (!call.isCancelled()) {
+ event.getBlock().breakNaturally();
+ }
+ }
+ if (location.getY() == 0) {
+ event.setCancelled(true);
+ return;
+ }
+ if (!plot.hasOwner()) {
+ BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
+ if (Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_UNOWNED)) {
+ return;
+ }
+ event.setCancelled(true);
+ return;
+ }
+ BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
+ if (!plot.isAdded(plotPlayer.getUUID())) {
+ List destroy = plot.getFlag(BreakFlag.class);
+ Block block = event.getBlock();
+ if (destroy.contains(BlockTypeWrapper.get(BukkitAdapter.asBlockType(block.getType()))) || Permissions
+ .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_OTHER)) {
+ return;
+ }
+ plot.debug(player.getName() + " could not break " + block.getType() + " because it was not in the break flag");
+ event.setCancelled(true);
+ return;
+ }
+ return;
+ }
+ BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
+ if (Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_ROAD)) {
+ return;
+ }
+ event.setCancelled(true);
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onFade(BlockFadeEvent event) {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getOwnedPlot(location);
+ if (plot == null) {
+ event.setCancelled(true);
+ return;
+ }
+ switch (block.getType()) {
+ case ICE:
+ if (!plot.getFlag(IceMeltFlag.class)) {
+ plot.debug("Ice could not melt because ice-melt = false");
+ event.setCancelled(true);
+ }
+ break;
+ case SNOW:
+ if (!plot.getFlag(SnowMeltFlag.class)) {
+ plot.debug("Snow could not melt because snow-melt = false");
+ event.setCancelled(true);
+ }
+ break;
+ case FARMLAND:
+ if (!plot.getFlag(SoilDryFlag.class)) {
+ plot.debug("Soil could not dry because soil-dry = false");
+ event.setCancelled(true);
+ }
+ break;
+ case TUBE_CORAL_BLOCK:
+ case BRAIN_CORAL_BLOCK:
+ case BUBBLE_CORAL_BLOCK:
+ case FIRE_CORAL_BLOCK:
+ case HORN_CORAL_BLOCK:
+ case TUBE_CORAL:
+ case BRAIN_CORAL:
+ case BUBBLE_CORAL:
+ case FIRE_CORAL:
+ case HORN_CORAL:
+ case TUBE_CORAL_FAN:
+ case BRAIN_CORAL_FAN:
+ case BUBBLE_CORAL_FAN:
+ case FIRE_CORAL_FAN:
+ case HORN_CORAL_FAN:
+ case BRAIN_CORAL_WALL_FAN:
+ case BUBBLE_CORAL_WALL_FAN:
+ case FIRE_CORAL_WALL_FAN:
+ case HORN_CORAL_WALL_FAN:
+ case TUBE_CORAL_WALL_FAN:
+ if (!plot.getFlag(CoralDryFlag.class)) {
+ plot.debug("Coral could not dry because coral-dry = false");
+ event.setCancelled(true);
+ }
+ break;
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onChange(BlockFromToEvent event) {
+ Block from = event.getBlock();
+
+ // Check liquid flow flag inside of origin plot too
+ final Location fLocation = BukkitUtil.adapt(from.getLocation());
+ final PlotArea fromArea = fLocation.getPlotArea();
+ if (fromArea != null) {
+ final Plot plot = fromArea.getOwnedPlot(fLocation);
+ if (plot != null && plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event.getBlock().isLiquid()) {
+ plot.debug("Liquid could now flow because liquid-flow = disabled");
+ event.setCancelled(true);
+ return;
+ }
+ }
+
+ Block to = event.getToBlock();
+ Location tLocation = BukkitUtil.adapt(to.getLocation());
+ PlotArea area = tLocation.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getOwnedPlot(tLocation);
+ if (plot != null) {
+ if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects.equals(plot, area.getOwnedPlot(fLocation))) {
+ event.setCancelled(true);
+ return;
+ }
+ if (plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.ENABLED && event.getBlock().isLiquid()) {
+ return;
+ }
+ if (plot.getFlag(DisablePhysicsFlag.class)) {
+ plot.debug(event.getBlock().getType() + " could not update because disable-physics = true");
+ event.setCancelled(true);
+ return;
+ }
+ if (plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event.getBlock().isLiquid()) {
+ plot.debug("Liquid could not flow because liquid-flow = disabled");
+ event.setCancelled(true);
+ }
+ } else if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects.equals(null, area.getOwnedPlot(fLocation))) {
+ event.setCancelled(true);
+ } else if (event.getBlock().isLiquid()) {
+ final org.bukkit.Location location = event.getBlock().getLocation();
+
+ /*
+ X = block location
+ A-H = potential plot locations
+ Z
+ ^
+ | A B C
+ o D X E
+ | F G H
+ v
+ <-----O-----> x
+ */
+ if (BukkitUtil.adapt(location.clone().add(-1, 0, 1) /* A */).getPlot() != null
+ || BukkitUtil.adapt(location.clone().add(1, 0, 0) /* B */).getPlot() != null
+ || BukkitUtil.adapt(location.clone().add(1, 0, 1) /* C */).getPlot() != null
+ || BukkitUtil.adapt(location.clone().add(-1, 0, 0) /* D */).getPlot() != null
+ || BukkitUtil.adapt(location.clone().add(1, 0, 0) /* E */).getPlot() != null
+ || BukkitUtil.adapt(location.clone().add(-1, 0, -1) /* F */).getPlot() != null
+ || BukkitUtil.adapt(location.clone().add(0, 0, -1) /* G */).getPlot() != null
+ || BukkitUtil.adapt(location.clone().add(1, 0, 1) /* H */).getPlot() != null) {
+ event.setCancelled(true);
+ }
+ }
+ }
+
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onGrow(BlockGrowEvent event) {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ if (location.isUnownedPlotArea()) {
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBlockPistonExtend(BlockPistonExtendEvent event) {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ BlockFace face = event.getDirection();
+ Vector relative = new Vector(face.getModX(), face.getModY(), face.getModZ());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
+ return;
+ }
+ for (Block block1 : event.getBlocks()) {
+ Location bloc = BukkitUtil.adapt(block1.getLocation());
+ if (bloc.isPlotArea() || bloc.add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ()).isPlotArea()) {
+ event.setCancelled(true);
+ return;
+ }
+ }
+ if (location.add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ()).isPlotArea()) {
+ // Prevent pistons from extending if they are: bordering a plot
+ // area, facing inside plot area, and not pushing any blocks
+ event.setCancelled(true);
+ }
+ return;
+ }
+ Plot plot = area.getOwnedPlot(location);
+ if (plot == null) {
+ event.setCancelled(true);
+ return;
+ }
+ for (Block block1 : event.getBlocks()) {
+ Location bloc = BukkitUtil.adapt(block1.getLocation());
+ if (!area.contains(bloc.getX(), bloc.getZ()) || !area.contains(bloc.getX() + relative.getBlockX(), bloc.getZ() + relative.getBlockZ())) {
+ event.setCancelled(true);
+ return;
+ }
+ if (!plot.equals(area.getOwnedPlot(bloc)) || !plot
+ .equals(area.getOwnedPlot(bloc.add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ())))) {
+ event.setCancelled(true);
+ return;
+ }
+ }
+ if (!plot.equals(area.getOwnedPlot(location.add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ())))) {
+ // This branch is only necessary to prevent pistons from extending
+ // if they are: on a plot edge, facing outside the plot, and not
+ // pushing any blocks
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBlockPistonRetract(BlockPistonRetractEvent event) {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ BlockFace face = event.getDirection();
+ Vector relative = new Vector(face.getModX(), face.getModY(), face.getModZ());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
+ return;
+ }
+ for (Block block1 : event.getBlocks()) {
+ Location bloc = BukkitUtil.adapt(block1.getLocation());
+ if (bloc.isPlotArea() || bloc.add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ()).isPlotArea()) {
+ event.setCancelled(true);
+ return;
+ }
+ }
+ return;
+ }
+ Plot plot = area.getOwnedPlot(location);
+ if (plot == null) {
+ event.setCancelled(true);
+ return;
+ }
+ for (Block block1 : event.getBlocks()) {
+ Location bloc = BukkitUtil.adapt(block1.getLocation());
+ if (!area.contains(bloc.getX(), bloc.getZ()) || !area.contains(bloc.getX() + relative.getBlockX(), bloc.getZ() + relative.getBlockZ())) {
+ event.setCancelled(true);
+ return;
+ }
+ if (!plot.equals(area.getOwnedPlot(bloc)) || !plot
+ .equals(area.getOwnedPlot(bloc.add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ())))) {
+ event.setCancelled(true);
+ return;
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBlockDispense(BlockDispenseEvent event) {
+ Material type = event.getItem().getType();
+ switch (type) {
+ case SHULKER_BOX:
+ case WHITE_SHULKER_BOX:
+ case ORANGE_SHULKER_BOX:
+ case MAGENTA_SHULKER_BOX:
+ case LIGHT_BLUE_SHULKER_BOX:
+ case YELLOW_SHULKER_BOX:
+ case LIME_SHULKER_BOX:
+ case PINK_SHULKER_BOX:
+ case GRAY_SHULKER_BOX:
+ case LIGHT_GRAY_SHULKER_BOX:
+ case CYAN_SHULKER_BOX:
+ case PURPLE_SHULKER_BOX:
+ case BLUE_SHULKER_BOX:
+ case BROWN_SHULKER_BOX:
+ case GREEN_SHULKER_BOX:
+ case RED_SHULKER_BOX:
+ case BLACK_SHULKER_BOX:
+ case CARVED_PUMPKIN:
+ case WITHER_SKELETON_SKULL:
+ case FLINT_AND_STEEL:
+ case BONE_MEAL:
+ case SHEARS:
+ case GLASS_BOTTLE:
+ case GLOWSTONE:
+ case COD_BUCKET:
+ case PUFFERFISH_BUCKET:
+ case SALMON_BUCKET:
+ case TROPICAL_FISH_BUCKET:
+ case BUCKET:
+ case WATER_BUCKET:
+ case LAVA_BUCKET: {
+ if (event.getBlock().getType() == Material.DROPPER) {
+ return;
+ }
+ BlockFace targetFace = ((Directional) event.getBlock().getState().getData()).getFacing();
+ Location location = BukkitUtil.adapt(event.getBlock().getRelative(targetFace).getLocation());
+ if (location.isPlotRoad()) {
+ event.setCancelled(true);
+ }
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onStructureGrow(StructureGrowEvent event) {
+ if (!this.plotAreaManager.hasPlotArea(event.getWorld().getName())) {
+ return;
+ }
+ List blocks = event.getBlocks();
+ if (blocks.isEmpty()) {
+ return;
+ }
+ Location location = BukkitUtil.adapt(blocks.get(0).getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ for (int i = blocks.size() - 1; i >= 0; i--) {
+ location = BukkitUtil.adapt(blocks.get(i).getLocation());
+ if (location.isPlotArea()) {
+ blocks.remove(i);
+ }
+ }
+ return;
+ } else {
+ Plot origin = area.getOwnedPlot(location);
+ if (origin == null) {
+ event.setCancelled(true);
+ return;
+ }
+ for (int i = blocks.size() - 1; i >= 0; i--) {
+ location = BukkitUtil.adapt(blocks.get(i).getLocation());
+ if (!area.contains(location.getX(), location.getZ())) {
+ blocks.remove(i);
+ continue;
+ }
+ Plot plot = area.getOwnedPlot(location);
+ if (!Objects.equals(plot, origin)) {
+ event.getBlocks().remove(i);
+ }
+ }
+ }
+ Plot origin = area.getPlot(location);
+ if (origin == null) {
+ event.setCancelled(true);
+ return;
+ }
+ for (int i = blocks.size() - 1; i >= 0; i--) {
+ location = BukkitUtil.adapt(blocks.get(i).getLocation());
+ Plot plot = area.getOwnedPlot(location);
+ /*
+ * plot → the base plot of the merged area
+ * origin → the plot where the event gets called
+ */
+
+ // Are plot and origin different AND are both plots merged
+ if (!Objects.equals(plot, origin) && (!plot.isMerged() && !origin.isMerged())) {
+ event.getBlocks().remove(i);
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBigBoom(BlockExplodeEvent event) {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ String world = location.getWorldName();
+ if (!this.plotAreaManager.hasPlotArea(world)) {
+ return;
+ }
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ Iterator iterator = event.blockList().iterator();
+ while (iterator.hasNext()) {
+ location = BukkitUtil.adapt(iterator.next().getLocation());
+ if (location.isPlotArea()) {
+ iterator.remove();
+ }
+ }
+ return;
+ }
+ Plot plot = area.getOwnedPlot(location);
+ if (plot == null || !plot.getFlag(ExplosionFlag.class)) {
+ event.setCancelled(true);
+ if (plot != null) {
+ plot.debug("Explosion was cancelled because explosion = false");
+ }
+ }
+ event.blockList().removeIf(blox -> !plot.equals(area.getOwnedPlot(BukkitUtil.adapt(blox.getLocation()))));
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBlockBurn(BlockBurnEvent event) {
+ Block block = event.getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+
+ Plot plot = location.getOwnedPlot();
+ if (plot == null || !plot.getFlag(BlockBurnFlag.class)) {
+ if (plot != null) {
+ plot.debug("Block burning was cancelled because block-burn = false");
+ }
+ event.setCancelled(true);
+ }
+
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBlockIgnite(BlockIgniteEvent event) {
+ Player player = event.getPlayer();
+ Entity ignitingEntity = event.getIgnitingEntity();
+ Block block = event.getBlock();
+ BlockIgniteEvent.IgniteCause igniteCause = event.getCause();
+ Location location1 = BukkitUtil.adapt(block.getLocation());
+ PlotArea area = location1.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ if (igniteCause == BlockIgniteEvent.IgniteCause.LIGHTNING) {
+ event.setCancelled(true);
+ return;
+ }
+
+ Plot plot = area.getOwnedPlot(location1);
+ if (player != null) {
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ if (plot == null) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_ROAD)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_ROAD);
+ event.setCancelled(true);
+ }
+ } else if (!plot.hasOwner()) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_UNOWNED)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_UNOWNED);
+ event.setCancelled(true);
+ }
+ } else if (!plot.isAdded(pp.getUUID())) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ event.setCancelled(true);
+ }
+ } else if (!plot.getFlag(BlockIgnitionFlag.class)) {
+ event.setCancelled(true);
+ }
+ } else {
+ if (plot == null) {
+ event.setCancelled(true);
+ return;
+ }
+ if (ignitingEntity != null) {
+ if (!plot.getFlag(BlockIgnitionFlag.class)) {
+ event.setCancelled(true);
+ plot.debug("Block ignition was cancelled because block-ignition = false");
+ return;
+ }
+ if (igniteCause == BlockIgniteEvent.IgniteCause.FIREBALL) {
+ if (ignitingEntity instanceof Fireball) {
+ Projectile fireball = (Projectile) ignitingEntity;
+ Location location = null;
+ if (fireball.getShooter() instanceof Entity) {
+ Entity shooter = (Entity) fireball.getShooter();
+ location = BukkitUtil.adapt(shooter.getLocation());
+ } else if (fireball.getShooter() instanceof BlockProjectileSource) {
+ Block shooter = ((BlockProjectileSource) fireball.getShooter()).getBlock();
+ location = BukkitUtil.adapt(shooter.getLocation());
+ }
+ if (location != null && !plot.equals(location.getPlot())) {
+ event.setCancelled(true);
+ }
+ }
+ }
+
+ } else if (event.getIgnitingBlock() != null) {
+ Block ignitingBlock = event.getIgnitingBlock();
+ Plot plotIgnited = BukkitUtil.adapt(ignitingBlock.getLocation()).getPlot();
+ if (igniteCause == BlockIgniteEvent.IgniteCause.FLINT_AND_STEEL && (!plot.getFlag(BlockIgnitionFlag.class) || plotIgnited == null
+ || !plotIgnited.equals(plot))
+ || (igniteCause == BlockIgniteEvent.IgniteCause.SPREAD || igniteCause == BlockIgniteEvent.IgniteCause.LAVA) && (
+ !plot.getFlag(BlockIgnitionFlag.class) || plotIgnited == null || !plotIgnited.equals(plot))) {
+ event.setCancelled(true);
+ }
+ }
+ }
+ }
+}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntityEventListener.java b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntityEventListener.java
new file mode 100644
index 000000000..2d4162881
--- /dev/null
+++ b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntityEventListener.java
@@ -0,0 +1,330 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.bukkit.util.BukkitEntityUtil;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.flag.implementations.DisablePhysicsFlag;
+import com.plotsquared.core.plot.flag.implementations.ExplosionFlag;
+import com.plotsquared.core.plot.flag.implementations.InvincibleFlag;
+import com.plotsquared.core.plot.flag.implementations.MobPlaceFlag;
+import com.plotsquared.core.plot.world.PlotAreaManager;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.Ageable;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.FallingBlock;
+import org.bukkit.entity.TNTPrimed;
+import org.bukkit.entity.Vehicle;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.CreatureSpawnEvent;
+import org.bukkit.event.entity.EntityChangeBlockEvent;
+import org.bukkit.event.entity.EntityCombustByEntityEvent;
+import org.bukkit.event.entity.EntityDamageByEntityEvent;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.event.entity.EntityExplodeEvent;
+import org.bukkit.event.entity.ExplosionPrimeEvent;
+import org.bukkit.event.vehicle.VehicleCreateEvent;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+
+import javax.annotation.Nonnull;
+import javax.inject.Inject;
+import java.util.Iterator;
+import java.util.List;
+
+@SuppressWarnings("unused")
+public class EntityEventListener implements Listener {
+
+ private final PlotAreaManager plotAreaManager;
+ private float lastRadius;
+
+ @Inject public EntityEventListener(@Nonnull final PlotAreaManager plotAreaManager) {
+ this.plotAreaManager = plotAreaManager;
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST) public void onEntityCombustByEntity(EntityCombustByEntityEvent event) {
+ EntityDamageByEntityEvent eventChange =
+ new EntityDamageByEntityEvent(event.getCombuster(), event.getEntity(), EntityDamageEvent.DamageCause.FIRE_TICK, event.getDuration());
+ onEntityDamageByEntityEvent(eventChange);
+ if (eventChange.isCancelled()) {
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST) public void onEntityDamageByEntityEvent(EntityDamageByEntityEvent event) {
+ Entity damager = event.getDamager();
+ Location location = BukkitUtil.adapt(damager.getLocation());
+ if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
+ return;
+ }
+ Entity victim = event.getEntity();
+/*
+ if (victim.getType().equals(EntityType.ITEM_FRAME)) {
+ Plot plot = BukkitUtil.getLocation(victim).getPlot();
+ if (plot != null && !plot.isAdded(damager.getUniqueId())) {
+ event.setCancelled(true);
+ return;
+ }
+ }
+*/
+ if (!BukkitEntityUtil.entityDamage(damager, victim, event.getCause())) {
+ if (event.isCancelled()) {
+ if (victim instanceof Ageable) {
+ Ageable ageable = (Ageable) victim;
+ if (ageable.getAge() == -24000) {
+ ageable.setAge(0);
+ ageable.setAdult();
+ }
+ }
+ }
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void creatureSpawnEvent(CreatureSpawnEvent event) {
+ Entity entity = event.getEntity();
+ Location location = BukkitUtil.adapt(entity.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ CreatureSpawnEvent.SpawnReason reason = event.getSpawnReason();
+ switch (reason.toString()) {
+ case "DISPENSE_EGG":
+ case "EGG":
+ case "OCELOT_BABY":
+ case "SPAWNER_EGG":
+ if (!area.isSpawnEggs()) {
+ event.setCancelled(true);
+ return;
+ }
+ break;
+ case "REINFORCEMENTS":
+ case "NATURAL":
+ case "MOUNT":
+ case "PATROL":
+ case "RAID":
+ case "SHEARED":
+ case "SHOULDER_ENTITY":
+ case "SILVERFISH_BLOCK":
+ case "TRAP":
+ case "VILLAGE_DEFENSE":
+ case "VILLAGE_INVASION":
+ case "BEEHIVE":
+ case "CHUNK_GEN":
+ if (!area.isMobSpawning()) {
+ event.setCancelled(true);
+ return;
+ }
+ case "BREEDING":
+ if (!area.isSpawnBreeding()) {
+ event.setCancelled(true);
+ return;
+ }
+ break;
+ case "BUILD_IRONGOLEM":
+ case "BUILD_SNOWMAN":
+ case "BUILD_WITHER":
+ case "CUSTOM":
+ if (!area.isSpawnCustom() && entity.getType() != EntityType.ARMOR_STAND) {
+ event.setCancelled(true);
+ return;
+ }
+ break;
+ case "SPAWNER":
+ if (!area.isMobSpawnerSpawning()) {
+ event.setCancelled(true);
+ return;
+ }
+ break;
+ }
+ Plot plot = area.getOwnedPlotAbs(location);
+ if (plot == null) {
+ if (!area.isMobSpawning()) {
+ event.setCancelled(true);
+ }
+ return;
+ }
+ if (BukkitEntityUtil.checkEntity(entity, plot)) {
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST) public void onEntityFall(EntityChangeBlockEvent event) {
+ if (event.getEntityType() != EntityType.FALLING_BLOCK) {
+ return;
+ }
+ Block block = event.getBlock();
+ World world = block.getWorld();
+ String worldName = world.getName();
+ if (!this.plotAreaManager.hasPlotArea(worldName)) {
+ return;
+ }
+ Location location = BukkitUtil.adapt(block.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getOwnedPlotAbs(location);
+ if (plot == null || plot.getFlag(DisablePhysicsFlag.class)) {
+ event.setCancelled(true);
+ plot.debug("Falling block event was cancelled because disable-physics = true");
+ return;
+ }
+ if (event.getTo().hasGravity()) {
+ Entity entity = event.getEntity();
+ List meta = entity.getMetadata("plot");
+ if (meta.isEmpty()) {
+ return;
+ }
+ Plot origin = (Plot) meta.get(0).value();
+ if (origin != null && !origin.equals(plot)) {
+ event.setCancelled(true);
+ entity.remove();
+ }
+ } else if (event.getTo() == Material.AIR) {
+ event.getEntity().setMetadata("plot", new FixedMetadataValue((Plugin) PlotSquared.platform(), plot));
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGH) public void onDamage(EntityDamageEvent event) {
+ if (event.getEntityType() != EntityType.PLAYER) {
+ return;
+ }
+ Location location = BukkitUtil.adapt(event.getEntity().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = location.getOwnedPlot();
+ if (plot == null) {
+ if (area.isRoadFlags() && area.getRoadFlag(InvincibleFlag.class)) {
+ event.setCancelled(true);
+ }
+ return;
+ }
+ if (plot.getFlag(InvincibleFlag.class)) {
+ plot.debug(event.getEntity().getName() + " could not take damage because invincible = true");
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBigBoom(EntityExplodeEvent event) {
+ Location location = BukkitUtil.adapt(event.getLocation());
+ PlotArea area = location.getPlotArea();
+ boolean plotArea = location.isPlotArea();
+ if (!plotArea) {
+ if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
+ return;
+ }
+ return;
+ }
+ Plot plot = area.getOwnedPlot(location);
+ if (plot != null) {
+ if (plot.getFlag(ExplosionFlag.class)) {
+ List meta = event.getEntity().getMetadata("plot");
+ Plot origin;
+ if (meta.isEmpty()) {
+ origin = plot;
+ } else {
+ origin = (Plot) meta.get(0).value();
+ }
+ if (this.lastRadius != 0) {
+ List nearby = event.getEntity().getNearbyEntities(this.lastRadius, this.lastRadius, this.lastRadius);
+ for (Entity near : nearby) {
+ if (near instanceof TNTPrimed || near.getType().equals(EntityType.MINECART_TNT)) {
+ if (!near.hasMetadata("plot")) {
+ near.setMetadata("plot", new FixedMetadataValue((Plugin) PlotSquared.platform(), plot));
+ }
+ }
+ }
+ this.lastRadius = 0;
+ }
+ Iterator iterator = event.blockList().iterator();
+ while (iterator.hasNext()) {
+ Block block = iterator.next();
+ location = BukkitUtil.adapt(block.getLocation());
+ if (!area.contains(location.getX(), location.getZ()) || !origin.equals(area.getOwnedPlot(location))) {
+ iterator.remove();
+ }
+ }
+ return;
+ } else {
+ plot.debug("Explosion was cancelled because explosion = false");
+ }
+ }
+ event.setCancelled(true);
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+ public void onPeskyMobsChangeTheWorldLikeWTFEvent(EntityChangeBlockEvent event) {
+ Entity e = event.getEntity();
+ if (!(e instanceof FallingBlock)) {
+ Location location = BukkitUtil.adapt(event.getBlock().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area != null) {
+ Plot plot = area.getOwnedPlot(location);
+ if (plot != null && plot.getFlag(MobPlaceFlag.class)) {
+ plot.debug(e.getType() + " could not change block because mob-place = false");
+ return;
+ }
+ event.setCancelled(true);
+ }
+ }
+ }
+
+ @EventHandler public void onPrime(ExplosionPrimeEvent event) {
+ this.lastRadius = event.getRadius() + 1;
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onVehicleCreate(VehicleCreateEvent event) {
+ Vehicle entity = event.getVehicle();
+ Location location = BukkitUtil.adapt(entity.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getOwnedPlotAbs(location);
+ if (plot == null || BukkitEntityUtil.checkEntity(entity, plot)) {
+ entity.remove();
+ return;
+ }
+ if (Settings.Enabled_Components.KILL_ROAD_VEHICLES) {
+ entity.setMetadata("plot", new FixedMetadataValue((Plugin) PlotSquared.platform(), plot));
+ }
+ }
+}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntitySpawnListener.java b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntitySpawnListener.java
index f30f653b3..24d22e6a0 100644
--- a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntitySpawnListener.java
+++ b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/EntitySpawnListener.java
@@ -25,6 +25,7 @@
*/
package com.plotsquared.bukkit.listener;
+import com.plotsquared.bukkit.util.BukkitEntityUtil;
import com.plotsquared.bukkit.util.BukkitUtil;
import com.plotsquared.core.PlotSquared;
import com.plotsquared.core.configuration.Settings;
@@ -53,8 +54,8 @@ import org.bukkit.event.world.ChunkLoadEvent;
import org.bukkit.metadata.FixedMetadataValue;
import org.bukkit.metadata.MetadataValue;
import org.bukkit.plugin.Plugin;
-import javax.annotation.Nonnull;
+import javax.annotation.Nonnull;
import java.util.List;
public class EntitySpawnListener implements Listener {
@@ -66,8 +67,7 @@ public class EntitySpawnListener implements Listener {
public static void testNether(final Entity entity) {
@Nonnull World world = entity.getWorld();
- if (world.getEnvironment() != World.Environment.NETHER
- && world.getEnvironment() != World.Environment.THE_END) {
+ if (world.getEnvironment() != World.Environment.NETHER && world.getEnvironment() != World.Environment.THE_END) {
return;
}
test(entity);
@@ -91,8 +91,7 @@ public class EntitySpawnListener implements Listener {
List meta = entity.getMetadata(KEY);
if (meta.isEmpty()) {
if (PlotSquared.get().getPlotAreaManager().hasPlotArea(world.getName())) {
- entity.setMetadata(KEY,
- new FixedMetadataValue((Plugin) PlotSquared.platform(), entity.getLocation()));
+ entity.setMetadata(KEY, new FixedMetadataValue((Plugin) PlotSquared.platform(), entity.getLocation()));
}
} else {
org.bukkit.Location origin = (org.bukkit.Location) meta.get(0).value();
@@ -123,8 +122,7 @@ public class EntitySpawnListener implements Listener {
}
}
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void creatureSpawnEvent(EntitySpawnEvent event) {
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void creatureSpawnEvent(EntitySpawnEvent event) {
Entity entity = event.getEntity();
Location location = BukkitUtil.adapt(entity.getLocation());
PlotArea area = location.getPlotArea();
@@ -155,13 +153,12 @@ public class EntitySpawnListener implements Listener {
}
switch (entity.getType()) {
case ENDER_CRYSTAL:
- if (PlayerEvents.checkEntity(entity, plot)) {
+ if (BukkitEntityUtil.checkEntity(entity, plot)) {
event.setCancelled(true);
}
case SHULKER:
if (!entity.hasMetadata("shulkerPlot")) {
- entity.setMetadata("shulkerPlot",
- new FixedMetadataValue((Plugin) PlotSquared.platform(), plot.getId()));
+ entity.setMetadata("shulkerPlot", new FixedMetadataValue((Plugin) PlotSquared.platform(), plot.getId()));
}
}
}
@@ -192,8 +189,7 @@ public class EntitySpawnListener implements Listener {
}
}
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void vehicleMove(VehicleMoveEvent event) {
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void vehicleMove(VehicleMoveEvent event) {
testNether(event.getVehicle());
}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEventListener.java b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEventListener.java
new file mode 100644
index 000000000..0311638c3
--- /dev/null
+++ b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEventListener.java
@@ -0,0 +1,1448 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.destroystokyo.paper.MaterialTags;
+import com.google.common.base.Charsets;
+import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.bukkit.util.BukkitEntityUtil;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.bukkit.util.UpdateUtility;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.listener.PlayerBlockEventType;
+import com.plotsquared.core.listener.PlotListener;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.MetaDataAccess;
+import com.plotsquared.core.player.PlayerMetaDataKeys;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.PlotId;
+import com.plotsquared.core.plot.PlotInventory;
+import com.plotsquared.core.plot.flag.FlagContainer;
+import com.plotsquared.core.plot.flag.implementations.AnimalInteractFlag;
+import com.plotsquared.core.plot.flag.implementations.BlockedCmdsFlag;
+import com.plotsquared.core.plot.flag.implementations.ChatFlag;
+import com.plotsquared.core.plot.flag.implementations.DenyTeleportFlag;
+import com.plotsquared.core.plot.flag.implementations.DoneFlag;
+import com.plotsquared.core.plot.flag.implementations.DropProtectionFlag;
+import com.plotsquared.core.plot.flag.implementations.HangingBreakFlag;
+import com.plotsquared.core.plot.flag.implementations.HangingPlaceFlag;
+import com.plotsquared.core.plot.flag.implementations.HostileInteractFlag;
+import com.plotsquared.core.plot.flag.implementations.ItemDropFlag;
+import com.plotsquared.core.plot.flag.implementations.KeepInventoryFlag;
+import com.plotsquared.core.plot.flag.implementations.MiscInteractFlag;
+import com.plotsquared.core.plot.flag.implementations.PlayerInteractFlag;
+import com.plotsquared.core.plot.flag.implementations.PreventCreativeCopyFlag;
+import com.plotsquared.core.plot.flag.implementations.TamedInteractFlag;
+import com.plotsquared.core.plot.flag.implementations.UntrustedVisitFlag;
+import com.plotsquared.core.plot.flag.implementations.UseFlag;
+import com.plotsquared.core.plot.flag.implementations.VehicleBreakFlag;
+import com.plotsquared.core.plot.flag.implementations.VehicleUseFlag;
+import com.plotsquared.core.plot.flag.implementations.VillagerInteractFlag;
+import com.plotsquared.core.plot.flag.types.BlockTypeWrapper;
+import com.plotsquared.core.plot.message.PlotMessage;
+import com.plotsquared.core.plot.world.PlotAreaManager;
+import com.plotsquared.core.util.EventDispatcher;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.MathMan;
+import com.plotsquared.core.util.Permissions;
+import com.plotsquared.core.util.PremiumVerification;
+import com.plotsquared.core.util.RegExUtil;
+import com.plotsquared.core.util.entity.EntityCategories;
+import com.plotsquared.core.util.task.TaskManager;
+import com.plotsquared.core.util.task.TaskTime;
+import com.sk89q.worldedit.WorldEdit;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldedit.world.block.BlockType;
+import io.papermc.lib.PaperLib;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.FluidCollisionMode;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.command.PluginCommand;
+import org.bukkit.entity.ArmorStand;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.ItemFrame;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.Tameable;
+import org.bukkit.entity.Vehicle;
+import org.bukkit.event.Event;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.entity.EntityPickupItemEvent;
+import org.bukkit.event.entity.PlayerDeathEvent;
+import org.bukkit.event.hanging.HangingBreakByEntityEvent;
+import org.bukkit.event.hanging.HangingPlaceEvent;
+import org.bukkit.event.inventory.ClickType;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.inventory.InventoryCloseEvent;
+import org.bukkit.event.player.AsyncPlayerChatEvent;
+import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
+import org.bukkit.event.player.PlayerBucketEmptyEvent;
+import org.bukkit.event.player.PlayerBucketFillEvent;
+import org.bukkit.event.player.PlayerChangedWorldEvent;
+import org.bukkit.event.player.PlayerCommandPreprocessEvent;
+import org.bukkit.event.player.PlayerDropItemEvent;
+import org.bukkit.event.player.PlayerEggThrowEvent;
+import org.bukkit.event.player.PlayerEvent;
+import org.bukkit.event.player.PlayerInteractAtEntityEvent;
+import org.bukkit.event.player.PlayerInteractEntityEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
+import org.bukkit.event.player.PlayerRespawnEvent;
+import org.bukkit.event.player.PlayerTeleportEvent;
+import org.bukkit.event.vehicle.VehicleDestroyEvent;
+import org.bukkit.event.vehicle.VehicleEntityCollisionEvent;
+import org.bukkit.event.vehicle.VehicleMoveEvent;
+import org.bukkit.help.HelpTopic;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.PlayerInventory;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.bukkit.metadata.FixedMetadataValue;
+import org.bukkit.metadata.MetadataValue;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.util.Vector;
+
+import javax.annotation.Nonnull;
+import javax.inject.Inject;
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.UUID;
+import java.util.regex.Pattern;
+
+/**
+ * Player Events involving plots.
+ */
+@SuppressWarnings("unused")
+public class PlayerEventListener extends PlotListener implements Listener {
+
+ private final EventDispatcher eventDispatcher;
+ private final WorldEdit worldEdit;
+ private final PlotAreaManager plotAreaManager;
+ // To prevent recursion
+ private boolean tmpTeleport = true;
+ private Field fieldPlayer;
+ private PlayerMoveEvent moveTmp;
+ private String internalVersion;
+
+ {
+ try {
+ fieldPlayer = PlayerEvent.class.getDeclaredField("player");
+ fieldPlayer.setAccessible(true);
+ } catch (NoSuchFieldException e) {
+ e.printStackTrace();
+ }
+ }
+
+ @Inject public PlayerEventListener(@Nonnull final PlotAreaManager plotAreaManager,
+ @Nonnull final EventDispatcher eventDispatcher,
+ @Nonnull final WorldEdit worldEdit) {
+ super(eventDispatcher);
+ this.eventDispatcher = eventDispatcher;
+ this.worldEdit = worldEdit;
+ this.plotAreaManager = plotAreaManager;
+ }
+
+ @EventHandler public void onVehicleEntityCollision(VehicleEntityCollisionEvent e) {
+ if (e.getVehicle().getType() == EntityType.BOAT) {
+ Location location = BukkitUtil.adapt(e.getEntity().getLocation());
+ if (location.isPlotArea()) {
+ if (e.getEntity() instanceof Player) {
+ PlotPlayer player = BukkitUtil.adapt((Player) e.getEntity());
+ Plot plot = player.getCurrentPlot();
+ if (plot != null) {
+ if (!plot.isAdded(player.getUUID())) {
+ //Here the event is only canceled if the player is not the owner
+ //of the property on which he is located.
+ e.setCancelled(true);
+ }
+ } else {
+ e.setCancelled(true);
+ }
+ } else {
+ //Here the event is cancelled too, otherwise you can move the
+ //boat with EchoPets or other mobs running around on the plot.
+ e.setCancelled(true);
+ }
+ }
+ }
+ }
+
+ @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST) public void playerCommand(PlayerCommandPreprocessEvent event) {
+ String msg = event.getMessage().toLowerCase().replaceAll("/", "").trim();
+ if (msg.isEmpty()) {
+ return;
+ }
+ Player player = event.getPlayer();
+ PlotPlayer plotPlayer = BukkitUtil.adapt(player);
+ Location location = plotPlayer.getLocation();
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ String[] parts = msg.split(" ");
+ Plot plot = plotPlayer.getCurrentPlot();
+ // Check WorldEdit
+ switch (parts[0].toLowerCase()) {
+ case "up":
+ case "/up":
+ case "worldedit:up":
+ case "worldedit:/up":
+ if (plot == null || (!plot.isAdded(plotPlayer.getUUID()) && !Permissions
+ .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER, true))) {
+ event.setCancelled(true);
+ return;
+ }
+ }
+ if (plot == null && !area.isRoadFlags()) {
+ return;
+ }
+
+ List blockedCommands = plot != null ? plot.getFlag(BlockedCmdsFlag.class) : area.getFlag(BlockedCmdsFlag.class);
+ if (!blockedCommands.isEmpty() && !Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_INTERACT_BLOCKED_CMDS)) {
+ String part = parts[0];
+ if (parts[0].contains(":")) {
+ part = parts[0].split(":")[1];
+ msg = msg.replace(parts[0].split(":")[0] + ':', "");
+ }
+ String s1 = part;
+ List aliases = new ArrayList<>();
+ for (HelpTopic cmdLabel : Bukkit.getServer().getHelpMap().getHelpTopics()) {
+ if (part.equals(cmdLabel.getName())) {
+ break;
+ }
+ String label = cmdLabel.getName().replaceFirst("/", "");
+ if (aliases.contains(label)) {
+ continue;
+ }
+ PluginCommand p;
+ if ((p = Bukkit.getPluginCommand(label)) != null) {
+ for (String a : p.getAliases()) {
+ if (aliases.contains(a)) {
+ continue;
+ }
+ aliases.add(a);
+ a = a.replaceFirst("/", "");
+ if (!a.equals(label) && a.equals(part)) {
+ part = label;
+ break;
+ }
+ }
+ }
+ }
+ if (!s1.equals(part)) {
+ msg = msg.replace(s1, part);
+ }
+ for (String s : blockedCommands) {
+ Pattern pattern;
+ if (!RegExUtil.compiledPatterns.containsKey(s)) {
+ RegExUtil.compiledPatterns.put(s, pattern = Pattern.compile(s));
+ } else {
+ pattern = RegExUtil.compiledPatterns.get(s);
+ }
+ if (pattern.matcher(msg).matches()) {
+ String perm;
+ if (plot != null && plot.isAdded(plotPlayer.getUUID())) {
+ perm = "plots.admin.command.blocked-cmds.shared";
+ } else {
+ perm = "plots.admin.command.blocked-cmds.road";
+ }
+ if (!Permissions.hasPermission(plotPlayer, perm)) {
+ MainUtil.sendMessage(plotPlayer, Captions.COMMAND_BLOCKED);
+ event.setCancelled(true);
+ }
+ return;
+ }
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onPreLogin(final AsyncPlayerPreLoginEvent event) {
+ final UUID uuid;
+ if (Settings.UUID.OFFLINE) {
+ if (Settings.UUID.FORCE_LOWERCASE) {
+ uuid = UUID.nameUUIDFromBytes(("OfflinePlayer:" + event.getName().toLowerCase()).getBytes(Charsets.UTF_8));
+ } else {
+ uuid = UUID.nameUUIDFromBytes(("OfflinePlayer:" + event.getName()).getBytes(Charsets.UTF_8));
+ }
+ } else {
+ uuid = event.getUniqueId();
+ }
+ PlotSquared.get().getImpromptuUUIDPipeline().storeImmediately(event.getName(), uuid);
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onConnect(PlayerJoinEvent event) {
+ final Player player = event.getPlayer();
+ PlotSquared.platform().getPlayerManager().removePlayer(player.getUniqueId());
+ final PlotPlayer pp = BukkitUtil.adapt(player);
+
+ Location location = pp.getLocation();
+ PlotArea area = location.getPlotArea();
+ if (area != null) {
+ Plot plot = area.getPlot(location);
+ if (plot != null) {
+ plotEntry(pp, plot);
+ }
+ }
+ // Delayed
+
+ // Async
+ TaskManager.runTaskLaterAsync(() -> {
+ if (!player.hasPlayedBefore() && player.isOnline()) {
+ player.saveData();
+ }
+ this.eventDispatcher.doJoinTask(pp);
+ }, TaskTime.seconds(1L));
+
+ if (pp.hasPermission(Captions.PERMISSION_ADMIN_UPDATE_NOTIFICATION.getTranslated()) && Settings.Enabled_Components.UPDATE_NOTIFICATIONS
+ && PremiumVerification.isPremium() && UpdateUtility.hasUpdate) {
+ new PlotMessage("-----------------------------------").send(pp);
+ new PlotMessage(Captions.PREFIX + "There appears to be a PlotSquared update available!").color("$1").send(pp);
+ new PlotMessage(Captions.PREFIX + "&6You are running version " + UpdateUtility.internalVersion.versionString() + ", &6latest version is "
+ + UpdateUtility.spigotVersion).color("$1").send(pp);
+ new PlotMessage(Captions.PREFIX + "Download at:").color("$1").send(pp);
+ player.sendMessage(" https://www.spigotmc.org/resources/77506/updates");
+ new PlotMessage("-----------------------------------").send(pp);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void playerRespawn(PlayerRespawnEvent event) {
+ Player player = event.getPlayer();
+ PlotPlayer pp = BukkitUtil.adapt(player);
+ this.eventDispatcher.doRespawnTask(pp);
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onTeleport(PlayerTeleportEvent event) {
+ Player player = event.getPlayer();
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ try (final MetaDataAccess lastPlotAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+ Plot lastPlot = lastPlotAccess.get().orElse(null);
+ org.bukkit.Location to = event.getTo();
+ //noinspection ConstantConditions
+ if (to != null) {
+ Location location = BukkitUtil.adapt(to);
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ if (lastPlot != null) {
+ plotExit(pp, lastPlot);
+ lastPlotAccess.remove();
+ }
+ try (final MetaDataAccess lastLocationAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
+ lastLocationAccess.remove();
+ }
+ return;
+ }
+ Plot plot = area.getPlot(location);
+ if (plot != null) {
+ final boolean result = DenyTeleportFlag.allowsTeleport(pp, plot);
+ // there is one possibility to still allow teleportation:
+ // to is identical to the plot's home location, and untrusted-visit is true
+ // i.e. untrusted-visit can override deny-teleport
+ // this is acceptable, because otherwise it wouldn't make sense to have both flags set
+ if (!result && !(plot.getFlag(UntrustedVisitFlag.class) && plot.getHomeSynchronous().equals(BukkitUtil.adaptComplete(to)))) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_ENTRY_DENIED);
+ event.setCancelled(true);
+ }
+ }
+ }
+ }
+ playerMove(event);
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void vehicleMove(VehicleMoveEvent event)
+ throws IllegalAccessException {
+ final org.bukkit.Location from = event.getFrom();
+ final org.bukkit.Location to = event.getTo();
+
+ int toX, toZ;
+ if ((toX = MathMan.roundInt(to.getX())) != MathMan.roundInt(from.getX()) | (toZ = MathMan.roundInt(to.getZ())) != MathMan
+ .roundInt(from.getZ())) {
+ Vehicle vehicle = event.getVehicle();
+
+ // Check allowed
+ if (!vehicle.getPassengers().isEmpty()) {
+ Entity passenger = vehicle.getPassengers().get(0);
+
+ if (passenger instanceof Player) {
+ final Player player = (Player) passenger;
+ // reset
+ if (moveTmp == null) {
+ moveTmp = new PlayerMoveEvent(null, from, to);
+ }
+ moveTmp.setFrom(from);
+ moveTmp.setTo(to);
+ moveTmp.setCancelled(false);
+ fieldPlayer.set(moveTmp, player);
+
+ List passengers = vehicle.getPassengers();
+
+ this.playerMove(moveTmp);
+ org.bukkit.Location dest;
+ if (moveTmp.isCancelled()) {
+ dest = from;
+ } else if (MathMan.roundInt(moveTmp.getTo().getX()) != toX || MathMan.roundInt(moveTmp.getTo().getZ()) != toZ) {
+ dest = to;
+ } else {
+ dest = null;
+ }
+ if (dest != null) {
+ vehicle.eject();
+ vehicle.setVelocity(new Vector(0d, 0d, 0d));
+ PaperLib.teleportAsync(vehicle, dest);
+ passengers.forEach(vehicle::addPassenger);
+ return;
+ }
+ }
+ if (Settings.Enabled_Components.KILL_ROAD_VEHICLES) {
+ final com.sk89q.worldedit.world.entity.EntityType entityType = BukkitAdapter.adapt(vehicle.getType());
+ // Horses etc are vehicles, but they're also animals
+ // so this filters out all living entities
+ if (EntityCategories.VEHICLE.contains(entityType) && !EntityCategories.ANIMAL.contains(entityType)) {
+ List meta = vehicle.getMetadata("plot");
+ Plot toPlot = BukkitUtil.adapt(to).getPlot();
+ if (!meta.isEmpty()) {
+ Plot origin = (Plot) meta.get(0).value();
+ if (origin != null && !origin.getBasePlot(false).equals(toPlot)) {
+ vehicle.remove();
+ }
+ } else if (toPlot != null) {
+ vehicle.setMetadata("plot", new FixedMetadataValue((Plugin) PlotSquared.platform(), toPlot));
+ }
+ }
+ }
+ }
+
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void playerMove(PlayerMoveEvent event) {
+ org.bukkit.Location from = event.getFrom();
+ org.bukkit.Location to = event.getTo();
+ int x2;
+ if (MathMan.roundInt(from.getX()) != (x2 = MathMan.roundInt(to.getX()))) {
+ Player player = event.getPlayer();
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ // Cancel teleport
+ if (TaskManager.removeFromTeleportQueue(pp.getName())) {
+ MainUtil.sendMessage(pp, Captions.TELEPORT_FAILED);
+ }
+ // Set last location
+ Location location = BukkitUtil.adapt(to);
+ try (final MetaDataAccess lastLocationAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
+ lastLocationAccess.remove();
+ }
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ try (final MetaDataAccess lastPlotAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+ lastPlotAccess.remove();
+ }
+ return;
+ }
+ Plot now = area.getPlot(location);
+ Plot lastPlot;
+ try (final MetaDataAccess lastPlotAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+ lastPlot = lastPlotAccess.get().orElse(null);
+ }
+ if (now == null) {
+ try (final MetaDataAccess kickAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
+ if (lastPlot != null && !plotExit(pp, lastPlot) && this.tmpTeleport && !kickAccess.get().orElse(false)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_EXIT_DENIED);
+ this.tmpTeleport = false;
+ if (lastPlot.equals(BukkitUtil.adapt(from).getPlot())) {
+ player.teleport(from);
+ } else {
+ player.teleport(player.getWorld().getSpawnLocation());
+ }
+ this.tmpTeleport = true;
+ event.setCancelled(true);
+ return;
+ }
+ }
+ } else if (now.equals(lastPlot)) {
+ ForceFieldListener.handleForcefield(player, pp, now);
+ } else if (!plotEntry(pp, now) && this.tmpTeleport) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_ENTRY_DENIED);
+ this.tmpTeleport = false;
+ to.setX(from.getBlockX());
+ to.setY(from.getBlockY());
+ to.setZ(from.getBlockZ());
+ player.teleport(event.getTo());
+ this.tmpTeleport = true;
+ return;
+ }
+ int border = area.getBorder();
+ if (x2 > border && this.tmpTeleport) {
+ to.setX(border - 1);
+ this.tmpTeleport = false;
+ player.teleport(event.getTo());
+ this.tmpTeleport = true;
+ MainUtil.sendMessage(pp, Captions.BORDER);
+ }
+ if (x2 < -border && this.tmpTeleport) {
+ to.setX(-border + 1);
+ this.tmpTeleport = false;
+ player.teleport(event.getTo());
+ this.tmpTeleport = true;
+ MainUtil.sendMessage(pp, Captions.BORDER);
+ }
+ }
+ int z2;
+ if (MathMan.roundInt(from.getZ()) != (z2 = MathMan.roundInt(to.getZ()))) {
+ Player player = event.getPlayer();
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ // Cancel teleport
+ if (TaskManager.removeFromTeleportQueue(pp.getName())) {
+ MainUtil.sendMessage(pp, Captions.TELEPORT_FAILED);
+ }
+ // Set last location
+ Location location = BukkitUtil.adapt(to);
+ try (final MetaDataAccess lastLocationAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
+ lastLocationAccess.set(location);
+ }
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ try (final MetaDataAccess lastPlotAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+ lastPlotAccess.remove();
+ }
+ return;
+ }
+ Plot now = area.getPlot(location);
+ Plot lastPlot;
+ try (final MetaDataAccess lastPlotAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+ lastPlot = lastPlotAccess.get().orElse(null);
+ }
+ if (now == null) {
+ try (final MetaDataAccess kickAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
+ if (lastPlot != null && !plotExit(pp, lastPlot) && this.tmpTeleport && !kickAccess.get().orElse(false)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_EXIT_DENIED);
+ this.tmpTeleport = false;
+ if (lastPlot.equals(BukkitUtil.adapt(from).getPlot())) {
+ player.teleport(from);
+ } else {
+ player.teleport(player.getWorld().getSpawnLocation());
+ }
+ this.tmpTeleport = true;
+ event.setCancelled(true);
+ return;
+ }
+ }
+ } else if (now.equals(lastPlot)) {
+ ForceFieldListener.handleForcefield(player, pp, now);
+ } else if (!plotEntry(pp, now) && this.tmpTeleport) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_ENTRY_DENIED);
+ this.tmpTeleport = false;
+ player.teleport(from);
+ to.setX(from.getBlockX());
+ to.setY(from.getBlockY());
+ to.setZ(from.getBlockZ());
+ player.teleport(event.getTo());
+ this.tmpTeleport = true;
+ return;
+ }
+ int border = area.getBorder();
+ if (z2 > border && this.tmpTeleport) {
+ to.setZ(border - 1);
+ this.tmpTeleport = false;
+ player.teleport(event.getTo());
+ this.tmpTeleport = true;
+ MainUtil.sendMessage(pp, Captions.BORDER);
+ } else if (z2 < -border && this.tmpTeleport) {
+ to.setZ(-border + 1);
+ this.tmpTeleport = false;
+ player.teleport(event.getTo());
+ this.tmpTeleport = true;
+ MainUtil.sendMessage(pp, Captions.BORDER);
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.LOW) public void onChat(AsyncPlayerChatEvent event) {
+ if (event.isCancelled()) {
+ return;
+ }
+
+ BukkitPlayer plotPlayer = BukkitUtil.adapt(event.getPlayer());
+ Location location = plotPlayer.getLocation();
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getPlot(location);
+ if (plot == null) {
+ return;
+ }
+ if (!((plot.getFlag(ChatFlag.class) && area.isPlotChat() && plotPlayer.getAttribute("chat")) || area.isForcingPlotChat())) {
+ return;
+ }
+ if (plot.isDenied(plotPlayer.getUUID()) && !Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_CHAT_BYPASS)) {
+ return;
+ }
+ event.setCancelled(true);
+ String message = event.getMessage();
+ String format = Captions.PLOT_CHAT_FORMAT.getTranslated();
+ String sender = event.getPlayer().getDisplayName();
+ PlotId id = plot.getId();
+ Set recipients = event.getRecipients();
+ recipients.clear();
+ Set spies = new HashSet<>();
+ for (final PlotPlayer pp : PlotSquared.platform().getPlayerManager().getPlayers()) {
+ if (pp.getAttribute("chatspy")) {
+ spies.add(((BukkitPlayer) pp).player);
+ } else {
+ Plot current = pp.getCurrentPlot();
+ if (current != null && current.getBasePlot(false).equals(plot)) {
+ recipients.add(((BukkitPlayer) pp).player);
+ }
+ }
+ }
+ String partial =
+ ChatColor.translateAlternateColorCodes('&', format.replace("%plot_id%", id.getX() + ";" + id.getY()).replace("%sender%", sender));
+ if (plotPlayer.hasPermission("plots.chat.color")) {
+ message = Captions.color(message);
+ }
+ String full = partial.replace("%msg%", message);
+ for (Player receiver : recipients) {
+ receiver.sendMessage(full);
+ }
+ if (!spies.isEmpty()) {
+ String spyMessage =
+ Captions.PLOT_CHAT_SPY_FORMAT.getTranslated().replace("%plot_id%", id.getX() + ";" + id.getY()).replace("%sender%", sender)
+ .replace("%msg%", message);
+ for (Player player : spies) {
+ player.sendMessage(spyMessage);
+ }
+ }
+ // TODO: Re-implement
+ // PlotSquared.debug(full);
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onWorldChanged(PlayerChangedWorldEvent event) {
+ Player player = event.getPlayer();
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ // Delete last location
+ Plot plot;
+ try (final MetaDataAccess lastPlotAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
+ plot = lastPlotAccess.remove();
+ }
+ try (final MetaDataAccess lastLocationAccess = pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
+ lastLocationAccess.remove();
+ }
+ if (plot != null) {
+ plotExit(pp, plot);
+ }
+ if (this.worldEdit != null) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_WORLDEDIT_BYPASS)) {
+ if (pp.getAttribute("worldedit")) {
+ pp.removeAttribute("worldedit");
+ }
+ }
+ }
+ Location location = pp.getLocation();
+ PlotArea area = location.getPlotArea();
+ if (location.isPlotArea()) {
+ plot = location.getPlot();
+ if (plot != null) {
+ plotEntry(pp, plot);
+ }
+ }
+ }
+
+ @SuppressWarnings("deprecation") @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+ public void onInventoryClick(InventoryClickEvent event) {
+ /*if (!event.isLeftClick() || (event.getAction() != InventoryAction.PLACE_ALL) || event
+ .isShiftClick()) {
+ return;
+ }*/
+ HumanEntity entity = event.getWhoClicked();
+ if (!(entity instanceof Player) || !this.plotAreaManager.hasPlotArea(entity.getWorld().getName())) {
+ return;
+ }
+
+ HumanEntity clicker = event.getWhoClicked();
+ if (!(clicker instanceof Player)) {
+ return;
+ }
+ Player player = (Player) clicker;
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ final PlotInventory inventory = PlotInventory.getOpenPlotInventory(pp);
+ if (inventory != null && event.getRawSlot() == event.getSlot()) {
+ if (!inventory.onClick(event.getSlot())) {
+ event.setResult(Event.Result.DENY);
+ event.setCancelled(true);
+ inventory.close();
+ }
+ }
+ PlayerInventory inv = player.getInventory();
+ int slot = inv.getHeldItemSlot();
+ if ((slot > 8) || !event.getEventName().equals("InventoryCreativeEvent")) {
+ return;
+ }
+ ItemStack current = inv.getItemInHand();
+ ItemStack newItem = event.getCursor();
+ ItemMeta newMeta = newItem.getItemMeta();
+ ItemMeta oldMeta = newItem.getItemMeta();
+
+ if (event.getClick() == ClickType.CREATIVE) {
+ final Plot plot = pp.getCurrentPlot();
+ if (plot != null) {
+ if (plot.getFlag(PreventCreativeCopyFlag.class) && !plot.isAdded(player.getUniqueId()) && !Permissions
+ .hasPermission(pp, Captions.PERMISSION_ADMIN_INTERACT_OTHER)) {
+ final ItemStack newStack = new ItemStack(newItem.getType(), newItem.getAmount());
+ event.setCursor(newStack);
+ plot.debug(player.getName() + " could not creative-copy an item because prevent-creative-copy = true");
+ }
+ } else {
+ PlotArea area = pp.getPlotAreaAbs();
+ if (area != null && area.isRoadFlags() && area.getRoadFlag(PreventCreativeCopyFlag.class)) {
+ final ItemStack newStack = new ItemStack(newItem.getType(), newItem.getAmount());
+ event.setCursor(newStack);
+ }
+ }
+ return;
+ }
+
+ String newLore = "";
+ if (newMeta != null) {
+ List lore = newMeta.getLore();
+ if (lore != null) {
+ newLore = lore.toString();
+ }
+ }
+ String oldLore = "";
+ if (oldMeta != null) {
+ List lore = oldMeta.getLore();
+ if (lore != null) {
+ oldLore = lore.toString();
+ }
+ }
+ if (!"[(+NBT)]".equals(newLore) || (current.equals(newItem) && newLore.equals(oldLore))) {
+ switch (newItem.getType()) {
+ case LEGACY_BANNER:
+ case PLAYER_HEAD:
+ if (newMeta != null) {
+ break;
+ }
+ default:
+ return;
+ }
+ }
+ Block block = player.getTargetBlock(null, 7);
+ org.bukkit.block.BlockState state = block.getState();
+ Material stateType = state.getType();
+ Material itemType = newItem.getType();
+ if (stateType != itemType) {
+ switch (stateType) {
+ case LEGACY_STANDING_BANNER:
+ case LEGACY_WALL_BANNER:
+ if (itemType == Material.LEGACY_BANNER) {
+ break;
+ }
+ case LEGACY_SKULL:
+ if (itemType == Material.LEGACY_SKULL_ITEM) {
+ break;
+ }
+ default:
+ return;
+ }
+ }
+ Location location = BukkitUtil.adapt(state.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = area.getPlotAbs(location);
+ boolean cancelled = false;
+ if (plot == null) {
+ if (!Permissions.hasPermission(pp, "plots.admin.interact.road")) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.interact.road");
+ cancelled = true;
+ }
+ } else if (!plot.hasOwner()) {
+ if (!Permissions.hasPermission(pp, "plots.admin.interact.unowned")) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.interact.unowned");
+ cancelled = true;
+ }
+ } else {
+ UUID uuid = pp.getUUID();
+ if (!plot.isAdded(uuid)) {
+ if (!Permissions.hasPermission(pp, "plots.admin.interact.other")) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.interact.other");
+ cancelled = true;
+ }
+ }
+ }
+ if (cancelled) {
+ if ((current.getType() == newItem.getType()) && (current.getDurability() == newItem.getDurability())) {
+ event.setCursor(new ItemStack(newItem.getType(), newItem.getAmount(), newItem.getDurability()));
+ event.setCancelled(true);
+ return;
+ }
+ event.setCursor(new ItemStack(newItem.getType(), newItem.getAmount(), newItem.getDurability()));
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onInteract(PlayerInteractAtEntityEvent e) {
+ Entity entity = e.getRightClicked();
+ if (!(entity instanceof ArmorStand) && !(entity instanceof ItemFrame)) {
+ return;
+ }
+ Location location = BukkitUtil.adapt(e.getRightClicked().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ EntitySpawnListener.testNether(entity);
+ Plot plot = location.getPlotAbs();
+ BukkitPlayer pp = BukkitUtil.adapt(e.getPlayer());
+ if (plot == null) {
+ if (!area.isRoadFlags() && !area.getRoadFlag(MiscInteractFlag.class) && !Permissions.hasPermission(pp, "plots.admin.interact.road")) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.interact.road");
+ e.setCancelled(true);
+ }
+ } else {
+ if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ e.setCancelled(true);
+ return;
+ }
+ }
+ if (!plot.hasOwner()) {
+ if (!Permissions.hasPermission(pp, "plots.admin.interact.unowned")) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.interact.unowned");
+ e.setCancelled(true);
+ }
+ } else {
+ UUID uuid = pp.getUUID();
+ if (plot.isAdded(uuid)) {
+ return;
+ }
+ if (plot.getFlag(MiscInteractFlag.class)) {
+ return;
+ }
+ if (!Permissions.hasPermission(pp, "plots.admin.interact.other")) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.interact.other");
+ e.setCancelled(true);
+ plot.debug(pp.getName() + " could not interact with " + entity.getType() + " bcause misc-interact = false");
+ }
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.LOW) public void onCancelledInteract(PlayerInteractEvent event) {
+ if (event.isCancelled() && event.getAction() == Action.RIGHT_CLICK_AIR) {
+ Player player = event.getPlayer();
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ PlotArea area = pp.getPlotAreaAbs();
+ if (area == null) {
+ return;
+ }
+ if (event.getAction() == Action.RIGHT_CLICK_AIR) {
+ Material item = event.getMaterial();
+ if (item.toString().toLowerCase().endsWith("_egg")) {
+ event.setCancelled(true);
+ event.setUseItemInHand(Event.Result.DENY);
+ }
+ }
+ ItemStack hand = player.getInventory().getItemInMainHand();
+ ItemStack offHand = player.getInventory().getItemInOffHand();
+ Material type = hand.getType();
+ Material offType = offHand.getType();
+ if (type == Material.AIR) {
+ type = offType;
+ }
+ if (type.toString().toLowerCase().endsWith("_egg")) {
+ Block block = player.getTargetBlockExact(5, FluidCollisionMode.SOURCE_ONLY);
+ if (block != null && block.getType() != Material.AIR) {
+ Location location = BukkitUtil.adapt(block.getLocation());
+ if (!this.eventDispatcher.checkPlayerBlockEvent(pp, PlayerBlockEventType.SPAWN_MOB, location, null, true)) {
+ event.setCancelled(true);
+ event.setUseItemInHand(Event.Result.DENY);
+ }
+ }
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true) public void onInteract(PlayerInteractEvent event) {
+ Player player = event.getPlayer();
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ PlotArea area = pp.getPlotAreaAbs();
+ if (area == null) {
+ return;
+ }
+ PlayerBlockEventType eventType = null;
+ BlockType blocktype1;
+ Block block = event.getClickedBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ Action action = event.getAction();
+ outer:
+ switch (action) {
+ case PHYSICAL: {
+ eventType = PlayerBlockEventType.TRIGGER_PHYSICAL;
+ blocktype1 = BukkitAdapter.asBlockType(block.getType());
+ break;
+ }
+ //todo rearrange the right click code. it is all over the place.
+ case RIGHT_CLICK_BLOCK: {
+ Material blockType = block.getType();
+ eventType = PlayerBlockEventType.INTERACT_BLOCK;
+ blocktype1 = BukkitAdapter.asBlockType(block.getType());
+
+ if (blockType.isInteractable()) {
+ if (!player.isSneaking()) {
+ break;
+ }
+ ItemStack hand = player.getInventory().getItemInMainHand();
+ ItemStack offHand = player.getInventory().getItemInOffHand();
+
+ // sneaking players interact with blocks if both hands are empty
+ if (hand.getType() == Material.AIR && offHand.getType() == Material.AIR) {
+ break;
+ }
+ }
+
+ Material type = event.getMaterial();
+
+ // in the following, lb needs to have the material of the item in hand i.e. type
+ switch (type) {
+ case REDSTONE:
+ case STRING:
+ case PUMPKIN_SEEDS:
+ case MELON_SEEDS:
+ case COCOA_BEANS:
+ case WHEAT_SEEDS:
+ case BEETROOT_SEEDS:
+ case SWEET_BERRIES:
+ return;
+ default:
+ //eventType = PlayerBlockEventType.PLACE_BLOCK;
+ if (type.isBlock()) {
+ return;
+ }
+ }
+ if (PaperLib.isPaper()) {
+ if (MaterialTags.SPAWN_EGGS.isTagged(type) || Material.EGG.equals(type)) {
+ eventType = PlayerBlockEventType.SPAWN_MOB;
+ break outer;
+ }
+ } else {
+ if (type.toString().toLowerCase().endsWith("egg")) {
+ eventType = PlayerBlockEventType.SPAWN_MOB;
+ break outer;
+ }
+ }
+ if (type.isEdible()) {
+ //Allow all players to eat while also allowing the block place event ot be fired
+ return;
+ }
+ switch (type) {
+ case ACACIA_BOAT:
+ case BIRCH_BOAT:
+ case CHEST_MINECART:
+ case COMMAND_BLOCK_MINECART:
+ case DARK_OAK_BOAT:
+ case FURNACE_MINECART:
+ case HOPPER_MINECART:
+ case JUNGLE_BOAT:
+ case MINECART:
+ case OAK_BOAT:
+ case SPRUCE_BOAT:
+ case TNT_MINECART:
+ eventType = PlayerBlockEventType.PLACE_VEHICLE;
+ break outer;
+ case FIREWORK_ROCKET:
+ case FIREWORK_STAR:
+ eventType = PlayerBlockEventType.SPAWN_MOB;
+ break outer;
+ case BOOK:
+ case KNOWLEDGE_BOOK:
+ case WRITABLE_BOOK:
+ case WRITTEN_BOOK:
+ eventType = PlayerBlockEventType.READ;
+ break outer;
+ case ARMOR_STAND:
+ location = BukkitUtil.adapt(block.getRelative(event.getBlockFace()).getLocation());
+ eventType = PlayerBlockEventType.PLACE_MISC;
+ break outer;
+ }
+ break;
+ }
+ case LEFT_CLICK_BLOCK: {
+ location = BukkitUtil.adapt(block.getLocation());
+ //eventType = PlayerBlockEventType.BREAK_BLOCK;
+ blocktype1 = BukkitAdapter.asBlockType(block.getType());
+ if (block.getType() == Material.DRAGON_EGG) {
+ eventType = PlayerBlockEventType.TELEPORT_OBJECT;
+ break;
+ }
+
+ return;
+ }
+ default:
+ return;
+ }
+ if (this.worldEdit != null && pp.getAttribute("worldedit")) {
+ if (event.getMaterial() == Material.getMaterial(this.worldEdit.getConfiguration().wandItem)) {
+ return;
+ }
+ }
+ if (!this.eventDispatcher.checkPlayerBlockEvent(pp, eventType, location, blocktype1, true)) {
+ event.setCancelled(true);
+ event.setUseInteractedBlock(Event.Result.DENY);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBucketEmpty(PlayerBucketEmptyEvent event) {
+ BlockFace bf = event.getBlockFace();
+ Block block = event.getBlockClicked().getLocation().add(bf.getModX(), bf.getModY(), bf.getModZ()).getBlock();
+ Location location = BukkitUtil.adapt(block.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ BukkitPlayer pp = BukkitUtil.adapt(event.getPlayer());
+ Plot plot = area.getPlot(location);
+ if (plot == null) {
+ if (Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_ROAD)) {
+ return;
+ }
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_ROAD);
+ event.setCancelled(true);
+ } else if (!plot.hasOwner()) {
+ if (Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_UNOWNED)) {
+ return;
+ }
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_UNOWNED);
+ event.setCancelled(true);
+ } else if (!plot.isAdded(pp.getUUID())) {
+ List use = plot.getFlag(UseFlag.class);
+ final BlockType blockType = BukkitAdapter.asBlockType(block.getType());
+ for (final BlockTypeWrapper blockTypeWrapper : use) {
+ if (blockTypeWrapper.accepts(blockType)) {
+ return;
+ }
+ }
+ if (Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ return;
+ }
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ event.setCancelled(true);
+ } else if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ event.setCancelled(true);
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST) public void onInventoryClose(InventoryCloseEvent event) {
+ HumanEntity closer = event.getPlayer();
+ if (!(closer instanceof Player)) {
+ return;
+ }
+ Player player = (Player) closer;
+ PlotInventory.removePlotInventoryOpen(BukkitUtil.adapt(player));
+ }
+
+ @EventHandler(priority = EventPriority.MONITOR) public void onLeave(PlayerQuitEvent event) {
+ TaskManager.removeFromTeleportQueue(event.getPlayer().getName());
+ BukkitPlayer pp = BukkitUtil.adapt(event.getPlayer());
+ pp.unregister();
+ this.logout(pp.getUUID());
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onBucketFill(PlayerBucketFillEvent event) {
+ Block blockClicked = event.getBlockClicked();
+ Location location = BukkitUtil.adapt(blockClicked.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Player player = event.getPlayer();
+ BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
+ Plot plot = area.getPlot(location);
+ if (plot == null) {
+ if (Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_ROAD)) {
+ return;
+ }
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_ROAD);
+ event.setCancelled(true);
+ } else if (!plot.hasOwner()) {
+ if (Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_UNOWNED)) {
+ return;
+ }
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_UNOWNED);
+ event.setCancelled(true);
+ } else if (!plot.isAdded(plotPlayer.getUUID())) {
+ List use = plot.getFlag(UseFlag.class);
+ Block block = event.getBlockClicked();
+ final BlockType blockType = BukkitAdapter.asBlockType(block.getType());
+ for (final BlockTypeWrapper blockTypeWrapper : use) {
+ if (blockTypeWrapper.accepts(blockType)) {
+ return;
+ }
+ }
+ if (Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ return;
+ }
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ event.setCancelled(true);
+ } else if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
+ if (!Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ event.setCancelled(true);
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onHangingPlace(HangingPlaceEvent event) {
+ Block block = event.getBlock().getRelative(event.getBlockFace());
+ Location location = BukkitUtil.adapt(block.getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Player p = event.getPlayer();
+ if (p == null) {
+ event.setCancelled(true);
+ return;
+ }
+ BukkitPlayer pp = BukkitUtil.adapt(p);
+ Plot plot = area.getPlot(location);
+ if (plot == null) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_ROAD)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_ROAD);
+ event.setCancelled(true);
+ }
+ } else {
+ if (!plot.hasOwner()) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_UNOWNED)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_UNOWNED);
+ event.setCancelled(true);
+ }
+ return;
+ }
+ if (!plot.isAdded(pp.getUUID())) {
+ if (!plot.getFlag(HangingPlaceFlag.class)) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ event.setCancelled(true);
+ }
+ return;
+ }
+ }
+ if (BukkitEntityUtil.checkEntity(event.getEntity(), plot)) {
+ event.setCancelled(true);
+ }
+
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onHangingBreakByEntity(HangingBreakByEntityEvent event) {
+ Entity remover = event.getRemover();
+ if (remover instanceof Player) {
+ Player p = (Player) remover;
+ Location location = BukkitUtil.adapt(event.getEntity().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ BukkitPlayer pp = BukkitUtil.adapt(p);
+ Plot plot = area.getPlot(location);
+ if (plot == null) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_DESTROY_ROAD)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_DESTROY_ROAD);
+ event.setCancelled(true);
+ }
+ } else if (!plot.hasOwner()) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_DESTROY_UNOWNED)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_DESTROY_UNOWNED);
+ event.setCancelled(true);
+ }
+ } else if (!plot.isAdded(pp.getUUID())) {
+ if (plot.getFlag(HangingBreakFlag.class)) {
+ return;
+ }
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_DESTROY_OTHER)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_DESTROY_OTHER);
+ event.setCancelled(true);
+ plot.debug(p.getName() + " could not break hanging entity because hanging-break = false");
+ }
+ }
+ } else if (remover instanceof Projectile) {
+ Projectile p = (Projectile) remover;
+ if (p.getShooter() instanceof Player) {
+ Player shooter = (Player) p.getShooter();
+ Location location = BukkitUtil.adapt(event.getEntity().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ BukkitPlayer player = BukkitUtil.adapt(shooter);
+ Plot plot = area.getPlot(BukkitUtil.adapt(event.getEntity().getLocation()));
+ if (plot != null) {
+ if (!plot.hasOwner()) {
+ if (!Permissions.hasPermission(player, Captions.PERMISSION_ADMIN_DESTROY_UNOWNED)) {
+ MainUtil.sendMessage(player, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_DESTROY_UNOWNED);
+ event.setCancelled(true);
+ }
+ } else if (!plot.isAdded(player.getUUID())) {
+ if (!plot.getFlag(HangingBreakFlag.class)) {
+ if (!Permissions.hasPermission(player, Captions.PERMISSION_ADMIN_DESTROY_OTHER)) {
+ MainUtil.sendMessage(player, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_DESTROY_OTHER);
+ event.setCancelled(true);
+ plot.debug(player.getName() + " could not break hanging entity because hanging-break = false");
+ }
+ }
+ }
+ }
+ }
+ } else {
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
+ Location location = BukkitUtil.adapt(event.getRightClicked().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Player p = event.getPlayer();
+ BukkitPlayer pp = BukkitUtil.adapt(p);
+ Plot plot = area.getPlot(location);
+ if (plot == null && !area.isRoadFlags()) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_INTERACT_ROAD)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_INTERACT_ROAD);
+ event.setCancelled(true);
+ }
+ } else if (plot != null && !plot.hasOwner()) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_INTERACT_UNOWNED)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_INTERACT_UNOWNED);
+ event.setCancelled(true);
+ }
+ } else if ((plot != null && !plot.isAdded(pp.getUUID())) || (plot == null && area.isRoadFlags())) {
+ final Entity entity = event.getRightClicked();
+ final com.sk89q.worldedit.world.entity.EntityType entityType = BukkitAdapter.adapt(entity.getType());
+
+ FlagContainer flagContainer;
+ if (plot == null) {
+ flagContainer = area.getRoadFlagContainer();
+ } else {
+ flagContainer = plot.getFlagContainer();
+ }
+
+ if (EntityCategories.HOSTILE.contains(entityType) && flagContainer.getFlag(HostileInteractFlag.class).getValue()) {
+ return;
+ }
+
+ if (EntityCategories.ANIMAL.contains(entityType) && flagContainer.getFlag(AnimalInteractFlag.class).getValue()) {
+ return;
+ }
+
+ // This actually makes use of the interface, so we don't use the
+ // category
+ if (entity instanceof Tameable && ((Tameable) entity).isTamed() && flagContainer.getFlag(TamedInteractFlag.class).getValue()) {
+ return;
+ }
+
+ if (EntityCategories.VEHICLE.contains(entityType) && flagContainer.getFlag(VehicleUseFlag.class).getValue()) {
+ return;
+ }
+
+ if (EntityCategories.PLAYER.contains(entityType) && flagContainer.getFlag(PlayerInteractFlag.class).getValue()) {
+ return;
+ }
+
+ if (EntityCategories.VILLAGER.contains(entityType) && flagContainer.getFlag(VillagerInteractFlag.class).getValue()) {
+ return;
+ }
+
+ if ((EntityCategories.HANGING.contains(entityType) || EntityCategories.OTHER.contains(entityType)) && flagContainer
+ .getFlag(MiscInteractFlag.class).getValue()) {
+ return;
+ }
+
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_INTERACT_OTHER)) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_INTERACT_OTHER);
+ event.setCancelled(true);
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onVehicleDestroy(VehicleDestroyEvent event) {
+ Location location = BukkitUtil.adapt(event.getVehicle().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Entity attacker = event.getAttacker();
+ if (attacker instanceof Player) {
+ Player p = (Player) attacker;
+ BukkitPlayer pp = BukkitUtil.adapt(p);
+ Plot plot = area.getPlot(location);
+ if (plot == null) {
+ if (!Permissions.hasPermission(pp, "plots.admin.vehicle.break.road")) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.vehicle.break.road");
+ event.setCancelled(true);
+ }
+ } else {
+ if (!plot.hasOwner()) {
+ if (!Permissions.hasPermission(pp, "plots.admin.vehicle.break.unowned")) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.vehicle.break.unowned");
+ event.setCancelled(true);
+ return;
+ }
+ return;
+ }
+ if (!plot.isAdded(pp.getUUID())) {
+ if (plot.getFlag(VehicleBreakFlag.class)) {
+ return;
+ }
+ if (!Permissions.hasPermission(pp, "plots.admin.vehicle.break.other")) {
+ MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.vehicle.break.other");
+ event.setCancelled(true);
+ plot.debug(pp.getName() + " could not break vehicle because vehicle-break = false");
+ }
+ }
+ }
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onPlayerEggThrow(PlayerEggThrowEvent event) {
+ Location location = BukkitUtil.adapt(event.getEgg().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Player player = event.getPlayer();
+ BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
+ Plot plot = area.getPlot(location);
+ if (plot == null) {
+ if (!Permissions.hasPermission(plotPlayer, "plots.admin.projectile.road")) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT, "plots.admin.projectile.road");
+ event.setHatching(false);
+ }
+ } else if (!plot.hasOwner()) {
+ if (!Permissions.hasPermission(plotPlayer, "plots.admin.projectile.unowned")) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT, "plots.admin.projectile.unowned");
+ event.setHatching(false);
+ }
+ } else if (!plot.isAdded(plotPlayer.getUUID())) {
+ if (!Permissions.hasPermission(plotPlayer, "plots.admin.projectile.other")) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT, "plots.admin.projectile.other");
+ event.setHatching(false);
+ }
+ }
+ }
+
+ @EventHandler public void onItemDrop(PlayerDropItemEvent event) {
+ Player player = event.getPlayer();
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ Location location = pp.getLocation();
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = location.getOwnedPlot();
+ if (plot == null) {
+ if (area.isRoadFlags() && !area.getRoadFlag(ItemDropFlag.class)) {
+ event.setCancelled(true);
+ }
+ return;
+ }
+ UUID uuid = pp.getUUID();
+ if (!plot.isAdded(uuid)) {
+ if (!plot.getFlag(ItemDropFlag.class)) {
+ plot.debug(player.getName() + " could not drop item because of item-drop = false");
+ event.setCancelled(true);
+ }
+ }
+ }
+
+ @EventHandler public void onItemPickup(EntityPickupItemEvent event) {
+ LivingEntity ent = event.getEntity();
+ if (ent instanceof Player) {
+ Player player = (Player) ent;
+ BukkitPlayer pp = BukkitUtil.adapt(player);
+ Location location = pp.getLocation();
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = location.getOwnedPlot();
+ if (plot == null) {
+ if (area.isRoadFlags() && area.getRoadFlag(DropProtectionFlag.class)) {
+ event.setCancelled(true);
+ }
+ return;
+ }
+ UUID uuid = pp.getUUID();
+ if (!plot.isAdded(uuid) && plot.getFlag(DropProtectionFlag.class)) {
+ plot.debug(player.getName() + " could not pick up item because of drop-protection = true");
+ event.setCancelled(true);
+ }
+ }
+ }
+
+ @EventHandler public void onDeath(final PlayerDeathEvent event) {
+ Location location = BukkitUtil.adapt(event.getEntity().getLocation());
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return;
+ }
+ Plot plot = location.getOwnedPlot();
+ if (plot == null) {
+ if (area.isRoadFlags() && area.getRoadFlag(KeepInventoryFlag.class)) {
+ event.setCancelled(true);
+ }
+ return;
+ }
+ if (plot.getFlag(KeepInventoryFlag.class)) {
+ if (plot.getFlag(KeepInventoryFlag.class)) {
+ plot.debug(event.getEntity().getName() + " kept their inventory because of keep-inventory = true");
+ event.setKeepInventory(true);
+ }
+ }
+ }
+}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEvents.java b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEvents.java
deleted file mode 100644
index 0e783067c..000000000
--- a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/PlayerEvents.java
+++ /dev/null
@@ -1,3274 +0,0 @@
-/*
- * _____ _ _ _____ _
- * | __ \| | | | / ____| | |
- * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
- * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
- * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
- * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
- * | |
- * |_|
- * PlotSquared plot management system for Minecraft
- * Copyright (C) 2020 IntellectualSites
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-package com.plotsquared.bukkit.listener;
-
-import com.destroystokyo.paper.MaterialTags;
-import com.google.common.base.Charsets;
-import com.google.inject.Inject;
-import com.plotsquared.bukkit.player.BukkitPlayer;
-import com.plotsquared.bukkit.util.BukkitUtil;
-import com.plotsquared.bukkit.util.UpdateUtility;
-import com.plotsquared.core.PlotSquared;
-import com.plotsquared.core.configuration.Captions;
-import com.plotsquared.core.configuration.Settings;
-import com.plotsquared.core.database.DBFunc;
-import com.plotsquared.core.listener.PlayerBlockEventType;
-import com.plotsquared.core.listener.PlotListener;
-import com.plotsquared.core.location.Location;
-import com.plotsquared.core.player.MetaDataAccess;
-import com.plotsquared.core.player.PlayerMetaDataKeys;
-import com.plotsquared.core.player.PlotPlayer;
-import com.plotsquared.core.plot.Plot;
-import com.plotsquared.core.plot.PlotArea;
-import com.plotsquared.core.plot.PlotHandler;
-import com.plotsquared.core.plot.PlotId;
-import com.plotsquared.core.plot.PlotInventory;
-import com.plotsquared.core.plot.flag.FlagContainer;
-import com.plotsquared.core.plot.flag.implementations.AnimalAttackFlag;
-import com.plotsquared.core.plot.flag.implementations.AnimalCapFlag;
-import com.plotsquared.core.plot.flag.implementations.AnimalInteractFlag;
-import com.plotsquared.core.plot.flag.implementations.BlockBurnFlag;
-import com.plotsquared.core.plot.flag.implementations.BlockIgnitionFlag;
-import com.plotsquared.core.plot.flag.implementations.BlockedCmdsFlag;
-import com.plotsquared.core.plot.flag.implementations.BreakFlag;
-import com.plotsquared.core.plot.flag.implementations.ChatFlag;
-import com.plotsquared.core.plot.flag.implementations.CoralDryFlag;
-import com.plotsquared.core.plot.flag.implementations.DenyTeleportFlag;
-import com.plotsquared.core.plot.flag.implementations.DisablePhysicsFlag;
-import com.plotsquared.core.plot.flag.implementations.DoneFlag;
-import com.plotsquared.core.plot.flag.implementations.DropProtectionFlag;
-import com.plotsquared.core.plot.flag.implementations.EntityCapFlag;
-import com.plotsquared.core.plot.flag.implementations.ExplosionFlag;
-import com.plotsquared.core.plot.flag.implementations.GrassGrowFlag;
-import com.plotsquared.core.plot.flag.implementations.HangingBreakFlag;
-import com.plotsquared.core.plot.flag.implementations.HangingPlaceFlag;
-import com.plotsquared.core.plot.flag.implementations.HostileAttackFlag;
-import com.plotsquared.core.plot.flag.implementations.HostileCapFlag;
-import com.plotsquared.core.plot.flag.implementations.HostileInteractFlag;
-import com.plotsquared.core.plot.flag.implementations.IceFormFlag;
-import com.plotsquared.core.plot.flag.implementations.IceMeltFlag;
-import com.plotsquared.core.plot.flag.implementations.InstabreakFlag;
-import com.plotsquared.core.plot.flag.implementations.InvincibleFlag;
-import com.plotsquared.core.plot.flag.implementations.ItemDropFlag;
-import com.plotsquared.core.plot.flag.implementations.KeepInventoryFlag;
-import com.plotsquared.core.plot.flag.implementations.KelpGrowFlag;
-import com.plotsquared.core.plot.flag.implementations.LiquidFlowFlag;
-import com.plotsquared.core.plot.flag.implementations.MiscBreakFlag;
-import com.plotsquared.core.plot.flag.implementations.MiscCapFlag;
-import com.plotsquared.core.plot.flag.implementations.MiscInteractFlag;
-import com.plotsquared.core.plot.flag.implementations.MobCapFlag;
-import com.plotsquared.core.plot.flag.implementations.MobPlaceFlag;
-import com.plotsquared.core.plot.flag.implementations.MycelGrowFlag;
-import com.plotsquared.core.plot.flag.implementations.PlaceFlag;
-import com.plotsquared.core.plot.flag.implementations.PlayerInteractFlag;
-import com.plotsquared.core.plot.flag.implementations.PreventCreativeCopyFlag;
-import com.plotsquared.core.plot.flag.implementations.PveFlag;
-import com.plotsquared.core.plot.flag.implementations.PvpFlag;
-import com.plotsquared.core.plot.flag.implementations.RedstoneFlag;
-import com.plotsquared.core.plot.flag.implementations.SnowFormFlag;
-import com.plotsquared.core.plot.flag.implementations.SnowMeltFlag;
-import com.plotsquared.core.plot.flag.implementations.SoilDryFlag;
-import com.plotsquared.core.plot.flag.implementations.TamedAttackFlag;
-import com.plotsquared.core.plot.flag.implementations.TamedInteractFlag;
-import com.plotsquared.core.plot.flag.implementations.UntrustedVisitFlag;
-import com.plotsquared.core.plot.flag.implementations.UseFlag;
-import com.plotsquared.core.plot.flag.implementations.VehicleBreakFlag;
-import com.plotsquared.core.plot.flag.implementations.VehicleCapFlag;
-import com.plotsquared.core.plot.flag.implementations.VehicleUseFlag;
-import com.plotsquared.core.plot.flag.implementations.VillagerInteractFlag;
-import com.plotsquared.core.plot.flag.implementations.VineGrowFlag;
-import com.plotsquared.core.plot.flag.types.BlockTypeWrapper;
-import com.plotsquared.core.plot.message.PlotMessage;
-import com.plotsquared.core.plot.world.PlotAreaManager;
-import com.plotsquared.core.util.EntityUtil;
-import com.plotsquared.core.util.EventDispatcher;
-import com.plotsquared.core.util.MainUtil;
-import com.plotsquared.core.util.MathMan;
-import com.plotsquared.core.util.Permissions;
-import com.plotsquared.core.util.PremiumVerification;
-import com.plotsquared.core.util.RegExUtil;
-import com.plotsquared.core.util.WorldUtil;
-import com.plotsquared.core.util.entity.EntityCategories;
-import com.plotsquared.core.util.task.TaskManager;
-import com.plotsquared.core.util.task.TaskTime;
-import com.sk89q.worldedit.WorldEdit;
-import com.sk89q.worldedit.bukkit.BukkitAdapter;
-import com.sk89q.worldedit.world.block.BlockType;
-import io.papermc.lib.PaperLib;
-import org.bukkit.Bukkit;
-import org.bukkit.ChatColor;
-import org.bukkit.FluidCollisionMode;
-import org.bukkit.GameMode;
-import org.bukkit.Material;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.command.PluginCommand;
-import org.bukkit.entity.Ageable;
-import org.bukkit.entity.ArmorStand;
-import org.bukkit.entity.Arrow;
-import org.bukkit.entity.Creature;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.entity.FallingBlock;
-import org.bukkit.entity.Fireball;
-import org.bukkit.entity.HumanEntity;
-import org.bukkit.entity.ItemFrame;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-import org.bukkit.entity.Projectile;
-import org.bukkit.entity.TNTPrimed;
-import org.bukkit.entity.Tameable;
-import org.bukkit.entity.ThrownPotion;
-import org.bukkit.entity.Vehicle;
-import org.bukkit.event.Event;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.Action;
-import org.bukkit.event.block.BlockBreakEvent;
-import org.bukkit.event.block.BlockBurnEvent;
-import org.bukkit.event.block.BlockDamageEvent;
-import org.bukkit.event.block.BlockDispenseEvent;
-import org.bukkit.event.block.BlockExplodeEvent;
-import org.bukkit.event.block.BlockFadeEvent;
-import org.bukkit.event.block.BlockFormEvent;
-import org.bukkit.event.block.BlockFromToEvent;
-import org.bukkit.event.block.BlockGrowEvent;
-import org.bukkit.event.block.BlockIgniteEvent;
-import org.bukkit.event.block.BlockPhysicsEvent;
-import org.bukkit.event.block.BlockPistonExtendEvent;
-import org.bukkit.event.block.BlockPistonRetractEvent;
-import org.bukkit.event.block.BlockPlaceEvent;
-import org.bukkit.event.block.BlockRedstoneEvent;
-import org.bukkit.event.block.BlockSpreadEvent;
-import org.bukkit.event.block.EntityBlockFormEvent;
-import org.bukkit.event.entity.CreatureSpawnEvent;
-import org.bukkit.event.entity.EntityChangeBlockEvent;
-import org.bukkit.event.entity.EntityCombustByEntityEvent;
-import org.bukkit.event.entity.EntityDamageByEntityEvent;
-import org.bukkit.event.entity.EntityDamageEvent;
-import org.bukkit.event.entity.EntityExplodeEvent;
-import org.bukkit.event.entity.EntityPickupItemEvent;
-import org.bukkit.event.entity.ExplosionPrimeEvent;
-import org.bukkit.event.entity.LingeringPotionSplashEvent;
-import org.bukkit.event.entity.PlayerDeathEvent;
-import org.bukkit.event.entity.PotionSplashEvent;
-import org.bukkit.event.entity.ProjectileHitEvent;
-import org.bukkit.event.entity.ProjectileLaunchEvent;
-import org.bukkit.event.hanging.HangingBreakByEntityEvent;
-import org.bukkit.event.hanging.HangingPlaceEvent;
-import org.bukkit.event.inventory.ClickType;
-import org.bukkit.event.inventory.InventoryClickEvent;
-import org.bukkit.event.inventory.InventoryCloseEvent;
-import org.bukkit.event.player.AsyncPlayerChatEvent;
-import org.bukkit.event.player.AsyncPlayerPreLoginEvent;
-import org.bukkit.event.player.PlayerBucketEmptyEvent;
-import org.bukkit.event.player.PlayerBucketFillEvent;
-import org.bukkit.event.player.PlayerChangedWorldEvent;
-import org.bukkit.event.player.PlayerCommandPreprocessEvent;
-import org.bukkit.event.player.PlayerDropItemEvent;
-import org.bukkit.event.player.PlayerEggThrowEvent;
-import org.bukkit.event.player.PlayerEvent;
-import org.bukkit.event.player.PlayerInteractAtEntityEvent;
-import org.bukkit.event.player.PlayerInteractEntityEvent;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerMoveEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.event.player.PlayerRespawnEvent;
-import org.bukkit.event.player.PlayerTeleportEvent;
-import org.bukkit.event.vehicle.VehicleCreateEvent;
-import org.bukkit.event.vehicle.VehicleDestroyEvent;
-import org.bukkit.event.vehicle.VehicleEntityCollisionEvent;
-import org.bukkit.event.vehicle.VehicleMoveEvent;
-import org.bukkit.event.world.StructureGrowEvent;
-import org.bukkit.help.HelpTopic;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.PlayerInventory;
-import org.bukkit.inventory.meta.ItemMeta;
-import org.bukkit.material.Directional;
-import org.bukkit.metadata.FixedMetadataValue;
-import org.bukkit.metadata.MetadataValue;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.projectiles.BlockProjectileSource;
-import org.bukkit.projectiles.ProjectileSource;
-import org.bukkit.util.Vector;
-
-import javax.annotation.Nonnull;
-import java.lang.reflect.Field;
-import java.util.ArrayList;
-import java.util.HashSet;
-import java.util.Iterator;
-import java.util.List;
-import java.util.Objects;
-import java.util.Set;
-import java.util.UUID;
-import java.util.regex.Pattern;
-
-/**
- * Player Events involving plots.
- */
-@SuppressWarnings("unused") public class PlayerEvents extends PlotListener implements Listener {
-
- public static final com.sk89q.worldedit.world.entity.EntityType FAKE_ENTITY_TYPE =
- new com.sk89q.worldedit.world.entity.EntityType("plotsquared:fake");
-
- private final PlotAreaManager plotAreaManager;
- private final EventDispatcher eventDispatcher;
- private final WorldEdit worldEdit;
-
- private boolean pistonBlocks = true;
- private float lastRadius;
- // To prevent recursion
- private boolean tmpTeleport = true;
- private Field fieldPlayer;
- private PlayerMoveEvent moveTmp;
- private String internalVersion;
-
- @Inject public PlayerEvents(@Nonnull final PlotAreaManager plotAreaManager,
- @Nonnull final EventDispatcher eventDispatcher,
- @Nonnull final WorldEdit worldEdit,
- @Nonnull final WorldUtil worldUtil) {
- super(eventDispatcher);
- this.plotAreaManager = plotAreaManager;
- this.eventDispatcher = eventDispatcher;
- this.worldEdit = worldEdit;
- try {
- fieldPlayer = PlayerEvent.class.getDeclaredField("player");
- fieldPlayer.setAccessible(true);
- } catch (NoSuchFieldException e) {
- e.printStackTrace();
- }
- }
-
- public static void sendBlockChange(final org.bukkit.Location bloc, final BlockData data) {
- TaskManager.runTaskLater(() -> {
- String world = bloc.getWorld().getName();
- int x = bloc.getBlockX();
- int z = bloc.getBlockZ();
- int distance = Bukkit.getViewDistance() * 16;
-
- for (final PlotPlayer player : PlotSquared.platform().getPlayerManager()
- .getPlayers()) {
- Location location = player.getLocation();
- if (location.getWorldName().equals(world)) {
- if (16 * Math.abs(location.getX() - x) / 16 > distance
- || 16 * Math.abs(location.getZ() - z) / 16 > distance) {
- continue;
- }
- ((BukkitPlayer) player).player.sendBlockChange(bloc, data);
- }
- }
- }, TaskTime.ticks(3L));
- }
-
- public static boolean checkEntity(Entity entity, Plot plot) {
- if (plot == null || !plot.hasOwner() || plot.getFlags().isEmpty() && plot.getArea()
- .getFlagContainer().getFlagMap().isEmpty()) {
- return false;
- }
-
- final com.sk89q.worldedit.world.entity.EntityType entityType =
- BukkitAdapter.adapt(entity.getType());
-
- if (EntityCategories.PLAYER.contains(entityType)) {
- return false;
- }
-
- if (EntityCategories.PROJECTILE.contains(entityType) || EntityCategories.OTHER
- .contains(entityType) || EntityCategories.HANGING.contains(entityType)) {
- return EntityUtil.checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED,
- MiscCapFlag.MISC_CAP_UNLIMITED);
- }
-
- // Has to go go before vehicle as horses are both
- // animals and vehicles
- if (EntityCategories.ANIMAL.contains(entityType) || EntityCategories.VILLAGER
- .contains(entityType) || EntityCategories.TAMEABLE.contains(entityType)) {
- return EntityUtil
- .checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED, MobCapFlag.MOB_CAP_UNLIMITED,
- AnimalCapFlag.ANIMAL_CAP_UNLIMITED);
- }
-
- if (EntityCategories.HOSTILE.contains(entityType)) {
- return EntityUtil
- .checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED, MobCapFlag.MOB_CAP_UNLIMITED,
- HostileCapFlag.HOSTILE_CAP_UNLIMITED);
- }
-
- if (EntityCategories.VEHICLE.contains(entityType)) {
- return EntityUtil.checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED,
- VehicleCapFlag.VEHICLE_CAP_UNLIMITED);
- }
-
- return EntityUtil.checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED);
- }
-
- @EventHandler public void onVehicleEntityCollision(VehicleEntityCollisionEvent e) {
- if (e.getVehicle().getType() == EntityType.BOAT) {
- Location location = BukkitUtil.adapt(e.getEntity().getLocation());
- if (location.isPlotArea()) {
- if (e.getEntity() instanceof Player) {
- PlotPlayer player = BukkitUtil.adapt((Player) e.getEntity());
- Plot plot = player.getCurrentPlot();
- if (plot != null) {
- if (!plot.isAdded(player.getUUID())) {
- //Here the event is only canceled if the player is not the owner
- //of the property on which he is located.
- e.setCancelled(true);
- }
- } else {
- e.setCancelled(true);
- }
- } else {
- //Here the event is cancelled too, otherwise you can move the
- //boat with EchoPets or other mobs running around on the plot.
- e.setCancelled(true);
- }
- }
- }
- }
-
- @EventHandler public void onRedstoneEvent(BlockRedstoneEvent event) {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = location.getOwnedPlot();
- if (plot == null) {
- if (area.isRoadFlags() && area.getRoadFlag(RedstoneFlag.class)) {
- event.setNewCurrent(0);
- }
- return;
- }
- if (!plot.getFlag(RedstoneFlag.class)) {
- event.setNewCurrent(0);
- plot.debug("Redstone event was cancelled because redstone = false");
- return;
- }
- if (Settings.Redstone.DISABLE_OFFLINE) {
- boolean disable = false;
- if (!plot.getOwner().equals(DBFunc.SERVER)) {
- if (plot.isMerged()) {
- disable = true;
- for (UUID owner : plot.getOwners()) {
- if (PlotSquared.platform().getPlayerManager().getPlayerIfExists(owner)
- != null) {
- disable = false;
- break;
- }
- }
- } else {
- disable = PlotSquared.platform().getPlayerManager()
- .getPlayerIfExists(plot.getOwnerAbs()) == null;
- }
- }
- if (disable) {
- for (UUID trusted : plot.getTrusted()) {
- if (PlotSquared.platform().getPlayerManager().getPlayerIfExists(trusted)
- != null) {
- disable = false;
- break;
- }
- }
- if (disable) {
- event.setNewCurrent(0);
- plot.debug(
- "Redstone event was cancelled because no trusted player was in the plot");
- return;
- }
- }
- }
- if (Settings.Redstone.DISABLE_UNOCCUPIED) {
- for (final PlotPlayer player : PlotSquared.platform().getPlayerManager()
- .getPlayers()) {
- if (plot.equals(player.getCurrentPlot())) {
- return;
- }
- }
- event.setNewCurrent(0);
- }
- }
-
- @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
- public void onPhysicsEvent(BlockPhysicsEvent event) {
- switch (event.getChangedType()) {
- case COMPARATOR: {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- if (location.isPlotArea()) {
- return;
- }
- Plot plot = location.getOwnedPlotAbs();
- if (plot == null) {
- return;
- }
- if (!plot.getFlag(RedstoneFlag.class)) {
- event.setCancelled(true);
- plot.debug("Prevented comparator update because redstone = false");
- }
- return;
- }
- case ANVIL:
- case DRAGON_EGG:
- case GRAVEL:
- case SAND:
- case TURTLE_EGG:
- case TURTLE_HELMET:
- case TURTLE_SPAWN_EGG: {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getOwnedPlotAbs(location);
- if (plot == null) {
- return;
- }
- if (plot.getFlag(DisablePhysicsFlag.class)) {
- event.setCancelled(true);
- plot.debug("Prevented block physics because disable-physics = true");
- }
- return;
- }
- default:
- if (Settings.Redstone.DETECT_INVALID_EDGE_PISTONS) {
- Block block = event.getBlock();
- switch (block.getType()) {
- case PISTON:
- case STICKY_PISTON:
- org.bukkit.block.data.Directional piston =
- (org.bukkit.block.data.Directional) block.getBlockData();
- Location location = BukkitUtil.adapt(block.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getOwnedPlotAbs(location);
- if (plot == null) {
- return;
- }
- switch (piston.getFacing()) {
- case EAST:
- location = location.add(1, 0, 0);
- break;
- case SOUTH:
- location = location.add(-1, 0, 0);
- break;
- case WEST:
- location = location.add(0, 0, 1);
- break;
- case NORTH:
- location = location.add(0, 0, -1);
- break;
- }
- Plot newPlot = area.getOwnedPlotAbs(location);
- if (!plot.equals(newPlot)) {
- event.setCancelled(true);
- plot.debug(
- "Prevented piston update because of invalid edge piston detection");
- return;
- }
- }
- }
- break;
- }
- }
-
- @EventHandler public void onProjectileLaunch(ProjectileLaunchEvent event) {
- Projectile entity = event.getEntity();
- if (!(entity instanceof ThrownPotion)) {
- return;
- }
- ProjectileSource shooter = entity.getShooter();
- if (!(shooter instanceof Player)) {
- return;
- }
- Location location = BukkitUtil.adapt(entity.getLocation());
- if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
- return;
- }
- PlotPlayer pp = BukkitUtil.adapt((Player) shooter);
- Plot plot = location.getOwnedPlot();
- if (plot != null && !plot.isAdded(pp.getUUID())) {
- entity.remove();
- event.setCancelled(true);
- }
- }
-
- @EventHandler public boolean onProjectileHit(ProjectileHitEvent event) {
- Projectile entity = event.getEntity();
- Location location = BukkitUtil.adapt(entity.getLocation());
- if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
- return true;
- }
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return true;
- }
- Plot plot = area.getPlot(location);
- ProjectileSource shooter = entity.getShooter();
- if (shooter instanceof Player) {
- PlotPlayer pp = BukkitUtil.adapt((Player) shooter);
- if (plot == null) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_PROJECTILE_UNOWNED)) {
- entity.remove();
- return false;
- }
- return true;
- }
- if (plot.isAdded(pp.getUUID()) || Permissions
- .hasPermission(pp, Captions.PERMISSION_PROJECTILE_OTHER)) {
- return true;
- }
- entity.remove();
- return false;
- }
- if (!(shooter instanceof Entity) && shooter != null) {
- if (plot == null) {
- entity.remove();
- return false;
- }
- Location sLoc =
- BukkitUtil.adapt(((BlockProjectileSource) shooter).getBlock().getLocation());
- if (!area.contains(sLoc.getX(), sLoc.getZ())) {
- entity.remove();
- return false;
- }
- Plot sPlot = area.getOwnedPlotAbs(sLoc);
- if (sPlot == null || !PlotHandler.sameOwners(plot, sPlot)) {
- entity.remove();
- return false;
- }
- }
- return true;
- }
-
- @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
- public void playerCommand(PlayerCommandPreprocessEvent event) {
- String msg = event.getMessage().toLowerCase().replaceAll("/", "").trim();
- if (msg.isEmpty()) {
- return;
- }
- Player player = event.getPlayer();
- PlotPlayer plotPlayer = BukkitUtil.adapt(player);
- Location location = plotPlayer.getLocation();
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- String[] parts = msg.split(" ");
- Plot plot = plotPlayer.getCurrentPlot();
- // Check WorldEdit
- switch (parts[0].toLowerCase()) {
- case "up":
- case "/up":
- case "worldedit:up":
- case "worldedit:/up":
- if (plot == null || (!plot.isAdded(plotPlayer.getUUID()) && !Permissions
- .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER, true))) {
- event.setCancelled(true);
- return;
- }
- }
- if (plot == null && !area.isRoadFlags()) {
- return;
- }
-
- List blockedCommands = plot != null ?
- plot.getFlag(BlockedCmdsFlag.class) :
- area.getFlag(BlockedCmdsFlag.class);
- if (!blockedCommands.isEmpty() && !Permissions
- .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_INTERACT_BLOCKED_CMDS)) {
- String part = parts[0];
- if (parts[0].contains(":")) {
- part = parts[0].split(":")[1];
- msg = msg.replace(parts[0].split(":")[0] + ':', "");
- }
- String s1 = part;
- List aliases = new ArrayList<>();
- for (HelpTopic cmdLabel : Bukkit.getServer().getHelpMap().getHelpTopics()) {
- if (part.equals(cmdLabel.getName())) {
- break;
- }
- String label = cmdLabel.getName().replaceFirst("/", "");
- if (aliases.contains(label)) {
- continue;
- }
- PluginCommand p;
- if ((p = Bukkit.getPluginCommand(label)) != null) {
- for (String a : p.getAliases()) {
- if (aliases.contains(a)) {
- continue;
- }
- aliases.add(a);
- a = a.replaceFirst("/", "");
- if (!a.equals(label) && a.equals(part)) {
- part = label;
- break;
- }
- }
- }
- }
- if (!s1.equals(part)) {
- msg = msg.replace(s1, part);
- }
- for (String s : blockedCommands) {
- Pattern pattern;
- if (!RegExUtil.compiledPatterns.containsKey(s)) {
- RegExUtil.compiledPatterns.put(s, pattern = Pattern.compile(s));
- } else {
- pattern = RegExUtil.compiledPatterns.get(s);
- }
- if (pattern.matcher(msg).matches()) {
- String perm;
- if (plot != null && plot.isAdded(plotPlayer.getUUID())) {
- perm = "plots.admin.command.blocked-cmds.shared";
- } else {
- perm = "plots.admin.command.blocked-cmds.road";
- }
- if (!Permissions.hasPermission(plotPlayer, perm)) {
- MainUtil.sendMessage(plotPlayer, Captions.COMMAND_BLOCKED);
- event.setCancelled(true);
- }
- return;
- }
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onPreLoin(final AsyncPlayerPreLoginEvent event) {
- final UUID uuid;
- if (Settings.UUID.OFFLINE) {
- if (Settings.UUID.FORCE_LOWERCASE) {
- uuid = UUID.nameUUIDFromBytes(
- ("OfflinePlayer:" + event.getName().toLowerCase()).getBytes(Charsets.UTF_8));
- } else {
- uuid = UUID.nameUUIDFromBytes(
- ("OfflinePlayer:" + event.getName()).getBytes(Charsets.UTF_8));
- }
- } else {
- uuid = event.getUniqueId();
- }
- PlotSquared.get().getImpromptuUUIDPipeline().storeImmediately(event.getName(), uuid);
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onConnect(PlayerJoinEvent event) {
- final Player player = event.getPlayer();
- PlotSquared.platform().getPlayerManager().removePlayer(player.getUniqueId());
- final PlotPlayer pp = BukkitUtil.adapt(player);
-
- Location location = pp.getLocation();
- PlotArea area = location.getPlotArea();
- if (area != null) {
- Plot plot = area.getPlot(location);
- if (plot != null) {
- plotEntry(pp, plot);
- }
- }
- // Delayed
-
- // Async
- TaskManager.runTaskLaterAsync(() -> {
- if (!player.hasPlayedBefore() && player.isOnline()) {
- player.saveData();
- }
- this.eventDispatcher.doJoinTask(pp);
- }, TaskTime.seconds(1L));
-
- if (pp.hasPermission(Captions.PERMISSION_ADMIN_UPDATE_NOTIFICATION.getTranslated())
- && Settings.Enabled_Components.UPDATE_NOTIFICATIONS && PremiumVerification.isPremium()
- && UpdateUtility.hasUpdate) {
- new PlotMessage("-----------------------------------").send(pp);
- new PlotMessage(Captions.PREFIX + "There appears to be a PlotSquared update available!")
- .color("$1").send(pp);
- new PlotMessage(
- Captions.PREFIX + "&6You are running version " + UpdateUtility.internalVersion
- .versionString() + ", &6latest version is " + UpdateUtility.spigotVersion)
- .color("$1").send(pp);
- new PlotMessage(Captions.PREFIX + "Download at:").color("$1").send(pp);
- player.sendMessage(" https://www.spigotmc.org/resources/77506/updates");
- new PlotMessage("-----------------------------------").send(pp);
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void playerRespawn(PlayerRespawnEvent event) {
- Player player = event.getPlayer();
- PlotPlayer pp = BukkitUtil.adapt(player);
- this.eventDispatcher.doRespawnTask(pp);
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onTeleport(PlayerTeleportEvent event) {
- Player player = event.getPlayer();
- BukkitPlayer pp = BukkitUtil.adapt(player);
- try (final MetaDataAccess lastPlotAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
- Plot lastPlot = lastPlotAccess.get().orElse(null);
- org.bukkit.Location to = event.getTo();
- //noinspection ConstantConditions
- if (to != null) {
- Location location = BukkitUtil.adapt(to);
- PlotArea area = location.getPlotArea();
- if (area == null) {
- if (lastPlot != null) {
- plotExit(pp, lastPlot);
- lastPlotAccess.remove();
- }
- try (final MetaDataAccess lastLocationAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
- lastLocationAccess.remove();
- }
- return;
- }
- Plot plot = area.getPlot(location);
- if (plot != null) {
- final boolean result = DenyTeleportFlag.allowsTeleport(pp, plot);
- // there is one possibility to still allow teleportation:
- // to is identical to the plot's home location, and untrusted-visit is true
- // i.e. untrusted-visit can override deny-teleport
- // this is acceptable, because otherwise it wouldn't make sense to have both flags set
- if (!result && !(plot.getFlag(UntrustedVisitFlag.class) && plot.getHomeSynchronous().equals(BukkitUtil.adaptComplete(to)))) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_ENTRY_DENIED);
- event.setCancelled(true);
- }
- }
- }
- }
- playerMove(event);
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void vehicleMove(VehicleMoveEvent event) throws IllegalAccessException {
- final org.bukkit.Location from = event.getFrom();
- final org.bukkit.Location to = event.getTo();
-
- int toX, toZ;
- if ((toX = MathMan.roundInt(to.getX())) != MathMan.roundInt(from.getX())
- | (toZ = MathMan.roundInt(to.getZ())) != MathMan.roundInt(from.getZ())) {
- Vehicle vehicle = event.getVehicle();
-
- // Check allowed
- if (!vehicle.getPassengers().isEmpty()) {
- Entity passenger = vehicle.getPassengers().get(0);
-
- if (passenger instanceof Player) {
- final Player player = (Player) passenger;
- // reset
- if (moveTmp == null) {
- moveTmp = new PlayerMoveEvent(null, from, to);
- }
- moveTmp.setFrom(from);
- moveTmp.setTo(to);
- moveTmp.setCancelled(false);
- fieldPlayer.set(moveTmp, player);
-
- List passengers = vehicle.getPassengers();
-
- this.playerMove(moveTmp);
- org.bukkit.Location dest;
- if (moveTmp.isCancelled()) {
- dest = from;
- } else if (MathMan.roundInt(moveTmp.getTo().getX()) != toX
- || MathMan.roundInt(moveTmp.getTo().getZ()) != toZ) {
- dest = to;
- } else {
- dest = null;
- }
- if (dest != null) {
- vehicle.eject();
- vehicle.setVelocity(new Vector(0d, 0d, 0d));
- PaperLib.teleportAsync(vehicle, dest);
- passengers.forEach(vehicle::addPassenger);
- return;
- }
- }
- if (Settings.Enabled_Components.KILL_ROAD_VEHICLES) {
- final com.sk89q.worldedit.world.entity.EntityType entityType =
- BukkitAdapter.adapt(vehicle.getType());
- // Horses etc are vehicles, but they're also animals
- // so this filters out all living entities
- if (EntityCategories.VEHICLE.contains(entityType) && !EntityCategories.ANIMAL
- .contains(entityType)) {
- List meta = vehicle.getMetadata("plot");
- Plot toPlot = BukkitUtil.adapt(to).getPlot();
- if (!meta.isEmpty()) {
- Plot origin = (Plot) meta.get(0).value();
- if (origin != null && !origin.getBasePlot(false).equals(toPlot)) {
- vehicle.remove();
- }
- } else if (toPlot != null) {
- vehicle.setMetadata("plot",
- new FixedMetadataValue((Plugin) PlotSquared.platform(), toPlot));
- }
- }
- }
- }
-
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void playerMove(PlayerMoveEvent event) {
- org.bukkit.Location from = event.getFrom();
- org.bukkit.Location to = event.getTo();
- int x2;
- if (MathMan.roundInt(from.getX()) != (x2 = MathMan.roundInt(to.getX()))) {
- Player player = event.getPlayer();
- BukkitPlayer pp = BukkitUtil.adapt(player);
- // Cancel teleport
- if (TaskManager.removeFromTeleportQueue(pp.getName())) {
- MainUtil.sendMessage(pp, Captions.TELEPORT_FAILED);
- }
- // Set last location
- Location location = BukkitUtil.adapt(to);
- try (final MetaDataAccess lastLocationAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
- lastLocationAccess.remove();
- }
- PlotArea area = location.getPlotArea();
- if (area == null) {
- try (final MetaDataAccess lastPlotAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
- lastPlotAccess.remove();
- }
- return;
- }
- Plot now = area.getPlot(location);
- Plot lastPlot;
- try (final MetaDataAccess lastPlotAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
- lastPlot = lastPlotAccess.get().orElse(null);
- }
- if (now == null) {
- try (final MetaDataAccess kickAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
- if (lastPlot != null && !plotExit(pp, lastPlot) && this.tmpTeleport && !kickAccess.get().orElse(false)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_EXIT_DENIED);
- this.tmpTeleport = false;
- if (lastPlot.equals(BukkitUtil.adapt(from).getPlot())) {
- player.teleport(from);
- } else {
- player.teleport(player.getWorld().getSpawnLocation());
- }
- this.tmpTeleport = true;
- event.setCancelled(true);
- return;
- }
- }
- } else if (now.equals(lastPlot)) {
- ForceFieldListener.handleForcefield(player, pp, now);
- } else if (!plotEntry(pp, now) && this.tmpTeleport) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_ENTRY_DENIED);
- this.tmpTeleport = false;
- to.setX(from.getBlockX());
- to.setY(from.getBlockY());
- to.setZ(from.getBlockZ());
- player.teleport(event.getTo());
- this.tmpTeleport = true;
- return;
- }
- int border = area.getBorder();
- if (x2 > border && this.tmpTeleport) {
- to.setX(border - 1);
- this.tmpTeleport = false;
- player.teleport(event.getTo());
- this.tmpTeleport = true;
- MainUtil.sendMessage(pp, Captions.BORDER);
- }
- if (x2 < -border && this.tmpTeleport) {
- to.setX(-border + 1);
- this.tmpTeleport = false;
- player.teleport(event.getTo());
- this.tmpTeleport = true;
- MainUtil.sendMessage(pp, Captions.BORDER);
- }
- }
- int z2;
- if (MathMan.roundInt(from.getZ()) != (z2 = MathMan.roundInt(to.getZ()))) {
- Player player = event.getPlayer();
- BukkitPlayer pp = BukkitUtil.adapt(player);
- // Cancel teleport
- if (TaskManager.removeFromTeleportQueue(pp.getName())) {
- MainUtil.sendMessage(pp, Captions.TELEPORT_FAILED);
- }
- // Set last location
- Location location = BukkitUtil.adapt(to);
- try (final MetaDataAccess lastLocationAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
- lastLocationAccess.set(location);
- }
- PlotArea area = location.getPlotArea();
- if (area == null) {
- try (final MetaDataAccess lastPlotAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
- lastPlotAccess.remove();
- }
- return;
- }
- Plot now = area.getPlot(location);
- Plot lastPlot;
- try (final MetaDataAccess lastPlotAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
- lastPlot = lastPlotAccess.get().orElse(null);
- }
- if (now == null) {
- try (final MetaDataAccess kickAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_KICK)) {
- if (lastPlot != null && !plotExit(pp, lastPlot) && this.tmpTeleport && !kickAccess.get().orElse(false)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_EXIT_DENIED);
- this.tmpTeleport = false;
- if (lastPlot.equals(BukkitUtil.adapt(from).getPlot())) {
- player.teleport(from);
- } else {
- player.teleport(player.getWorld().getSpawnLocation());
- }
- this.tmpTeleport = true;
- event.setCancelled(true);
- return;
- }
- }
- } else if (now.equals(lastPlot)) {
- ForceFieldListener.handleForcefield(player, pp, now);
- } else if (!plotEntry(pp, now) && this.tmpTeleport) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_ENTRY_DENIED);
- this.tmpTeleport = false;
- player.teleport(from);
- to.setX(from.getBlockX());
- to.setY(from.getBlockY());
- to.setZ(from.getBlockZ());
- player.teleport(event.getTo());
- this.tmpTeleport = true;
- return;
- }
- int border = area.getBorder();
- if (z2 > border && this.tmpTeleport) {
- to.setZ(border - 1);
- this.tmpTeleport = false;
- player.teleport(event.getTo());
- this.tmpTeleport = true;
- MainUtil.sendMessage(pp, Captions.BORDER);
- } else if (z2 < -border && this.tmpTeleport) {
- to.setZ(-border + 1);
- this.tmpTeleport = false;
- player.teleport(event.getTo());
- this.tmpTeleport = true;
- MainUtil.sendMessage(pp, Captions.BORDER);
- }
- }
- }
-
- @EventHandler(priority = EventPriority.LOW) public void onChat(AsyncPlayerChatEvent event) {
- if (event.isCancelled()) {
- return;
- }
-
- BukkitPlayer plotPlayer = BukkitUtil.adapt(event.getPlayer());
- Location location = plotPlayer.getLocation();
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getPlot(location);
- if (plot == null) {
- return;
- }
- if (!((plot.getFlag(ChatFlag.class) && area.isPlotChat() && plotPlayer.getAttribute("chat"))
- || area.isForcingPlotChat())) {
- return;
- }
- if (plot.isDenied(plotPlayer.getUUID()) && !Permissions
- .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_CHAT_BYPASS)) {
- return;
- }
- event.setCancelled(true);
- String message = event.getMessage();
- String format = Captions.PLOT_CHAT_FORMAT.getTranslated();
- String sender = event.getPlayer().getDisplayName();
- PlotId id = plot.getId();
- Set recipients = event.getRecipients();
- recipients.clear();
- Set spies = new HashSet<>();
- for (final PlotPlayer pp : PlotSquared.platform().getPlayerManager().getPlayers()) {
- if (pp.getAttribute("chatspy")) {
- spies.add(((BukkitPlayer) pp).player);
- } else {
- Plot current = pp.getCurrentPlot();
- if (current != null && current.getBasePlot(false).equals(plot)) {
- recipients.add(((BukkitPlayer) pp).player);
- }
- }
- }
- String partial = ChatColor.translateAlternateColorCodes('&',
- format.replace("%plot_id%", id.getX() + ";" + id.getY()).replace("%sender%", sender));
- if (plotPlayer.hasPermission("plots.chat.color")) {
- message = Captions.color(message);
- }
- String full = partial.replace("%msg%", message);
- for (Player receiver : recipients) {
- receiver.sendMessage(full);
- }
- if (!spies.isEmpty()) {
- String spyMessage = Captions.PLOT_CHAT_SPY_FORMAT.getTranslated()
- .replace("%plot_id%", id.getX() + ";" + id.getY()).replace("%sender%", sender)
- .replace("%msg%", message);
- for (Player player : spies) {
- player.sendMessage(spyMessage);
- }
- }
- // TODO: Re-implement
- // PlotSquared.debug(full);
- }
-
- @EventHandler(priority = EventPriority.LOWEST) public void blockDestroy(BlockBreakEvent event) {
- Player player = event.getPlayer();
- Location location = BukkitUtil.adapt(event.getBlock().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getPlot(location);
- if (plot != null) {
- BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
- if (event.getBlock().getY() == 0) {
- if (!Permissions
- .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_GROUNDLEVEL)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_DESTROY_GROUNDLEVEL);
- event.setCancelled(true);
- return;
- }
- } else if ((location.getY() > area.getMaxBuildHeight() || location.getY() < area
- .getMinBuildHeight()) && !Permissions
- .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {
- event.setCancelled(true);
- MainUtil.sendMessage(plotPlayer, Captions.HEIGHT_LIMIT.getTranslated()
- .replace("{limit}", String.valueOf(area.getMaxBuildHeight())));
- }
- if (!plot.hasOwner()) {
- if (!Permissions
- .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_UNOWNED, true)) {
- event.setCancelled(true);
- }
- return;
- }
- if (!plot.isAdded(plotPlayer.getUUID())) {
- List destroy = plot.getFlag(BreakFlag.class);
- Block block = event.getBlock();
- final BlockType blockType = BukkitAdapter.asBlockType(block.getType());
- for (final BlockTypeWrapper blockTypeWrapper : destroy) {
- if (blockTypeWrapper.accepts(blockType)) {
- return;
- }
- }
- if (Permissions
- .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_OTHER)) {
- return;
- }
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_DESTROY_OTHER);
- event.setCancelled(true);
- } else if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
- if (!Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- event.setCancelled(true);
- return;
- }
- }
- return;
- }
- BukkitPlayer pp = BukkitUtil.adapt(player);
- if (Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_DESTROY_ROAD)) {
- return;
- }
- if (this.worldEdit!= null && pp.getAttribute("worldedit")) {
- if (player.getInventory().getItemInMainHand().getType() == Material
- .getMaterial(this.worldEdit.getConfiguration().wandItem)) {
- return;
- }
- }
- MainUtil
- .sendMessage(pp, Captions.NO_PERMISSION_EVENT, Captions.PERMISSION_ADMIN_DESTROY_ROAD);
- event.setCancelled(true);
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBigBoom(EntityExplodeEvent event) {
- Location location = BukkitUtil.adapt(event.getLocation());
- PlotArea area = location.getPlotArea();
- boolean plotArea = location.isPlotArea();
- if (!plotArea) {
- if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
- return;
- }
- return;
- }
- Plot plot = area.getOwnedPlot(location);
- if (plot != null) {
- if (plot.getFlag(ExplosionFlag.class)) {
- List meta = event.getEntity().getMetadata("plot");
- Plot origin;
- if (meta.isEmpty()) {
- origin = plot;
- } else {
- origin = (Plot) meta.get(0).value();
- }
- if (this.lastRadius != 0) {
- List nearby = event.getEntity()
- .getNearbyEntities(this.lastRadius, this.lastRadius, this.lastRadius);
- for (Entity near : nearby) {
- if (near instanceof TNTPrimed || near.getType()
- .equals(EntityType.MINECART_TNT)) {
- if (!near.hasMetadata("plot")) {
- near.setMetadata("plot",
- new FixedMetadataValue((Plugin) PlotSquared.platform(), plot));
- }
- }
- }
- this.lastRadius = 0;
- }
- Iterator iterator = event.blockList().iterator();
- while (iterator.hasNext()) {
- Block block = iterator.next();
- location = BukkitUtil.adapt(block.getLocation());
- if (!area.contains(location.getX(), location.getZ()) || !origin
- .equals(area.getOwnedPlot(location))) {
- iterator.remove();
- }
- }
- return;
- } else {
- plot.debug("Explosion was cancelled because explosion = false");
- }
- }
- event.setCancelled(true);
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onWorldChanged(PlayerChangedWorldEvent event) {
- Player player = event.getPlayer();
- BukkitPlayer pp = BukkitUtil.adapt(player);
- // Delete last location
- Plot plot;
- try (final MetaDataAccess lastPlotAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LAST_PLOT)) {
- plot = lastPlotAccess.remove();
- }
- try (final MetaDataAccess lastLocationAccess =
- pp.accessTemporaryMetaData(PlayerMetaDataKeys.TEMPORARY_LOCATION)) {
- lastLocationAccess.remove();
- }
- if (plot != null) {
- plotExit(pp, plot);
- }
- if (this.worldEdit != null) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_WORLDEDIT_BYPASS)) {
- if (pp.getAttribute("worldedit")) {
- pp.removeAttribute("worldedit");
- }
- }
- }
- Location location = pp.getLocation();
- PlotArea area = location.getPlotArea();
- if (location.isPlotArea()) {
- plot = location.getPlot();
- if (plot != null) {
- plotEntry(pp, plot);
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onPeskyMobsChangeTheWorldLikeWTFEvent(EntityChangeBlockEvent event) {
- Entity e = event.getEntity();
- if (!(e instanceof FallingBlock)) {
- Location location = BukkitUtil.adapt(event.getBlock().getLocation());
- PlotArea area = location.getPlotArea();
- if (area != null) {
- Plot plot = area.getOwnedPlot(location);
- if (plot != null && plot.getFlag(MobPlaceFlag.class)) {
- plot.debug(e.getType() + " could not change block because mob-place = false");
- return;
- }
- event.setCancelled(true);
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onEntityBlockForm(EntityBlockFormEvent event) {
- String world = event.getBlock().getWorld().getName();
- if (!this.plotAreaManager.hasPlotArea(world)) {
- return;
- }
- Location location = BukkitUtil.adapt(event.getBlock().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getOwnedPlot(location);
- if (plot == null) {
- event.setCancelled(true);
- return;
- }
- Entity entity = event.getEntity();
- if (entity instanceof Player) {
- Player player = (Player) entity;
- if (!plot.hasOwner()) {
- BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
- if (plot.getFlag(IceFormFlag.class)) {
- plot.debug("Ice could not be formed because ice-form = false");
- return;
- }
- event.setCancelled(true);
- return;
- }
- BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
- if (!plot.isAdded(plotPlayer.getUUID())) {
- if (plot.getFlag(IceFormFlag.class)) {
- plot.debug("Ice could not be formed because ice-form = false");
- return;
- }
- event.setCancelled(true);
- return;
- }
- return;
- }
- if (!plot.getFlag(IceFormFlag.class)) {
- event.setCancelled(true);
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBlockSpread(BlockSpreadEvent event) {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- if (location.isPlotRoad()) {
- event.setCancelled(true);
- return;
- }
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getOwnedPlot(location);
- if (plot == null) {
- return;
- }
- switch (event.getSource().getType()) {
- case GRASS_BLOCK:
- if (!plot.getFlag(GrassGrowFlag.class)) {
- plot.debug("Grass could not grow because grass-grow = false");
- event.setCancelled(true);
- }
- break;
- case MYCELIUM:
- if (!plot.getFlag(MycelGrowFlag.class)) {
- plot.debug("Mycelium could not grow because mycel-grow = false");
- event.setCancelled(true);
- }
- break;
- case VINE:
- if (!plot.getFlag(VineGrowFlag.class)) {
- plot.debug("Vine could not grow because vine-grow = false");
- event.setCancelled(true);
- }
- break;
- case KELP:
- if (!plot.getFlag(KelpGrowFlag.class)) {
- plot.debug("Kelp could not grow because kelp-grow = false");
- event.setCancelled(true);
- }
- break;
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBlockForm(BlockFormEvent event) {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- if (location.isPlotRoad()) {
- event.setCancelled(true);
- return;
- }
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getOwnedPlot(location);
- if (plot == null) {
- return;
- }
- switch (event.getNewState().getType()) {
- case SNOW:
- case SNOW_BLOCK:
- if (!plot.getFlag(SnowFormFlag.class)) {
- plot.debug("Snow could not form because snow-form = false");
- event.setCancelled(true);
- }
- return;
- case ICE:
- case FROSTED_ICE:
- case PACKED_ICE:
- if (!plot.getFlag(IceFormFlag.class)) {
- plot.debug("Ice could not form because ice-form = false");
- event.setCancelled(true);
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBlockDamage(BlockDamageEvent event) {
- Player player = event.getPlayer();
- Location location = BukkitUtil.adapt(event.getBlock().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- if (player.getGameMode() != GameMode.SURVIVAL) {
- return;
- }
- Plot plot = area.getPlot(location);
- if (plot != null) {
- if (plot.getFlag(InstabreakFlag.class)) {
- Block block = event.getBlock();
- BlockBreakEvent call = new BlockBreakEvent(block, player);
- Bukkit.getServer().getPluginManager().callEvent(call);
- if (!call.isCancelled()) {
- event.getBlock().breakNaturally();
- }
- }
- if (location.getY() == 0) {
- event.setCancelled(true);
- return;
- }
- if (!plot.hasOwner()) {
- BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
- if (Permissions
- .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_UNOWNED)) {
- return;
- }
- event.setCancelled(true);
- return;
- }
- BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
- if (!plot.isAdded(plotPlayer.getUUID())) {
- List destroy = plot.getFlag(BreakFlag.class);
- Block block = event.getBlock();
- if (destroy
- .contains(BlockTypeWrapper.get(BukkitAdapter.asBlockType(block.getType())))
- || Permissions
- .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_OTHER)) {
- return;
- }
- plot.debug(player.getName() + " could not break " + block.getType()
- + " because it was not in the break flag");
- event.setCancelled(true);
- return;
- }
- return;
- }
- BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
- if (Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_DESTROY_ROAD)) {
- return;
- }
- event.setCancelled(true);
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onFade(BlockFadeEvent event) {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getOwnedPlot(location);
- if (plot == null) {
- event.setCancelled(true);
- return;
- }
- switch (block.getType()) {
- case ICE:
- if (!plot.getFlag(IceMeltFlag.class)) {
- plot.debug("Ice could not melt because ice-melt = false");
- event.setCancelled(true);
- }
- break;
- case SNOW:
- if (!plot.getFlag(SnowMeltFlag.class)) {
- plot.debug("Snow could not melt because snow-melt = false");
- event.setCancelled(true);
- }
- break;
- case FARMLAND:
- if (!plot.getFlag(SoilDryFlag.class)) {
- plot.debug("Soil could not dry because soil-dry = false");
- event.setCancelled(true);
- }
- break;
- case TUBE_CORAL_BLOCK:
- case BRAIN_CORAL_BLOCK:
- case BUBBLE_CORAL_BLOCK:
- case FIRE_CORAL_BLOCK:
- case HORN_CORAL_BLOCK:
- case TUBE_CORAL:
- case BRAIN_CORAL:
- case BUBBLE_CORAL:
- case FIRE_CORAL:
- case HORN_CORAL:
- case TUBE_CORAL_FAN:
- case BRAIN_CORAL_FAN:
- case BUBBLE_CORAL_FAN:
- case FIRE_CORAL_FAN:
- case HORN_CORAL_FAN:
- case BRAIN_CORAL_WALL_FAN:
- case BUBBLE_CORAL_WALL_FAN:
- case FIRE_CORAL_WALL_FAN:
- case HORN_CORAL_WALL_FAN:
- case TUBE_CORAL_WALL_FAN:
- if (!plot.getFlag(CoralDryFlag.class)) {
- plot.debug("Coral could not dry because coral-dry = false");
- event.setCancelled(true);
- }
- break;
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onChange(BlockFromToEvent event) {
- Block from = event.getBlock();
-
- // Check liquid flow flag inside of origin plot too
- final Location fLocation = BukkitUtil.adapt(from.getLocation());
- final PlotArea fromArea = fLocation.getPlotArea();
- if (fromArea != null) {
- final Plot plot = fromArea.getOwnedPlot(fLocation);
- if (plot != null
- && plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event
- .getBlock().isLiquid()) {
- plot.debug("Liquid could now flow because liquid-flow = disabled");
- event.setCancelled(true);
- return;
- }
- }
-
- Block to = event.getToBlock();
- Location tLocation = BukkitUtil.adapt(to.getLocation());
- PlotArea area = tLocation.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getOwnedPlot(tLocation);
- if (plot != null) {
- if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects
- .equals(plot, area.getOwnedPlot(fLocation))) {
- event.setCancelled(true);
- return;
- }
- if (plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.ENABLED && event
- .getBlock().isLiquid()) {
- return;
- }
- if (plot.getFlag(DisablePhysicsFlag.class)) {
- plot.debug(event.getBlock().getType()
- + " could not update because disable-physics = true");
- event.setCancelled(true);
- return;
- }
- if (plot.getFlag(LiquidFlowFlag.class) == LiquidFlowFlag.FlowStatus.DISABLED && event
- .getBlock().isLiquid()) {
- plot.debug("Liquid could not flow because liquid-flow = disabled");
- event.setCancelled(true);
- }
- } else if (!area.contains(fLocation.getX(), fLocation.getZ()) || !Objects
- .equals(null, area.getOwnedPlot(fLocation))) {
- event.setCancelled(true);
- } else if (event.getBlock().isLiquid()) {
- final org.bukkit.Location location = event.getBlock().getLocation();
-
- /*
- X = block location
- A-H = potential plot locations
-
- Z
- ^
- | A B C
- o D X E
- | F G H
- v
- <-----O-----> x
- */
- if (BukkitUtil.adapt(location.clone().add(-1, 0, 1) /* A */).getPlot() != null
- || BukkitUtil.adapt(location.clone().add(1, 0, 0) /* B */).getPlot() != null
- || BukkitUtil.adapt(location.clone().add(1, 0, 1) /* C */).getPlot() != null
- || BukkitUtil.adapt(location.clone().add(-1, 0, 0) /* D */).getPlot() != null
- || BukkitUtil.adapt(location.clone().add(1, 0, 0) /* E */).getPlot() != null
- || BukkitUtil.adapt(location.clone().add(-1, 0, -1) /* F */).getPlot() != null
- || BukkitUtil.adapt(location.clone().add(0, 0, -1) /* G */).getPlot() != null
- || BukkitUtil.adapt(location.clone().add(1, 0, 1) /* H */).getPlot() != null) {
- event.setCancelled(true);
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onGrow(BlockGrowEvent event) {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- if (location.isUnownedPlotArea()) {
- event.setCancelled(true);
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBlockPistonExtend(BlockPistonExtendEvent event) {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- BlockFace face = event.getDirection();
- Vector relative = new Vector(face.getModX(), face.getModY(), face.getModZ());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
- return;
- }
- for (Block block1 : event.getBlocks()) {
- Location bloc = BukkitUtil.adapt(block1.getLocation());
- if (bloc.isPlotArea() || bloc
- .add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ())
- .isPlotArea()) {
- event.setCancelled(true);
- return;
- }
- }
- if (location.add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ())
- .isPlotArea()) {
- // Prevent pistons from extending if they are: bordering a plot
- // area, facing inside plot area, and not pushing any blocks
- event.setCancelled(true);
- }
- return;
- }
- Plot plot = area.getOwnedPlot(location);
- if (plot == null) {
- event.setCancelled(true);
- return;
- }
- for (Block block1 : event.getBlocks()) {
- Location bloc = BukkitUtil.adapt(block1.getLocation());
- if (!area.contains(bloc.getX(), bloc.getZ()) || !area
- .contains(bloc.getX() + relative.getBlockX(), bloc.getZ() + relative.getBlockZ())) {
- event.setCancelled(true);
- return;
- }
- if (!plot.equals(area.getOwnedPlot(bloc)) || !plot.equals(area.getOwnedPlot(
- bloc.add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ())))) {
- event.setCancelled(true);
- return;
- }
- }
- if (!plot.equals(area.getOwnedPlot(
- location.add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ())))) {
- // This branch is only necessary to prevent pistons from extending
- // if they are: on a plot edge, facing outside the plot, and not
- // pushing any blocks
- event.setCancelled(true);
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBlockPistonRetract(BlockPistonRetractEvent event) {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- BlockFace face = event.getDirection();
- Vector relative = new Vector(face.getModX(), face.getModY(), face.getModZ());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
- return;
- }
- for (Block block1 : event.getBlocks()) {
- Location bloc = BukkitUtil.adapt(block1.getLocation());
- if (bloc.isPlotArea() || bloc
- .add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ())
- .isPlotArea()) {
- event.setCancelled(true);
- return;
- }
- }
- return;
- }
- Plot plot = area.getOwnedPlot(location);
- if (plot == null) {
- event.setCancelled(true);
- return;
- }
- for (Block block1 : event.getBlocks()) {
- Location bloc = BukkitUtil.adapt(block1.getLocation());
- if (!area.contains(bloc.getX(), bloc.getZ()) || !area
- .contains(bloc.getX() + relative.getBlockX(), bloc.getZ() + relative.getBlockZ())) {
- event.setCancelled(true);
- return;
- }
- if (!plot.equals(area.getOwnedPlot(bloc)) || !plot.equals(area.getOwnedPlot(
- bloc.add(relative.getBlockX(), relative.getBlockY(), relative.getBlockZ())))) {
- event.setCancelled(true);
- return;
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBlockDispense(BlockDispenseEvent event) {
- Material type = event.getItem().getType();
- switch (type) {
- case SHULKER_BOX:
- case WHITE_SHULKER_BOX:
- case ORANGE_SHULKER_BOX:
- case MAGENTA_SHULKER_BOX:
- case LIGHT_BLUE_SHULKER_BOX:
- case YELLOW_SHULKER_BOX:
- case LIME_SHULKER_BOX:
- case PINK_SHULKER_BOX:
- case GRAY_SHULKER_BOX:
- case LIGHT_GRAY_SHULKER_BOX:
- case CYAN_SHULKER_BOX:
- case PURPLE_SHULKER_BOX:
- case BLUE_SHULKER_BOX:
- case BROWN_SHULKER_BOX:
- case GREEN_SHULKER_BOX:
- case RED_SHULKER_BOX:
- case BLACK_SHULKER_BOX:
- case CARVED_PUMPKIN:
- case WITHER_SKELETON_SKULL:
- case FLINT_AND_STEEL:
- case BONE_MEAL:
- case SHEARS:
- case GLASS_BOTTLE:
- case GLOWSTONE:
- case COD_BUCKET:
- case PUFFERFISH_BUCKET:
- case SALMON_BUCKET:
- case TROPICAL_FISH_BUCKET:
- case BUCKET:
- case WATER_BUCKET:
- case LAVA_BUCKET: {
- if (event.getBlock().getType() == Material.DROPPER) {
- return;
- }
- BlockFace targetFace =
- ((Directional) event.getBlock().getState().getData()).getFacing();
- Location location =
- BukkitUtil.adapt(event.getBlock().getRelative(targetFace).getLocation());
- if (location.isPlotRoad()) {
- event.setCancelled(true);
- }
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onStructureGrow(StructureGrowEvent event) {
- if (!this.plotAreaManager.hasPlotArea(event.getWorld().getName())) {
- return;
- }
- List blocks = event.getBlocks();
- if (blocks.isEmpty()) {
- return;
- }
- Location location = BukkitUtil.adapt(blocks.get(0).getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- for (int i = blocks.size() - 1; i >= 0; i--) {
- location = BukkitUtil.adapt(blocks.get(i).getLocation());
- if (location.isPlotArea()) {
- blocks.remove(i);
- }
- }
- return;
- } else {
- Plot origin = area.getOwnedPlot(location);
- if (origin == null) {
- event.setCancelled(true);
- return;
- }
- for (int i = blocks.size() - 1; i >= 0; i--) {
- location = BukkitUtil.adapt(blocks.get(i).getLocation());
- if (!area.contains(location.getX(), location.getZ())) {
- blocks.remove(i);
- continue;
- }
- Plot plot = area.getOwnedPlot(location);
- if (!Objects.equals(plot, origin)) {
- event.getBlocks().remove(i);
- }
- }
- }
- Plot origin = area.getPlot(location);
- if (origin == null) {
- event.setCancelled(true);
- return;
- }
- for (int i = blocks.size() - 1; i >= 0; i--) {
- location = BukkitUtil.adapt(blocks.get(i).getLocation());
- Plot plot = area.getOwnedPlot(location);
- /*
- * plot → the base plot of the merged area
- * origin → the plot where the event gets called
- */
-
- // Are plot and origin different AND are both plots merged
- if (!Objects.equals(plot, origin) && (!plot.isMerged() && !origin.isMerged())) {
- event.getBlocks().remove(i);
- }
- }
- }
-
- @SuppressWarnings("deprecation")
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onInventoryClick(InventoryClickEvent event) {
- /*if (!event.isLeftClick() || (event.getAction() != InventoryAction.PLACE_ALL) || event
- .isShiftClick()) {
- return;
- }*/
- HumanEntity entity = event.getWhoClicked();
- if (!(entity instanceof Player) || !this.plotAreaManager
- .hasPlotArea(entity.getWorld().getName())) {
- return;
- }
-
- HumanEntity clicker = event.getWhoClicked();
- if (!(clicker instanceof Player)) {
- return;
- }
- Player player = (Player) clicker;
- BukkitPlayer pp = BukkitUtil.adapt(player);
- final PlotInventory inventory = PlotInventory.getOpenPlotInventory(pp);
- if (inventory != null && event.getRawSlot() == event.getSlot()) {
- if (!inventory.onClick(event.getSlot())) {
- event.setResult(Event.Result.DENY);
- event.setCancelled(true);
- inventory.close();
- }
- }
- PlayerInventory inv = player.getInventory();
- int slot = inv.getHeldItemSlot();
- if ((slot > 8) || !event.getEventName().equals("InventoryCreativeEvent")) {
- return;
- }
- ItemStack current = inv.getItemInHand();
- ItemStack newItem = event.getCursor();
- ItemMeta newMeta = newItem.getItemMeta();
- ItemMeta oldMeta = newItem.getItemMeta();
-
- if (event.getClick() == ClickType.CREATIVE) {
- final Plot plot = pp.getCurrentPlot();
- if (plot != null) {
- if (plot.getFlag(PreventCreativeCopyFlag.class) && !plot
- .isAdded(player.getUniqueId()) && !Permissions
- .hasPermission(pp, Captions.PERMISSION_ADMIN_INTERACT_OTHER)) {
- final ItemStack newStack =
- new ItemStack(newItem.getType(), newItem.getAmount());
- event.setCursor(newStack);
- plot.debug(player.getName()
- + " could not creative-copy an item because prevent-creative-copy = true");
- }
- } else {
- PlotArea area = pp.getPlotAreaAbs();
- if (area != null && area.isRoadFlags() && area
- .getRoadFlag(PreventCreativeCopyFlag.class)) {
- final ItemStack newStack =
- new ItemStack(newItem.getType(), newItem.getAmount());
- event.setCursor(newStack);
- }
- }
- return;
- }
-
- String newLore = "";
- if (newMeta != null) {
- List lore = newMeta.getLore();
- if (lore != null) {
- newLore = lore.toString();
- }
- }
- String oldLore = "";
- if (oldMeta != null) {
- List lore = oldMeta.getLore();
- if (lore != null) {
- oldLore = lore.toString();
- }
- }
- if (!"[(+NBT)]".equals(newLore) || (current.equals(newItem) && newLore.equals(oldLore))) {
- switch (newItem.getType()) {
- case LEGACY_BANNER:
- case PLAYER_HEAD:
- if (newMeta != null) {
- break;
- }
- default:
- return;
- }
- }
- Block block = player.getTargetBlock(null, 7);
- org.bukkit.block.BlockState state = block.getState();
- Material stateType = state.getType();
- Material itemType = newItem.getType();
- if (stateType != itemType) {
- switch (stateType) {
- case LEGACY_STANDING_BANNER:
- case LEGACY_WALL_BANNER:
- if (itemType == Material.LEGACY_BANNER) {
- break;
- }
- case LEGACY_SKULL:
- if (itemType == Material.LEGACY_SKULL_ITEM) {
- break;
- }
- default:
- return;
- }
- }
- Location location = BukkitUtil.adapt(state.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getPlotAbs(location);
- boolean cancelled = false;
- if (plot == null) {
- if (!Permissions.hasPermission(pp, "plots.admin.interact.road")) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.interact.road");
- cancelled = true;
- }
- } else if (!plot.hasOwner()) {
- if (!Permissions.hasPermission(pp, "plots.admin.interact.unowned")) {
- MainUtil
- .sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.interact.unowned");
- cancelled = true;
- }
- } else {
- UUID uuid = pp.getUUID();
- if (!plot.isAdded(uuid)) {
- if (!Permissions.hasPermission(pp, "plots.admin.interact.other")) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- "plots.admin.interact.other");
- cancelled = true;
- }
- }
- }
- if (cancelled) {
- if ((current.getType() == newItem.getType()) && (current.getDurability() == newItem
- .getDurability())) {
- event.setCursor(
- new ItemStack(newItem.getType(), newItem.getAmount(), newItem.getDurability()));
- event.setCancelled(true);
- return;
- }
- event.setCursor(
- new ItemStack(newItem.getType(), newItem.getAmount(), newItem.getDurability()));
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onPotionSplash(LingeringPotionSplashEvent event) {
- Projectile entity = event.getEntity();
- Location location = BukkitUtil.adapt(entity.getLocation());
- if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
- return;
- }
- if (!this.onProjectileHit(event)) {
- event.setCancelled(true);
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onInteract(PlayerInteractAtEntityEvent e) {
- Entity entity = e.getRightClicked();
- if (!(entity instanceof ArmorStand) && !(entity instanceof ItemFrame)) {
- return;
- }
- Location location = BukkitUtil.adapt(e.getRightClicked().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- EntitySpawnListener.testNether(entity);
- Plot plot = location.getPlotAbs();
- BukkitPlayer pp = BukkitUtil.adapt(e.getPlayer());
- if (plot == null) {
- if (!area.isRoadFlags() && !area.getRoadFlag(MiscInteractFlag.class) && !Permissions
- .hasPermission(pp, "plots.admin.interact.road")) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT, "plots.admin.interact.road");
- e.setCancelled(true);
- }
- } else {
- if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- e.setCancelled(true);
- return;
- }
- }
- if (!plot.hasOwner()) {
- if (!Permissions.hasPermission(pp, "plots.admin.interact.unowned")) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- "plots.admin.interact.unowned");
- e.setCancelled(true);
- }
- } else {
- UUID uuid = pp.getUUID();
- if (plot.isAdded(uuid)) {
- return;
- }
- if (plot.getFlag(MiscInteractFlag.class)) {
- return;
- }
- if (!Permissions.hasPermission(pp, "plots.admin.interact.other")) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- "plots.admin.interact.other");
- e.setCancelled(true);
- plot.debug(pp.getName() + " could not interact with " + entity.getType()
- + " bcause misc-interact = false");
- }
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBigBoom(BlockExplodeEvent event) {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- String world = location.getWorldName();
- if (!this.plotAreaManager.hasPlotArea(world)) {
- return;
- }
- PlotArea area = location.getPlotArea();
- if (area == null) {
- Iterator iterator = event.blockList().iterator();
- while (iterator.hasNext()) {
- location = BukkitUtil.adapt(iterator.next().getLocation());
- if (location.isPlotArea()) {
- iterator.remove();
- }
- }
- return;
- }
- Plot plot = area.getOwnedPlot(location);
- if (plot == null || !plot.getFlag(ExplosionFlag.class)) {
- event.setCancelled(true);
- if (plot != null) {
- plot.debug("Explosion was cancelled because explosion = false");
- }
- }
- event.blockList().removeIf(
- blox -> !plot.equals(area.getOwnedPlot(BukkitUtil.adapt(blox.getLocation()))));
- }
-
- @EventHandler(priority = EventPriority.LOW)
- public void onCancelledInteract(PlayerInteractEvent event) {
- if (event.isCancelled() && event.getAction() == Action.RIGHT_CLICK_AIR) {
- Player player = event.getPlayer();
- BukkitPlayer pp = BukkitUtil.adapt(player);
- PlotArea area = pp.getPlotAreaAbs();
- if (area == null) {
- return;
- }
- if (event.getAction() == Action.RIGHT_CLICK_AIR) {
- Material item = event.getMaterial();
- if (item.toString().toLowerCase().endsWith("_egg")) {
- event.setCancelled(true);
- event.setUseItemInHand(Event.Result.DENY);
- }
- }
- ItemStack hand = player.getInventory().getItemInMainHand();
- ItemStack offHand = player.getInventory().getItemInOffHand();
- Material type = hand.getType();
- Material offType = offHand.getType();
- if (type == Material.AIR) {
- type = offType;
- }
- if (type.toString().toLowerCase().endsWith("_egg")) {
- Block block = player.getTargetBlockExact(5, FluidCollisionMode.SOURCE_ONLY);
- if (block != null && block.getType() != Material.AIR) {
- Location location = BukkitUtil.adapt(block.getLocation());
- if (!this.eventDispatcher
- .checkPlayerBlockEvent(pp, PlayerBlockEventType.SPAWN_MOB, location, null,
- true)) {
- event.setCancelled(true);
- event.setUseItemInHand(Event.Result.DENY);
- }
- }
- }
- }
- }
-
- @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true)
- public void onInteract(PlayerInteractEvent event) {
- Player player = event.getPlayer();
- BukkitPlayer pp = BukkitUtil.adapt(player);
- PlotArea area = pp.getPlotAreaAbs();
- if (area == null) {
- return;
- }
- PlayerBlockEventType eventType = null;
- BlockType blocktype1;
- Block block = event.getClickedBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- Action action = event.getAction();
- outer:
- switch (action) {
- case PHYSICAL: {
- eventType = PlayerBlockEventType.TRIGGER_PHYSICAL;
- blocktype1 = BukkitAdapter.asBlockType(block.getType());
- break;
- }
- //todo rearrange the right click code. it is all over the place.
- case RIGHT_CLICK_BLOCK: {
- Material blockType = block.getType();
- eventType = PlayerBlockEventType.INTERACT_BLOCK;
- blocktype1 = BukkitAdapter.asBlockType(block.getType());
-
- if (blockType.isInteractable()) {
- if (!player.isSneaking()) {
- break;
- }
- ItemStack hand = player.getInventory().getItemInMainHand();
- ItemStack offHand = player.getInventory().getItemInOffHand();
-
- // sneaking players interact with blocks if both hands are empty
- if (hand.getType() == Material.AIR && offHand.getType() == Material.AIR) {
- break;
- }
- }
-
- Material type = event.getMaterial();
-
- // in the following, lb needs to have the material of the item in hand i.e. type
- switch (type) {
- case REDSTONE:
- case STRING:
- case PUMPKIN_SEEDS:
- case MELON_SEEDS:
- case COCOA_BEANS:
- case WHEAT_SEEDS:
- case BEETROOT_SEEDS:
- case SWEET_BERRIES:
- return;
- default:
- //eventType = PlayerBlockEventType.PLACE_BLOCK;
- if (type.isBlock()) {
- return;
- }
- }
- if (PaperLib.isPaper()) {
- if (MaterialTags.SPAWN_EGGS.isTagged(type) || Material.EGG.equals(type)) {
- eventType = PlayerBlockEventType.SPAWN_MOB;
- break outer;
- }
- } else {
- if (type.toString().toLowerCase().endsWith("egg")) {
- eventType = PlayerBlockEventType.SPAWN_MOB;
- break outer;
- }
- }
- if (type.isEdible()) {
- //Allow all players to eat while also allowing the block place event ot be fired
- return;
- }
- switch (type) {
- case ACACIA_BOAT:
- case BIRCH_BOAT:
- case CHEST_MINECART:
- case COMMAND_BLOCK_MINECART:
- case DARK_OAK_BOAT:
- case FURNACE_MINECART:
- case HOPPER_MINECART:
- case JUNGLE_BOAT:
- case MINECART:
- case OAK_BOAT:
- case SPRUCE_BOAT:
- case TNT_MINECART:
- eventType = PlayerBlockEventType.PLACE_VEHICLE;
- break outer;
- case FIREWORK_ROCKET:
- case FIREWORK_STAR:
- eventType = PlayerBlockEventType.SPAWN_MOB;
- break outer;
- case BOOK:
- case KNOWLEDGE_BOOK:
- case WRITABLE_BOOK:
- case WRITTEN_BOOK:
- eventType = PlayerBlockEventType.READ;
- break outer;
- case ARMOR_STAND:
- location = BukkitUtil
- .adapt(block.getRelative(event.getBlockFace()).getLocation());
- eventType = PlayerBlockEventType.PLACE_MISC;
- break outer;
- }
- break;
- }
- case LEFT_CLICK_BLOCK: {
- location = BukkitUtil.adapt(block.getLocation());
- //eventType = PlayerBlockEventType.BREAK_BLOCK;
- blocktype1 = BukkitAdapter.asBlockType(block.getType());
- if (block.getType() == Material.DRAGON_EGG) {
- eventType = PlayerBlockEventType.TELEPORT_OBJECT;
- break;
- }
-
- return;
- }
- default:
- return;
- }
- if (this.worldEdit != null && pp.getAttribute("worldedit")) {
- if (event.getMaterial() == Material
- .getMaterial(this.worldEdit.getConfiguration().wandItem)) {
- return;
- }
- }
- if (!this.eventDispatcher
- .checkPlayerBlockEvent(pp, eventType, location, blocktype1, true)) {
- event.setCancelled(true);
- event.setUseInteractedBlock(Event.Result.DENY);
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void creatureSpawnEvent(CreatureSpawnEvent event) {
- Entity entity = event.getEntity();
- Location location = BukkitUtil.adapt(entity.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- CreatureSpawnEvent.SpawnReason reason = event.getSpawnReason();
- switch (reason.toString()) {
- case "DISPENSE_EGG":
- case "EGG":
- case "OCELOT_BABY":
- case "SPAWNER_EGG":
- if (!area.isSpawnEggs()) {
- event.setCancelled(true);
- return;
- }
- break;
- case "REINFORCEMENTS":
- case "NATURAL":
- case "MOUNT":
- case "PATROL":
- case "RAID":
- case "SHEARED":
- case "SHOULDER_ENTITY":
- case "SILVERFISH_BLOCK":
- case "TRAP":
- case "VILLAGE_DEFENSE":
- case "VILLAGE_INVASION":
- case "BEEHIVE":
- case "CHUNK_GEN":
- if (!area.isMobSpawning()) {
- event.setCancelled(true);
- return;
- }
- case "BREEDING":
- if (!area.isSpawnBreeding()) {
- event.setCancelled(true);
- return;
- }
- break;
- case "BUILD_IRONGOLEM":
- case "BUILD_SNOWMAN":
- case "BUILD_WITHER":
- case "CUSTOM":
- if (!area.isSpawnCustom() && entity.getType() != EntityType.ARMOR_STAND) {
- event.setCancelled(true);
- return;
- }
- break;
- case "SPAWNER":
- if (!area.isMobSpawnerSpawning()) {
- event.setCancelled(true);
- return;
- }
- break;
- }
- Plot plot = area.getOwnedPlotAbs(location);
- if (plot == null) {
- if (!area.isMobSpawning()) {
- event.setCancelled(true);
- }
- return;
- }
- if (checkEntity(entity, plot)) {
- event.setCancelled(true);
- }
- }
-
- @EventHandler(ignoreCancelled = true, priority = EventPriority.HIGHEST)
- public void onEntityFall(EntityChangeBlockEvent event) {
- if (event.getEntityType() != EntityType.FALLING_BLOCK) {
- return;
- }
- Block block = event.getBlock();
- World world = block.getWorld();
- String worldName = world.getName();
- if (!this.plotAreaManager.hasPlotArea(worldName)) {
- return;
- }
- Location location = BukkitUtil.adapt(block.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getOwnedPlotAbs(location);
- if (plot == null || plot.getFlag(DisablePhysicsFlag.class)) {
- event.setCancelled(true);
- plot.debug("Falling block event was cancelled because disable-physics = true");
- return;
- }
- if (event.getTo().hasGravity()) {
- Entity entity = event.getEntity();
- List meta = entity.getMetadata("plot");
- if (meta.isEmpty()) {
- return;
- }
- Plot origin = (Plot) meta.get(0).value();
- if (origin != null && !origin.equals(plot)) {
- event.setCancelled(true);
- entity.remove();
- }
- } else if (event.getTo() == Material.AIR) {
- event.getEntity()
- .setMetadata("plot", new FixedMetadataValue((Plugin) PlotSquared.platform(), plot));
- }
- }
-
- @EventHandler public void onPrime(ExplosionPrimeEvent event) {
- this.lastRadius = event.getRadius() + 1;
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBlockBurn(BlockBurnEvent event) {
- Block block = event.getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
-
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
-
- Plot plot = location.getOwnedPlot();
- if (plot == null || !plot.getFlag(BlockBurnFlag.class)) {
- if (plot != null) {
- plot.debug("Block burning was cancelled because block-burn = false");
- }
- event.setCancelled(true);
- }
-
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBlockIgnite(BlockIgniteEvent event) {
- Player player = event.getPlayer();
- Entity ignitingEntity = event.getIgnitingEntity();
- Block block = event.getBlock();
- BlockIgniteEvent.IgniteCause igniteCause = event.getCause();
- Location location1 = BukkitUtil.adapt(block.getLocation());
- PlotArea area = location1.getPlotArea();
- if (area == null) {
- return;
- }
- if (igniteCause == BlockIgniteEvent.IgniteCause.LIGHTNING) {
- event.setCancelled(true);
- return;
- }
-
- Plot plot = area.getOwnedPlot(location1);
- if (player != null) {
- BukkitPlayer pp = BukkitUtil.adapt(player);
- if (plot == null) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_ROAD)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_ROAD);
- event.setCancelled(true);
- }
- } else if (!plot.hasOwner()) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_UNOWNED)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_UNOWNED);
- event.setCancelled(true);
- }
- } else if (!plot.isAdded(pp.getUUID())) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- event.setCancelled(true);
- }
- } else if (!plot.getFlag(BlockIgnitionFlag.class)) {
- event.setCancelled(true);
- }
- } else {
- if (plot == null) {
- event.setCancelled(true);
- return;
- }
- if (ignitingEntity != null) {
- if (!plot.getFlag(BlockIgnitionFlag.class)) {
- event.setCancelled(true);
- plot.debug("Block ignition was cancelled because block-ignition = false");
- return;
- }
- if (igniteCause == BlockIgniteEvent.IgniteCause.FIREBALL) {
- if (ignitingEntity instanceof Fireball) {
- Projectile fireball = (Projectile) ignitingEntity;
- Location location = null;
- if (fireball.getShooter() instanceof Entity) {
- Entity shooter = (Entity) fireball.getShooter();
- location = BukkitUtil.adapt(shooter.getLocation());
- } else if (fireball.getShooter() instanceof BlockProjectileSource) {
- Block shooter =
- ((BlockProjectileSource) fireball.getShooter()).getBlock();
- location = BukkitUtil.adapt(shooter.getLocation());
- }
- if (location != null && !plot.equals(location.getPlot())) {
- event.setCancelled(true);
- }
- }
- }
-
- } else if (event.getIgnitingBlock() != null) {
- Block ignitingBlock = event.getIgnitingBlock();
- Plot plotIgnited = BukkitUtil.adapt(ignitingBlock.getLocation()).getPlot();
- if (igniteCause == BlockIgniteEvent.IgniteCause.FLINT_AND_STEEL && (
- !plot.getFlag(BlockIgnitionFlag.class) || plotIgnited == null || !plotIgnited
- .equals(plot)) || (igniteCause == BlockIgniteEvent.IgniteCause.SPREAD
- || igniteCause == BlockIgniteEvent.IgniteCause.LAVA) && (
- !plot.getFlag(BlockIgnitionFlag.class) || plotIgnited == null || !plotIgnited
- .equals(plot))) {
- event.setCancelled(true);
- }
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBucketEmpty(PlayerBucketEmptyEvent event) {
- BlockFace bf = event.getBlockFace();
- Block block =
- event.getBlockClicked().getLocation().add(bf.getModX(), bf.getModY(), bf.getModZ())
- .getBlock();
- Location location = BukkitUtil.adapt(block.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- BukkitPlayer pp = BukkitUtil.adapt(event.getPlayer());
- Plot plot = area.getPlot(location);
- if (plot == null) {
- if (Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_ROAD)) {
- return;
- }
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_ROAD);
- event.setCancelled(true);
- } else if (!plot.hasOwner()) {
- if (Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_UNOWNED)) {
- return;
- }
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_UNOWNED);
- event.setCancelled(true);
- } else if (!plot.isAdded(pp.getUUID())) {
- List use = plot.getFlag(UseFlag.class);
- final BlockType blockType = BukkitAdapter.asBlockType(block.getType());
- for (final BlockTypeWrapper blockTypeWrapper : use) {
- if (blockTypeWrapper.accepts(blockType)) {
- return;
- }
- }
- if (Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- return;
- }
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- event.setCancelled(true);
- } else if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- event.setCancelled(true);
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST)
- public void onInventoryClose(InventoryCloseEvent event) {
- HumanEntity closer = event.getPlayer();
- if (!(closer instanceof Player)) {
- return;
- }
- Player player = (Player) closer;
- PlotInventory.removePlotInventoryOpen(BukkitUtil.adapt(player));
- }
-
- @EventHandler(priority = EventPriority.MONITOR) public void onLeave(PlayerQuitEvent event) {
- TaskManager.removeFromTeleportQueue(event.getPlayer().getName());
- BukkitPlayer pp = BukkitUtil.adapt(event.getPlayer());
- pp.unregister();
- this.logout(pp.getUUID());
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onBucketFill(PlayerBucketFillEvent event) {
- Block blockClicked = event.getBlockClicked();
- Location location = BukkitUtil.adapt(blockClicked.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Player player = event.getPlayer();
- BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
- Plot plot = area.getPlot(location);
- if (plot == null) {
- if (Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_ROAD)) {
- return;
- }
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_ROAD);
- event.setCancelled(true);
- } else if (!plot.hasOwner()) {
- if (Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_UNOWNED)) {
- return;
- }
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_UNOWNED);
- event.setCancelled(true);
- } else if (!plot.isAdded(plotPlayer.getUUID())) {
- List use = plot.getFlag(UseFlag.class);
- Block block = event.getBlockClicked();
- final BlockType blockType = BukkitAdapter.asBlockType(block.getType());
- for (final BlockTypeWrapper blockTypeWrapper : use) {
- if (blockTypeWrapper.accepts(blockType)) {
- return;
- }
- }
- if (Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- return;
- }
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- event.setCancelled(true);
- } else if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
- if (!Permissions.hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- event.setCancelled(true);
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onVehicleCreate(VehicleCreateEvent event) {
- Vehicle entity = event.getVehicle();
- Location location = BukkitUtil.adapt(entity.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = area.getOwnedPlotAbs(location);
- if (plot == null || checkEntity(entity, plot)) {
- entity.remove();
- return;
- }
- if (Settings.Enabled_Components.KILL_ROAD_VEHICLES) {
- entity
- .setMetadata("plot", new FixedMetadataValue((Plugin) PlotSquared.platform(), plot));
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onHangingPlace(HangingPlaceEvent event) {
- Block block = event.getBlock().getRelative(event.getBlockFace());
- Location location = BukkitUtil.adapt(block.getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Player p = event.getPlayer();
- if (p == null) {
- event.setCancelled(true);
- return;
- }
- BukkitPlayer pp = BukkitUtil.adapt(p);
- Plot plot = area.getPlot(location);
- if (plot == null) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_ROAD)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_ROAD);
- event.setCancelled(true);
- }
- } else {
- if (!plot.hasOwner()) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_UNOWNED)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_UNOWNED);
- event.setCancelled(true);
- }
- return;
- }
- if (!plot.isAdded(pp.getUUID())) {
- if (!plot.getFlag(HangingPlaceFlag.class)) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- event.setCancelled(true);
- }
- return;
- }
- }
- if (checkEntity(event.getEntity(), plot)) {
- event.setCancelled(true);
- }
-
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onHangingBreakByEntity(HangingBreakByEntityEvent event) {
- Entity remover = event.getRemover();
- if (remover instanceof Player) {
- Player p = (Player) remover;
- Location location = BukkitUtil.adapt(event.getEntity().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- BukkitPlayer pp = BukkitUtil.adapt(p);
- Plot plot = area.getPlot(location);
- if (plot == null) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_DESTROY_ROAD)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_DESTROY_ROAD);
- event.setCancelled(true);
- }
- } else if (!plot.hasOwner()) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_DESTROY_UNOWNED)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_DESTROY_UNOWNED);
- event.setCancelled(true);
- }
- } else if (!plot.isAdded(pp.getUUID())) {
- if (plot.getFlag(HangingBreakFlag.class)) {
- return;
- }
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_DESTROY_OTHER)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_DESTROY_OTHER);
- event.setCancelled(true);
- plot.debug(p.getName()
- + " could not break hanging entity because hanging-break = false");
- }
- }
- } else if (remover instanceof Projectile) {
- Projectile p = (Projectile) remover;
- if (p.getShooter() instanceof Player) {
- Player shooter = (Player) p.getShooter();
- Location location = BukkitUtil.adapt(event.getEntity().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- BukkitPlayer player = BukkitUtil.adapt(shooter);
- Plot plot = area.getPlot(BukkitUtil.adapt(event.getEntity().getLocation()));
- if (plot != null) {
- if (!plot.hasOwner()) {
- if (!Permissions
- .hasPermission(player, Captions.PERMISSION_ADMIN_DESTROY_UNOWNED)) {
- MainUtil.sendMessage(player, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_DESTROY_UNOWNED);
- event.setCancelled(true);
- }
- } else if (!plot.isAdded(player.getUUID())) {
- if (!plot.getFlag(HangingBreakFlag.class)) {
- if (!Permissions
- .hasPermission(player, Captions.PERMISSION_ADMIN_DESTROY_OTHER)) {
- MainUtil.sendMessage(player, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_DESTROY_OTHER);
- event.setCancelled(true);
- plot.debug(player.getName()
- + " could not break hanging entity because hanging-break = false");
- }
- }
- }
- }
- }
- } else {
- event.setCancelled(true);
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onPlayerInteractEntity(PlayerInteractEntityEvent event) {
- Location location = BukkitUtil.adapt(event.getRightClicked().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Player p = event.getPlayer();
- BukkitPlayer pp = BukkitUtil.adapt(p);
- Plot plot = area.getPlot(location);
- if (plot == null && !area.isRoadFlags()) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_INTERACT_ROAD)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_INTERACT_ROAD);
- event.setCancelled(true);
- }
- } else if (plot != null && !plot.hasOwner()) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_INTERACT_UNOWNED)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_INTERACT_UNOWNED);
- event.setCancelled(true);
- }
- } else if ((plot != null && !plot.isAdded(pp.getUUID())) || (plot == null && area
- .isRoadFlags())) {
- final Entity entity = event.getRightClicked();
- final com.sk89q.worldedit.world.entity.EntityType entityType =
- BukkitAdapter.adapt(entity.getType());
-
- FlagContainer flagContainer;
- if (plot == null) {
- flagContainer = area.getRoadFlagContainer();
- } else {
- flagContainer = plot.getFlagContainer();
- }
-
- if (EntityCategories.HOSTILE.contains(entityType) && flagContainer
- .getFlag(HostileInteractFlag.class).getValue()) {
- return;
- }
-
- if (EntityCategories.ANIMAL.contains(entityType) && flagContainer
- .getFlag(AnimalInteractFlag.class).getValue()) {
- return;
- }
-
- // This actually makes use of the interface, so we don't use the
- // category
- if (entity instanceof Tameable && ((Tameable) entity).isTamed() && flagContainer
- .getFlag(TamedInteractFlag.class).getValue()) {
- return;
- }
-
- if (EntityCategories.VEHICLE.contains(entityType) && flagContainer
- .getFlag(VehicleUseFlag.class).getValue()) {
- return;
- }
-
- if (EntityCategories.PLAYER.contains(entityType) && flagContainer
- .getFlag(PlayerInteractFlag.class).getValue()) {
- return;
- }
-
- if (EntityCategories.VILLAGER.contains(entityType) && flagContainer
- .getFlag(VillagerInteractFlag.class).getValue()) {
- return;
- }
-
- if ((EntityCategories.HANGING.contains(entityType) || EntityCategories.OTHER
- .contains(entityType)) && flagContainer.getFlag(MiscInteractFlag.class)
- .getValue()) {
- return;
- }
-
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_INTERACT_OTHER)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_INTERACT_OTHER);
- event.setCancelled(true);
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onVehicleDestroy(VehicleDestroyEvent event) {
- Location location = BukkitUtil.adapt(event.getVehicle().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Entity attacker = event.getAttacker();
- if (attacker instanceof Player) {
- Player p = (Player) attacker;
- BukkitPlayer pp = BukkitUtil.adapt(p);
- Plot plot = area.getPlot(location);
- if (plot == null) {
- if (!Permissions.hasPermission(pp, "plots.admin.vehicle.break.road")) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- "plots.admin.vehicle.break.road");
- event.setCancelled(true);
- }
- } else {
- if (!plot.hasOwner()) {
- if (!Permissions.hasPermission(pp, "plots.admin.vehicle.break.unowned")) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- "plots.admin.vehicle.break.unowned");
- event.setCancelled(true);
- return;
- }
- return;
- }
- if (!plot.isAdded(pp.getUUID())) {
- if (plot.getFlag(VehicleBreakFlag.class)) {
- return;
- }
- if (!Permissions.hasPermission(pp, "plots.admin.vehicle.break.other")) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- "plots.admin.vehicle.break.other");
- event.setCancelled(true);
- plot.debug(pp.getName()
- + " could not break vehicle because vehicle-break = false");
- }
- }
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onPotionSplash(PotionSplashEvent event) {
- ThrownPotion damager = event.getPotion();
- Location location = BukkitUtil.adapt(damager.getLocation());
- if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
- return;
- }
- int count = 0;
- for (LivingEntity victim : event.getAffectedEntities()) {
- if (!entityDamage(damager, victim)) {
- event.setIntensity(victim, 0);
- count++;
- }
- }
- if ((count > 0 && count == event.getAffectedEntities().size()) || !onProjectileHit(event)) {
- event.setCancelled(true);
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST)
- public void onEntityCombustByEntity(EntityCombustByEntityEvent event) {
- EntityDamageByEntityEvent eventChange =
- new EntityDamageByEntityEvent(event.getCombuster(), event.getEntity(),
- EntityDamageEvent.DamageCause.FIRE_TICK, event.getDuration());
- onEntityDamageByEntityEvent(eventChange);
- if (eventChange.isCancelled()) {
- event.setCancelled(true);
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST)
- public void onEntityDamageByEntityEvent(EntityDamageByEntityEvent event) {
- Entity damager = event.getDamager();
- Location location = BukkitUtil.adapt(damager.getLocation());
- if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
- return;
- }
- Entity victim = event.getEntity();
-/*
- if (victim.getType().equals(EntityType.ITEM_FRAME)) {
- Plot plot = BukkitUtil.getLocation(victim).getPlot();
- if (plot != null && !plot.isAdded(damager.getUniqueId())) {
- event.setCancelled(true);
- return;
- }
- }
-*/
- if (!entityDamage(damager, victim, event.getCause())) {
- if (event.isCancelled()) {
- if (victim instanceof Ageable) {
- Ageable ageable = (Ageable) victim;
- if (ageable.getAge() == -24000) {
- ageable.setAge(0);
- ageable.setAdult();
- }
- }
- }
- event.setCancelled(true);
- }
- }
-
- private boolean entityDamage(Entity damager, Entity victim) {
- return entityDamage(damager, victim, null);
- }
-
- private boolean entityDamage(Entity damager, Entity victim,
- EntityDamageEvent.DamageCause cause) {
- Location dloc = BukkitUtil.adapt(damager.getLocation());
- Location vloc = BukkitUtil.adapt(victim.getLocation());
- PlotArea dArea = dloc.getPlotArea();
- PlotArea vArea;
- if (dArea != null && dArea.contains(vloc.getX(), vloc.getZ())) {
- vArea = dArea;
- } else {
- vArea = vloc.getPlotArea();
- }
- if (dArea == null && vArea == null) {
- return true;
- }
-
- Plot dplot;
- if (dArea != null) {
- dplot = dArea.getPlot(dloc);
- } else {
- dplot = null;
- }
- Plot vplot;
- if (vArea != null) {
- vplot = vArea.getPlot(vloc);
- } else {
- vplot = null;
- }
-
- Plot plot;
- String stub;
- boolean isPlot = true;
- if (dplot == null && vplot == null) {
- if (dArea == null) {
- return true;
- }
- plot = null;
- stub = "road";
- isPlot = false;
- } else {
- // Prioritize plots for close to seamless pvp zones
- if (victim.getTicksLived() > damager.getTicksLived()) {
- if (dplot == null || !(victim instanceof Player)) {
- if (vplot == null) {
- plot = dplot;
- } else {
- plot = vplot;
- }
- } else {
- plot = dplot;
- }
- } else if (dplot == null || !(victim instanceof Player)) {
- if (vplot == null) {
- plot = dplot;
- } else {
- plot = vplot;
- }
- } else if (vplot == null) {
- plot = dplot;
- } else {
- plot = vplot;
- }
- if (plot.hasOwner()) {
- stub = "other";
- } else {
- stub = "unowned";
- }
- }
- boolean roadFlags = vArea != null ? vArea.isRoadFlags() : dArea.isRoadFlags();
- PlotArea area = vArea != null ? vArea : dArea;
-
- Player player;
- if (damager instanceof Player) { // attacker is player
- player = (Player) damager;
- } else if (damager instanceof Projectile) {
- Projectile projectile = (Projectile) damager;
- ProjectileSource shooter = projectile.getShooter();
- if (shooter instanceof Player) { // shooter is player
- player = (Player) shooter;
- } else { // shooter is not player
- if (shooter instanceof BlockProjectileSource) {
- Location sLoc = BukkitUtil
- .adapt(((BlockProjectileSource) shooter).getBlock().getLocation());
- dplot = dArea.getPlot(sLoc);
- }
- player = null;
- }
- } else { // Attacker is not player
- player = null;
- }
- if (player != null) {
- BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
-
- final com.sk89q.worldedit.world.entity.EntityType entityType;
-
- // Create a fake entity type if the type does not have a name
- if (victim.getType().getName() == null) {
- entityType = FAKE_ENTITY_TYPE;
- } else {
- entityType = BukkitAdapter.adapt(victim.getType());
- }
-
- if (EntityCategories.HANGING.contains(entityType)) { // hanging
- if (plot != null && (plot.getFlag(HangingBreakFlag.class) || plot
- .isAdded(plotPlayer.getUUID()))) {
- if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
- if (!Permissions
- .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- return false;
- }
- }
- return true;
- }
- if (!Permissions.hasPermission(plotPlayer, "plots.admin.destroy." + stub)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.destroy." + stub);
- return false;
- }
- } else if (victim.getType() == EntityType.ARMOR_STAND) {
- if (plot != null && (plot.getFlag(MiscBreakFlag.class) || plot
- .isAdded(plotPlayer.getUUID()))) {
- return true;
- }
- if (!Permissions.hasPermission(plotPlayer, "plots.admin.destroy." + stub)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.destroy." + stub);
- if (plot != null) {
- plot.debug(player.getName()
- + " could not break armor stand because misc-break = false");
- }
- return false;
- }
- } else if (EntityCategories.HOSTILE.contains(entityType)) {
- if (isPlot) {
- if (plot.getFlag(HostileAttackFlag.class) || plot.getFlag(PveFlag.class) || plot
- .isAdded(plotPlayer.getUUID())) {
- return true;
- }
- } else if (roadFlags && (area.getRoadFlag(HostileAttackFlag.class) || area
- .getFlag(PveFlag.class))) {
- return true;
- }
- if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.pve." + stub);
- if (plot != null) {
- plot.debug(player.getName() + " could not attack " + entityType
- + " because pve = false OR hostile-attack = false");
- }
- return false;
- }
- } else if (EntityCategories.TAMEABLE.contains(entityType)) { // victim is tameable
- if (isPlot) {
- if (plot.getFlag(TamedAttackFlag.class) || plot.getFlag(PveFlag.class) || plot
- .isAdded(plotPlayer.getUUID())) {
- return true;
- }
- } else if (roadFlags && (area.getRoadFlag(TamedAttackFlag.class) || area
- .getFlag(PveFlag.class))) {
- return true;
- }
- if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.pve." + stub);
- if (plot != null) {
- plot.debug(player.getName() + " could not attack " + entityType
- + " because pve = false OR tamned-attack = false");
- }
- return false;
- }
- } else if (EntityCategories.PLAYER.contains(entityType)) {
- if (isPlot) {
- if (!plot.getFlag(PvpFlag.class) && !Permissions
- .hasPermission(plotPlayer, "plots.admin.pvp." + stub)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.pvp." + stub);
- plot.debug(player.getName() + " could not attack " + entityType
- + " because pve = false");
- return false;
- } else {
- return true;
- }
- } else if (roadFlags && area.getRoadFlag(PvpFlag.class)) {
- return true;
- }
- if (!Permissions.hasPermission(plotPlayer, "plots.admin.pvp." + stub)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.pvp." + stub);
- return false;
- }
- } else if (EntityCategories.ANIMAL.contains(entityType)) { // victim is animal
- if (isPlot) {
- if (plot.getFlag(AnimalAttackFlag.class) || plot.getFlag(PveFlag.class) || plot
- .isAdded(plotPlayer.getUUID())) {
- plot.debug(player.getName() + " could not attack " + entityType
- + " because pve = false OR animal-attack = false");
- return true;
- }
- } else if (roadFlags && (area.getRoadFlag(AnimalAttackFlag.class) || area
- .getFlag(PveFlag.class))) {
- if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.pve." + stub);
- return false;
- }
- }
- } else if (EntityCategories.VEHICLE
- .contains(entityType)) { // Vehicles are managed in vehicle destroy event
- return true;
- } else { // victim is something else
- if (isPlot) {
- if (plot.getFlag(PveFlag.class) || plot.isAdded(plotPlayer.getUUID())) {
- return true;
- }
- } else if (roadFlags && area.getRoadFlag(PveFlag.class)) {
- return true;
- }
- if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.pve." + stub);
- if (plot != null) {
- plot.debug(player.getName() + " could not attack " + entityType
- + " because pve = false");
- }
- return false;
- }
- }
- return true;
- } else if (dplot != null && (!dplot.equals(vplot) || Objects
- .equals(dplot.getOwnerAbs(), vplot.getOwnerAbs()))) {
- return vplot != null && vplot.getFlag(PveFlag.class);
- }
- //disable the firework damage. too much of a headache to support at the moment.
- if (vplot != null) {
- if (EntityDamageEvent.DamageCause.ENTITY_EXPLOSION == cause
- && damager.getType() == EntityType.FIREWORK) {
- return false;
- }
- }
- if (vplot == null && roadFlags && area.getRoadFlag(PveFlag.class)) {
- return true;
- }
- return ((vplot != null && vplot.getFlag(PveFlag.class)) || !(damager instanceof Arrow
- && !(victim instanceof Creature)));
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void onPlayerEggThrow(PlayerEggThrowEvent event) {
- Location location = BukkitUtil.adapt(event.getEgg().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Player player = event.getPlayer();
- BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
- Plot plot = area.getPlot(location);
- if (plot == null) {
- if (!Permissions.hasPermission(plotPlayer, "plots.admin.projectile.road")) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.projectile.road");
- event.setHatching(false);
- }
- } else if (!plot.hasOwner()) {
- if (!Permissions.hasPermission(plotPlayer, "plots.admin.projectile.unowned")) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.projectile.unowned");
- event.setHatching(false);
- }
- } else if (!plot.isAdded(plotPlayer.getUUID())) {
- if (!Permissions.hasPermission(plotPlayer, "plots.admin.projectile.other")) {
- MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
- "plots.admin.projectile.other");
- event.setHatching(false);
- }
- }
- }
-
- @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
- public void blockCreate(BlockPlaceEvent event) {
- Location location = BukkitUtil.adapt(event.getBlock().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Player player = event.getPlayer();
- BukkitPlayer pp = BukkitUtil.adapt(player);
- Plot plot = area.getPlot(location);
- if (plot != null) {
- if ((location.getY() > area.getMaxBuildHeight() || location.getY() < area
- .getMinBuildHeight()) && !Permissions
- .hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_HEIGHT_LIMIT)) {
- event.setCancelled(true);
- MainUtil.sendMessage(pp, Captions.HEIGHT_LIMIT.getTranslated()
- .replace("{limit}", String.valueOf(area.getMaxBuildHeight())));
- }
- if (!plot.hasOwner()) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_UNOWNED)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_UNOWNED);
- event.setCancelled(true);
- return;
- }
- } else if (!plot.isAdded(pp.getUUID())) {
- List place = plot.getFlag(PlaceFlag.class);
- if (place != null) {
- Block block = event.getBlock();
- if (place.contains(
- BlockTypeWrapper.get(BukkitAdapter.asBlockType(block.getType())))) {
- return;
- }
- }
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- event.setCancelled(true);
- plot.debug(player.getName() + " could not place " + event.getBlock().getType()
- + " because of the place flag");
- return;
- }
- } else if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
- if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_OTHER);
- event.setCancelled(true);
- return;
- }
- }
- if (plot.getFlag(DisablePhysicsFlag.class)) {
- Block block = event.getBlockPlaced();
- if (block.getType().hasGravity()) {
- sendBlockChange(block.getLocation(), block.getBlockData());
- plot.debug(event.getBlock().getType()
- + " did not fall because of disable-physics = true");
- }
- }
- } else if (!Permissions.hasPermission(pp, Captions.PERMISSION_ADMIN_BUILD_ROAD)) {
- MainUtil.sendMessage(pp, Captions.NO_PERMISSION_EVENT,
- Captions.PERMISSION_ADMIN_BUILD_ROAD);
- event.setCancelled(true);
- }
- }
-
- @EventHandler(priority = EventPriority.HIGH) public void onDamage(EntityDamageEvent event) {
- if (event.getEntityType() != EntityType.PLAYER) {
- return;
- }
- Location location = BukkitUtil.adapt(event.getEntity().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = location.getOwnedPlot();
- if (plot == null) {
- if (area.isRoadFlags() && area.getRoadFlag(InvincibleFlag.class)) {
- event.setCancelled(true);
- }
- return;
- }
- if (plot.getFlag(InvincibleFlag.class)) {
- plot.debug(
- event.getEntity().getName() + " could not take damage because invincible = true");
- event.setCancelled(true);
- }
- }
-
- @EventHandler public void onItemDrop(PlayerDropItemEvent event) {
- Player player = event.getPlayer();
- BukkitPlayer pp = BukkitUtil.adapt(player);
- Location location = pp.getLocation();
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = location.getOwnedPlot();
- if (plot == null) {
- if (area.isRoadFlags() && !area.getRoadFlag(ItemDropFlag.class)) {
- event.setCancelled(true);
- }
- return;
- }
- UUID uuid = pp.getUUID();
- if (!plot.isAdded(uuid)) {
- if (!plot.getFlag(ItemDropFlag.class)) {
- plot.debug(player.getName() + " could not drop item because of item-drop = false");
- event.setCancelled(true);
- }
- }
- }
-
- @EventHandler public void onItemPickup(EntityPickupItemEvent event) {
- LivingEntity ent = event.getEntity();
- if (ent instanceof Player) {
- Player player = (Player) ent;
- BukkitPlayer pp = BukkitUtil.adapt(player);
- Location location = pp.getLocation();
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = location.getOwnedPlot();
- if (plot == null) {
- if (area.isRoadFlags() && area.getRoadFlag(DropProtectionFlag.class)) {
- event.setCancelled(true);
- }
- return;
- }
- UUID uuid = pp.getUUID();
- if (!plot.isAdded(uuid) && plot.getFlag(DropProtectionFlag.class)) {
- plot.debug(
- player.getName() + " could not pick up item because of drop-protection = true");
- event.setCancelled(true);
- }
- }
- }
-
- @EventHandler public void onDeath(final PlayerDeathEvent event) {
- Location location = BukkitUtil.adapt(event.getEntity().getLocation());
- PlotArea area = location.getPlotArea();
- if (area == null) {
- return;
- }
- Plot plot = location.getOwnedPlot();
- if (plot == null) {
- if (area.isRoadFlags() && area.getRoadFlag(KeepInventoryFlag.class)) {
- event.setCancelled(true);
- }
- return;
- }
- if (plot.getFlag(KeepInventoryFlag.class)) {
- if (plot.getFlag(KeepInventoryFlag.class)) {
- plot.debug(event.getEntity().getName()
- + " kept their inventory because of keep-inventory = true");
- event.setKeepInventory(true);
- }
- }
- }
-}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/ProjectileEventListener.java b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/ProjectileEventListener.java
new file mode 100644
index 000000000..4a5f78bc3
--- /dev/null
+++ b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/ProjectileEventListener.java
@@ -0,0 +1,161 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.bukkit.util.BukkitEntityUtil;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.PlotHandler;
+import com.plotsquared.core.plot.world.PlotAreaManager;
+import com.plotsquared.core.util.Permissions;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.entity.ThrownPotion;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.entity.LingeringPotionSplashEvent;
+import org.bukkit.event.entity.PotionSplashEvent;
+import org.bukkit.event.entity.ProjectileHitEvent;
+import org.bukkit.event.entity.ProjectileLaunchEvent;
+import org.bukkit.projectiles.BlockProjectileSource;
+import org.bukkit.projectiles.ProjectileSource;
+
+import javax.annotation.Nonnull;
+import javax.inject.Inject;
+
+@SuppressWarnings("unused")
+public class ProjectileEventListener implements Listener {
+
+ private final PlotAreaManager plotAreaManager;
+
+ @Inject public ProjectileEventListener(@Nonnull final PlotAreaManager plotAreaManager) {
+ this.plotAreaManager = plotAreaManager;
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onPotionSplash(LingeringPotionSplashEvent event) {
+ Projectile entity = event.getEntity();
+ Location location = BukkitUtil.adapt(entity.getLocation());
+ if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
+ return;
+ }
+ if (!this.onProjectileHit(event)) {
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) public void onPotionSplash(PotionSplashEvent event) {
+ ThrownPotion damager = event.getPotion();
+ Location location = BukkitUtil.adapt(damager.getLocation());
+ if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
+ return;
+ }
+ int count = 0;
+ for (LivingEntity victim : event.getAffectedEntities()) {
+ if (!BukkitEntityUtil.entityDamage(damager, victim)) {
+ event.setIntensity(victim, 0);
+ count++;
+ }
+ }
+ if ((count > 0 && count == event.getAffectedEntities().size()) || !onProjectileHit(event)) {
+ event.setCancelled(true);
+ }
+ }
+
+ @EventHandler public void onProjectileLaunch(ProjectileLaunchEvent event) {
+ Projectile entity = event.getEntity();
+ if (!(entity instanceof ThrownPotion)) {
+ return;
+ }
+ ProjectileSource shooter = entity.getShooter();
+ if (!(shooter instanceof Player)) {
+ return;
+ }
+ Location location = BukkitUtil.adapt(entity.getLocation());
+ if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
+ return;
+ }
+ PlotPlayer pp = BukkitUtil.adapt((Player) shooter);
+ Plot plot = location.getOwnedPlot();
+ if (plot != null && !plot.isAdded(pp.getUUID())) {
+ entity.remove();
+ event.setCancelled(true);
+ }
+ }
+
+ @SuppressWarnings({"BooleanMethodIsAlwaysInverted", "cos it's not... dum IntelliJ"}) @EventHandler
+ public boolean onProjectileHit(ProjectileHitEvent event) {
+ Projectile entity = event.getEntity();
+ Location location = BukkitUtil.adapt(entity.getLocation());
+ if (!this.plotAreaManager.hasPlotArea(location.getWorldName())) {
+ return true;
+ }
+ PlotArea area = location.getPlotArea();
+ if (area == null) {
+ return true;
+ }
+ Plot plot = area.getPlot(location);
+ ProjectileSource shooter = entity.getShooter();
+ if (shooter instanceof Player) {
+ PlotPlayer pp = BukkitUtil.adapt((Player) shooter);
+ if (plot == null) {
+ if (!Permissions.hasPermission(pp, Captions.PERMISSION_PROJECTILE_UNOWNED)) {
+ entity.remove();
+ return false;
+ }
+ return true;
+ }
+ if (plot.isAdded(pp.getUUID()) || Permissions.hasPermission(pp, Captions.PERMISSION_PROJECTILE_OTHER)) {
+ return true;
+ }
+ entity.remove();
+ return false;
+ }
+ if (!(shooter instanceof Entity) && shooter != null) {
+ if (plot == null) {
+ entity.remove();
+ return false;
+ }
+ Location sLoc = BukkitUtil.adapt(((BlockProjectileSource) shooter).getBlock().getLocation());
+ if (!area.contains(sLoc.getX(), sLoc.getZ())) {
+ entity.remove();
+ return false;
+ }
+ Plot sPlot = area.getOwnedPlotAbs(sLoc);
+ if (sPlot == null || !PlotHandler.sameOwners(plot, sPlot)) {
+ entity.remove();
+ return false;
+ }
+ }
+ return true;
+ }
+}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/listener/ServerListener.java b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/ServerListener.java
new file mode 100644
index 000000000..2f965a753
--- /dev/null
+++ b/Bukkit/src/main/java/com/plotsquared/bukkit/listener/ServerListener.java
@@ -0,0 +1,55 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.bukkit.listener;
+
+import com.plotsquared.bukkit.BukkitPlatform;
+import com.plotsquared.bukkit.placeholder.MVdWPlaceholders;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.configuration.Captions;
+import org.bukkit.Bukkit;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.Listener;
+import org.bukkit.event.server.ServerLoadEvent;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class ServerListener implements Listener {
+
+ private static final Logger logger = LoggerFactory.getLogger("P2/" + ServerListener.class.getSimpleName());
+
+ private final BukkitPlatform plugin;
+
+ public ServerListener(BukkitPlatform plugin) {
+ this.plugin = plugin;
+ }
+
+ @EventHandler public void onServerLoad(ServerLoadEvent event) {
+ if (Bukkit.getPluginManager().getPlugin("MVdWPlaceholderAPI") != null) {
+ new MVdWPlaceholders(this.plugin, PlotSquared.get().getPlaceholderRegistry());
+ logger.info(Captions.PREFIX + "&6PlotSquared hooked into MVdWPlaceholderAPI");
+ }
+ }
+}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/MVdWPlaceholders.java b/Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/MVdWPlaceholders.java
new file mode 100644
index 000000000..0549d1529
--- /dev/null
+++ b/Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/MVdWPlaceholders.java
@@ -0,0 +1,72 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.bukkit.placeholder;
+
+import be.maximvdw.placeholderapi.PlaceholderAPI;
+import com.google.common.eventbus.Subscribe;
+import com.plotsquared.bukkit.util.BukkitUtil;
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.util.placeholders.Placeholder;
+import com.plotsquared.core.util.placeholders.PlaceholderRegistry;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * Placeholder support for MVdWPlaceholderAPI
+ */
+public class MVdWPlaceholders {
+
+ private static final String PREFIX = "plotsquared_";
+ private final Plugin plugin;
+ private final PlaceholderRegistry registry;
+
+ public MVdWPlaceholders(@NotNull final Plugin plugin, @NotNull final PlaceholderRegistry registry) {
+ this.plugin = plugin;
+ this.registry = registry;
+ for (final Placeholder placeholder : registry.getPlaceholders()) {
+ this.addPlaceholder(placeholder);
+ }
+ PlotSquared.get().getEventDispatcher().registerListener(this);
+ }
+
+ @Subscribe public void onNewPlaceholder(@NotNull final PlaceholderRegistry.PlaceholderAddedEvent event) {
+ this.addPlaceholder(event.getPlaceholder());
+ }
+
+ private void addPlaceholder(@NotNull final Placeholder placeholder) {
+ PlaceholderAPI.registerPlaceholder(plugin, PREFIX + String.format("%s", placeholder.getKey()), placeholderReplaceEvent -> {
+ if (!placeholderReplaceEvent.isOnline() || placeholderReplaceEvent.getPlayer() == null) {
+ return "";
+ }
+ final PlotPlayer player = BukkitUtil.adapt(placeholderReplaceEvent.getPlayer());
+ String key = placeholderReplaceEvent.getPlaceholder().substring(PREFIX.length());
+ return registry.getPlaceholderValue(key, player);
+ });
+ }
+
+}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/PAPIPlaceholders.java b/Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/PAPIPlaceholders.java
new file mode 100644
index 000000000..9a5ebdb82
--- /dev/null
+++ b/Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/PAPIPlaceholders.java
@@ -0,0 +1,89 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.bukkit.placeholder;
+
+import com.plotsquared.core.PlotSquared;
+import com.plotsquared.core.player.PlotPlayer;
+import me.clip.placeholderapi.PlaceholderAPIPlugin;
+import me.clip.placeholderapi.expansion.PlaceholderExpansion;
+import org.bukkit.entity.Player;
+
+public class PAPIPlaceholders extends PlaceholderExpansion {
+
+ public PAPIPlaceholders() {
+ }
+
+ @Override public boolean persist() {
+ return true;
+ }
+
+ @Override public boolean canRegister() {
+ return true;
+ }
+
+ @Override public String getAuthor() {
+ return "IntellectualSites";
+ }
+
+ @Override public String getIdentifier() {
+ return "plotsquared";
+ }
+
+ @Override public String getVersion() {
+ return "3";
+ }
+
+ @Override public String onPlaceholderRequest(Player p, String identifier) {
+ final PlotPlayer pl = PlotSquared.platform().getPlayerManager().getPlayerIfExists(p.getUniqueId());
+
+ if (pl == null) {
+ return "";
+ }
+
+ // PAPI specific ones that don't translate well over into other placeholder APIs
+ if (identifier.startsWith("has_plot_")) {
+ identifier = identifier.substring("has_plot_".length());
+ if (identifier.isEmpty())
+ return "";
+
+ return pl.getPlotCount(identifier) > 0 ?
+ PlaceholderAPIPlugin.booleanTrue() :
+ PlaceholderAPIPlugin.booleanFalse();
+ }
+
+ if (identifier.startsWith("plot_count_")) {
+ identifier = identifier.substring("plot_count_".length());
+ if (identifier.isEmpty())
+ return "";
+
+ return String.valueOf(pl.getPlotCount(identifier));
+ }
+
+ // PlotSquared placeholders
+ return PlotSquared.get().getPlaceholderRegistry().getPlaceholderValue(identifier, pl);
+ }
+
+}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/Placeholders.java b/Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/Placeholders.java
deleted file mode 100644
index d79a7b4fb..000000000
--- a/Bukkit/src/main/java/com/plotsquared/bukkit/placeholder/Placeholders.java
+++ /dev/null
@@ -1,213 +0,0 @@
-/*
- * _____ _ _ _____ _
- * | __ \| | | | / ____| | |
- * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
- * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
- * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
- * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
- * | |
- * |_|
- * PlotSquared plot management system for Minecraft
- * Copyright (C) 2020 IntellectualSites
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program. If not, see .
- */
-package com.plotsquared.bukkit.placeholder;
-
-import com.plotsquared.core.PlotSquared;
-import com.plotsquared.core.player.PlotPlayer;
-import com.plotsquared.core.plot.Plot;
-import com.plotsquared.core.plot.flag.GlobalFlagContainer;
-import com.plotsquared.core.plot.flag.PlotFlag;
-import com.plotsquared.core.util.PlayerManager;
-import me.clip.placeholderapi.PlaceholderAPIPlugin;
-import me.clip.placeholderapi.expansion.PlaceholderExpansion;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-
-import java.util.UUID;
-
-public class Placeholders extends PlaceholderExpansion {
-
- public Placeholders() {
- }
-
- @Override public boolean persist() {
- return true;
- }
-
- @Override public boolean canRegister() {
- return true;
- }
-
- @Override public String getAuthor() {
- return "NotMyFault";
- }
-
- @Override public String getIdentifier() {
- return "plotsquared";
- }
-
- @Override public String getVersion() {
- return "2.5";
- }
-
- @Override public String onPlaceholderRequest(Player p, String identifier) {
- final PlotPlayer pl = PlotSquared.platform().getPlayerManager().getPlayerIfExists(p.getUniqueId());
-
- if (pl == null) {
- return "";
- }
-
- if (identifier.startsWith("has_plot_")) {
- identifier = identifier.substring("has_plot_".length());
- if (identifier.isEmpty())
- return "";
-
- return pl.getPlotCount(identifier) > 0 ?
- PlaceholderAPIPlugin.booleanTrue() :
- PlaceholderAPIPlugin.booleanFalse();
- }
-
- if (identifier.startsWith("plot_count_")) {
- identifier = identifier.substring("plot_count_".length());
- if (identifier.isEmpty())
- return "";
-
- return String.valueOf(pl.getPlotCount(identifier));
- }
-
- switch (identifier) {
- case "currentplot_world": {
- return p.getWorld().getName();
- }
- case "has_plot": {
- return (pl.getPlotCount() > 0) ?
- PlaceholderAPIPlugin.booleanTrue() :
- PlaceholderAPIPlugin.booleanFalse();
- }
- case "allowed_plot_count": {
- return String.valueOf(pl.getAllowedPlots());
- }
- case "plot_count": {
- return String.valueOf(pl.getPlotCount());
- }
- }
-
- Plot plot = pl.getCurrentPlot();
-
- if (plot == null) {
- return "";
- }
-
- switch (identifier) {
- case "currentplot_alias": {
- return plot.getAlias();
- }
- case "currentplot_owner": {
- final UUID plotOwner = plot.getOwnerAbs();
- if (plotOwner == null) {
- return "";
- }
-
- try {
- return PlayerManager.getName(plotOwner, false);
- } catch (final Exception ignored) {}
-
- final String name = Bukkit.getOfflinePlayer(plotOwner).getName();
- return name != null ? name : "unknown";
- }
- case "currentplot_members": {
- if (plot.getMembers() == null && plot.getTrusted() == null) {
- return "0";
- }
- return String.valueOf(plot.getMembers().size() + plot.getTrusted().size());
- }
- case "currentplot_members_added": {
- if (plot.getMembers() == null) {
- return "0";
- }
- return String.valueOf(plot.getMembers().size());
- }
- case "currentplot_members_trusted": {
- if (plot.getTrusted() == null) {
- return "0";
- }
- return String.valueOf(plot.getTrusted().size());
- }
- case "currentplot_members_denied": {
- if (plot.getDenied() == null) {
- return "0";
- }
- return String.valueOf(plot.getDenied().size());
- }
- case "has_build_rights": {
- return plot.isAdded(pl.getUUID()) ?
- PlaceholderAPIPlugin.booleanTrue() :
- PlaceholderAPIPlugin.booleanFalse();
- }
- case "currentplot_x": {
- return String.valueOf(plot.getId().getX());
- }
- case "currentplot_y": {
- return String.valueOf(plot.getId().getY());
- }
- case "currentplot_xy": {
- return plot.getId().getX() + ";" + plot.getId().getY();
- }
- case "currentplot_rating": {
- return String.valueOf(plot.getAverageRating());
- }
- case "currentplot_biome": {
- return plot.getBiomeSynchronous() + "";
- }
- default:
- break;
- }
- if (identifier.startsWith("currentplot_localflag_")) {
- return getFlagValue(plot, identifier.substring("currentplot_localflag_".length()),
- false);
- }
- if (identifier.startsWith("currentplot_flag_")) {
- return getFlagValue(plot, identifier.substring("currentplot_flag_".length()), true);
- }
- return "";
- }
-
- /**
- * Return the flag value from its name on the current plot.
- * If the flag doesn't exist it returns an empty string.
- * If the flag exists but it is not set on current plot and the parameter inherit is set to true,
- * it returns the default value.
- *
- * @param plot Current plot where the player is
- * @param flagName Name of flag to get from current plot
- * @param inherit Define if it returns only the flag set on currentplot or also inherited flag
- * @return The value of flag serialized in string
- */
- private String getFlagValue(final Plot plot, final String flagName, final boolean inherit) {
- if (flagName.isEmpty())
- return "";
- final PlotFlag flag = GlobalFlagContainer.getInstance().getFlagFromString(flagName);
- if (flag == null)
- return "";
-
- if (inherit) {
- return plot.getFlag(flag).toString();
- } else {
- final PlotFlag plotFlag = plot.getFlagContainer().queryLocal(flag.getClass());
- return (plotFlag != null) ? plotFlag.getValue().toString() : "";
- }
- }
-}
diff --git a/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitEntityUtil.java b/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitEntityUtil.java
new file mode 100644
index 000000000..17291eec9
--- /dev/null
+++ b/Bukkit/src/main/java/com/plotsquared/bukkit/util/BukkitEntityUtil.java
@@ -0,0 +1,363 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.bukkit.util;
+
+import com.plotsquared.bukkit.player.BukkitPlayer;
+import com.plotsquared.core.configuration.Captions;
+import com.plotsquared.core.configuration.Settings;
+import com.plotsquared.core.location.Location;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.PlotArea;
+import com.plotsquared.core.plot.flag.implementations.AnimalAttackFlag;
+import com.plotsquared.core.plot.flag.implementations.AnimalCapFlag;
+import com.plotsquared.core.plot.flag.implementations.DoneFlag;
+import com.plotsquared.core.plot.flag.implementations.EntityCapFlag;
+import com.plotsquared.core.plot.flag.implementations.HangingBreakFlag;
+import com.plotsquared.core.plot.flag.implementations.HostileAttackFlag;
+import com.plotsquared.core.plot.flag.implementations.HostileCapFlag;
+import com.plotsquared.core.plot.flag.implementations.MiscBreakFlag;
+import com.plotsquared.core.plot.flag.implementations.MiscCapFlag;
+import com.plotsquared.core.plot.flag.implementations.MobCapFlag;
+import com.plotsquared.core.plot.flag.implementations.PveFlag;
+import com.plotsquared.core.plot.flag.implementations.PvpFlag;
+import com.plotsquared.core.plot.flag.implementations.TamedAttackFlag;
+import com.plotsquared.core.plot.flag.implementations.VehicleCapFlag;
+import com.plotsquared.core.util.EntityUtil;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.Permissions;
+import com.plotsquared.core.util.entity.EntityCategories;
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import org.bukkit.entity.Arrow;
+import org.bukkit.entity.Creature;
+import org.bukkit.entity.Entity;
+import org.bukkit.entity.EntityType;
+import org.bukkit.entity.Player;
+import org.bukkit.entity.Projectile;
+import org.bukkit.event.entity.EntityDamageEvent;
+import org.bukkit.projectiles.BlockProjectileSource;
+import org.bukkit.projectiles.ProjectileSource;
+
+import java.util.Objects;
+
+public class BukkitEntityUtil {
+
+ public static final com.sk89q.worldedit.world.entity.EntityType FAKE_ENTITY_TYPE =
+ new com.sk89q.worldedit.world.entity.EntityType("plotsquared:fake");
+
+ public static boolean entityDamage(Entity damager, Entity victim) {
+ return entityDamage(damager, victim, null);
+ }
+
+ public static boolean entityDamage(Entity damager, Entity victim,
+ EntityDamageEvent.DamageCause cause) {
+ Location dloc = BukkitUtil.adapt(damager.getLocation());
+ Location vloc = BukkitUtil.adapt(victim.getLocation());
+ PlotArea dArea = dloc.getPlotArea();
+ PlotArea vArea;
+ if (dArea != null && dArea.contains(vloc.getX(), vloc.getZ())) {
+ vArea = dArea;
+ } else {
+ vArea = vloc.getPlotArea();
+ }
+ if (dArea == null && vArea == null) {
+ return true;
+ }
+
+ Plot dplot;
+ if (dArea != null) {
+ dplot = dArea.getPlot(dloc);
+ } else {
+ dplot = null;
+ }
+ Plot vplot;
+ if (vArea != null) {
+ vplot = vArea.getPlot(vloc);
+ } else {
+ vplot = null;
+ }
+
+ Plot plot;
+ String stub;
+ boolean isPlot = true;
+ if (dplot == null && vplot == null) {
+ if (dArea == null) {
+ return true;
+ }
+ plot = null;
+ stub = "road";
+ isPlot = false;
+ } else {
+ // Prioritize plots for close to seamless pvp zones
+ if (victim.getTicksLived() > damager.getTicksLived()) {
+ if (dplot == null || !(victim instanceof Player)) {
+ if (vplot == null) {
+ plot = dplot;
+ } else {
+ plot = vplot;
+ }
+ } else {
+ plot = dplot;
+ }
+ } else if (dplot == null || !(victim instanceof Player)) {
+ if (vplot == null) {
+ plot = dplot;
+ } else {
+ plot = vplot;
+ }
+ } else if (vplot == null) {
+ plot = dplot;
+ } else {
+ plot = vplot;
+ }
+ if (plot.hasOwner()) {
+ stub = "other";
+ } else {
+ stub = "unowned";
+ }
+ }
+ boolean roadFlags = vArea != null ? vArea.isRoadFlags() : dArea.isRoadFlags();
+ PlotArea area = vArea != null ? vArea : dArea;
+
+ Player player;
+ if (damager instanceof Player) { // attacker is player
+ player = (Player) damager;
+ } else if (damager instanceof Projectile) {
+ Projectile projectile = (Projectile) damager;
+ ProjectileSource shooter = projectile.getShooter();
+ if (shooter instanceof Player) { // shooter is player
+ player = (Player) shooter;
+ } else { // shooter is not player
+ if (shooter instanceof BlockProjectileSource) {
+ Location sLoc = BukkitUtil
+ .adapt(((BlockProjectileSource) shooter).getBlock().getLocation());
+ dplot = dArea.getPlot(sLoc);
+ }
+ player = null;
+ }
+ } else { // Attacker is not player
+ player = null;
+ }
+ if (player != null) {
+ BukkitPlayer plotPlayer = BukkitUtil.adapt(player);
+
+ final com.sk89q.worldedit.world.entity.EntityType entityType;
+
+ // Create a fake entity type if the type does not have a name
+ if (victim.getType().getName() == null) {
+ entityType = FAKE_ENTITY_TYPE;
+ } else {
+ entityType = BukkitAdapter.adapt(victim.getType());
+ }
+
+ if (EntityCategories.HANGING.contains(entityType)) { // hanging
+ if (plot != null && (plot.getFlag(HangingBreakFlag.class) || plot
+ .isAdded(plotPlayer.getUUID()))) {
+ if (Settings.Done.RESTRICT_BUILDING && DoneFlag.isDone(plot)) {
+ if (!Permissions
+ .hasPermission(plotPlayer, Captions.PERMISSION_ADMIN_BUILD_OTHER)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+ Captions.PERMISSION_ADMIN_BUILD_OTHER);
+ return false;
+ }
+ }
+ return true;
+ }
+ if (!Permissions.hasPermission(plotPlayer, "plots.admin.destroy." + stub)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+ "plots.admin.destroy." + stub);
+ return false;
+ }
+ } else if (victim.getType() == EntityType.ARMOR_STAND) {
+ if (plot != null && (plot.getFlag(MiscBreakFlag.class) || plot
+ .isAdded(plotPlayer.getUUID()))) {
+ return true;
+ }
+ if (!Permissions.hasPermission(plotPlayer, "plots.admin.destroy." + stub)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+ "plots.admin.destroy." + stub);
+ if (plot != null) {
+ plot.debug(player.getName()
+ + " could not break armor stand because misc-break = false");
+ }
+ return false;
+ }
+ } else if (EntityCategories.HOSTILE.contains(entityType)) {
+ if (isPlot) {
+ if (plot.getFlag(HostileAttackFlag.class) || plot.getFlag(PveFlag.class) || plot
+ .isAdded(plotPlayer.getUUID())) {
+ return true;
+ }
+ } else if (roadFlags && (area.getRoadFlag(HostileAttackFlag.class) || area
+ .getFlag(PveFlag.class))) {
+ return true;
+ }
+ if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+ "plots.admin.pve." + stub);
+ if (plot != null) {
+ plot.debug(player.getName() + " could not attack " + entityType
+ + " because pve = false OR hostile-attack = false");
+ }
+ return false;
+ }
+ } else if (EntityCategories.TAMEABLE.contains(entityType)) { // victim is tameable
+ if (isPlot) {
+ if (plot.getFlag(TamedAttackFlag.class) || plot.getFlag(PveFlag.class) || plot
+ .isAdded(plotPlayer.getUUID())) {
+ return true;
+ }
+ } else if (roadFlags && (area.getRoadFlag(TamedAttackFlag.class) || area
+ .getFlag(PveFlag.class))) {
+ return true;
+ }
+ if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+ "plots.admin.pve." + stub);
+ if (plot != null) {
+ plot.debug(player.getName() + " could not attack " + entityType
+ + " because pve = false OR tamned-attack = false");
+ }
+ return false;
+ }
+ } else if (EntityCategories.PLAYER.contains(entityType)) {
+ if (isPlot) {
+ if (!plot.getFlag(PvpFlag.class) && !Permissions
+ .hasPermission(plotPlayer, "plots.admin.pvp." + stub)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+ "plots.admin.pvp." + stub);
+ plot.debug(player.getName() + " could not attack " + entityType
+ + " because pve = false");
+ return false;
+ } else {
+ return true;
+ }
+ } else if (roadFlags && area.getRoadFlag(PvpFlag.class)) {
+ return true;
+ }
+ if (!Permissions.hasPermission(plotPlayer, "plots.admin.pvp." + stub)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+ "plots.admin.pvp." + stub);
+ return false;
+ }
+ } else if (EntityCategories.ANIMAL.contains(entityType)) { // victim is animal
+ if (isPlot) {
+ if (plot.getFlag(AnimalAttackFlag.class) || plot.getFlag(PveFlag.class) || plot
+ .isAdded(plotPlayer.getUUID())) {
+ plot.debug(player.getName() + " could not attack " + entityType
+ + " because pve = false OR animal-attack = false");
+ return true;
+ }
+ } else if (roadFlags && (area.getRoadFlag(AnimalAttackFlag.class) || area
+ .getFlag(PveFlag.class))) {
+ if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+ "plots.admin.pve." + stub);
+ return false;
+ }
+ }
+ } else if (EntityCategories.VEHICLE
+ .contains(entityType)) { // Vehicles are managed in vehicle destroy event
+ return true;
+ } else { // victim is something else
+ if (isPlot) {
+ if (plot.getFlag(PveFlag.class) || plot.isAdded(plotPlayer.getUUID())) {
+ return true;
+ }
+ } else if (roadFlags && area.getRoadFlag(PveFlag.class)) {
+ return true;
+ }
+ if (!Permissions.hasPermission(plotPlayer, "plots.admin.pve." + stub)) {
+ MainUtil.sendMessage(plotPlayer, Captions.NO_PERMISSION_EVENT,
+ "plots.admin.pve." + stub);
+ if (plot != null) {
+ plot.debug(player.getName() + " could not attack " + entityType
+ + " because pve = false");
+ }
+ return false;
+ }
+ }
+ return true;
+ } else if (dplot != null && (!dplot.equals(vplot) || Objects
+ .equals(dplot.getOwnerAbs(), vplot.getOwnerAbs()))) {
+ return vplot != null && vplot.getFlag(PveFlag.class);
+ }
+ //disable the firework damage. too much of a headache to support at the moment.
+ if (vplot != null) {
+ if (EntityDamageEvent.DamageCause.ENTITY_EXPLOSION == cause
+ && damager.getType() == EntityType.FIREWORK) {
+ return false;
+ }
+ }
+ if (vplot == null && roadFlags && area.getRoadFlag(PveFlag.class)) {
+ return true;
+ }
+ return ((vplot != null && vplot.getFlag(PveFlag.class)) || !(damager instanceof Arrow
+ && !(victim instanceof Creature)));
+ }
+
+ public static boolean checkEntity(Entity entity, Plot plot) {
+ if (plot == null || !plot.hasOwner() || plot.getFlags().isEmpty() && plot.getArea()
+ .getFlagContainer().getFlagMap().isEmpty()) {
+ return false;
+ }
+
+ final com.sk89q.worldedit.world.entity.EntityType entityType =
+ BukkitAdapter.adapt(entity.getType());
+
+ if (EntityCategories.PLAYER.contains(entityType)) {
+ return false;
+ }
+
+ if (EntityCategories.PROJECTILE.contains(entityType) || EntityCategories.OTHER
+ .contains(entityType) || EntityCategories.HANGING.contains(entityType)) {
+ return EntityUtil.checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED,
+ MiscCapFlag.MISC_CAP_UNLIMITED);
+ }
+
+ // Has to go go before vehicle as horses are both
+ // animals and vehicles
+ if (EntityCategories.ANIMAL.contains(entityType) || EntityCategories.VILLAGER
+ .contains(entityType) || EntityCategories.TAMEABLE.contains(entityType)) {
+ return EntityUtil
+ .checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED, MobCapFlag.MOB_CAP_UNLIMITED,
+ AnimalCapFlag.ANIMAL_CAP_UNLIMITED);
+ }
+
+ if (EntityCategories.HOSTILE.contains(entityType)) {
+ return EntityUtil
+ .checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED, MobCapFlag.MOB_CAP_UNLIMITED,
+ HostileCapFlag.HOSTILE_CAP_UNLIMITED);
+ }
+
+ if (EntityCategories.VEHICLE.contains(entityType)) {
+ return EntityUtil.checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED,
+ VehicleCapFlag.VEHICLE_CAP_UNLIMITED);
+ }
+
+ return EntityUtil.checkEntity(plot, EntityCapFlag.ENTITY_CAP_UNLIMITED);
+ }
+
+}
diff --git a/Bukkit/src/main/resources/plugin.yml b/Bukkit/src/main/resources/plugin.yml
index 3cfa79a65..175f201c8 100644
--- a/Bukkit/src/main/resources/plugin.yml
+++ b/Bukkit/src/main/resources/plugin.yml
@@ -6,7 +6,7 @@ load: STARTUP
description: "Easy, yet powerful Plot World generation and management."
authors: [Citymonstret, Empire92, MattBDev, dordsor21, NotMyFault, SirYwell]
website: https://www.spigotmc.org/resources/77506/
-softdepend: [Vault, PlaceholderAPI, Essentials, LuckPerms, BungeePerms]
+softdepend: [Vault, PlaceholderAPI, Essentials, LuckPerms, BungeePerms, MVdWPlaceholderAPI]
loadbefore: [MultiWorld, Multiverse-Core]
depend: [WorldEdit]
database: false
diff --git a/Core/src/main/java/com/plotsquared/core/PlotSquared.java b/Core/src/main/java/com/plotsquared/core/PlotSquared.java
index 25737ec72..7c321620d 100644
--- a/Core/src/main/java/com/plotsquared/core/PlotSquared.java
+++ b/Core/src/main/java/com/plotsquared/core/PlotSquared.java
@@ -56,6 +56,8 @@ import com.plotsquared.core.plot.PlotId;
import com.plotsquared.core.plot.PlotManager;
import com.plotsquared.core.plot.expiration.ExpireManager;
import com.plotsquared.core.plot.expiration.ExpiryTask;
+import com.plotsquared.core.plot.flag.GlobalFlagContainer;
+import com.plotsquared.core.plot.world.DefaultPlotAreaManager;
import com.plotsquared.core.plot.world.PlotAreaManager;
import com.plotsquared.core.plot.world.SinglePlotArea;
import com.plotsquared.core.plot.world.SinglePlotAreaManager;
@@ -64,6 +66,13 @@ import com.plotsquared.core.util.FileUtils;
import com.plotsquared.core.util.LegacyConverter;
import com.plotsquared.core.util.MathMan;
import com.plotsquared.core.util.ReflectionUtils;
+import com.plotsquared.core.util.RegionManager;
+import com.plotsquared.core.util.SchematicHandler;
+import com.plotsquared.core.util.SetupUtils;
+import com.plotsquared.core.util.StringMan;
+import com.plotsquared.core.util.WorldUtil;
+import com.plotsquared.core.util.logger.ILogger;
+import com.plotsquared.core.util.placeholders.PlaceholderRegistry;
import com.plotsquared.core.util.query.PlotQuery;
import com.plotsquared.core.util.task.TaskManager;
import com.plotsquared.core.uuid.UUIDPipeline;
@@ -146,6 +155,7 @@ public class PlotSquared {
private File storageFile;
@Getter private EventDispatcher eventDispatcher;
@Getter private PlotListener plotListener;
+ @Getter private PlaceholderRegistry placeholderRegistry;
/**
* Initialize PlotSquared with the desired Implementation class.
@@ -171,6 +181,9 @@ public class PlotSquared {
//
ConfigurationSerialization.registerClass(BlockBucket.class, "BlockBucket");
+ // Setup the global flag container
+ GlobalFlagContainer.setup();
+
try {
new ReflectionUtils(this.platform.getNMSPackage());
try {
diff --git a/Core/src/main/java/com/plotsquared/core/generator/ClassicPlotManager.java b/Core/src/main/java/com/plotsquared/core/generator/ClassicPlotManager.java
index 7c2263954..2361c6814 100644
--- a/Core/src/main/java/com/plotsquared/core/generator/ClassicPlotManager.java
+++ b/Core/src/main/java/com/plotsquared/core/generator/ClassicPlotManager.java
@@ -40,7 +40,6 @@ import com.plotsquared.core.util.task.TaskManager;
import com.sk89q.worldedit.function.pattern.Pattern;
import com.sk89q.worldedit.regions.CuboidRegion;
import com.sk89q.worldedit.world.block.BlockTypes;
-import org.jetbrains.annotations.NotNull;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
@@ -62,7 +61,7 @@ public class ClassicPlotManager extends SquarePlotManager {
}
@Override
- public boolean setComponent(@NotNull PlotId plotId, @NotNull String component, @NotNull Pattern blocks, @Nullable QueueCoordinator queue) {
+ public boolean setComponent(@Nonnull PlotId plotId, @Nonnull String component, @Nonnull Pattern blocks, @Nullable QueueCoordinator queue) {
final Optional componentOptional = ClassicPlotManagerComponent.fromString(component);
if (componentOptional.isPresent()) {
switch (componentOptional.get()) {
@@ -87,9 +86,10 @@ public class ClassicPlotManager extends SquarePlotManager {
return false;
}
- @Override public boolean unClaimPlot(@NotNull Plot plot, @Nullable Runnable whenDone, @Nullable QueueCoordinator queue) {
+ @Override public boolean unClaimPlot(@Nonnull Plot plot, @Nullable Runnable whenDone, @Nullable QueueCoordinator queue) {
setWallFilling(plot.getId(), classicPlotWorld.WALL_FILLING.toPattern(), queue);
- if (!classicPlotWorld.WALL_BLOCK.isAir() || !classicPlotWorld.WALL_BLOCK.equals(classicPlotWorld.CLAIMED_WALL_BLOCK)) {
+ if (classicPlotWorld.PLACE_TOP_BLOCK && (!classicPlotWorld.WALL_BLOCK.isAir() || !classicPlotWorld.WALL_BLOCK
+ .equals(classicPlotWorld.CLAIMED_WALL_BLOCK))) {
setWall(plot.getId(), classicPlotWorld.WALL_BLOCK.toPattern(), queue);
}
TaskManager.runTask(whenDone);
@@ -328,7 +328,7 @@ public class ClassicPlotManager extends SquarePlotManager {
/**
* PLOT MERGING.
*/
- @Override public boolean createRoadEast(@NotNull Plot plot, @Nullable QueueCoordinator queue) {
+ @Override public boolean createRoadEast(@Nonnull Plot plot, @Nullable QueueCoordinator queue) {
Location pos1 = getPlotBottomLocAbs(plot.getId());
Location pos2 = getPlotTopLocAbs(plot.getId());
int sx = pos2.getX() + 1;
@@ -350,18 +350,23 @@ public class ClassicPlotManager extends SquarePlotManager {
BlockUtil.get((short) 7, (byte) 0));
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT, ez - 1), classicPlotWorld.WALL_FILLING.toPattern());
- queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT + 1, sz + 1),
- Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT + 1, ez - 1), classicPlotWorld.WALL_BLOCK.toPattern());
+
+ if (classicPlotWorld.PLACE_TOP_BLOCK) {
+ queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT + 1, sz + 1),
+ Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.WALL_HEIGHT + 1, ez - 1), classicPlotWorld.WALL_BLOCK.toPattern());
+ }
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), ex, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT, ez - 1), classicPlotWorld.WALL_FILLING.toPattern());
- queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT + 1, sz + 1),
- Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT + 1, ez - 1), classicPlotWorld.WALL_BLOCK.toPattern());
+ if (classicPlotWorld.PLACE_TOP_BLOCK) {
+ queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT + 1, sz + 1),
+ Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.WALL_HEIGHT + 1, ez - 1), classicPlotWorld.WALL_BLOCK.toPattern());
+ }
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT, ez - 1), classicPlotWorld.ROAD_BLOCK.toPattern());
- return !enqueue || queue.enqueue();
+ return queue.enqueue();
}
- @Override public boolean createRoadSouth(@NotNull Plot plot, @Nullable QueueCoordinator queue) {
+ @Override public boolean createRoadSouth(@Nonnull Plot plot, @Nullable QueueCoordinator queue) {
Location pos1 = getPlotBottomLocAbs(plot.getId());
Location pos2 = getPlotTopLocAbs(plot.getId());
int sz = pos2.getZ() + 1;
@@ -383,18 +388,23 @@ public class ClassicPlotManager extends SquarePlotManager {
BlockUtil.get((short) 7, (byte) 0));
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT, sz), classicPlotWorld.WALL_FILLING.toPattern());
- queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.WALL_HEIGHT + 1, sz),
- Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT + 1, sz), classicPlotWorld.WALL_BLOCK.toPattern());
+
+ if (classicPlotWorld.PLACE_TOP_BLOCK) {
+ queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.WALL_HEIGHT + 1, sz),
+ Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT + 1, sz), classicPlotWorld.WALL_BLOCK.toPattern());
+ }
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, ez),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT, ez), classicPlotWorld.WALL_FILLING.toPattern());
- queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.WALL_HEIGHT + 1, ez),
- Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT + 1, ez), classicPlotWorld.WALL_BLOCK.toPattern());
+ if (classicPlotWorld.PLACE_TOP_BLOCK) {
+ queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.WALL_HEIGHT + 1, ez),
+ Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.WALL_HEIGHT + 1, ez), classicPlotWorld.WALL_BLOCK.toPattern());
+ }
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, 1, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.ROAD_HEIGHT, ez - 1), classicPlotWorld.ROAD_BLOCK.toPattern());
- return !enqueue || queue.enqueue();
+ return queue.enqueue();
}
- @Override public boolean createRoadSouthEast(@NotNull Plot plot, @Nullable QueueCoordinator queue) {
+ @Override public boolean createRoadSouthEast(@Nonnull Plot plot, @Nullable QueueCoordinator queue) {
Location pos2 = getPlotTopLocAbs(plot.getId());
int sx = pos2.getX() + 1;
int ex = sx + classicPlotWorld.ROAD_WIDTH - 1;
@@ -417,7 +427,7 @@ public class ClassicPlotManager extends SquarePlotManager {
return !enqueue || queue.enqueue();
}
- @Override public boolean removeRoadEast(@NotNull Plot plot, @Nullable QueueCoordinator queue) {
+ @Override public boolean removeRoadEast(@Nonnull Plot plot, @Nullable QueueCoordinator queue) {
Location pos1 = getPlotBottomLocAbs(plot.getId());
Location pos2 = getPlotTopLocAbs(plot.getId());
int sx = pos2.getX() + 1;
@@ -439,10 +449,11 @@ public class ClassicPlotManager extends SquarePlotManager {
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT - 1, ez - 1), classicPlotWorld.MAIN_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.PLOT_HEIGHT, sz + 1),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT, ez - 1), classicPlotWorld.TOP_BLOCK.toPattern());
+
return !enqueue || queue.enqueue();
}
- @Override public boolean removeRoadSouth(@NotNull Plot plot, @Nullable QueueCoordinator queue) {
+ @Override public boolean removeRoadSouth(@Nonnull Plot plot, @Nullable QueueCoordinator queue) {
Location pos1 = getPlotBottomLocAbs(plot.getId());
Location pos2 = getPlotTopLocAbs(plot.getId());
int sz = pos2.getZ() + 1;
@@ -464,10 +475,11 @@ public class ClassicPlotManager extends SquarePlotManager {
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.PLOT_HEIGHT - 1, ez), classicPlotWorld.MAIN_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx + 1, classicPlotWorld.PLOT_HEIGHT, sz),
Location.at(classicPlotWorld.getWorldName(), ex - 1, classicPlotWorld.PLOT_HEIGHT, ez), classicPlotWorld.TOP_BLOCK.toPattern());
+
return !enqueue || queue.enqueue();
}
- @Override public boolean removeRoadSouthEast(@NotNull Plot plot, @Nullable QueueCoordinator queue) {
+ @Override public boolean removeRoadSouthEast(@Nonnull Plot plot, @Nullable QueueCoordinator queue) {
Location location = getPlotTopLocAbs(plot.getId());
int sx = location.getX() + 1;
int ex = sx + classicPlotWorld.ROAD_WIDTH - 1;
@@ -488,6 +500,7 @@ public class ClassicPlotManager extends SquarePlotManager {
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT - 1, ez), classicPlotWorld.MAIN_BLOCK.toPattern());
queue.setCuboid(Location.at(classicPlotWorld.getWorldName(), sx, classicPlotWorld.PLOT_HEIGHT, sz),
Location.at(classicPlotWorld.getWorldName(), ex, classicPlotWorld.PLOT_HEIGHT, ez), classicPlotWorld.TOP_BLOCK.toPattern());
+
return !enqueue || queue.enqueue();
}
@@ -496,9 +509,9 @@ public class ClassicPlotManager extends SquarePlotManager {
*
* @return false if part of the merge failed, otherwise true if successful.
*/
- @Override public boolean finishPlotMerge(@NotNull List plotIds, @Nullable QueueCoordinator queue) {
+ @Override public boolean finishPlotMerge(@Nonnull List plotIds, @Nullable QueueCoordinator queue) {
final BlockBucket claim = classicPlotWorld.CLAIMED_WALL_BLOCK;
- if (!claim.isAir() || !claim.equals(classicPlotWorld.WALL_BLOCK)) {
+ if (classicPlotWorld.PLACE_TOP_BLOCK && (!claim.isAir() || !claim.equals(classicPlotWorld.WALL_BLOCK))) {
for (PlotId plotId : plotIds) {
setWall(plotId, claim.toPattern(), queue);
}
@@ -512,9 +525,9 @@ public class ClassicPlotManager extends SquarePlotManager {
return true;
}
- @Override public boolean finishPlotUnlink(@NotNull List plotIds, @Nullable QueueCoordinator queue) {
+ @Override public boolean finishPlotUnlink(@Nonnull List plotIds, @Nullable QueueCoordinator queue) {
final BlockBucket claim = classicPlotWorld.CLAIMED_WALL_BLOCK;
- if (!claim.isAir() || !claim.equals(classicPlotWorld.WALL_BLOCK)) {
+ if (classicPlotWorld.PLACE_TOP_BLOCK && (!claim.isAir() || !claim.equals(classicPlotWorld.WALL_BLOCK))) {
for (PlotId id : plotIds) {
setWall(id, claim.toPattern(), queue);
}
@@ -522,23 +535,23 @@ public class ClassicPlotManager extends SquarePlotManager {
return true; // return false if unlink has been denied
}
- @Override public boolean startPlotMerge(@NotNull List plotIds, @Nullable QueueCoordinator queue) {
+ @Override public boolean startPlotMerge(@Nonnull List plotIds, @Nullable QueueCoordinator queue) {
return true;
}
- @Override public boolean startPlotUnlink(@NotNull List plotIds, @Nullable QueueCoordinator queue) {
+ @Override public boolean startPlotUnlink(@Nonnull List plotIds, @Nullable QueueCoordinator queue) {
return true;
}
- @Override public boolean claimPlot(@NotNull Plot plot, @Nullable QueueCoordinator queue) {
+ @Override public boolean claimPlot(@Nonnull Plot plot, @Nullable QueueCoordinator queue) {
final BlockBucket claim = classicPlotWorld.CLAIMED_WALL_BLOCK;
- if (!claim.isAir() || !claim.equals(classicPlotWorld.WALL_BLOCK)) {
+ if (classicPlotWorld.PLACE_TOP_BLOCK && (!claim.isAir() || !claim.equals(classicPlotWorld.WALL_BLOCK))) {
return setWall(plot.getId(), claim.toPattern(), queue);
}
return true;
}
- @Override public String[] getPlotComponents(@NotNull PlotId plotId) {
+ @Override public String[] getPlotComponents(@Nonnull PlotId plotId) {
return ClassicPlotManagerComponent.stringValues();
}
@@ -548,7 +561,7 @@ public class ClassicPlotManager extends SquarePlotManager {
* @param plot The plot
* @return The location where a sign should be
*/
- @Override public Location getSignLoc(@NotNull Plot plot) {
+ @Override public Location getSignLoc(@Nonnull Plot plot) {
plot = plot.getBasePlot(false);
final Location bot = plot.getBottomAbs();
return Location.at(classicPlotWorld.getWorldName(), bot.getX() - 1, classicPlotWorld.ROAD_HEIGHT + 1, bot.getZ() - 2);
diff --git a/Core/src/main/java/com/plotsquared/core/generator/ClassicPlotWorld.java b/Core/src/main/java/com/plotsquared/core/generator/ClassicPlotWorld.java
index a09901c2c..172b09480 100644
--- a/Core/src/main/java/com/plotsquared/core/generator/ClassicPlotWorld.java
+++ b/Core/src/main/java/com/plotsquared/core/generator/ClassicPlotWorld.java
@@ -57,6 +57,7 @@ public abstract class ClassicPlotWorld extends SquarePlotWorld {
public BlockBucket ROAD_BLOCK = new BlockBucket(BlockTypes.QUARTZ_BLOCK);
// BlockUtil.get((short) 155, (byte) 0);
public boolean PLOT_BEDROCK = true;
+ public boolean PLACE_TOP_BLOCK = true;
public ClassicPlotWorld(@Nonnull final String worldName,
@Nullable final String id,
@@ -90,6 +91,8 @@ public abstract class ClassicPlotWorld extends SquarePlotWorld {
ConfigurationUtil.BLOCK_BUCKET),
new ConfigurationNode("wall.block_claimed", this.CLAIMED_WALL_BLOCK,
"Wall block (claimed)", ConfigurationUtil.BLOCK_BUCKET),
+ new ConfigurationNode("wall.place_top_block", this.PLACE_TOP_BLOCK,
+ "Place or not the top block", ConfigurationUtil.BOOLEAN),
new ConfigurationNode("road.width", this.ROAD_WIDTH, "Road width",
ConfigurationUtil.INTEGER),
new ConfigurationNode("road.height", this.ROAD_HEIGHT, "Road height",
@@ -120,5 +123,6 @@ public abstract class ClassicPlotWorld extends SquarePlotWorld {
this.WALL_FILLING = new BlockBucket(config.getString("wall.filling"));
this.WALL_HEIGHT = Math.min(254, config.getInt("wall.height"));
this.CLAIMED_WALL_BLOCK = new BlockBucket(config.getString("wall.block_claimed"));
+ this.PLACE_TOP_BLOCK = config.getBoolean("wall.place_top_block");
}
}
diff --git a/Core/src/main/java/com/plotsquared/core/generator/HybridGen.java b/Core/src/main/java/com/plotsquared/core/generator/HybridGen.java
index e91d3104d..cec5fd90d 100644
--- a/Core/src/main/java/com/plotsquared/core/generator/HybridGen.java
+++ b/Core/src/main/java/com/plotsquared/core/generator/HybridGen.java
@@ -180,8 +180,10 @@ public class HybridGen extends IndependentPlotGenerator {
result.setBlock(x, y, z, hybridPlotWorld.WALL_FILLING.toPattern());
}
if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
- result.setBlock(x, hybridPlotWorld.WALL_HEIGHT + 1, z,
- hybridPlotWorld.WALL_BLOCK.toPattern());
+ if (hybridPlotWorld.PLACE_TOP_BLOCK) {
+ result.setBlock(x, hybridPlotWorld.WALL_HEIGHT + 1, z,
+ hybridPlotWorld.WALL_BLOCK.toPattern());
+ }
} else {
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z,
true);
@@ -205,8 +207,10 @@ public class HybridGen extends IndependentPlotGenerator {
result.setBlock(x, y, z, hybridPlotWorld.WALL_FILLING.toPattern());
}
if (!hybridPlotWorld.ROAD_SCHEMATIC_ENABLED) {
- result.setBlock(x, hybridPlotWorld.WALL_HEIGHT + 1, z,
- hybridPlotWorld.WALL_BLOCK.toPattern());
+ if (hybridPlotWorld.PLACE_TOP_BLOCK) {
+ result.setBlock(x, hybridPlotWorld.WALL_HEIGHT + 1, z,
+ hybridPlotWorld.WALL_BLOCK.toPattern());
+ }
} else {
placeSchem(hybridPlotWorld, result, relativeX[x], relativeZ[z], x, z,
true);
diff --git a/Core/src/main/java/com/plotsquared/core/plot/Plot.java b/Core/src/main/java/com/plotsquared/core/plot/Plot.java
index 2c3c462e3..b12a7a5d5 100644
--- a/Core/src/main/java/com/plotsquared/core/plot/Plot.java
+++ b/Core/src/main/java/com/plotsquared/core/plot/Plot.java
@@ -2312,7 +2312,7 @@ public class Plot {
*
* @return The plot alias
*/
- public String getAlias() {
+ @Nonnull public String getAlias() {
if (this.settings == null) {
return "";
}
diff --git a/Core/src/main/java/com/plotsquared/core/plot/flag/GlobalFlagContainer.java b/Core/src/main/java/com/plotsquared/core/plot/flag/GlobalFlagContainer.java
index 4d7fdd396..3c44a8b5a 100644
--- a/Core/src/main/java/com/plotsquared/core/plot/flag/GlobalFlagContainer.java
+++ b/Core/src/main/java/com/plotsquared/core/plot/flag/GlobalFlagContainer.java
@@ -25,6 +25,7 @@
*/
package com.plotsquared.core.plot.flag;
+import com.google.common.base.Preconditions;
import com.plotsquared.core.plot.flag.implementations.AnalysisFlag;
import com.plotsquared.core.plot.flag.implementations.AnimalAttackFlag;
import com.plotsquared.core.plot.flag.implementations.AnimalCapFlag;
@@ -114,7 +115,13 @@ import java.util.Map;
public final class GlobalFlagContainer extends FlagContainer {
- @Getter private static final GlobalFlagContainer instance = new GlobalFlagContainer();
+ @Getter private static GlobalFlagContainer instance;
+
+ public static void setup() {
+ Preconditions.checkState(instance == null, "Cannot setup the container twice");
+ instance = new GlobalFlagContainer();
+ }
+
private static Map> stringClassMap;
private GlobalFlagContainer() {
@@ -124,6 +131,7 @@ public final class GlobalFlagContainer extends FlagContainer {
}
});
stringClassMap = new HashMap<>();
+
// Register all default flags here
// Boolean flags
this.addFlag(ExplosionFlag.EXPLOSION_FALSE);
diff --git a/Core/src/main/java/com/plotsquared/core/util/EntityUtil.java b/Core/src/main/java/com/plotsquared/core/util/EntityUtil.java
index 098604597..56a8fb364 100644
--- a/Core/src/main/java/com/plotsquared/core/util/EntityUtil.java
+++ b/Core/src/main/java/com/plotsquared/core/util/EntityUtil.java
@@ -43,7 +43,7 @@ import static com.plotsquared.core.util.entity.EntityCategories.CAP_VEHICLE;
* Entity related general utility methods
*/
@UtilityClass
-public final class EntityUtil {
+public class EntityUtil {
private static int capNumeral(@Nonnull final String flagName) {
int i;
diff --git a/Core/src/main/java/com/plotsquared/core/util/EventDispatcher.java b/Core/src/main/java/com/plotsquared/core/util/EventDispatcher.java
index 47ae83d29..eefaec5c4 100644
--- a/Core/src/main/java/com/plotsquared/core/util/EventDispatcher.java
+++ b/Core/src/main/java/com/plotsquared/core/util/EventDispatcher.java
@@ -104,6 +104,9 @@ public class EventDispatcher {
eventBus.unregister(listener);
}
}
+ public void callGenericEvent(@Nonnull final Object event) {
+ eventBus.post(event);
+ }
public void callEvent(@Nonnull final PlotEvent event) {
eventBus.post(event);
diff --git a/Core/src/main/java/com/plotsquared/core/util/placeholders/Placeholder.java b/Core/src/main/java/com/plotsquared/core/util/placeholders/Placeholder.java
new file mode 100644
index 000000000..38e28a586
--- /dev/null
+++ b/Core/src/main/java/com/plotsquared/core/util/placeholders/Placeholder.java
@@ -0,0 +1,63 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.core.util.placeholders;
+
+import com.google.common.base.Preconditions;
+import com.plotsquared.core.player.PlotPlayer;
+import lombok.EqualsAndHashCode;
+import lombok.ToString;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A placeholder is a keyed value that gets replaced by a {@link PlotPlayer player}-specific value at runtime
+ */
+@EqualsAndHashCode(of = "key") @ToString(of = "key")
+public abstract class Placeholder {
+
+ private final String key;
+
+ public Placeholder(@NotNull final String key) {
+ this.key = Preconditions.checkNotNull(key, "Key may not be null");
+ }
+
+ /**
+ * Get the value of the placeholder for a particular player
+ *
+ * @param player Player
+ * @return Placeholder value. Return {@code ""} if no placeholder value can be returned
+ */
+ @NotNull public abstract String getValue(@NotNull final PlotPlayer player);
+
+ /**
+ * Get the placeholder key
+ *
+ * @return Placeholder key
+ */
+ @NotNull public final String getKey() {
+ return this.key;
+ }
+
+}
diff --git a/Core/src/main/java/com/plotsquared/core/util/placeholders/PlaceholderRegistry.java b/Core/src/main/java/com/plotsquared/core/util/placeholders/PlaceholderRegistry.java
new file mode 100644
index 000000000..11afc948d
--- /dev/null
+++ b/Core/src/main/java/com/plotsquared/core/util/placeholders/PlaceholderRegistry.java
@@ -0,0 +1,231 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.core.util.placeholders;
+
+import com.google.common.base.Function;
+import com.google.common.base.Preconditions;
+import com.google.common.collect.Maps;
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.flag.GlobalFlagContainer;
+import com.plotsquared.core.plot.flag.PlotFlag;
+import com.plotsquared.core.util.EventDispatcher;
+import com.plotsquared.core.util.MainUtil;
+import com.plotsquared.core.util.PlayerManager;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Locale;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.BiFunction;
+
+/**
+ * Registry that contains {@link Placeholder placeholders}
+ */
+public final class PlaceholderRegistry {
+
+ private final Map placeholders;
+ private final EventDispatcher eventDispatcher;
+
+ public PlaceholderRegistry(@NotNull final EventDispatcher eventDispatcher) {
+ this.placeholders = Maps.newHashMap();
+ this.eventDispatcher = eventDispatcher;
+ this.registerDefault();
+ }
+
+ private void registerDefault() {
+ final GlobalFlagContainer globalFlagContainer = GlobalFlagContainer.getInstance();
+ for (final PlotFlag flag : globalFlagContainer.getRecognizedPlotFlags()) {
+ this.registerPlaceholder(new PlotFlagPlaceholder(flag, true));
+ this.registerPlaceholder(new PlotFlagPlaceholder(flag, false));
+ }
+ GlobalFlagContainer.getInstance().subscribe((flag, type) -> {
+ this.registerPlaceholder(new PlotFlagPlaceholder(flag, true));
+ this.registerPlaceholder(new PlotFlagPlaceholder(flag, false));
+ });
+ this.createPlaceholder("currentplot_world", player -> player.getLocation().getWorldName());
+ this.createPlaceholder("has_plot", player -> player.getPlotCount() > 0 ? "true" : "false");
+ this.createPlaceholder("allowed_plot_count", player -> Integer.toString(player.getAllowedPlots()));
+ this.createPlaceholder("plot_count", player -> Integer.toString(player.getPlotCount()));
+ this.createPlaceholder("currentplot_alias", (player, plot) -> plot.getAlias());
+ this.createPlaceholder("currentplot_owner", (player, plot) -> {
+ final UUID plotOwner = plot.getOwnerAbs();
+ if (plotOwner == null) {
+ return "";
+ }
+
+ try {
+ return PlayerManager.getName(plotOwner, false);
+ } catch (final Exception ignored) {}
+
+ return "unknown";
+ });
+ this.createPlaceholder("currentplot_members", (player, plot) -> {
+ if (plot.getMembers() == null && plot.getTrusted() == null) {
+ return "0";
+ }
+ return String.valueOf(plot.getMembers().size() + plot.getTrusted().size());
+ });
+ this.createPlaceholder("currentplot_members_added", (player, plot) -> {
+ if (plot.getMembers() == null) {
+ return "0";
+ }
+ return String.valueOf(plot.getMembers().size());
+ });
+ this.createPlaceholder("currentplot_members_trusted", (player, plot) -> {
+ if (plot.getTrusted() == null) {
+ return "0";
+ }
+ return String.valueOf(plot.getTrusted().size());
+ });
+ this.createPlaceholder("currentplot_members_denied", (player, plot) -> {
+ if (plot.getDenied() == null) {
+ return "0";
+ }
+ return String.valueOf(plot.getDenied().size());
+ });
+ this.createPlaceholder("has_build_rights", (player, plot) ->
+ plot.isAdded(player.getUUID()) ? "true" : "false");
+ this.createPlaceholder("currentplot_x", (player, plot) -> Integer.toString(plot.getId().getX()));
+ this.createPlaceholder("currentplot_y", (player, plot) -> Integer.toString(plot.getId().getY()));
+ this.createPlaceholder("currentplot_xy", (player, plot) -> plot.getId().toString());
+ this.createPlaceholder("currentplot_rating", (player, plot) -> Double.toString(plot.getAverageRating()));
+ this.createPlaceholder("currentplot_biome", (player, plot) -> plot.getBiomeSynchronous().toString());
+ }
+
+ /**
+ * Create a functional placeholder
+ *
+ * @param key Placeholder key
+ * @param placeholderFunction Placeholder generator. Cannot return null
+ */
+ @SuppressWarnings("ALL") public void createPlaceholder(@NotNull final String key,
+ @NotNull final Function, String> placeholderFunction) {
+ this.registerPlaceholder(new Placeholder(key) {
+ @Override @NotNull public String getValue(@NotNull final PlotPlayer player) {
+ return placeholderFunction.apply(player);
+ }
+ });
+ }
+
+ /**
+ * Create a functional placeholder
+ *
+ * @param key Placeholder key
+ * @param placeholderFunction Placeholder generator. Cannot return null
+ */
+ public void createPlaceholder(@NotNull final String key,
+ @NotNull final BiFunction, Plot, String> placeholderFunction) {
+ this.registerPlaceholder(new PlotSpecificPlaceholder(key) {
+ @Override @NotNull public String getValue(@NotNull final PlotPlayer player, @NotNull final Plot plot) {
+ return placeholderFunction.apply(player, plot);
+ }
+ });
+ }
+
+ /**
+ * Register a placeholder
+ *
+ * @param placeholder Placeholder instance
+ */
+ public void registerPlaceholder(@NotNull final Placeholder placeholder) {
+ final Placeholder previous = this.placeholders
+ .put(placeholder.getKey().toLowerCase(Locale.ENGLISH),
+ Preconditions.checkNotNull(placeholder, "Placeholder may not be null"));
+ if (previous == null) {
+ this.eventDispatcher.callGenericEvent(new PlaceholderAddedEvent(placeholder));
+ }
+ }
+
+ /**
+ * Get a placeholder instance from its key
+ *
+ * @param key Placeholder key
+ * @return Placeholder value
+ */
+ @Nullable public Placeholder getPlaceholder(@NotNull final String key) {
+ return this.placeholders.get(
+ Preconditions.checkNotNull(key, "Key may not be null").toLowerCase(Locale.ENGLISH));
+ }
+
+ /**
+ * Get the placeholder value evaluated for a player, and catch and deal with any problems
+ * occurring while doing so
+ *
+ * @param key Placeholder key
+ * @param player Player to evaluate for
+ * @return Replacement value
+ */
+ @NotNull public String getPlaceholderValue(@NotNull final String key,
+ @NotNull final PlotPlayer player) {
+ final Placeholder placeholder = getPlaceholder(key);
+ if (placeholder == null) {
+ return "";
+ }
+ String placeholderValue = "";
+ try {
+ placeholderValue = placeholder.getValue(player);
+ // If a placeholder for some reason decides to be disobedient, we catch it here
+ if (placeholderValue == null) {
+ new RuntimeException(String
+ .format("Placeholder '%s' returned null for player '%s'", placeholder.getKey(),
+ player.getName())).printStackTrace();
+ }
+ } catch (final Exception exception) {
+ new RuntimeException(String
+ .format("Placeholder '%s' failed to evalulate for player '%s'",
+ placeholder.getKey(), player.getName()), exception).printStackTrace();
+ }
+ return placeholderValue;
+ }
+
+ /**
+ * Get all placeholders
+ *
+ * @return Unmodifiable collection of placeholders
+ */
+ @NotNull public Collection getPlaceholders() {
+ return Collections.unmodifiableCollection(this.placeholders.values());
+ }
+
+
+ /**
+ * Event called when a new {@link Placeholder} has been added
+ */
+ @RequiredArgsConstructor
+ @Getter
+ public static class PlaceholderAddedEvent {
+
+ private final Placeholder placeholder;
+
+ }
+
+}
diff --git a/Core/src/main/java/com/plotsquared/core/util/placeholders/PlotFlagPlaceholder.java b/Core/src/main/java/com/plotsquared/core/util/placeholders/PlotFlagPlaceholder.java
new file mode 100644
index 000000000..4a3d1876a
--- /dev/null
+++ b/Core/src/main/java/com/plotsquared/core/util/placeholders/PlotFlagPlaceholder.java
@@ -0,0 +1,76 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.core.util.placeholders;
+
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import com.plotsquared.core.plot.flag.GlobalFlagContainer;
+import com.plotsquared.core.plot.flag.PlotFlag;
+import org.jetbrains.annotations.NotNull;
+
+public final class PlotFlagPlaceholder extends PlotSpecificPlaceholder {
+
+ private final PlotFlag flag;
+ private final boolean local;
+
+ public PlotFlagPlaceholder(@NotNull final PlotFlag flag, final boolean local) {
+ super(String.format("currentplot_%sflag_%s", local ? "local": "", flag.getName()));
+ this.flag = flag;
+ this.local = local;
+ }
+
+ @Override @NotNull public String getValue(@NotNull final PlotPlayer player, @NotNull final Plot plot) {
+ return this.getFlagValue(plot, this.flag.getName(), !this.local);
+ }
+
+ /**
+ * Return the flag value from its name on the current plot.
+ * If the flag doesn't exist it returns an empty string.
+ * If the flag exists but it is not set on current plot and the parameter inherit is set to true,
+ * it returns the default value.
+ *
+ * @param plot Current plot where the player is
+ * @param flagName Name of flag to get from current plot
+ * @param inherit Define if it returns only the flag set on the current plot or also inherited flags
+ * @return The value of flag serialized in string
+ */
+ @NotNull private String getFlagValue(@NotNull final Plot plot, @NotNull final String flagName, final boolean inherit) {
+ if (flagName.isEmpty()) {
+ return "";
+ }
+ final PlotFlag flag = GlobalFlagContainer.getInstance().getFlagFromString(flagName);
+ if (flag == null) {
+ return "";
+ }
+ if (inherit) {
+ return plot.getFlag(flag).toString();
+ } else {
+ final PlotFlag plotFlag = plot.getFlagContainer().queryLocal(flag.getClass());
+ return (plotFlag != null) ? plotFlag.getValue().toString() : "";
+ }
+ }
+
+}
diff --git a/Core/src/main/java/com/plotsquared/core/util/placeholders/PlotSpecificPlaceholder.java b/Core/src/main/java/com/plotsquared/core/util/placeholders/PlotSpecificPlaceholder.java
new file mode 100644
index 000000000..92285238d
--- /dev/null
+++ b/Core/src/main/java/com/plotsquared/core/util/placeholders/PlotSpecificPlaceholder.java
@@ -0,0 +1,59 @@
+/*
+ * _____ _ _ _____ _
+ * | __ \| | | | / ____| | |
+ * | |__) | | ___ | |_| (___ __ _ _ _ __ _ _ __ ___ __| |
+ * | ___/| |/ _ \| __|\___ \ / _` | | | |/ _` | '__/ _ \/ _` |
+ * | | | | (_) | |_ ____) | (_| | |_| | (_| | | | __/ (_| |
+ * |_| |_|\___/ \__|_____/ \__, |\__,_|\__,_|_| \___|\__,_|
+ * | |
+ * |_|
+ * PlotSquared plot management system for Minecraft
+ * Copyright (C) 2020 IntellectualSites
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program. If not, see .
+ */
+package com.plotsquared.core.util.placeholders;
+
+import com.plotsquared.core.player.PlotPlayer;
+import com.plotsquared.core.plot.Plot;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * A {@link Placeholder placeholder} that requires a {@link com.plotsquared.core.plot.Plot plot}
+ */
+public abstract class PlotSpecificPlaceholder extends Placeholder {
+
+ public PlotSpecificPlaceholder(@NotNull final String key) {
+ super(key);
+ }
+
+ @Override @NotNull public final String getValue(@NotNull final PlotPlayer player) {
+ final Plot plot = player.getCurrentPlot();
+ if (plot == null) {
+ return "";
+ }
+ return this.getValue(player, plot);
+ }
+
+ /**
+ * Get the value of the placeholder for the {@link PlotPlayer player} in a specific {@link Plot plot}
+ *
+ * @param player Player that the placeholder is evaluated for
+ * @param plot Plot that the player is in
+ * @return Placeholder value, or {@code ""} if the placeholder does not apply
+ */
+ @NotNull public abstract String getValue(@NotNull final PlotPlayer player,
+ @NotNull final Plot plot);
+
+}
diff --git a/Core/src/main/java/com/plotsquared/core/uuid/UUIDPipeline.java b/Core/src/main/java/com/plotsquared/core/uuid/UUIDPipeline.java
index 5e92691b1..a245a9117 100644
--- a/Core/src/main/java/com/plotsquared/core/uuid/UUIDPipeline.java
+++ b/Core/src/main/java/com/plotsquared/core/uuid/UUIDPipeline.java
@@ -31,11 +31,11 @@ import com.plotsquared.core.configuration.Captions;
import com.plotsquared.core.configuration.Settings;
import com.plotsquared.core.util.ThreadUtils;
import com.plotsquared.core.util.task.TaskManager;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
import java.util.ArrayList;
import java.util.Collection;
import java.util.Collections;
@@ -168,8 +168,10 @@ public class UUIDPipeline {
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} catch (TimeoutException ignored) {
- logger.warn("[P2] (UUID) Request for {} timed out", username);
// This is completely valid, we just don't care anymore
+ if (Settings.DEBUG) {
+ logger.warn("[P2] (UUID) Request for {} timed out", username);
+ }
}
return null;
}
@@ -191,8 +193,10 @@ public class UUIDPipeline {
} catch (InterruptedException | ExecutionException e) {
e.printStackTrace();
} catch (TimeoutException ignored) {
- logger.warn("[P2] (UUID) Request for {} timed out", uuid);
// This is completely valid, we just don't care anymore
+ if (Settings.DEBUG) {
+ logger.warn("[P2] (UUID) Request for {} timed out", uuid);
+ }
}
return null;
}
@@ -203,20 +207,19 @@ public class UUIDPipeline {
* @param username Username
* @param uuid UUID consumer
*/
- public void getSingle(@Nonnull final String username,
- @Nonnull final BiConsumer uuid) {
+ public void getSingle(@Nonnull final String username, @Nonnull final BiConsumer uuid) {
this.getUUIDs(Collections.singletonList(username)).applyToEither(timeoutAfter(Settings.UUID.NON_BLOCKING_TIMEOUT), Function.identity())
.whenComplete((uuids, throwable) -> {
- if (throwable != null) {
- uuid.accept(null, throwable);
- } else {
- if (!uuids.isEmpty()) {
- uuid.accept(uuids.get(0).getUuid(), null);
+ if (throwable != null) {
+ uuid.accept(null, throwable);
} else {
- uuid.accept(null, null);
+ if (!uuids.isEmpty()) {
+ uuid.accept(uuids.get(0).getUuid(), null);
+ } else {
+ uuid.accept(null, null);
+ }
}
- }
- });
+ });
}
/**
@@ -225,20 +228,19 @@ public class UUIDPipeline {
* @param uuid UUID
* @param username Username consumer
*/
- public void getSingle(@Nonnull final UUID uuid,
- @Nonnull final BiConsumer username) {
+ public void getSingle(@Nonnull final UUID uuid, @Nonnull final BiConsumer username) {
this.getNames(Collections.singletonList(uuid)).applyToEither(timeoutAfter(Settings.UUID.NON_BLOCKING_TIMEOUT), Function.identity())
.whenComplete((uuids, throwable) -> {
- if (throwable != null) {
- username.accept(null, throwable);
- } else {
- if (!uuids.isEmpty()) {
- username.accept(uuids.get(0).getUsername(), null);
+ if (throwable != null) {
+ username.accept(null, throwable);
} else {
- username.accept(null, null);
+ if (!uuids.isEmpty()) {
+ username.accept(uuids.get(0).getUsername(), null);
+ } else {
+ username.accept(null, null);
+ }
}
- }
- });
+ });
}
/**
@@ -251,8 +253,7 @@ public class UUIDPipeline {
* @param timeout Timeout in milliseconds
* @return Mappings
*/
- public CompletableFuture> getNames(@Nonnull final Collection requests,
- final long timeout) {
+ public CompletableFuture> getNames(@Nonnull final Collection requests, final long timeout) {
return this.getNames(requests).applyToEither(timeoutAfter(timeout), Function.identity());
}
@@ -266,8 +267,7 @@ public class UUIDPipeline {
* @param timeout Timeout in milliseconds
* @return Mappings
*/
- public CompletableFuture> getUUIDs(@Nonnull final Collection requests,
- final long timeout) {
+ public CompletableFuture> getUUIDs(@Nonnull final Collection requests, final long timeout) {
return this.getUUIDs(requests).applyToEither(timeoutAfter(timeout), Function.identity());
}
@@ -345,8 +345,7 @@ public class UUIDPipeline {
* @param requests Names
* @return Mappings
*/
- public CompletableFuture> getUUIDs(
- @Nonnull final Collection requests) {
+ public CompletableFuture> getUUIDs(@Nonnull final Collection requests) {
if (requests.isEmpty()) {
return CompletableFuture.completedFuture(Collections.emptyList());
}