Merge pull request #1 from RedstonerServer/blockplacemods_3.1

Blockplacemods 3.2

src/com/redstoner/modules/blockplacemods/BlockPlaceMods.java

@@ -0,0 +1,195 @@
+package com.redstoner.modules.blockplacemods;
+
+import com.nemez.cmdmgr.Command;
+import com.redstoner.annotations.AutoRegisterListener;
+import com.redstoner.annotations.Version;
+import com.redstoner.misc.Main;
+import com.redstoner.misc.Utils;
+import com.redstoner.modules.Module;
+import com.redstoner.modules.blockplacemods.mods.Mod;
+import com.redstoner.modules.blockplacemods.mods.ModAbstract;
+import com.redstoner.modules.blockplacemods.mods.ModToggledAbstract;
+import com.redstoner.utils.CommandException;
+import com.redstoner.utils.CommandMap;
+import org.bukkit.ChatColor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.event.Listener;
+
+import java.util.*;
+
+@AutoRegisterListener
+@Version(major = 3, minor = 2, revision = 8, compatible = 3)
+public final class BlockPlaceMods implements Module, Listener
+{
+	public static String PREFIX = ChatColor.GRAY + "[" + ChatColor.DARK_GREEN + "BPM" + ChatColor.GRAY + "]"
+			+ ChatColor.GREEN;
+			
+	@Override
+	public boolean onEnable()
+	{
+		ModAbstract.registerAll();
+		for (Mod mod : new ArrayList<>(ModAbstract.getMods().values()))
+		{
+			mod.registerListeners();
+		}
+		try
+		{
+			Map<String, org.bukkit.command.Command> commandMap = CommandMap.getCommandMap();
+			org.bukkit.command.Command command = new BlockPlaceModsCommand();
+			for (String alias : getCommandAliases())
+			{
+				commandMap.put(alias, command);
+			}
+		}
+		catch (ReflectiveOperationException ex)
+		{
+			return false;
+		}
+		return true;
+	}
+	
+	@Override
+	public void onDisable()
+	{
+		for (Mod mod : ModAbstract.getMods().values())
+		{
+			mod.unregisterListeners();
+		}
+		
+		try
+		{
+			Map<String, org.bukkit.command.Command> commandMap = CommandMap.getCommandMap();
+			for (String alias : getCommandAliases())
+			{
+				if (commandMap.get(alias).getClass() == BlockPlaceModsCommand.class)
+				{
+					commandMap.remove(alias);
+				}
+			}
+		}
+		catch (Exception ignored)
+		{}
+	}
+	
+	private static String[] getCommandAliases()
+	{
+		String pluginName = Main.plugin.getName().toLowerCase();
+		// @noformat
+		return new String[]{"mod", 		pluginName + ":mod",
+				"set", 		pluginName + ":mod",
+				"toggle",	pluginName + ":toggle"
+		};
+		// @format
+	}
+	
+	@Command(hook = "mod_empty")
+	public void onModEmptyCommand(CommandSender sender)
+	{
+		onModCommand(sender, "");
+	}
+	
+	@Command(hook = "mod")
+	public void onModCommand(CommandSender sender, String input)
+	{
+		String[] args = new ArrayList<>(Arrays.asList(input.split(" "))).stream()
+				.filter(x -> x != null && !x.trim().isEmpty()).toArray(String[]::new);
+		String prefix = PREFIX;
+		String message;
+		try
+		{
+			if (args.length > 0)
+			{
+				Mod target = ModAbstract.getMod(args[0].toLowerCase());
+				if (target != null)
+				{
+					prefix += "&7[&2" + capitalize(target.getName()) + "&7]&a";
+					if (!(sender instanceof Player))
+					{
+						message = "&cYou must be a player to use any block place mod";
+					}
+					else
+					{
+						message = target.runCommand((Player) sender, Arrays.copyOfRange(args, 1, args.length));
+					}
+				}
+				else if (args[0].equalsIgnoreCase("help"))
+				{
+					message = commandHelp(sender, args);
+				}
+				else
+				{
+					message = "&cThat argument could not be recognized";
+				}
+			}
+			else
+			{
+				message = commandHelp(sender, args);
+			}
+		}
+		catch (CommandException ex)
+		{
+			message = " &c" + ex.getMessage();
+		}
+		catch (Throwable t)
+		{
+			message = " &cAn unexpected error occurred while executing this command.";
+			t.printStackTrace();
+		}
+		Utils.sendMessage(sender, prefix, message, '&');
+	}
+	
+	private String commandHelp(CommandSender sender, String[] args)
+	{
+		StringBuilder result = new StringBuilder("§7BlockPlaceMods adds some redstone-centric utilities");
+		result.append("\n").append(ChatColor.GRAY.toString()).append("Available mods:");
+		List<Mod> mods = new ArrayList<>(new HashSet<>(ModAbstract.getMods().values()));
+		mods.sort(Comparator.<Mod> comparingInt(m -> ModToggledAbstract.class.isInstance(m) ? 1 : -1)
+				.thenComparing(Mod::getName));
+		for (Mod mod : mods)
+		{
+			result.append("\n").append(ChatColor.AQUA.toString()).append("/mod ").append(ChatColor.ITALIC.toString())
+					.append(mod.getName());
+			for (String alias : mod.getAliases())
+			{
+				result.append('|').append(alias);
+			}
+			result.append(ChatColor.GRAY.toString()).append(" - ").append(mod.getDescription());
+		}
+		return result.toString();
+	}
+	
+	private static String capitalize(String modName)
+	{
+		if (modName.isEmpty())
+		{
+			return modName;
+		}
+		char first = modName.charAt(0);
+		if (first != (first = Character.toUpperCase(first)))
+		{
+			char[] result = modName.toCharArray();
+			result[0] = first;
+			return String.valueOf(result);
+		}
+		return modName;
+	}
+	
+	private class BlockPlaceModsCommand extends org.bukkit.command.Command
+	{
+		public BlockPlaceModsCommand()
+		{
+			super("mod");
+			String[] aliases = getCommandAliases();
+			setAliases(Arrays.asList(Arrays.copyOfRange(aliases, 1, aliases.length)));
+		}
+		
+		@Override
+		public boolean execute(CommandSender sender, String label, String[] args)
+		{
+			onModCommand(sender, String.join(" ", args));
+			return true;
+		}
+	}
+	
+}

