Add EssentialsAntiBuild to 3.x :: still needs a little work

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>

EssentialsAntiBuild/src/net/ess3/antibuild/AntiBuildConfig.java

@@ -0,0 +1,73 @@
+package net.ess3.antibuild;
+
+
+public enum AntiBuildConfig
+{
+	disable_build("protect.disable.build", true),
+	disable_use("protect.disable.use", true),
+	alert_on_placement("protect.alert.on-placement"),
+	alert_on_use("protect.alert.on-use"),
+	alert_on_break("protect.alert.on-break"),
+	blacklist_placement("protect.blacklist.placement"),
+	blacklist_usage("protect.blacklist.usage"),
+	blacklist_break("protect.blacklist.break"),
+	blacklist_piston("protect.blacklist.piston");
+	private final String configName;
+	private final String defValueString;
+	private final boolean defValueBoolean;
+	private final boolean isList;
+	private final boolean isString;
+
+	private AntiBuildConfig(final String configName)
+	{
+		this(configName, null, false, true, false);
+	}
+
+	private AntiBuildConfig(final String configName, final boolean defValueBoolean)
+	{
+		this(configName, null, defValueBoolean, false, false);
+	}
+
+	private AntiBuildConfig(final String configName, final String defValueString, final boolean defValueBoolean, final boolean isList, final boolean isString)
+	{
+		this.configName = configName;
+		this.defValueString = defValueString;
+		this.defValueBoolean = defValueBoolean;
+		this.isList = isList;
+		this.isString = isString;
+	}
+
+	/**
+	 * @return the configName
+	 */
+	public String getConfigName()
+	{
+		return configName;
+	}
+
+	/**
+	 * @return the default value String
+	 */
+	public String getDefaultValueString()
+	{
+		return defValueString;
+	}
+
+	/**
+	 * @return the default value boolean
+	 */
+	public boolean getDefaultValueBoolean()
+	{
+		return defValueBoolean;
+	}
+
+	public boolean isString()
+	{
+		return isString;
+	}
+
+	public boolean isList()
+	{
+		return isList;
+	}
+}

EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsAntiBuild.java

@@ -0,0 +1,65 @@
+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 final transient Map<AntiBuildConfig, Boolean> settingsBoolean = new EnumMap<AntiBuildConfig, Boolean>(AntiBuildConfig.class);
+	private final transient Map<AntiBuildConfig, List<Integer>> settingsList = new EnumMap<AntiBuildConfig, List<Integer>>(AntiBuildConfig.class);
+	private transient EssentialsConnect ess = 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 AntiBuildConfig list, 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 Map<AntiBuildConfig, Boolean> getSettingsBoolean()
+	{
+		return settingsBoolean;
+	}
+
+	@Override
+	public Map<AntiBuildConfig, List<Integer>> getSettingsList()
+	{
+		return settingsList;
+	}
+
+	@Override
+	public boolean getSettingBool(final AntiBuildConfig protectConfig)
+	{
+		final Boolean bool = settingsBoolean.get(protectConfig);
+		return bool == null ? protectConfig.getDefaultValueBoolean() : bool;
+	}
+}

EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsAntiBuildListener.java

