Reworked project structure

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/EcoPlugin.java

@@ -0,0 +1,126 @@
+package com.willfp.eco.spigot;
+
+import com.willfp.eco.spigot.display.packets.PacketAutoRecipe;
+import com.willfp.eco.spigot.display.packets.PacketChat;
+import com.willfp.eco.spigot.display.packets.PacketOpenWindowMerchant;
+import com.willfp.eco.spigot.display.packets.PacketSetCreativeSlot;
+import com.willfp.eco.spigot.display.packets.PacketSetSlot;
+import com.willfp.eco.spigot.display.packets.PacketWindowItems;
+import com.willfp.eco.spigot.integrations.anticheat.plugins.AnticheatAAC;
+import com.willfp.eco.spigot.integrations.anticheat.plugins.AnticheatMatrix;
+import com.willfp.eco.spigot.integrations.anticheat.plugins.AnticheatNCP;
+import com.willfp.eco.spigot.integrations.antigrief.plugins.AntigriefFactionsUUID;
+import com.willfp.eco.spigot.integrations.antigrief.plugins.AntigriefGriefPrevention;
+import com.willfp.eco.spigot.integrations.antigrief.plugins.AntigriefKingdoms;
+import com.willfp.eco.spigot.integrations.antigrief.plugins.AntigriefLands;
+import com.willfp.eco.spigot.integrations.antigrief.plugins.AntigriefTowny;
+import com.willfp.eco.spigot.integrations.antigrief.plugins.AntigriefWorldGuard;
+import com.willfp.eco.util.command.AbstractCommand;
+import com.willfp.eco.util.drops.internal.FastCollatedDropQueue;
+import com.willfp.eco.util.events.armorequip.ArmorListener;
+import com.willfp.eco.util.events.armorequip.DispenserArmorListener;
+import com.willfp.eco.util.events.entitydeathbyentity.EntityDeathByEntityListeners;
+import com.willfp.eco.util.events.naturalexpgainevent.NaturalExpGainListeners;
+import com.willfp.eco.util.integrations.IntegrationLoader;
+import com.willfp.eco.util.integrations.anticheat.AnticheatManager;
+import com.willfp.eco.util.integrations.antigrief.AntigriefManager;
+import com.willfp.eco.util.plugin.AbstractEcoPlugin;
+import com.willfp.eco.util.protocollib.AbstractPacketAdapter;
+import com.willfp.eco.util.recipe.RecipeListener;
+import lombok.Getter;
+import org.bukkit.event.Listener;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class EcoPlugin extends AbstractEcoPlugin {
+    /**
+     * Instance of eco.
+     */
+    @Getter
+    private static EcoPlugin instance;
+
+    /**
+     * Create a new instance of eco.
+     */
+    public EcoPlugin() {
+        super("eco", 87955, 10043, "com.willfp.eco.proxy", "&a");
+        instance = this;
+    }
+
+    @Override
+    public void enable() {
+        new FastCollatedDropQueue.CollatedRunnable(this);
+        this.getEventManager().registerListener(new NaturalExpGainListeners());
+        this.getEventManager().registerListener(new ArmorListener());
+        this.getEventManager().registerListener(new DispenserArmorListener());
+        this.getEventManager().registerListener(new EntityDeathByEntityListeners(this));
+        this.getEventManager().registerListener(new RecipeListener(this));
+    }
+
+    @Override
+    public void disable() {
+
+    }
+
+    @Override
+    public void load() {
+
+    }
+
+    @Override
+    public void onReload() {
+        new FastCollatedDropQueue.CollatedRunnable(this);
+    }
+
+    @Override
+    public void postLoad() {
+
+    }
+
+    @Override
+    public List<IntegrationLoader> getIntegrationLoaders() {
+        return Arrays.asList(
+                // AntiGrief
+                new IntegrationLoader("WorldGuard", () -> AntigriefManager.register(new AntigriefWorldGuard())),
+                new IntegrationLoader("GriefPrevention", () -> AntigriefManager.register(new AntigriefGriefPrevention())),
+                new IntegrationLoader("FactionsUUID", () -> AntigriefManager.register(new AntigriefFactionsUUID())),
+                new IntegrationLoader("Towny", () -> AntigriefManager.register(new AntigriefTowny())),
+                new IntegrationLoader("Lands", () -> AntigriefManager.register(new AntigriefLands(this))),
+                new IntegrationLoader("Kingdoms", () -> AntigriefManager.register(new AntigriefKingdoms())),
+
+                // Anticheat
+                new IntegrationLoader("AAC5", () -> AnticheatManager.register(this, new AnticheatAAC())),
+                new IntegrationLoader("Matrix", () -> AnticheatManager.register(this, new AnticheatMatrix())),
+                new IntegrationLoader("NoCheatPlus", () -> AnticheatManager.register(this, new AnticheatNCP()))
+        );
+    }
+
+    @Override
+    public List<AbstractCommand> getCommands() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<AbstractPacketAdapter> getPacketAdapters() {
+        return Arrays.asList(
+                new PacketAutoRecipe(this),
+                new PacketChat(this),
+                new PacketOpenWindowMerchant(this),
+                new PacketSetCreativeSlot(this),
+                new PacketSetSlot(this),
+                new PacketWindowItems(this)
+        );
+    }
+
+    @Override
+    public List<Listener> getListeners() {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<Class<?>> getUpdatableClasses() {
+        return new ArrayList<>();
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/InternalProxyUtils.java

@@ -0,0 +1,20 @@
+package com.willfp.eco.spigot;
+
+import com.willfp.eco.util.proxy.AbstractProxy;
+import com.willfp.eco.proxy.util.ProxyFactory;
+import lombok.experimental.UtilityClass;
+import org.jetbrains.annotations.NotNull;
+
+@UtilityClass
+public class InternalProxyUtils {
+    /**
+     * Get the implementation of a specified proxy.
+     *
+     * @param proxyClass The proxy interface.
+     * @param <T>        The type of the proxy.
+     * @return The proxy implementation.
+     */
+    public @NotNull <T extends AbstractProxy> T getProxy(@NotNull final Class<T> proxyClass) {
+        return new ProxyFactory<>(EcoPlugin.getInstance(), proxyClass).getProxy();
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/display/packets/PacketAutoRecipe.java

@@ -0,0 +1,51 @@
+package com.willfp.eco.spigot.display.packets;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.ProtocolLibrary;
+import com.comphenix.protocol.events.PacketContainer;
+import com.willfp.eco.proxy.proxies.AutoCraftProxy;
+import com.willfp.eco.spigot.InternalProxyUtils;
+import com.willfp.eco.util.plugin.AbstractEcoPlugin;
+import com.willfp.eco.util.protocollib.AbstractPacketAdapter;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.InvocationTargetException;
+
+public class PacketAutoRecipe extends AbstractPacketAdapter {
+    /**
+     * Instantiate a new listener for {@link PacketType.Play.Server#SET_SLOT}.
+     *
+     * @param plugin The plugin to listen through.
+     */
+    public PacketAutoRecipe(@NotNull final AbstractEcoPlugin plugin) {
+        super(plugin, PacketType.Play.Server.AUTO_RECIPE, false);
+    }
+
+    @Override
+    public void onSend(@NotNull final PacketContainer packet,
+                       @NotNull final Player player) {
+        if (!AbstractEcoPlugin.LOADED_ECO_PLUGINS.contains(packet.getMinecraftKeys().getValues().get(0).getFullKey().split(":")[0])) {
+            return;
+        }
+
+        if (packet.getMinecraftKeys().getValues().get(0).getFullKey().split(":")[1].contains("displayed")) {
+            return;
+        }
+
+        try {
+            InternalProxyUtils.getProxy(AutoCraftProxy.class).modifyPacket(packet.getHandle());
+        } catch (NoSuchFieldException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+
+        PacketContainer newAutoRecipe = new PacketContainer(PacketType.Play.Server.AUTO_RECIPE);
+        newAutoRecipe.getMinecraftKeys().write(0, packet.getMinecraftKeys().read(0));
+
+        try {
+            ProtocolLibrary.getProtocolManager().sendServerPacket(player, newAutoRecipe);
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/display/packets/PacketChat.java

@@ -0,0 +1,41 @@
+package com.willfp.eco.spigot.display.packets;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.ListenerPriority;
+import com.comphenix.protocol.events.PacketContainer;
+import com.comphenix.protocol.wrappers.WrappedChatComponent;
+import com.willfp.eco.proxy.proxies.ChatComponentProxy;
+import com.willfp.eco.spigot.InternalProxyUtils;
+import com.willfp.eco.util.plugin.AbstractEcoPlugin;
+import com.willfp.eco.util.protocollib.AbstractPacketAdapter;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class PacketChat extends AbstractPacketAdapter {
+    /**
+     * Instantiate a new listener for {@link PacketType.Play.Server#CHAT}.
+     *
+     * @param plugin The plugin to listen through.
+     */
+    public PacketChat(@NotNull final AbstractEcoPlugin plugin) {
+        super(plugin, PacketType.Play.Server.CHAT, ListenerPriority.MONITOR, true);
+    }
+
+    @Override
+    public void onSend(@NotNull final PacketContainer packet,
+                       @NotNull final Player player) {
+        for (int i = 0; i < packet.getChatComponents().size(); i++) {
+            WrappedChatComponent component = packet.getChatComponents().read(i);
+            if (component == null) {
+                continue;
+            }
+
+            if (component.getHandle() == null) {
+                return;
+            }
+
+            WrappedChatComponent newComponent = WrappedChatComponent.fromHandle(InternalProxyUtils.getProxy(ChatComponentProxy.class).modifyComponent(component.getHandle()));
+            packet.getChatComponents().write(i, newComponent);
+        }
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/display/packets/PacketOpenWindowMerchant.java

@@ -0,0 +1,35 @@
+package com.willfp.eco.spigot.display.packets;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.willfp.eco.proxy.proxies.VillagerTradeProxy;
+import com.willfp.eco.spigot.InternalProxyUtils;
+import com.willfp.eco.util.plugin.AbstractEcoPlugin;
+import com.willfp.eco.util.protocollib.AbstractPacketAdapter;
+import org.bukkit.entity.Player;
+import org.bukkit.inventory.MerchantRecipe;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.List;
+import java.util.stream.Collectors;
+
+public class PacketOpenWindowMerchant extends AbstractPacketAdapter {
+    /**
+     * Instantiate a new listener for {@link PacketType.Play.Server#OPEN_WINDOW_MERCHANT}.
+     *
+     * @param plugin The plugin to listen through.
+     */
+    public PacketOpenWindowMerchant(@NotNull final AbstractEcoPlugin plugin) {
+        super(plugin, PacketType.Play.Server.OPEN_WINDOW_MERCHANT, false);
+    }
+
+    @Override
+    public void onSend(@NotNull final PacketContainer packet,
+                       @NotNull final Player player) {
+        List<MerchantRecipe> recipes = packet.getMerchantRecipeLists().readSafely(0);
+
+        recipes = recipes.stream().peek(merchantRecipe -> InternalProxyUtils.getProxy(VillagerTradeProxy.class).displayTrade(merchantRecipe)).collect(Collectors.toList());
+
+        packet.getMerchantRecipeLists().writeSafely(0, recipes);
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/display/packets/PacketSetCreativeSlot.java

@@ -0,0 +1,26 @@
+package com.willfp.eco.spigot.display.packets;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.willfp.eco.util.display.Display;
+import com.willfp.eco.util.plugin.AbstractEcoPlugin;
+import com.willfp.eco.util.protocollib.AbstractPacketAdapter;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class PacketSetCreativeSlot extends AbstractPacketAdapter {
+    /**
+     * Instantiate a new listener for {@link PacketType.Play.Client#SET_CREATIVE_SLOT}.
+     *
+     * @param plugin The plugin to listen through.
+     */
+    public PacketSetCreativeSlot(@NotNull final AbstractEcoPlugin plugin) {
+        super(plugin, PacketType.Play.Client.SET_CREATIVE_SLOT, false);
+    }
+
+    @Override
+    public void onReceive(@NotNull final PacketContainer packet,
+                          @NotNull final Player player) {
+        packet.getItemModifier().modify(0, Display::revert);
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/display/packets/PacketSetSlot.java

@@ -0,0 +1,26 @@
+package com.willfp.eco.spigot.display.packets;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.willfp.eco.util.display.Display;
+import com.willfp.eco.util.plugin.AbstractEcoPlugin;
+import com.willfp.eco.util.protocollib.AbstractPacketAdapter;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class PacketSetSlot extends AbstractPacketAdapter {
+    /**
+     * Instantiate a new listener for {@link PacketType.Play.Server#SET_SLOT}.
+     *
+     * @param plugin The plugin to listen through.
+     */
+    public PacketSetSlot(@NotNull final AbstractEcoPlugin plugin) {
+        super(plugin, PacketType.Play.Server.SET_SLOT, false);
+    }
+
+    @Override
+    public void onSend(@NotNull final PacketContainer packet,
+                       @NotNull final Player player) {
+        packet.getItemModifier().modify(0, Display::display);
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/display/packets/PacketWindowItems.java

@@ -0,0 +1,32 @@
+package com.willfp.eco.spigot.display.packets;
+
+import com.comphenix.protocol.PacketType;
+import com.comphenix.protocol.events.PacketContainer;
+import com.willfp.eco.util.display.Display;
+import com.willfp.eco.util.plugin.AbstractEcoPlugin;
+import com.willfp.eco.util.protocollib.AbstractPacketAdapter;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class PacketWindowItems extends AbstractPacketAdapter {
+    /**
+     * Instantiate a new listener for {@link PacketType.Play.Server#WINDOW_ITEMS}.
+     *
+     * @param plugin The plugin to listen through.
+     */
+    public PacketWindowItems(@NotNull final AbstractEcoPlugin plugin) {
+        super(plugin, PacketType.Play.Server.WINDOW_ITEMS, false);
+    }
+
+    @Override
+    public void onSend(@NotNull final PacketContainer packet,
+                       @NotNull final Player player) {
+        packet.getItemListModifier().modify(0, itemStacks -> {
+            if (itemStacks == null) {
+                return null;
+            }
+            itemStacks.forEach(Display::display);
+            return itemStacks;
+        });
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/integrations/anticheat/plugins/AnticheatAAC.java

@@ -0,0 +1,38 @@
+package com.willfp.eco.spigot.integrations.anticheat.plugins;
+
+import com.willfp.eco.util.integrations.anticheat.AnticheatWrapper;
+import me.konsolas.aac.api.AACAPI;
+import me.konsolas.aac.api.AACExemption;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Objects;
+
+public class AnticheatAAC implements AnticheatWrapper, Listener {
+    /**
+     * AAC exemption for eco.
+     */
+    private final AACExemption ecoExemption = new AACExemption("eco");
+
+    /**
+     * AAC api.
+     */
+    private final AACAPI api = Objects.requireNonNull(Bukkit.getServicesManager().load(AACAPI.class));
+
+    @Override
+    public String getPluginName() {
+        return "AAC";
+    }
+
+    @Override
+    public void exempt(@NotNull final Player player) {
+        api.addExemption(player, ecoExemption);
+    }
+
+    @Override
+    public void unexempt(@NotNull final Player player) {
+        api.removeExemption(player, ecoExemption);
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/integrations/anticheat/plugins/AnticheatMatrix.java

@@ -0,0 +1,44 @@
+package com.willfp.eco.spigot.integrations.anticheat.plugins;
+
+import com.willfp.eco.util.integrations.anticheat.AnticheatWrapper;
+import me.rerere.matrix.api.events.PlayerViolationEvent;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+public class AnticheatMatrix implements AnticheatWrapper, Listener {
+    /**
+     * Currently exempt players.
+     */
+    private final Set<UUID> exempt = new HashSet<>();
+
+    @Override
+    public String getPluginName() {
+        return "Matrix";
+    }
+
+    @Override
+    public void exempt(@NotNull final Player player) {
+        this.exempt.add(player.getUniqueId());
+    }
+
+    @Override
+    public void unexempt(@NotNull final Player player) {
+        this.exempt.remove(player.getUniqueId());
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    private void onViolate(@NotNull final PlayerViolationEvent event) {
+        if (!exempt.contains(event.getPlayer().getUniqueId())) {
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/integrations/anticheat/plugins/AnticheatNCP.java

@@ -0,0 +1,41 @@
+package com.willfp.eco.spigot.integrations.anticheat.plugins;
+
+import com.willfp.eco.util.integrations.anticheat.AnticheatWrapper;
+import fr.neatmonster.nocheatplus.checks.CheckType;
+import fr.neatmonster.nocheatplus.hooks.NCPExemptionManager;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+public class AnticheatNCP implements AnticheatWrapper {
+    /**
+     * Currently exempt players.
+     */
+    private final Set<UUID> exempt = new HashSet<>();
+
+    @Override
+    public String getPluginName() {
+        return "NCP";
+    }
+
+    @Override
+    public void exempt(@NotNull final Player player) {
+        if (!NCPExemptionManager.isExempted(player, CheckType.ALL)) {
+            return;
+        }
+
+        if (exempt.add(player.getUniqueId())) {
+            NCPExemptionManager.exemptPermanently(player, CheckType.ALL);
+        }
+    }
+
+    @Override
+    public void unexempt(@NotNull final Player player) {
+        if (exempt.remove(player.getUniqueId())) {
+            NCPExemptionManager.unexempt(player, CheckType.ALL);
+        }
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/integrations/anticheat/plugins/AnticheatSpartan.java

@@ -0,0 +1,44 @@
+package com.willfp.eco.spigot.integrations.anticheat.plugins;
+
+import com.willfp.eco.util.integrations.anticheat.AnticheatWrapper;
+import me.vagdedes.spartan.api.PlayerViolationEvent;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.jetbrains.annotations.NotNull;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.UUID;
+
+public class AnticheatSpartan implements AnticheatWrapper, Listener {
+    /**
+     * Currently exempt players.
+     */
+    private final Set<UUID> exempt = new HashSet<>();
+
+    @Override
+    public String getPluginName() {
+        return "Spartan";
+    }
+
+    @Override
+    public void exempt(@NotNull final Player player) {
+        this.exempt.add(player.getUniqueId());
+    }
+
+    @Override
+    public void unexempt(@NotNull final Player player) {
+        this.exempt.remove(player.getUniqueId());
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    private void onViolate(@NotNull final PlayerViolationEvent event) {
+        if (!exempt.contains(event.getPlayer().getUniqueId())) {
+            return;
+        }
+
+        event.setCancelled(true);
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/integrations/antigrief/plugins/AntigriefFactionsUUID.java

@@ -0,0 +1,75 @@
+package com.willfp.eco.spigot.integrations.antigrief.plugins;
+
+import com.massivecraft.factions.Board;
+import com.massivecraft.factions.FLocation;
+import com.massivecraft.factions.FPlayer;
+import com.massivecraft.factions.FPlayers;
+import com.massivecraft.factions.Faction;
+import com.massivecraft.factions.perms.PermissibleAction;
+import com.willfp.eco.util.integrations.antigrief.AntigriefWrapper;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class AntigriefFactionsUUID implements AntigriefWrapper {
+    @Override
+    public boolean canBreakBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        FPlayer fplayer = FPlayers.getInstance().getByPlayer(player);
+        FLocation flocation = new FLocation(block.getLocation());
+        Faction faction = Board.getInstance().getFactionAt(flocation);
+
+        if (!faction.hasAccess(fplayer, PermissibleAction.DESTROY)) {
+            return fplayer.isAdminBypassing();
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canCreateExplosion(@NotNull final Player player,
+                                      @NotNull final Location location) {
+        FLocation flocation = new FLocation(location);
+        Faction faction = Board.getInstance().getFactionAt(flocation);
+
+        return !faction.noExplosionsInTerritory();
+    }
+
+    @Override
+    public boolean canPlaceBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        FPlayer fplayer = FPlayers.getInstance().getByPlayer(player);
+        FLocation flocation = new FLocation(block.getLocation());
+        Faction faction = Board.getInstance().getFactionAt(flocation);
+
+        if (!faction.hasAccess(fplayer, PermissibleAction.BUILD)) {
+            return fplayer.isAdminBypassing();
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canInjure(@NotNull final Player player,
+                             @NotNull final LivingEntity victim) {
+        FPlayer fplayer = FPlayers.getInstance().getByPlayer(player);
+        FLocation flocation = new FLocation(victim.getLocation());
+        Faction faction = Board.getInstance().getFactionAt(flocation);
+
+        if (victim instanceof Player) {
+            if (faction.isPeaceful()) {
+                return fplayer.isAdminBypassing();
+            }
+        } else {
+            if (faction.hasAccess(fplayer, PermissibleAction.DESTROY)) {
+                return fplayer.isAdminBypassing();
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public String getPluginName() {
+        return "FactionsUUID";
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/integrations/antigrief/plugins/AntigriefGriefPrevention.java

@@ -0,0 +1,61 @@
+package com.willfp.eco.spigot.integrations.antigrief.plugins;
+
+import com.willfp.eco.util.integrations.antigrief.AntigriefWrapper;
+import me.ryanhamshire.GriefPrevention.Claim;
+import me.ryanhamshire.GriefPrevention.GriefPrevention;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class AntigriefGriefPrevention implements AntigriefWrapper {
+    @Override
+    public boolean canBreakBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        Claim claim = GriefPrevention.instance.dataStore.getClaimAt(block.getLocation(), false, null);
+        if (claim != null) {
+            return claim.allowBreak(player, block.getType()) == null;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canCreateExplosion(@NotNull final Player player,
+                                      @NotNull final Location location) {
+        Claim claim = GriefPrevention.instance.dataStore.getClaimAt(location, false, null);
+        if (claim != null) {
+            return claim.areExplosivesAllowed;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canPlaceBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        Claim claim = GriefPrevention.instance.dataStore.getClaimAt(block.getLocation(), false, null);
+        if (claim != null) {
+            return claim.allowBuild(player, block.getType()) == null;
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canInjure(@NotNull final Player player,
+                             @NotNull final LivingEntity victim) {
+        Claim claim = GriefPrevention.instance.dataStore.getClaimAt(victim.getLocation(), false, null);
+        if (victim instanceof Player) {
+            return claim == null;
+        } else {
+            if (claim != null && claim.ownerID != null) {
+                return claim.ownerID.equals(player.getUniqueId());
+            }
+            return true;
+        }
+    }
+
+    @Override
+    public String getPluginName() {
+        return "GriefPrevention";
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/integrations/antigrief/plugins/AntigriefKingdoms.java

@@ -0,0 +1,73 @@
+package com.willfp.eco.spigot.integrations.antigrief.plugins;
+
+import com.willfp.eco.util.integrations.antigrief.AntigriefWrapper;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.block.BlockBreakEvent;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.inventory.EquipmentSlot;
+import org.jetbrains.annotations.NotNull;
+import org.kingdoms.constants.kingdom.Kingdom;
+import org.kingdoms.constants.land.Land;
+import org.kingdoms.managers.PvPManager;
+import org.kingdoms.managers.land.LandManager;
+
+public class AntigriefKingdoms implements AntigriefWrapper {
+    @Override
+    public boolean canBreakBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        BlockBreakEvent event = new BlockBreakEvent(block, player);
+        LandManager.onBreak(event);
+        return !event.isCancelled();
+    }
+
+    @Override
+    public boolean canCreateExplosion(@NotNull final Player player,
+                                      @NotNull final Location location) {
+        Land land = Land.getLand(location);
+        if (land == null) {
+            return true;
+        }
+        if (!land.isClaimed()) {
+            return true;
+        }
+
+        Kingdom kingdom = land.getKingdom();
+        return kingdom.isMember(player);
+    }
+
+    @Override
+    public boolean canPlaceBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        Block placedOn = block.getRelative(0, -1, 0);
+        BlockPlaceEvent event = new BlockPlaceEvent(block, block.getState(), placedOn, player.getInventory().getItemInMainHand(), player, true, EquipmentSlot.HAND);
+        LandManager.onPlace(event);
+        return !event.isCancelled();
+    }
+
+    @Override
+    public boolean canInjure(@NotNull final Player player,
+                             @NotNull final LivingEntity victim) {
+        if (victim instanceof Player) {
+            return PvPManager.canFight(player, (Player) victim);
+        } else {
+            Land land = Land.getLand(victim.getLocation());
+            if (land == null) {
+                return true;
+            }
+            if (!land.isClaimed()) {
+                return true;
+            }
+
+            Kingdom kingdom = land.getKingdom();
+            return kingdom.isMember(player);
+        }
+    }
+
+    @Override
+    public String getPluginName() {
+        return "Kingdoms";
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/integrations/antigrief/plugins/AntigriefLands.java

@@ -0,0 +1,80 @@
+package com.willfp.eco.spigot.integrations.antigrief.plugins;
+
+import com.willfp.eco.util.integrations.antigrief.AntigriefWrapper;
+import com.willfp.eco.util.internal.PluginDependent;
+import com.willfp.eco.util.plugin.AbstractEcoPlugin;
+import me.angeschossen.lands.api.integration.LandsIntegration;
+import me.angeschossen.lands.api.land.Area;
+import me.angeschossen.lands.api.role.enums.RoleSetting;
+import org.bukkit.Location;
+import org.bukkit.block.Block;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class AntigriefLands extends PluginDependent implements AntigriefWrapper {
+    /**
+     * Lands integration.
+     */
+    private final LandsIntegration landsIntegration = new LandsIntegration(this.getPlugin());
+
+    /**
+     * Instantiate new lands integration.
+     *
+     * @param plugin The integration provider.
+     */
+    public AntigriefLands(@NotNull final AbstractEcoPlugin plugin) {
+        super(plugin);
+    }
+
+    @Override
+    public boolean canBreakBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        Area area = landsIntegration.getAreaByLoc(block.getLocation());
+        if (area != null) {
+            return area.canSetting(player, RoleSetting.BLOCK_BREAK, false);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canCreateExplosion(@NotNull final Player player,
+                                      @NotNull final Location location) {
+        Area area = landsIntegration.getAreaByLoc(location);
+        if (area != null) {
+            return area.canSetting(player, RoleSetting.BLOCK_IGNITE, false);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canPlaceBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        Area area = landsIntegration.getAreaByLoc(block.getLocation());
+        if (area != null) {
+            return area.canSetting(player, RoleSetting.BLOCK_PLACE, false);
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canInjure(@NotNull final Player player,
+                             @NotNull final LivingEntity victim) {
+        Area area = landsIntegration.getAreaByLoc(victim.getLocation());
+        if (victim instanceof Player) {
+            if (area != null) {
+                return area.canSetting(player, RoleSetting.ATTACK_PLAYER, false);
+            }
+        } else {
+            if (area != null) {
+                return area.canSetting(player, RoleSetting.ATTACK_ANIMAL, false);
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public String getPluginName() {
+        return "Lands";
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/integrations/antigrief/plugins/AntigriefTowny.java

@@ -0,0 +1,59 @@
+package com.willfp.eco.spigot.integrations.antigrief.plugins;
+
+import com.palmergames.bukkit.towny.object.Town;
+import com.palmergames.bukkit.towny.object.TownyPermission;
+import com.palmergames.bukkit.towny.object.WorldCoord;
+import com.palmergames.bukkit.towny.utils.PlayerCacheUtil;
+import com.willfp.eco.util.integrations.antigrief.AntigriefWrapper;
+import org.bukkit.Location;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class AntigriefTowny implements AntigriefWrapper {
+    @Override
+    public boolean canBreakBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        return PlayerCacheUtil.getCachePermission(player, block.getLocation(), block.getType(), TownyPermission.ActionType.DESTROY);
+    }
+
+    @Override
+    public boolean canCreateExplosion(@NotNull final Player player,
+                                      @NotNull final Location location) {
+        return PlayerCacheUtil.getCachePermission(player, location, Material.TNT, TownyPermission.ActionType.ITEM_USE);
+    }
+
+    @Override
+    public boolean canPlaceBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        return PlayerCacheUtil.getCachePermission(player, block.getLocation(), block.getType(), TownyPermission.ActionType.BUILD);
+    }
+
+    @Override
+    public boolean canInjure(@NotNull final Player player,
+                             @NotNull final LivingEntity victim) {
+        if (victim instanceof Player) {
+            try {
+                Town town = WorldCoord.parseWorldCoord(victim.getLocation()).getTownBlock().getTown();
+                return town.isPVP();
+            } catch (Exception ignored) {
+                // If exception, no town was found, thus return true.
+            }
+        } else {
+            try {
+                Town town = WorldCoord.parseWorldCoord(victim.getLocation()).getTownBlock().getTown();
+                return town.hasMobs();
+            } catch (Exception ignored) {
+                // If exception, no town was found, thus return true.
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public String getPluginName() {
+        return "Towny";
+    }
+}

eco-core/core-plugin/src/main/java/com/willfp/eco/spigot/integrations/antigrief/plugins/AntigriefWorldGuard.java

@@ -0,0 +1,85 @@
+package com.willfp.eco.spigot.integrations.antigrief.plugins;
+
+import com.sk89q.worldedit.bukkit.BukkitAdapter;
+import com.sk89q.worldguard.LocalPlayer;
+import com.sk89q.worldguard.WorldGuard;
+import com.sk89q.worldguard.bukkit.WorldGuardPlugin;
+import com.sk89q.worldguard.protection.flags.Flags;
+import com.sk89q.worldguard.protection.flags.StateFlag;
+import com.sk89q.worldguard.protection.regions.RegionContainer;
+import com.sk89q.worldguard.protection.regions.RegionQuery;
+import com.willfp.eco.util.integrations.antigrief.AntigriefWrapper;
+import org.apache.commons.lang.Validate;
+import org.bukkit.Location;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+import org.bukkit.entity.LivingEntity;
+import org.bukkit.entity.Player;
+import org.jetbrains.annotations.NotNull;
+
+public class AntigriefWorldGuard implements AntigriefWrapper {
+    @Override
+    public boolean canBreakBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+        RegionContainer container = WorldGuard.getInstance().getPlatform().getRegionContainer();
+        RegionQuery query = container.createQuery();
+
+        if (query.queryState(BukkitAdapter.adapt(block.getLocation()), localPlayer, Flags.BUILD) == StateFlag.State.DENY) {
+            return WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, BukkitAdapter.adapt(block.getWorld()));
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canCreateExplosion(@NotNull final Player player,
+                                      @NotNull final Location location) {
+        LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+        RegionContainer container = WorldGuard.getInstance().getPlatform().getRegionContainer();
+        RegionQuery query = container.createQuery();
+        World world = location.getWorld();
+        Validate.notNull(world, "World cannot be null!");
+
+        if (query.queryState(BukkitAdapter.adapt(location), localPlayer, Flags.OTHER_EXPLOSION) == StateFlag.State.DENY) {
+            return WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, BukkitAdapter.adapt(world));
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canPlaceBlock(@NotNull final Player player,
+                                 @NotNull final Block block) {
+        LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+        RegionContainer container = WorldGuard.getInstance().getPlatform().getRegionContainer();
+        RegionQuery query = container.createQuery();
+
+        if (query.queryState(BukkitAdapter.adapt(block.getLocation()), localPlayer, Flags.BLOCK_PLACE) == StateFlag.State.DENY) {
+            return WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, BukkitAdapter.adapt(block.getWorld()));
+        }
+        return true;
+    }
+
+    @Override
+    public boolean canInjure(@NotNull final Player player,
+                             @NotNull final LivingEntity victim) {
+        LocalPlayer localPlayer = WorldGuardPlugin.inst().wrapPlayer(player);
+        RegionContainer container = WorldGuard.getInstance().getPlatform().getRegionContainer();
+        RegionQuery query = container.createQuery();
+
+        if (victim instanceof Player) {
+            if (query.queryState(BukkitAdapter.adapt(victim.getLocation()), localPlayer, Flags.PVP) == StateFlag.State.DENY) {
+                return WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, BukkitAdapter.adapt(player.getWorld()));
+            }
+        } else {
+            if (query.queryState(BukkitAdapter.adapt(victim.getLocation()), localPlayer, Flags.DAMAGE_ANIMALS) == StateFlag.State.DENY) {
+                return WorldGuard.getInstance().getPlatform().getSessionManager().hasBypass(localPlayer, BukkitAdapter.adapt(player.getWorld()));
+            }
+        }
+        return true;
+    }
+
+    @Override
+    public String getPluginName() {
+        return "WorldGuard";
+    }
+}

eco-core/core-plugin/src/main/resources/plugin.yml

@@ -0,0 +1,26 @@
+name: eco
+version: 3.0.3
+main: com.willfp.eco.spigot.EcoPlugin
+api-version: 1.15
+authors: [Auxilor]
+website: willfp.com
+loadbefore:
+  - EcoEnchants
+  - Talismans
+  - ItemStats
+  - EcoArmor
+  - Illusioner
+depend:
+  - ProtocolLib
+softdepend:
+  - WorldGuard
+  - GriefPrevention
+  - Towny
+  - FactionsUUID
+  - Lands
+  - Kingdoms
+  - NoCheatPlus
+  - AAC
+  - Matrix
+  - Spartan
+  - PlaceholderAPI