src/com/redstoner/modules/blockplacemods/mods/Mod.java

@@ -0,0 +1,24 @@
+package com.redstoner.modules.blockplacemods.mods;
+
+import org.bukkit.entity.Player;
+
+import com.redstoner.utils.CommandException;
+
+import java.util.Set;
+
+public interface Mod
+{
+	String getName();
+	
+	String getDescription();
+	
+	Set<String> getAliases();
+	
+	Object getDefault();
+	
+	String runCommand(Player sender, String[] args) throws CommandException;
+	
+	void registerListeners();
+	
+	void unregisterListeners();
+}

src/com/redstoner/modules/blockplacemods/mods/ModAbstract.java

@@ -0,0 +1,82 @@
+package com.redstoner.modules.blockplacemods.mods;
+
+import com.redstoner.misc.Main;
+import com.redstoner.misc.Utils;
+import com.redstoner.modules.datamanager.DataManager;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import org.bukkit.event.HandlerList;
+import org.bukkit.event.Listener;
+import org.bukkit.event.inventory.InventoryType;
+
+import java.util.*;
+
+public abstract class ModAbstract implements Mod, Listener
+{
+	private static final Map<String, Mod> mods = new HashMap<>();
+	private final String name;
+	private final Set<String> aliases;
+	
+	public static Map<String, Mod> getMods()
+	{
+		return Collections.unmodifiableMap(mods);
+	}
+	
+	public static Mod getMod(String name)
+	{
+		return mods.get(name);
+	}
+	
+	public static void registerMod(Mod mod) {
+		mods.put(mod.getName(), mod);
+		for (String alias : mod.getAliases()) {
+			mods.putIfAbsent(alias, mod);
+		}
+	}
+	
+	public static void registerAll()
+	{
+		registerMod(new ModToggledCauldron());
+		registerMod(new ModToggledPiston());
+		registerMod(new ModToggledStep());
+		registerMod(new ModToggledTorch());
+		registerMod(new ModInventory("dropper", InventoryType.DROPPER));
+		registerMod(new ModInventory("furnace", InventoryType.FURNACE));
+		registerMod(new ModInventory("hopper", InventoryType.HOPPER));
+	}
+	
+	public ModAbstract(String name)
+	{
+		this.name = Objects.requireNonNull(name);
+		this.aliases = new HashSet<>(2);
+		Utils.info("Loaded mod " + name);
+	}
+	
+	@Override
+	public String getName() {
+		return name;
+	}
+	
+	@Override
+	public Set<String> getAliases()
+	{
+		return aliases;
+	}
+	
+	@Override
+	public void registerListeners()
+	{
+		Bukkit.getPluginManager().registerEvents(this, Main.plugin);
+	}
+	
+	@Override
+	public void unregisterListeners()
+	{
+		HandlerList.unregisterAll(this);
+	}
+	
+	protected void reset(Player player)
+	{
+		DataManager.removeData(player.getUniqueId().toString(), "BlockPlaceMods", getName());
+	}
+}