@@ -0,0 +1,299 @@
+package net.ess3.antibuild;
+
+import java.util.logging.Level;
+import static net.ess3.I18n._;
+import net.ess3.api.IEssentials;
+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 prot;
+	final private transient IEssentials ess;
+
+	public EssentialsAntiBuildListener(final IAntiBuild parent)
+	{
+		this.prot = parent;
+		this.ess = prot.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 User user = ess.getUser(event.getPlayer());
+		final Block block = event.getBlockPlaced();
+		final int typeId = block.getTypeId();
+		final Material type = block.getType();
+
+		if (prot.getSettingBool(AntiBuildConfig.disable_build) && !user.canBuild() && !user.isAuthorized("essentials.build")
+			&& !metaPermCheck(user, "place", block))
+		{
+			if (ess.getSettings().warnOnBuildDisallow())
+			{
+				user.sendMessage(_("antiBuildPlace", type.toString()));
+			}
+			event.setCancelled(true);
+			return;
+		}
+
+		if (prot.checkProtectionItems(AntiBuildConfig.blacklist_placement, typeId) && !user.isAuthorized("essentials.protect.exemptplacement"))
+		{
+			if (ess.getSettings().warnOnBuildDisallow())
+			{
+				user.sendMessage(_("antiBuildPlace", type.toString()));
+			}
+			event.setCancelled(true);
+			return;
+		}
+
+		if (prot.checkProtectionItems(AntiBuildConfig.alert_on_placement, typeId)
+			&& !user.isAuthorized("essentials.protect.alerts.notrigger"))
+		{
+			prot.getEssentialsConnect().alert(user, type.toString(), _("alertPlaced"));
+		}
+	}
+
+	@EventHandler(priority = EventPriority.HIGHEST, ignoreCancelled = true)
+	public void onBlockBreak(final BlockBreakEvent event)
+	{
+		final User user = ess.getUser(event.getPlayer());
+		final Block block = event.getBlock();
+		final int typeId = block.getTypeId();
+		final Material type = block.getType();
+
+		if (prot.getSettingBool(AntiBuildConfig.disable_build) && !user.canBuild() && !user.isAuthorized("essentials.build")
+			&& !metaPermCheck(user, "break", block))
+		{
+			if (ess.getSettings().warnOnBuildDisallow())
+			{
+				user.sendMessage(_("antiBuildBreak", type.toString()));
+			}
+			event.setCancelled(true);
+			return;
+		}
+
+		if (prot.checkProtectionItems(AntiBuildConfig.blacklist_break, typeId)
+			&& !user.isAuthorized("essentials.protect.exemptbreak"))
+		{
+			if (ess.getSettings().warnOnBuildDisallow())
+			{
+				user.sendMessage(_("antiBuildBreak", type.toString()));
+			}
+			event.setCancelled(true);
+			return;
+		}
+
+		if (prot.checkProtectionItems(AntiBuildConfig.alert_on_break, typeId)
+			&& !user.isAuthorized("essentials.protect.alerts.notrigger"))
+		{
+			prot.getEssentialsConnect().alert(user, type.toString(), _("alertBroke"));
+		}
+	}
+
+	@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 (prot.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 (prot.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 (prot.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
+			&& prot.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
+			&& prot.checkProtectionItems(AntiBuildConfig.alert_on_use, item.getTypeId())
+			&& !user.isAuthorized("essentials.protect.alerts.notrigger"))
+		{
+			prot.getEssentialsConnect().alert(user, item.getType().toString(), _("alertUsed"));
+		}
+
+		if (prot.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 (prot.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 (prot.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 User user = ess.getUser(event.getPlayer());
+		final ItemStack item = event.getItemDrop().getItemStack();
+
+		if (prot.getSettingBool(AntiBuildConfig.disable_use) && !user.canBuild() && !user.isAuthorized("essentials.build"))
+		{
+			if (!metaPermCheck(user, "drop", item.getTypeId(), item.getData().getData()))
+			{
+				event.setCancelled(true);
+				user.updateInventory();
+				if (ess.getSettings().warnOnBuildDisallow())
+				{
+					user.sendMessage(_("antiBuildDrop", item.getType().toString()));
+				}
+			}
+		}
+	}
+}

EssentialsAntiBuild/src/net/ess3/antibuild/EssentialsConnect.java

@@ -0,0 +1,80 @@
+package net.ess3.antibuild;
+
+import net.ess3.api.IConf;
+import net.ess3.api.IEssentials;
+import static net.ess3.I18n._;
+import java.util.logging.Level;
+import java.util.logging.Logger;
+import net.ess3.user.User;
+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 protect;
+
+	public EssentialsConnect(Plugin essPlugin, Plugin essProtect)
+	{
+		if (!essProtect.getDescription().getVersion().equals(essPlugin.getDescription().getVersion()))
+		{
+			LOGGER.log(Level.WARNING, _("versionMismatchAll"));
+		}
+		ess = (IEssentials)essPlugin;
+		protect = (IAntiBuild)essProtect;
+		AntiBuildReloader pr = new AntiBuildReloader();
+		pr.reloadConfig();
+		ess.addReloadListener(pr);
+	}
+
+	public void onDisable()
+	{
+	}
+
+	public IEssentials getEssentials()
+	{
+		return ess;
+	}
+
+	public void alert(final User user, final String item, final String type)
+	{
+		final Location loc = user.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 User alertUser = ess.getUser(p);
+			if (alertUser.isAuthorized("essentials.protect.alerts"))
+			{
+				alertUser.sendMessage(warnMessage);
+			}
+		}
+	}
+
+
+	private class AntiBuildReloader implements IConf
+	{
+		@Override
+		public void reloadConfig()
+		{
+			for (AntiBuildConfig protectConfig : AntiBuildConfig.values())
+			{
+				if (protectConfig.isList())
+				{
+					protect.getSettingsList().put(protectConfig, ess.getSettings().getProtectList(protectConfig.getConfigName()));
+				}
+				else
+				{
+					protect.getSettingsBoolean().put(protectConfig, ess.getSettings().getProtectBoolean(protectConfig.getConfigName(), protectConfig.getDefaultValueBoolean()));
+				}
+
+			}
+
+		}
+	}
+}

EssentialsAntiBuild/src/net/ess3/antibuild/IAntiBuild.java

@@ -0,0 +1,19 @@
+package net.ess3.antibuild;
+
+import java.util.List;
+import java.util.Map;
+import org.bukkit.plugin.Plugin;
+
+
+public interface IAntiBuild extends Plugin
+{
+	boolean checkProtectionItems(final AntiBuildConfig list, final int id);
+
+	boolean getSettingBool(final AntiBuildConfig protectConfig);
+
+	EssentialsConnect getEssentialsConnect();
+
+	Map<AntiBuildConfig, Boolean> getSettingsBoolean();
+
+	Map<AntiBuildConfig, List<Integer>> getSettingsList();
+}

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]

pom.xml

@@ -21,6 +21,7 @@
     <module>EssentialsSigns</module>
     <module>EssentialsUpdate</module>
     <module>EssentialsXMPP</module>
+    <module>EssentialsAntiBuild</module>
   </modules>
 
   <repositories>