diff options
Diffstat (limited to 'EssentialsAntiBuild')
8 files changed, 687 insertions, 0 deletions
diff --git a/EssentialsAntiBuild/pom.xml b/EssentialsAntiBuild/pom.xml new file mode 100644 index 000000000..1346a3706 --- /dev/null +++ b/EssentialsAntiBuild/pom.xml @@ -0,0 +1,21 @@ + +<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + <modelVersion>4.0.0</modelVersion> + + <parent> + <groupId>net.essentials3</groupId> + <artifactId>BuildAll</artifactId> + <version>3.0-SNAPSHOT</version> + <relativePath>../pom.xml</relativePath> + </parent> + + <artifactId>EssentialsAntiBuild</artifactId> + <dependencies> + <dependency> + <groupId>${project.groupId}</groupId> + <artifactId>Essentials</artifactId> + <version>${project.version}</version> + </dependency> + </dependencies> +</project> diff --git a/EssentialsAntiBuild/src/net/ess3/antibuild/AntiBuildHolder.java b/EssentialsAntiBuild/src/net/ess3/antibuild/AntiBuildHolder.java new file mode 100644 index 000000000..ef3aebc06 --- /dev/null +++ b/EssentialsAntiBuild/src/net/ess3/antibuild/AntiBuildHolder.java @@ -0,0 +1,31 @@ +package net.ess3.antibuild; + +import java.io.File; +import java.io.IOException; +import net.ess3.api.IEssentials; +import net.ess3.settings.antibuild.AntiBuild; +import net.ess3.storage.AsyncStorageObjectHolder; + +public class AntiBuildHolder extends AsyncStorageObjectHolder<AntiBuild> +{ + public AntiBuildHolder(final IEssentials ess) + { + super(ess, AntiBuild.class); + } + + @Override + public File getStorageFile() throws IOException + { + return new File(ess.getPlugin().getDataFolder(), "protect.yml"); + } + + @Override + public void finishRead() + { + } + + @Override + public void finishWrite() + { + } +} diff --git a/EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsAntiBuild.java b/EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsAntiBuild.java new file mode 100644 index 000000000..50e3f56f2 --- /dev/null +++ b/EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsAntiBuild.java @@ -0,0 +1,57 @@ +package net.ess3.antibuild; + +import java.util.EnumMap; +import java.util.List; +import java.util.Map; +import java.util.logging.Logger; +import org.bukkit.plugin.Plugin; +import org.bukkit.plugin.PluginManager; +import org.bukkit.plugin.java.JavaPlugin; + + +public class EssentialsAntiBuild extends JavaPlugin implements IAntiBuild +{ + private static final Logger LOGGER = Logger.getLogger("Minecraft"); + private transient EssentialsConnect ess = null; + private transient AntiBuildHolder settings = null; + + @Override + public void onEnable() + { + final PluginManager pm = this.getServer().getPluginManager(); + final Plugin essPlugin = pm.getPlugin("Essentials"); + if (essPlugin == null || !essPlugin.isEnabled()) + { + return; + } + ess = new EssentialsConnect(essPlugin, this); + + final EssentialsAntiBuildListener blockListener = new EssentialsAntiBuildListener(this); + pm.registerEvents(blockListener, this); + } + + @Override + public boolean checkProtectionItems(final int id) + { + final List<Integer> itemList = settingsList.get(list); + return itemList != null && !itemList.isEmpty() && itemList.contains(id); + } + + @Override + public EssentialsConnect getEssentialsConnect() + { + return ess; + } + + @Override + public AntiBuildHolder getSettings() + { + return settings; + } + + @Override + public void setSettings(final AntiBuildHolder settings) + { + this.settings = settings; + } +} diff --git a/EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsAntiBuildListener.java b/EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsAntiBuildListener.java new file mode 100644 index 000000000..03bce34b6 --- /dev/null +++ b/EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsAntiBuildListener.java @@ -0,0 +1,322 @@ +package net.ess3.antibuild; + +import java.util.logging.Level; +import static net.ess3.I18n._; +import net.ess3.api.IEssentials; +import net.ess3.api.IUser; +import net.ess3.user.User; +import org.bukkit.Material; +import org.bukkit.block.Block; +import org.bukkit.entity.Entity; +import org.bukkit.entity.HumanEntity; +import org.bukkit.entity.Player; +import org.bukkit.event.EventHandler; +import org.bukkit.event.EventPriority; +import org.bukkit.event.Listener; +import org.bukkit.event.block.*; +import org.bukkit.event.inventory.CraftItemEvent; +import org.bukkit.event.painting.PaintingBreakByEntityEvent; +import org.bukkit.event.player.PlayerDropItemEvent; +import org.bukkit.event.player.PlayerInteractEvent; +import org.bukkit.event.player.PlayerPickupItemEvent; +import org.bukkit.inventory.ItemStack; + + +public class EssentialsAntiBuildListener implements Listener +{ + final private transient IAntiBuild antib; + final private transient IEssentials ess; + + public EssentialsAntiBuildListener(final IAntiBuild parent) + { + this.antib = parent; + this.ess = antib.getEssentialsConnect().getEssentials(); + } + + private boolean metaPermCheck(final User user, final String action, final Block block) + { + if (block == null) + { + return false; + } + return metaPermCheck(user, action, block.getTypeId(), block.getData()); + } + + private boolean metaPermCheck(final User user, final String action, final int blockId) + { + final String blockPerm = "essentials.build." + action + "." + blockId; + return user.isAuthorized(blockPerm); + } + + private boolean metaPermCheck(final User user, final String action, final int blockId, final byte data) + { + final String blockPerm = "essentials.build." + action + "." + blockId; + final String dataPerm = blockPerm + ":" + data; + + if (user.isPermissionSet(dataPerm)) + { + return user.isAuthorized(dataPerm); + } + else + { + if (ess.getSettings().isDebug()) + { + ess.getLogger().log(Level.INFO, "DataValue perm on " + user.getName() + " is not directly set: " + dataPerm); + } + } + + return user.isAuthorized(blockPerm); + } + + @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) + public void onBlockPlace(final BlockPlaceEvent event) + { + final AntiBuildHolder ab = antib.getSettings(); + ab.acquireReadLock(); + final IUser user = ess.getUserMap().getUser(event.getPlayer()); + final Block block = event.getBlockPlaced(); + final int typeId = block.getTypeId(); + final Material type = block.getType(); + + try + { + + if (ab.getData().isBuild() + && !user.canBuild() && !user.hasPermission("essentials.build") + && !Permissions.getPlacePermission(type).isAuthorized(user)) + //metaPermCheck(user, "place", block)) todo - double check metadata + { + if (ab.getData().isWarnOnBuildDisallow()) + { + user.sendMessage(_("antiBuildPlace", type.toString())); + } + event.setCancelled(true); + return; + } + + if (ab.getData().getBlacklist().getPlacement().contains(type) && !Permissions.BLACKLIST_ALLOWPLACEMENT.isAuthorized(user)) + //antib.checkProtectionItems(AntiBuildConfig.blacklist_placement, typeId) && !user.isAuthorized("essentials.protect.exemptplacement")) + { + if (ab.getData().isWarnOnBuildDisallow()) + { + user.sendMessage(_("antiBuildPlace", type.toString())); + } + event.setCancelled(true); + return; + } + + if (ab.getData().getAlert().getAlertOnPlacement().contains(type) + && !Permissions.ALERTS_NOTRIGGER.isAuthorized(user)) + { + antib.getEssentialsConnect().alert(user, type.toString(), _("alertPlaced")); + } + } + finally + { + ab.unlock(); + } + } + + @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) + public void onBlockBreak(final BlockBreakEvent event) + { + final AntiBuildHolder ab = antib.getSettings(); + ab.acquireReadLock(); + final IUser user = ess.getUserMap().getUser(event.getPlayer()); + final Block block = event.getBlock(); + final int typeId = block.getTypeId(); + final Material type = block.getType(); + + try + { + if (ab.getData().isBuild() && !user.canBuild() && !user.isAuthorized("essentials.build") + && !Permissions.getBreakPermission(type).isAuthorized(user)) + //!metaPermCheck(user, "break", block)) + { + if (ab.getData().isWarnOnBuildDisallow()) + { + user.sendMessage(_("antiBuildBreak", type.toString())); + } + event.setCancelled(true); + return; + } + + if (ab.getData().getBlacklist().getBreaking().contains(type) && !Permissions.BLACKLIST_ALLOWBREAK.isAuthorized(user)) + { + if (ab.getData().isWarnOnBuildDisallow()) + { + user.sendMessage(_("antiBuildBreak", type.toString())); + } + event.setCancelled(true); + return; + } + + if (antib.checkProtectionItems(AntiBuildConfig.alert_on_break, typeId) + && !user.isAuthorized("essentials.protect.alerts.notrigger")) + { + antib.getEssentialsConnect().alert(user, type.toString(), _("alertBroke")); + } + } + finally + { + ab.unlock(); + } + } + + @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) + public void onPaintingBreak(final PaintingBreakByEntityEvent event) + { + final Entity entity = event.getRemover(); + if (entity instanceof Player) + { + final User user = ess.getUser(entity); + if (antib.getSettingBool(AntiBuildConfig.disable_build) && !user.canBuild() && !user.isAuthorized("essentials.build") + && !metaPermCheck(user, "break", Material.PAINTING.getId())) + { + if (ess.getSettings().warnOnBuildDisallow()) + { + user.sendMessage(_("antiBuildBreak", Material.PAINTING.toString())); + } + event.setCancelled(true); + } + } + } + + @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) + public void onBlockPistonExtend(final BlockPistonExtendEvent event) + { + for (Block block : event.getBlocks()) + { + if (antib.checkProtectionItems(AntiBuildConfig.blacklist_piston, block.getTypeId())) + { + event.setCancelled(true); + return; + } + } + } + + @EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true) + public void onBlockPistonRetract(final BlockPistonRetractEvent event) + { + if (!event.isSticky()) + { + return; + } + final Block block = event.getRetractLocation().getBlock(); + if (antib.checkProtectionItems(AntiBuildConfig.blacklist_piston, block.getTypeId())) + { + event.setCancelled(true); + return; + } + } + + @EventHandler(priority = EventPriority.LOW) + public void onPlayerInteract(final PlayerInteractEvent event) + { + // Do not return if cancelled, because the interact event has 2 cancelled states. + final User user = ess.getUser(event.getPlayer()); + final ItemStack item = event.getItem(); + + if (item != null + && antib.checkProtectionItems(AntiBuildConfig.blacklist_usage, item.getTypeId()) + && !user.isAuthorized("essentials.protect.exemptusage")) + { + if (ess.getSettings().warnOnBuildDisallow()) + { + user.sendMessage(_("antiBuildUse", item.getType().toString())); + } + event.setCancelled(true); + return; + } + + if (item != null + && antib.checkProtectionItems(AntiBuildConfig.alert_on_use, item.getTypeId()) + && !user.isAuthorized("essentials.protect.alerts.notrigger")) + { + antib.getEssentialsConnect().alert(user, item.getType().toString(), _("alertUsed")); + } + + if (antib.getSettingBool(AntiBuildConfig.disable_use) && !user.canBuild() && !user.isAuthorized("essentials.build")) + { + if (event.hasItem() && !metaPermCheck(user, "interact", item.getTypeId(), item.getData().getData())) + { + event.setCancelled(true); + if (ess.getSettings().warnOnBuildDisallow()) + { + user.sendMessage(_("antiBuildUse", item.getType().toString())); + } + return; + } + if (event.hasBlock() && !metaPermCheck(user, "interact", event.getClickedBlock())) + { + event.setCancelled(true); + if (ess.getSettings().warnOnBuildDisallow()) + { + user.sendMessage(_("antiBuildInteract", event.getClickedBlock().getType().toString())); + } + } + } + } + + @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true) + public void onCraftItemEvent(final CraftItemEvent event) + { + HumanEntity entity = event.getWhoClicked(); + + if (entity instanceof Player) + { + final User user = ess.getUser(entity); + final ItemStack item = event.getRecipe().getResult(); + + if (antib.getSettingBool(AntiBuildConfig.disable_use) && !user.canBuild() && !user.isAuthorized("essentials.build")) + { + if (!metaPermCheck(user, "craft", item.getTypeId(), item.getData().getData())) + { + event.setCancelled(true); + if (ess.getSettings().warnOnBuildDisallow()) + { + user.sendMessage(_("antiBuildCraft", item.getType().toString())); + } + } + } + } + } + + @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true) + public void onPlayerPickupItem(PlayerPickupItemEvent event) + { + + final User user = ess.getUser(event.getPlayer()); + final ItemStack item = event.getItem().getItemStack(); + + if (antib.getSettingBool(AntiBuildConfig.disable_use) && !user.canBuild() && !user.isAuthorized("essentials.build")) + { + if (!metaPermCheck(user, "pickup", item.getTypeId(), item.getData().getData())) + { + event.setCancelled(true); + event.getItem().setPickupDelay(50); + } + } + } + + @EventHandler(priority = EventPriority.LOW, ignoreCancelled = true) + public void onPlayerDropItem(final PlayerDropItemEvent event) + { + + final IUser user = ess.getUserMap().getUser(event.getPlayer()); + final ItemStack item = event.getItemDrop().getItemStack(); + + if (antib.getSettingBool(AntiBuildConfig.disable_use) && !user.canBuild() && !user.isAuthorized("essentials.build")) + { + if (!metaPermCheck(user, "drop", item.getTypeId(), item.getData().getData())) + { + event.setCancelled(true); + user.getPlayer().updateInventory(); + if (ess.getSettings().warnOnBuildDisallow()) + { + user.sendMessage(_("antiBuildDrop", item.getType().toString())); + } + } + } + } +} diff --git a/EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsConnect.java b/EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsConnect.java new file mode 100644 index 000000000..b9a669348 --- /dev/null +++ b/EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsConnect.java @@ -0,0 +1,55 @@ +package net.ess3.antibuild; + +import java.util.logging.Level; +import java.util.logging.Logger; +import static net.ess3.I18n._; +import net.ess3.api.IEssentials; +import net.ess3.api.IUser; +import org.bukkit.Location; +import org.bukkit.entity.Player; +import org.bukkit.plugin.Plugin; + + +public class EssentialsConnect +{ + private static final Logger LOGGER = Logger.getLogger("Minecraft"); + private final transient IEssentials ess; + private final transient IAntiBuild antib; + + public EssentialsConnect(Plugin essPlugin, Plugin essProtect) + { + if (!essProtect.getDescription().getVersion().equals(essPlugin.getDescription().getVersion())) + { + LOGGER.log(Level.WARNING, _("versionMismatchAll")); + } + ess = (IEssentials)essPlugin; + antib = (IAntiBuild)essProtect; + antib.setSettings(new AntiBuildHolder(ess)); + } + + public void onDisable() + { + } + + public IEssentials getEssentials() + { + return ess; + } + + public void alert(final IUser user, final String item, final String type) + { + final Location loc = user.getPlayer().getLocation(); + final String warnMessage = _("alertFormat", user.getName(), type, item, + loc.getWorld().getName() + "," + loc.getBlockX() + "," + + loc.getBlockY() + "," + loc.getBlockZ()); + LOGGER.log(Level.WARNING, warnMessage); + for (Player p : ess.getServer().getOnlinePlayers()) + { + final IUser alertUser = ess.getUserMap().getUser(p); + if (Permissions.ALERTS.isAuthorized(alertUser)) + { + alertUser.sendMessage(warnMessage); + } + } + } +}
\ No newline at end of file diff --git a/EssentialsAntiBuild/src/net/ess3/antibuild/IAntiBuild.java b/EssentialsAntiBuild/src/net/ess3/antibuild/IAntiBuild.java new file mode 100644 index 000000000..e65773bd7 --- /dev/null +++ b/EssentialsAntiBuild/src/net/ess3/antibuild/IAntiBuild.java @@ -0,0 +1,15 @@ +package net.ess3.antibuild; + + +import org.bukkit.plugin.Plugin; + +public interface IAntiBuild extends Plugin +{ + boolean checkProtectionItems(final int id); + + EssentialsConnect getEssentialsConnect(); + + AntiBuildHolder getSettings(); + + void setSettings(AntiBuildHolder settings); +} diff --git a/EssentialsAntiBuild/src/net/ess3/antibuild/Permissions.java b/EssentialsAntiBuild/src/net/ess3/antibuild/Permissions.java new file mode 100644 index 000000000..7088fb0e0 --- /dev/null +++ b/EssentialsAntiBuild/src/net/ess3/antibuild/Permissions.java @@ -0,0 +1,177 @@ +package net.ess3.antibuild; + +import java.util.EnumMap; +import java.util.Locale; +import net.ess3.api.IPermission; +import net.ess3.bukkit.PermissionFactory; +import net.ess3.permissions.BasePermission; +import org.bukkit.Material; +import org.bukkit.command.CommandSender; +import org.bukkit.permissions.Permission; +import org.bukkit.permissions.PermissionDefault; + + +public enum Permissions implements IPermission +{ + + BLACKLIST_ALLOWPLACEMENT, + BLACKLIST_ALLOWUSAGE, + BLACKLIST_ALLOWBREAK, + ALERTS, + ALERTS_NOTRIGGER; + private static final String base = "essentials.build."; + private final String permission; + private final PermissionDefault defaultPerm; + private transient Permission bukkitPerm = null; + + private Permissions() + { + this(PermissionDefault.OP); + } + + private Permissions(final PermissionDefault defaultPerm) + { + permission = base + toString().toLowerCase(Locale.ENGLISH).replace('_', '.'); + this.defaultPerm = defaultPerm; + } + + @Override + public String getPermissionName() + { + return permission; + } + + @Override + public Permission getPermission() + { + if (bukkitPerm != null) + { + return bukkitPerm; + } + else + { + return PermissionFactory.registerPermission(getPermissionName(), getPermissionDefault()); + } + } + + @Override + public PermissionDefault getPermissionDefault() + { + return this.defaultPerm; + } + + @Override + public boolean isAuthorized(final CommandSender sender) + { + return sender.hasPermission(getPermission()); + } + + private static EnumMap<Material, IPermission> permissions = new EnumMap<Material, IPermission>(Material.class); + + public static IPermission getPlacePermission(final Material mat) + { + IPermission perm = permissions.get(mat); + if (perm == null) + { + perm = new BasePermission("essentials.place.", mat.toString().toLowerCase(Locale.ENGLISH).replace("_", "")) + { + @Override + public PermissionDefault getPermissionDefault() + { + return PermissionDefault.TRUE; + } + }; + permissions.put(mat, perm); + } + return perm; + } + + public static IPermission getBreakPermission(final Material mat) + { + IPermission perm = permissions.get(mat); + if (perm == null) + { + perm = new BasePermission("essentials.break.", mat.toString().toLowerCase(Locale.ENGLISH).replace("_", "")) + { + @Override + public PermissionDefault getPermissionDefault() + { + return PermissionDefault.TRUE; + } + }; + permissions.put(mat, perm); + } + return perm; + } + + public static IPermission getInteractPermission(final Material mat) + { + IPermission perm = permissions.get(mat); + if (perm == null) + { + perm = new BasePermission("essentials.interact.", mat.toString().toLowerCase(Locale.ENGLISH).replace("_", "")) + { + @Override + public PermissionDefault getPermissionDefault() + { + return PermissionDefault.TRUE; + } + }; + permissions.put(mat, perm); + } + return perm; + } + public static IPermission getCraftPermission(final Material mat) + { + IPermission perm = permissions.get(mat); + if (perm == null) + { + perm = new BasePermission("essentials.craft.", mat.toString().toLowerCase(Locale.ENGLISH).replace("_", "")) + { + @Override + public PermissionDefault getPermissionDefault() + { + return PermissionDefault.TRUE; + } + }; + permissions.put(mat, perm); + } + return perm; + } + + public static IPermission getPickupPermission(final Material mat) + { + IPermission perm = permissions.get(mat); + if (perm == null) + { + perm = new BasePermission("essentials.pickup.", mat.toString().toLowerCase(Locale.ENGLISH).replace("_", "")) + { + @Override + public PermissionDefault getPermissionDefault() + { + return PermissionDefault.TRUE; + } + }; + permissions.put(mat, perm); + } + return perm; + } + + public static IPermission getDropPermission(final Material mat) + { + IPermission perm = permissions.get(mat); + if (perm == null) + { + perm = new BasePermission("essentials.drop.", mat.toString().toLowerCase(Locale.ENGLISH).replace("_", "")) + { + @Override + public PermissionDefault getPermissionDefault() + { + return PermissionDefault.TRUE; + } + }; + permissions.put(mat, perm); + } + return perm; + } +} diff --git a/EssentialsAntiBuild/src/plugin.yml b/EssentialsAntiBuild/src/plugin.yml new file mode 100644 index 000000000..c838528c5 --- /dev/null +++ b/EssentialsAntiBuild/src/plugin.yml @@ -0,0 +1,9 @@ +# This determines the command prefix when there are conflicts (/name:home, /name:help, etc.) +name: EssentialsAntiBuild +main: net.ess3.antibuild.EssentialsAnitBuild +# Note to developers: This next line cannot change, or the automatic versioning system will break. +version: ${build.number} +website: http://tiny.cc/EssentialsWiki +description: Provides build protection. +authors: [Zenexer, ementalo, Aelux, Brettflan, KimKandor, snowleo, ceulemans, Xeology, KHobbits, Iaccidentally] +softdepend: [Essentials]
\ No newline at end of file |