src/com/redstoner/modules/blockplacemods/mods/ModInventory.java

@@ -0,0 +1,195 @@
+package com.redstoner.modules.blockplacemods.mods;
+
+import java.util.Arrays;
+
+import org.bukkit.Material;
+import org.bukkit.block.BlockState;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.inventory.InventoryType;
+import org.bukkit.inventory.Inventory;
+import org.bukkit.inventory.InventoryHolder;
+import org.bukkit.inventory.ItemStack;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+
+import com.redstoner.modules.datamanager.DataManager;
+import com.redstoner.utils.CommandException;
+import com.redstoner.utils.ItemProperties;
+
+public class ModInventory extends ModAbstract
+{
+	protected InventoryType inventoryType;
+	
+	public ModInventory(String name, InventoryType inventoryType)
+	{
+		super(name);
+		this.inventoryType = inventoryType;
+	}
+	
+	private static int highestUsedIndex(ItemStack[] items)
+	{
+		for (int i = items.length - 1; i >= 0; i--)
+		{
+			if (items[i] != null)
+			{
+				return i;
+			}
+		}
+		return -1;
+	}
+	
+	@Override
+	public String getDescription()
+	{
+		return "Controls " + inventoryType.name().toLowerCase() + " placement content";
+	}
+	
+	@Override
+	public String runCommand(Player sender, String[] args) throws CommandException
+	{
+		if (args.length > 0)
+		{
+			if (args[0].equalsIgnoreCase("clear"))
+			{
+				reset(sender);
+				return "Reset data successfully";
+			}
+			try
+			{
+				int slot = Integer.parseInt(args[0]);
+				if (slot >= inventoryType.getDefaultSize())
+				{
+					throw new CommandException(
+							"Slot number " + slot + " is too high for " + inventoryType.toString().toLowerCase() + "s");
+				}
+				if (slot < 0)
+				{
+					throw new CommandException("Slot number " + slot + " is negative");
+				}
+				// Set the stored item to the item in the sender's hand
+				ItemStack item = sender.getInventory().getItemInMainHand();
+				if (item == null || item.getType() == Material.AIR || item.getAmount() == 0)
+				{
+					// Remove the item.
+					// Set item to null to ensure correct itemName below.
+					item = null;
+					if (present(sender))
+					{
+						set(sender, slot, null);
+					}
+				}
+				else
+				{
+					set(sender, slot, item);// don't need to clone because the reference isn't kept
+				}
+				String itemName = item == null ? "nothing"
+						: item.getAmount() + " " + item.getType().toString().toLowerCase().replace("_", "");
+				return "Set the item in slot " + slot + " to " + itemName;
+			}
+			catch (NumberFormatException ex)
+			{
+				if (!args[0].equalsIgnoreCase("help"))
+				{
+					throw new CommandException("Expected a number indicating the slot that you want to set");
+				}
+			}
+		}
+		StringBuilder message = new StringBuilder();
+		message.append("&a### &3Container&a Help ###\n");
+		message.append("&8").append(getDescription()).append('\n');
+		message.append("&6/mod ").append(getName().toLowerCase())
+				.append("&o <slot> &bsets the item in slot to your hand\n");
+		message.append("&6/mod ").append(getName().toLowerCase()).append("&o clear &bclears the data\n");
+		message.append("&6/mod ").append(getName().toLowerCase()).append("&o help &bshows this help page\n");
+		return message.toString();
+	}
+	
+	@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+	public void onBlockPlace(BlockPlaceEvent event)
+	{
+		if (present(event.getPlayer()))
+		{
+			BlockState state = event.getBlock().getState();
+			if (state instanceof InventoryHolder)
+			{
+				Inventory inv = ((InventoryHolder) state).getInventory();
+				if (inv.getType() == inventoryType)
+				{
+					ItemStack[] data = get(event.getPlayer());
+					inv.setContents(data);
+					state.update();
+				}
+			}
+		}
+	}
+	
+	protected ItemStack[] get(Player player)
+	{
+		Object obj = DataManager.getData(player.getUniqueId().toString(), "BlockPlaceMods", getName());
+		if (obj == null)
+			return getDefault();
+		JSONArray array = (JSONArray) obj;
+		ItemStack[] items = new ItemStack[Math.min(inventoryType.getDefaultSize(), array.size())];
+		for (int i = 0, n = items.length; i < n; i++)
+		{
+			Object obj2 = array.get(i);
+			if (obj2 instanceof JSONObject)
+			{ // if null, items[i] remains null
+				items[i] = new ItemProperties().loadFrom((JSONObject) obj2).toItemStack();
+			}
+		}
+		return items;
+	}
+	
+	protected void set(Player player, int index, ItemStack item)
+	{
+		ItemStack[] data = get(player);
+		if (item == null)
+		{
+			if (index < data.length)
+			{
+				data[index] = null;
+			}
+		}
+		else
+		{
+			if (index >= data.length)
+			{
+				data = Arrays.copyOf(data, index + 1);
+			}
+			data[index] = item;
+		}
+		set(player, data);
+	}
+	
+	@SuppressWarnings("unchecked")
+	protected void set(Player player, ItemStack[] data)
+	{
+		if (highestUsedIndex(data) == -1)
+			reset(player);
+		else
+		{
+			JSONArray array = new JSONArray();
+			for (int i = 0, n = highestUsedIndex(data); i < n; i++)
+			{
+				ItemStack item = data[i];
+				array.add(item == null ? null : new ItemProperties(item).toJSONObject());
+			}
+			DataManager.setData(player.getUniqueId().toString(), "BlockPlaceMods", getName(), array);
+		}
+	}
+	
+	protected boolean present(Player player)
+	{
+		return get(player) != null;
+	}
+	
+	@Override
+	public ItemStack[] getDefault()
+	{
+		return new ItemStack[0];
+	}
+}

