Redstoner/Modules
Archived
0
Fork 0
Code Activity

Converted Modules to gradle

Browse Source
This commit is contained in:
David
2018-11-07 23:50:06 +01:00
parent e86c52ef7c
commit 604cf01967
104 changed files with 24 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

206
src/main/java/com/redstoner/modules/blockplacemods/BlockPlaceMods.java Normal file
View File

@@ -0,0 +1,206 @@
package com.redstoner.modules.blockplacemods;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Comparator;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import org.bukkit.ChatColor;
import org.bukkit.command.CommandSender;
import org.bukkit.entity.Player;
import org.bukkit.event.Listener;
import com.nemez.cmdmgr.Command;
import com.redstoner.annotations.AutoRegisterListener;
import com.redstoner.annotations.Commands;
import com.redstoner.annotations.Version;
import com.redstoner.misc.CommandHolderType;
import com.redstoner.misc.Main;
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;
@Commands(CommandHolderType.None)
@AutoRegisterListener
@Version(major = 4, minor = 1, revision = 1, compatible = 4)
public final class BlockPlaceMods implements Module, Listener
{
@Override
public boolean onEnable()
{
ModAbstract.registerAll(getLogger());
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)
{
ex.printStackTrace();
return false;
}
return true;
}
@Override
public void postEnable()
{
setPrefix("BPM");
}
@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())
{
org.bukkit.command.Command command = commandMap.get(alias);
if (command != null && command.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 + ":set",
"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 = "";
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();
}
getLogger().message(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;
}
}
}

24
src/main/java/com/redstoner/modules/blockplacemods/mods/Mod.java Normal file
View File

@@ -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();
}

94
src/main/java/com/redstoner/modules/blockplacemods/mods/ModAbstract.java Normal file
View File

@@ -0,0 +1,94 @@
package com.redstoner.modules.blockplacemods.mods;
import java.util.Collections;
import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Objects;
import java.util.Set;
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 com.redstoner.misc.Main;
import com.redstoner.modules.ModuleLogger;
import com.redstoner.modules.datamanager.DataManager;
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;
private static ModuleLogger logger;
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(final ModuleLogger logger)
{
ModAbstract.logger = logger;
registerMod(new ModToggledCauldron());
registerMod(new ModToggledPiston());
registerMod(new ModToggledObserver());
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);
logger.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());
}
}

195
src/main/java/com/redstoner/modules/blockplacemods/mods/ModInventory.java Normal file
View File

@@ -0,0 +1,195 @@
package com.redstoner.modules.blockplacemods.mods;
import com.redstoner.modules.datamanager.DataManager;
import com.redstoner.utils.CommandException;
import com.redstoner.utils.ItemProperties;
import org.bukkit.GameMode;
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 java.util.Arrays;
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 Mod&a Help ###\n");
message.append("&7").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()) && event.getPlayer().getGameMode() == GameMode.CREATIVE)
{
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];
}
}

80
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledAbstract.java Normal file
View File

@@ -0,0 +1,80 @@
package com.redstoner.modules.blockplacemods.mods;
import com.redstoner.modules.datamanager.DataManager;
import com.redstoner.utils.CommandException;
import org.bukkit.entity.Player;
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### &3Toggled Mod&a Help ###");
message.append("\n&7").append(getDescription());
message.append("\n&6/mod ").append(getName()).append("&o (toggle) &btoggles state");
message.append("\n&6/mod ").append(getName()).append("&o on/off &bsets state");
message.append("\n&6/mod ").append(getName()).append("&o help &bshows this help page");
return message.toString();
}
final boolean enable;
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";
}
}

49
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledCauldron.java Normal file
View File

@@ -0,0 +1,49 @@
package com.redstoner.modules.blockplacemods.mods;
import org.bukkit.GameMode;
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 shiftless right click with redstone or fist";
}
@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())
&& (event.getPlayer().getGameMode() == GameMode.CREATIVE)
&& (event.getPlayer().getInventory().getItemInMainHand().getType() == Material.AIR))
{
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.getPlayer().getGameMode() == GameMode.CREATIVE))
{
event.getBlock().setData((byte) 3);
}
}
}

40
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledLogPlaceAbstract.java Normal file
View File

@@ -0,0 +1,40 @@
package com.redstoner.modules.blockplacemods.mods;
import org.bukkit.GameMode;
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;
/**
* A mod that makes placement of directional blocks act the way placement of logs does normally.
* Quartz pillar placement works like this too.
*
* Placed blocks face the block you clicked to place them.
*/
public abstract class ModToggledLogPlaceAbstract extends ModToggledAbstract {
protected ModToggledLogPlaceAbstract(String name, boolean enabledByDefault) {
super(name, enabledByDefault);
}
@SuppressWarnings("deprecation")
@EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
public void onBlockPlace(BlockPlaceEvent event)
{
Player player = event.getPlayer();
Block block;
if (hasEnabled(player) && !player.isSneaking() && player.getGameMode() == GameMode.CREATIVE
&& isApplicableToPlacedBlock(block = event.getBlock()))
{
block.setData((byte) getBlockDataForFacing(block.getFace(event.getBlockAgainst())));
}
}
protected abstract int getBlockDataForFacing(BlockFace direction);
protected abstract boolean isApplicableToPlacedBlock(Block block);
}

43
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledObserver.java Normal file
View File

@@ -0,0 +1,43 @@
package com.redstoner.modules.blockplacemods.mods;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
public class ModToggledObserver extends ModToggledLogPlaceAbstract {
protected ModToggledObserver() {
super("observer", false);
}
@Override
public String getDescription() {
return "If active, observers face the block you place them against";
}
@Override
protected boolean isApplicableToPlacedBlock(Block block) {
return block.getType() == Material.OBSERVER;
}
@Override
protected int getBlockDataForFacing(BlockFace direction) {
switch (direction) {
case UP:
return 0;
default:
case DOWN:
return 1;
case SOUTH:
return 2;
case NORTH:
return 3;
case EAST:
return 4;
case WEST:
return 5;
}
}
}

46
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledPiston.java Normal file
View File

@@ -0,0 +1,46 @@
package com.redstoner.modules.blockplacemods.mods;
import org.bukkit.Material;
import org.bukkit.block.Block;
import org.bukkit.block.BlockFace;
public class ModToggledPiston extends ModToggledLogPlaceAbstract
{
public ModToggledPiston()
{
super("piston", false);
}
@Override
public String getDescription()
{
return "If active, pistons face the block you place them against";
}
@Override
protected boolean isApplicableToPlacedBlock(Block block) {
Material type = block.getType();
return type == Material.PISTON_BASE || type == Material.PISTON_STICKY_BASE;
}
@Override
protected int getBlockDataForFacing(BlockFace direction) {
switch (direction)
{
default:
case DOWN:
return 0;
case UP:
return 1;
case NORTH:
return 2;
case SOUTH:
return 3;
case WEST:
return 4;
case EAST:
return 5;
}
}
}

40
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledStep.java Normal file
View File

@@ -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;
}
}

91
src/main/java/com/redstoner/modules/blockplacemods/mods/ModToggledTorch.java Normal file
View File

@@ -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();
}
}
}
}