src/com/redstoner/modules/blockplacemods/mods/ModToggledAbstract.java

@@ -0,0 +1,88 @@
+package com.redstoner.modules.blockplacemods.mods;
+
+import org.bukkit.entity.Player;
+
+import com.redstoner.modules.datamanager.DataManager;
+import com.redstoner.utils.CommandException;
+
+public abstract class ModToggledAbstract extends ModAbstract
+{
+	protected boolean enabledByDefault;
+	
+	public ModToggledAbstract(String name, boolean enabledByDefault) {
+		super(name);
+		this.enabledByDefault = enabledByDefault;
+	}
+	
+	@Override
+	public Boolean getDefault() {
+		return enabledByDefault;
+	}
+	
+	protected boolean hasEnabled(Player player)
+	{
+		return (boolean) DataManager.getOrDefault(player.getUniqueId().toString(), "BlockPlaceMods", getName(),
+				enabledByDefault);
+	}
+	
+	protected boolean setEnabled(Player sender, boolean enabled)
+	{
+		if (enabled == hasEnabled(sender))
+			return false;
+		if (enabled == enabledByDefault)
+			reset(sender);
+		else
+			DataManager.setData(sender.getUniqueId().toString(), "BlockPlaceMods", getName(), enabled);
+		return true;
+	}
+	
+	@Override
+	public String runCommand(Player sender, String[] args) throws CommandException
+	{
+		if (args.length == 0 || args[0].equalsIgnoreCase("toggle"))
+		{
+			boolean enabled = hasEnabled(sender);
+			setEnabled(sender, !enabled);
+			return !enabled ? "Enabled" : "Disabled";
+		}
+		if (args[0].equalsIgnoreCase("help"))
+		{
+			StringBuilder message = new StringBuilder();
+			message.append("&a### &3").append(getName()).append("&a Help ###");
+			message.append("\n&8If enabled, ").append(getDescription());
+			message.append("\n&6/mod ").append(getName().toLowerCase()).append("&o toggle &btoggles state");
+			message.append("\n&6/mod ").append(getName().toLowerCase()).append("&o on/off &bsets state");
+			message.append("\n&6/mod ").append(getName().toLowerCase()).append("&o help &bshows this help page");
+			return message.toString();
+		}
+		final boolean enable;
+		if (args[0] == null)
+		{
+			throw new CommandException("Missing argument");
+		}
+		else
+		{
+			switch (args[0].toLowerCase())
+			{
+				case "on":
+				case "enable":
+				case "true":
+					enable = true;
+					break;
+				case "off":
+				case "disable":
+				case "false":
+					enable = false;
+					break;
+				default:
+					throw new CommandException("Input '" + args[0] + "' was not understood. "
+							+ "Use one of: \non, enable, true, off, disable, false.");
+			}
+		}
+		if (!setEnabled(sender, enable))
+		{
+			throw new CommandException("Was already " + (enable ? "enabled" : "disabled"));
+		}
+		return enable ? "Enabled" : "Disabled";
+	}
+}

src/com/redstoner/modules/blockplacemods/mods/ModToggledCauldron.java

@@ -0,0 +1,46 @@
+package com.redstoner.modules.blockplacemods.mods;
+
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.block.BlockPlaceEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+
+public class ModToggledCauldron extends ModToggledAbstract
+{
+	public ModToggledCauldron()
+	{
+		super("cauldron", false);
+	}
+	
+	@Override
+	public String getDescription()
+	{
+		return "If active, placed cauldrons are filled, and they cycle on right click";
+	}
+	
+	@SuppressWarnings("deprecation")
+	@EventHandler
+	public void onPlayerInteract(PlayerInteractEvent event)
+	{
+		if (event.getAction() == Action.RIGHT_CLICK_BLOCK && !event.getPlayer().isSneaking()
+				&& event.getClickedBlock().getType() == Material.CAULDRON && hasEnabled(event.getPlayer()))
+		{
+			Block block = event.getClickedBlock();
+			block.setData((byte) ((block.getData() - 1) & 0x3));
+		}
+	}
+	
+	@SuppressWarnings("deprecation")
+	@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+	public void onBlockPlace(BlockPlaceEvent event)
+	{
+		if (event.getBlock().getType() == Material.CAULDRON && !event.getPlayer().isSneaking()
+				&& hasEnabled(event.getPlayer()))
+		{
+			event.getBlock().setData((byte) 3);
+		}
+	}
+}

src/com/redstoner/modules/blockplacemods/mods/ModToggledPiston.java

@@ -0,0 +1,63 @@
+package com.redstoner.modules.blockplacemods.mods;
+
+import org.bukkit.GameMode;
+import org.bukkit.Material;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockFace;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+public class ModToggledPiston extends ModToggledAbstract
+{
+	public ModToggledPiston()
+	{
+		super("piston", false);
+	}
+	
+	@Override
+	public String getDescription()
+	{
+		return "If active, pistons face the block you place them against";
+	}
+	
+	@SuppressWarnings("deprecation")
+	@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+	public void onBlockPlace(BlockPlaceEvent event)
+	{
+		Player player = event.getPlayer();
+		if (hasEnabled(player) && !player.isSneaking() && player.getGameMode() == GameMode.CREATIVE
+				&& isPiston(event.getBlock().getType()))
+		{
+			Block block = event.getBlock();
+			block.setData((byte) pistonDataForFace(block.getFace(event.getBlockAgainst())));
+		}
+	}
+	
+	private boolean isPiston(Material block)
+	{
+		return block == Material.PISTON_BASE || block == Material.PISTON_STICKY_BASE;
+	}
+	
+	private int pistonDataForFace(BlockFace face)
+	{
+		switch (face)
+		{
+			case DOWN:
+				return 0;
+			case UP:
+				return 1;
+			case NORTH:
+				return 2;
+			case SOUTH:
+				return 3;
+			case WEST:
+				return 4;
+			case EAST:
+				return 5;
+			default:
+				return 0;
+		}
+	}
+}

src/com/redstoner/modules/blockplacemods/mods/ModToggledStep.java

@@ -0,0 +1,40 @@
+package com.redstoner.modules.blockplacemods.mods;
+
+import org.bukkit.Material;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+public class ModToggledStep extends ModToggledAbstract
+{
+	public ModToggledStep()
+	{
+		super("step", true);
+		getAliases().add("slab");
+	}
+	
+	@Override
+	public String getDescription()
+	{
+		return "If active, placed steps will always turn upside-down";
+	}
+	
+	@SuppressWarnings("deprecation")
+	@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+	public void onBlockPlace(BlockPlaceEvent event)
+	{
+		if (isStep(event.getBlock().getType()) && !event.getPlayer().isSneaking() && hasEnabled(event.getPlayer()))
+		{
+			byte data = event.getBlock().getData();
+			if (data != (data |= 0x8))
+			{
+				event.getBlock().setData(data);
+			}
+		}
+	}
+	
+	private boolean isStep(Material block)
+	{
+		return block == Material.STEP || block == Material.STONE_SLAB2;
+	}
+}

src/com/redstoner/modules/blockplacemods/mods/ModToggledTorch.java

@@ -0,0 +1,91 @@
+package com.redstoner.modules.blockplacemods.mods;
+
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.Set;
+
+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.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.BlockPlaceEvent;
+
+import com.redstoner.misc.Main;
+
+public class ModToggledTorch extends ModToggledAbstract
+{
+	private final Set<Block> torchesPlaced = new HashSet<>();
+	
+	public ModToggledTorch()
+	{
+		super("torch", true);
+		Bukkit.getScheduler().scheduleSyncRepeatingTask(Main.plugin, this::updateTorches, 2, 2);
+	}
+	
+	@Override
+	public String getDescription()
+	{
+		return "If active, redstone torches placed on a redstone block disappear quickly";
+	}
+	
+	@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+	public void onBlockPlace(BlockPlaceEvent event)
+	{
+		final Player player = event.getPlayer();
+		if (!player.isSneaking() && player.getGameMode() == GameMode.CREATIVE && hasEnabled(player)
+				&& event.getBlock().getType() == Material.REDSTONE_TORCH_ON)
+		{
+			if (isAttachedToRedstoneBlock(event.getBlock()))
+			{
+				torchesPlaced.add(event.getBlock());
+			}
+		}
+	}
+	
+	@SuppressWarnings("deprecation")
+	private boolean isAttachedToRedstoneBlock(Block block)
+	{
+		BlockFace towardsAgainst = getFaceTowardsBlockAgainst(block.getData());
+		return towardsAgainst != null && block.getRelative(towardsAgainst).getType() == Material.REDSTONE_BLOCK;
+	}
+	
+	private BlockFace getFaceTowardsBlockAgainst(byte data)
+	{
+		switch (data)
+		{
+			case 1:
+				return BlockFace.WEST;
+			case 2:
+				return BlockFace.EAST;
+			case 3:
+				return BlockFace.NORTH;
+			case 4:
+				return BlockFace.SOUTH;
+			case 5:
+				return BlockFace.DOWN;
+			default:
+				return null;
+		}
+	}
+	
+	private void updateTorches()
+	{
+		for (Iterator<Block> it = torchesPlaced.iterator(); it.hasNext();)
+		{
+			Block block = it.next();
+			if (block.getType() == Material.REDSTONE_TORCH_OFF)
+			{
+				block.setType(Material.AIR);
+				it.remove();
+			}
+			else if (block.getType() != Material.REDSTONE_TORCH_ON || !isAttachedToRedstoneBlock(block))
+			{
+				it.remove();
+			}
+		}
+	}
+}

src/com/redstoner/modules/datamanager/DataManager.java

@@ -27,7 +27,7 @@ import com.redstoner.modules.CoreModule;
 import com.redstoner.modules.Module;
 
 @AutoRegisterListener
-@Version(major = 3, minor = 2, revision = 0, compatible = 3)
+@Version(major = 3, minor = 2, revision = 1, compatible = 3)
 public final class DataManager implements CoreModule, Listener
 {
 	protected final File dataFolder = new File(Main.plugin.getDataFolder(), "data");
@@ -322,6 +322,7 @@ public final class DataManager implements CoreModule, Listener
 		{}
 	}
 	
+	@SuppressWarnings("unchecked")
 	protected void removeData_(String id, String module, String key)
 	{
 		if (data.containsKey(id))
@@ -330,6 +331,7 @@ public final class DataManager implements CoreModule, Listener
 			if (moduleData == null)
 				return;
 			moduleData.remove(key);
+			data.put(module, data);
 			save_(id);
 		}
 		else

src/com/redstoner/utils/CommandException.java

@@ -0,0 +1,29 @@
+package com.redstoner.utils;
+
+public class CommandException extends Exception
+{
+	private static final long serialVersionUID = -7176634557736106754L;
+	
+	public CommandException(String message, Throwable cause)
+	{
+		super(message, cause);
+	}
+	
+	public CommandException(Throwable cause)
+	{
+		super(cause);
+	}
+	
+	public CommandException(String message, Throwable cause, boolean enableSuppression, boolean writableStackTrace)
+	{
+		super(message, cause, enableSuppression, writableStackTrace);
+	}
+	
+	public CommandException()
+	{}
+	
+	public CommandException(String message)
+	{
+		super(message);
+	}
+}

src/com/redstoner/utils/CommandMap.java

@@ -0,0 +1,23 @@
+package com.redstoner.utils;
+
+import java.lang.reflect.Field;
+import java.util.Map;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.SimpleCommandMap;
+import org.bukkit.plugin.SimplePluginManager;
+
+public class CommandMap
+{
+	@SuppressWarnings("unchecked")
+	public static Map<String, Command> getCommandMap() throws ReflectiveOperationException, ClassCastException
+	{
+		Field field = SimplePluginManager.class.getDeclaredField("commandMap");
+		field.setAccessible(true);
+		Object map = field.get(Bukkit.getPluginManager());
+		field = SimpleCommandMap.class.getDeclaredField("knownCommands");
+		field.setAccessible(true);
+		return (Map<String, Command>) field.get(map);
+	}
+}

src/com/redstoner/utils/ItemProperties.java

@@ -0,0 +1,272 @@
+package com.redstoner.utils;
+
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.function.BiConsumer;
+
+import org.bukkit.enchantments.Enchantment;
+import org.bukkit.inventory.ItemStack;
+import org.bukkit.inventory.meta.ItemMeta;
+import org.json.simple.JSONArray;
+import org.json.simple.JSONObject;
+import org.json.simple.parser.JSONParser;
+import org.json.simple.parser.ParseException;
+
+/** Save and load {@link ItemStack} in json format
+ * Any additional NBT data not included by {@link ItemMeta} is discarded. */
+public class ItemProperties
+{
+	private int id = 0;
+	private byte data = 0;
+	private int amount = 1;
+	private Map<Enchantment, Integer> enchantments;
+	private List<String> lore;
+	private String displayName;
+	private boolean unbreakable = false;
+	
+	public ItemProperties()
+	{}
+	
+	@SuppressWarnings("deprecation")
+	public ItemProperties(ItemStack item)
+	{
+		if (item == null)
+			return;
+		id = item.getTypeId();
+		data = item.getData().getData();
+		amount = item.getAmount();
+		enchantments = new HashMap<>();
+		ItemMeta meta = item.getItemMeta();
+		if (meta == null)
+			return;
+		if (meta.hasEnchants())
+		{
+			enchantments.putAll(meta.getEnchants());
+		}
+		if (meta.hasLore())
+		{
+			lore = meta.getLore();
+		}
+		if (meta.hasDisplayName())
+		{
+			displayName = meta.getDisplayName();
+		}
+		unbreakable = meta.isUnbreakable();
+	}
+	
+	@SuppressWarnings("deprecation")
+	public ItemStack toItemStack()
+	{
+		ItemStack result = new ItemStack(id, amount, data);
+		ItemMeta meta = result.getItemMeta();
+		if (meta == null)
+			return result;
+		if (enchantments != null)
+		{
+			enchantments.forEach(new BiConsumer<Enchantment, Integer>()
+			{
+				@Override
+				public void accept(Enchantment ench, Integer level)
+				{
+					meta.addEnchant(ench, level, true);
+				}
+			});
+		}
+		if (lore != null)
+		{
+			meta.setLore(lore);
+		}
+		if (displayName != null)
+		{
+			meta.setDisplayName(displayName);
+		}
+		meta.setUnbreakable(unbreakable);
+		result.setItemMeta(meta);
+		return result;
+	}
+	
+	@SuppressWarnings("unchecked")
+	public JSONObject toJSONObject()
+	{
+		JSONObject object = new JSONObject();
+		object.put("id", id + "");
+		object.put("data", data + "");
+		object.put("amount", amount + "");
+		if (displayName != null)
+		{
+			object.put("displayName", displayName);
+		}
+		if (enchantments != null)
+		{
+			Map<Enchantment, Integer> enchantments = this.enchantments;
+			JSONObject stringKeys = new JSONObject();
+			for (Map.Entry<Enchantment, Integer> entry : enchantments.entrySet())
+			{
+				stringKeys.put(entry.getKey().getName(), entry.getValue());
+			}
+			object.put("enchantments", stringKeys);
+		}
+		if (lore != null)
+		{
+			object.put("lore", JSONArray.toJSONString(lore));
+		}
+		if (unbreakable)
+		{
+			object.put("unbreakable", true);
+		}
+		return object;
+	}
+	
+	@Override
+	public String toString()
+	{
+		return toJSONObject().toString();
+	}
+	
+	@SuppressWarnings("unchecked")
+	public ItemProperties loadFrom(JSONObject object)
+	{
+		for (Object obj : object.entrySet())
+		{
+			Entry<String, Object> entry = (Entry<String, Object>) obj;
+			final String key = entry.getKey();
+			switch (key)
+			{
+				case "id":
+					id = Integer.parseInt((String) entry.getValue());
+					break;
+				case "data":
+					data = Byte.parseByte((String) entry.getValue());
+					break;
+				case "amount":
+					amount = Integer.parseInt((String) entry.getValue());
+					break;
+				case "unbreakable":
+					unbreakable = (boolean) entry.getValue();
+					break;
+				case "enchantments":
+				{
+					if (enchantments == null)
+					{
+						enchantments = new HashMap<>();
+					}
+					else if (!enchantments.isEmpty())
+					{
+						enchantments.clear();
+					}
+					JSONObject read = (JSONObject) entry.getValue();
+					if (read != null)
+					{
+						for (Object obj2 : read.entrySet())
+						{
+							Entry<String, Integer> entry2 = (Entry<String, Integer>) obj2;
+							Enchantment ench = Enchantment.getByName(entry2.getKey());
+							if (ench != null)
+							{
+								enchantments.put(ench, entry2.getValue());
+							}
+						}
+					}
+					break;
+				}
+				case "lore":
+					JSONParser parser = new JSONParser();
+					Object rawObject;
+					try
+					{
+						rawObject = parser.parse((String) entry.getValue());
+					}
+					catch (ParseException e)
+					{
+						rawObject = new JSONArray();
+					}
+					JSONArray jsonArray = (JSONArray) rawObject;
+					lore = jsonArray;
+					break;
+				case "displayName":
+					displayName = (String) entry.getValue();
+				default:
+			}
+		}
+		return this;
+	}
+	
+	public int getId()
+	{
+		return id;
+	}
+	
+	public byte getData()
+	{
+		return data;
+	}
+	
+	public int getAmount()
+	{
+		return amount;
+	}
+	
+	public Map<Enchantment, Integer> getEnchantments()
+	{
+		return enchantments;
+	}
+	
+	public List<String> getLore()
+	{
+		return lore;
+	}
+	
+	public String getDisplayName()
+	{
+		return displayName;
+	}
+	
+	public boolean isUnbreakable()
+	{
+		return unbreakable;
+	}
+	
+	public ItemProperties setId(int id)
+	{
+		this.id = id;
+		return this;
+	}
+	
+	public ItemProperties setData(byte data)
+	{
+		this.data = data;
+		return this;
+	}
+	
+	public ItemProperties setAmount(int amount)
+	{
+		this.amount = amount;
+		return this;
+	}
+	
+	public ItemProperties setEnchantments(Map<Enchantment, Integer> enchantments)
+	{
+		this.enchantments = enchantments;
+		return this;
+	}
+	
+	public ItemProperties setLore(List<String> lore)
+	{
+		this.lore = lore;
+		return this;
+	}
+	
+	public ItemProperties setDisplayName(String displayName)
+	{
+		this.displayName = displayName;
+		return this;
+	}
+	
+	public ItemProperties setUnbreakable(boolean unbreakable)
+	{
+		this.unbreakable = unbreakable;
+		return this;
+	}
+}

src/com/redstoner/utils/ThrowingSupplier.java

@@ -0,0 +1,12 @@
+package com.redstoner.utils;
+
+/**
+ * A supplier with a throws declaration.
+ * Once again, I have more solid alternatives, but if you want it in your utils... be my guest :D
+ *
+ * @param <T> The type of object computed by this supplier.
+ */
+@FunctionalInterface
+public interface ThrowingSupplier<T> {
+    T get() throws Throwable;
+}