spotless

I don't think anyone would turn this off...

build.gradle

@@ -57,7 +57,7 @@ plugins {
     id 'com.palantir.git-version'        version '0.13.0'       apply false
     id 'de.undercouch.download'          version '5.0.1'
     id 'com.github.gmazzo.buildconfig'   version '3.0.3'        apply false
-    id "com.diffplug.spotless"           version "6.7.2"
+    id 'com.diffplug.spotless'           version '6.7.2'        apply false
 }
 verifySettingsGradle()
 
@@ -90,7 +90,13 @@ idea {
         downloadSources = true
     }
 }
-apply from: Blowdryer.file('spotless.gradle')
+
+boolean disableSpotless = project.hasProperty("disableSpotless") ? project.disableSpotless.toBoolean() : false
+
+if (!disableSpotless) {
+    apply plugin: 'com.diffplug.spotless'
+    apply from: Blowdryer.file('spotless.gradle')
+}
 
 if(JavaVersion.current() != JavaVersion.VERSION_1_8) {
     throw new GradleException("This project requires Java 8, but it's running on " + JavaVersion.current())

dependencies.gradle

@@ -1,5 +1,6 @@
 // Add your dependencies here
 
 dependencies {
-
+    compile("com.github.GTNewHorizons:GTNHLib:0.0.1:dev")
+    runtime("com.github.GTNewHorizons:NotEnoughItems:2.2.20-GTNH:dev")
 }

docs/channels.md

@@ -0,0 +1,72 @@
+# Constructable Tool
+
+The convention is to use the stack size of tool stack to pass tier info.
+
+## Channels
+
+When one multi have multiple tiered component that can have interleaving tier, this becomes an obnoxious restriction, as
+one ItemStack cannot have two stack sizes at the same time.
+Here we use the item NBT to bypass this restriction.
+
+Basically, one hologram can contain multiple channels.
+Each channel can be identified with lower case strings and has the value being one positive Java int.
+There will be one and only one master channel and 0 or more sub channel.
+
+When a non-existent sub channel is queried, master channel will be used instead to fill its place.
+
+Structure element designers will usually not need to consider channels, i.e. proceed as if this concept does not exist, unless it must take input from multiple channels.
+
+Multi Designers will consider how to map each channel to each tiered component.
+He will be using `com.gtnewhorizon.structurelib.structure.StructureUtility.withChannel` to direct structure element on which channel to use.
+Conceptually, it will return an ItemStack with the master channel being the value of selected channel.
+In implementation, withChannel will return a new ItemStack with same item, nbt but different stack size.
+
+In any case, it is NOT safe to mutate or query this ItemStack beyond its stack size.
+What information this carries (beyond the stack size) is an implementation detail and should not be relied on.
+__For the future of mankind please do not rely on this.__
+
+### why is this called channel?
+
+IDK man, just give me a better name and I'd do the renaming.
+
+### Example: Multiblock Structure Designer
+
+GT++ Chemical Plant is a multi with 4 distinctly tiered component.
+
+It will use
+* master channel for its outer shell
+* channel `"casing"` for machine casings
+* channel `"pipe"` for pipe casings
+* channel `"coil"` for heating coils
+
+Its structure code will then look like
+```java
+.addElement('a', shellStructureElement())
+.addElement('b', withChannel("casing", machineCasingStructureElement()))
+.addElement('c', withChannel("pipe", pipeCasingStructureElement()))
+.addElement('d', withChannel("coil", coilStructureElement()))
+```
+
+whereas all these structure elements are designed without considering channels whatsoever
+
+### Example: Multi channel input Structure Element
+
+Suppose your hatch element has a required facing and can accept arbitrary meta tile entity, so it will need both meta id and facing input.
+
+
+It will use
+* master channel for its outer shell
+* channel `"casing"` for machine casings
+* channel `"pipe"` for pipe casings
+* channel `"coil"` for heating coils
+
+Its structure code will then look like
+```java
+.addElement('a', shellStructureElement())
+.addElement('b', withChannel("casing", machineCasingStructureElement()))
+.addElement('c', withChannel("pipe", pipeCasingStructureElement()))
+.addElement('d', withChannel("coil", coilStructureElement()))
+```
+
+whereas all these structure elements are designed without considering channels whatsoever
+

docs/walkthrough.md

@@ -0,0 +1,62 @@
+# StructureLib Developer Guide v0.1-SNAPSHOT
+
+## `IStructureDefinition`
+
+`IStructureDefinition` is the structure definition of your multi. You will have one `IStructureDefinition` for each multi.
+
+### Caching?
+
+You will construct this definition once per multi, either at class load or at first call to `getStructureDefinition()`.
+You can use a `ClassValue<IStructureDefinition<?>>` if you have a template for subclass.
+You can also use `StructureUtility.defer()` for simpler cases, but it is slightly less performant as it will allocate new
+objects on each structure check, whereas `ClassValue` will allocate once and cache it onwards.
+
+### Constructing
+
+IStructureDefinition is constructed using `IStructureDefinition#builder()`.
+
+Builder has two main methods
+1. `addShape` is a 2d string array describing the layout of structure. You can optionally use `StructureUtility#transpose()`
+to transpose the array to make the structure look nicer in source code.
+2. `addElement`. It takes a char identifier (mapped to a char in any of `addShape()` calls) and a IStructureElement.
+
+## `IStructureElement`
+
+`IStructureElement` are how you define which block will be accepted.
+They are simple stateless classes. They will rely on the multiblock controller to store any states they need.
+If you don't want to store these transient states in multiblock controller, you can use `StructureUtility#withContext()`
+
+They will usually come from `StructureUtility`.
+There is a vast library of `IStructureElement` there to cover basic needs.
+For more complex usage, you can define your own subclass, e.g. GregTech 5 Unofficial defines `ofHatchAdder()`, `ofCoil()`,
+`ofFrame()` and `buildHatchAdder()` in its `GT_StructureUtility` class.
+
+Here we will detail a few more complex `IStructureElement` that comes with standard library.
+
+### `ofBlocksTiered`
+
+This assumes you have a series of block, e.g. T1 motor, T2 motor, etc. Your multi will accept any of them (__as long as
+player does not mix them (*)__), but would like to know which is used.
+
+(*): Implementation wise, this structure element will only accept a block if its tier is the same as existing tier or
+if existing tier is unset (i.e. value of third argument)
+
+The first argument is tier extractor.
+You will need to provide a function to convert block+meta to a tier.
+This tier cam be an Enum, an Integer, a String, or basically anything.
+It doesn't even have to implement `Comparable`.
+The choice is yours.
+The extractor can return null and will never be passed a null block or an invalid block meta.
+
+The second argument is a list of all blocks you know that you will accept.
+This list is only for hint particle spawning and survival build.
+The hint/autoplace code will choose 1st pair to spawn/place if hologram has [channel data](./channels.md) of 1,
+2nd pair if 2, and so on.
+
+The third argument is the value when the tier has not been set by structure code.
+This means getter (5th argument) will usually return this upon first invocation for each round of structure check.
+
+The fourth argument will notify the multi of a tier change.
+
+The fifth argument is how multi notify the structure element about current tier.
+This is necessary as all structure element are stateless themselves.

repositories.gradle

@@ -1,5 +1,8 @@
 // Add any additional repositiroes for your dependencies here
 
 repositories {
-
+    maven {
+        name = "GTNH"
+        url = "http://jenkins.usrv.eu:8081/nexus/content/groups/public/"
+    }
 }

src/main/java/com/gtnewhorizon/structurelib/ClientProxy.java

@@ -3,6 +3,7 @@ package com.gtnewhorizon.structurelib;
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
 import com.gtnewhorizon.structurelib.entity.fx.EntityFXBlockHint;
+import com.gtnewhorizon.structurelib.net.SetChannelDataMessage;
 import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
 import java.util.ArrayList;
@@ -14,6 +15,7 @@ import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiNewChat;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
 import net.minecraft.util.ChatComponentText;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.World;
@@ -149,6 +151,11 @@ public class ClientProxy extends CommonProxy {
         return Minecraft.getMinecraft().theWorld.getTotalWorldTime();
     }
 
+    @Override
+    public void uploadChannels(ItemStack trigger) {
+        StructureLib.net.sendToServer(new SetChannelDataMessage(trigger));
+    }
+
     private static class HintParticleInfo {
         private final int x, y, z;
         private final List<EntityFXBlockHint> owner;

src/main/java/com/gtnewhorizon/structurelib/CommonProxy.java

@@ -5,6 +5,7 @@ import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.World;
@@ -48,4 +49,6 @@ public class CommonProxy {
     public long getOverworldTime() {
         return MinecraftServer.getServer().getEntityWorld().getTotalWorldTime();
     }
+
+    public void uploadChannels(ItemStack trigger) {}
 }

src/main/java/com/gtnewhorizon/structurelib/ConfigurationHandler.java

@@ -15,6 +15,8 @@ public enum ConfigurationHandler {
     private Configuration config;
     private int maxCoexistingHologram;
     private boolean removeCollidingHologram;
+    private int autoPlaceBudget;
+    private int autoPlaceInterval;
 
     ConfigurationHandler() {
         FMLCommonHandler.instance().bus().register(this);
@@ -50,6 +52,25 @@ public enum ConfigurationHandler {
                 "client.hologram",
                 true,
                 "An attempt will be made to remove an existing hologram if it collides with a new hologram.");
+        autoPlaceBudget = config.getInt(
+                "autoPlaceBudget",
+                "common.hologram",
+                25,
+                1,
+                200,
+                "Max number of elements can be placed in one round of auto place.\n"
+                        + "As expected, server side settings will overrides client settings.\n"
+                        + "Certain larger multi might increase these values beyond this configured value.");
+        autoPlaceInterval = config.getInt(
+                "autoPlaceInterval",
+                "common.hologram",
+                300,
+                0,
+                20000,
+                "Unit: milisecond. Minimal interval between two auto place round.\n"
+                        + "As expected, server side settings will overrides client settings.\n"
+                        + "Note this relates to the wall clock, not in game ticks.\n"
+                        + "Value smaller than default is likely to be perceived as no minimal interval whatsoever.");
 
         if (config.hasChanged()) {
             config.save();
@@ -71,6 +92,14 @@ public enum ConfigurationHandler {
         return removeCollidingHologram;
     }
 
+    public int getAutoPlaceBudget() {
+        return autoPlaceBudget;
+    }
+
+    public int getAutoPlaceInterval() {
+        return autoPlaceInterval;
+    }
+
     Configuration getConfig() {
         return config;
     }

src/main/java/com/gtnewhorizon/structurelib/GuiHandler.java

@@ -0,0 +1,23 @@
+package com.gtnewhorizon.structurelib;
+
+import com.gtnewhorizon.structurelib.gui.GuiScreenConfigureChannels;
+import cpw.mods.fml.common.network.IGuiHandler;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
+
+public class GuiHandler implements IGuiHandler {
+    @Override
+    public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
+        return null;
+    }
+
+    @Override
+    public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
+        switch (ID) {
+            case 0:
+                return new GuiScreenConfigureChannels(player.inventory.getStackInSlot(x));
+            default:
+                return null;
+        }
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/StructureLib.java

@@ -1,15 +1,18 @@
 package com.gtnewhorizon.structurelib;
 
 import com.gtnewhorizon.structurelib.block.BlockHint;
+import com.gtnewhorizon.structurelib.command.CommandConfigureChannels;
 import com.gtnewhorizon.structurelib.item.ItemBlockHint;
 import com.gtnewhorizon.structurelib.item.ItemConstructableTrigger;
 import com.gtnewhorizon.structurelib.item.ItemFrontRotationTool;
 import com.gtnewhorizon.structurelib.net.AlignmentMessage;
+import com.gtnewhorizon.structurelib.net.SetChannelDataMessage;
 import com.gtnewhorizon.structurelib.net.UpdateHintParticleMessage;
 import com.gtnewhorizon.structurelib.util.XSTR;
 import cpw.mods.fml.common.Mod;
 import cpw.mods.fml.common.SidedProxy;
 import cpw.mods.fml.common.event.FMLPreInitializationEvent;
+import cpw.mods.fml.common.event.FMLServerStartingEvent;
 import cpw.mods.fml.common.network.NetworkRegistry;
 import cpw.mods.fml.common.network.simpleimpl.SimpleNetworkWrapper;
 import cpw.mods.fml.common.registry.GameRegistry;
@@ -20,6 +23,7 @@ import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemBlock;
+import net.minecraft.launchwrapper.Launch;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
@@ -33,7 +37,7 @@ import org.apache.logging.log4j.Logger;
         acceptableRemoteVersions = "*",
         guiFactory = "com.gtnewhorizon.structurelib.GuiFactory")
 public class StructureLib {
-    public static boolean DEBUG_MODE = Boolean.getBoolean("structurelib.debug");
+    public static boolean DEBUG_MODE;
     public static boolean PANIC_MODE = Boolean.getBoolean("structurelib.panic");
     public static Logger LOGGER = LogManager.getLogger("StructureLib");
 
@@ -49,10 +53,22 @@ public class StructureLib {
                 AlignmentMessage.ServerHandler.class, AlignmentMessage.AlignmentQuery.class, 0, Side.SERVER);
         net.registerMessage(AlignmentMessage.ClientHandler.class, AlignmentMessage.AlignmentData.class, 1, Side.CLIENT);
         net.registerMessage(UpdateHintParticleMessage.Handler.class, UpdateHintParticleMessage.class, 2, Side.CLIENT);
+        net.registerMessage(SetChannelDataMessage.Handler.class, SetChannelDataMessage.class, 3, Side.SERVER);
+
+        try {
+            DEBUG_MODE = Boolean.parseBoolean(System.getProperty("structurelib.debug"));
+        } catch (IllegalArgumentException | NullPointerException e) {
+            // turn on debug by default in dev mode
+            // this will be overridden if above property is present and set to false
+            DEBUG_MODE = (Boolean) Launch.blackboard.get("fml.deobfuscatedEnvironment");
+        }
     }
 
     public static final XSTR RANDOM = new XSTR();
 
+    @Mod.Instance
+    static StructureLib INSTANCE;
+
     static Block blockHint;
     static Item itemBlockHint;
     static Item itemFrontRotationTool;
@@ -76,6 +92,12 @@ public class StructureLib {
                 itemConstructableTrigger = new ItemConstructableTrigger(),
                 itemConstructableTrigger.getUnlocalizedName());
         proxy.preInit(e);
+        NetworkRegistry.INSTANCE.registerGuiHandler(instance(), new GuiHandler());
+    }
+
+    @Mod.EventHandler
+    public void serverStarting(FMLServerStartingEvent e) {
+        e.registerServerCommand(new CommandConfigureChannels());
     }
 
     public static void addClientSideChatMessages(String... messages) {
@@ -93,4 +115,12 @@ public class StructureLib {
     public static long getOverworldTime() {
         return proxy.getOverworldTime();
     }
+
+    public static StructureLib instance() {
+        return INSTANCE;
+    }
+
+    public CommonProxy proxy() {
+        return proxy;
+    }
 }

src/main/java/com/gtnewhorizon/structurelib/alignment/constructable/ChannelDataAccessor.java

@@ -0,0 +1,107 @@
+package com.gtnewhorizon.structurelib.alignment.constructable;
+
+import static com.gtnewhorizon.structurelib.util.MiscUtils.getTagKeys;
+import static net.minecraftforge.common.util.Constants.NBT.TAG_COMPOUND;
+
+import com.gtnewhorizon.structurelib.StructureLib;
+import java.util.Locale;
+import java.util.Map.Entry;
+import java.util.stream.Stream;
+import net.minecraft.init.Items;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraftforge.common.util.Constants.NBT;
+import org.apache.commons.lang3.tuple.ImmutablePair;
+
+public class ChannelDataAccessor {
+    private static final String SECONDARY_HINT_TAG = "channels";
+
+    private ChannelDataAccessor() {}
+
+    public static ItemStack withChannel(ItemStack masterStack, String channel) {
+        if (channel == null || channel.isEmpty()) throw new IllegalArgumentException();
+        if (StructureLib.DEBUG_MODE && !channel.toLowerCase(Locale.ROOT).equals(channel))
+            throw new IllegalArgumentException("Channel name can be lower case ONLY");
+        if (!masterStack.hasTagCompound()
+                || !masterStack.stackTagCompound.hasKey(SECONDARY_HINT_TAG, TAG_COMPOUND)
+                || !masterStack
+                        .stackTagCompound
+                        .getCompoundTag(SECONDARY_HINT_TAG)
+                        .hasKey(channel, NBT.TAG_INT)) return masterStack;
+        ItemStack ret = new ItemStack(
+                masterStack.getItem(),
+                masterStack.stackTagCompound.getCompoundTag(SECONDARY_HINT_TAG).getInteger(channel),
+                Items.feather.getDamage(masterStack));
+        ret.setTagCompound(masterStack.stackTagCompound);
+        return ret;
+    }
+
+    public static boolean hasSubChannel(ItemStack masterStack) {
+        return masterStack.hasTagCompound() && masterStack.stackTagCompound.hasKey(SECONDARY_HINT_TAG, TAG_COMPOUND);
+    }
+
+    public static boolean hasSubChannel(ItemStack masterStack, String channel) {
+        if (StructureLib.DEBUG_MODE && !channel.toLowerCase(Locale.ROOT).equals(channel))
+            throw new IllegalArgumentException("Channel name can be lower case ONLY");
+        return !channel.isEmpty()
+                && masterStack.hasTagCompound()
+                && masterStack.stackTagCompound.hasKey(SECONDARY_HINT_TAG, TAG_COMPOUND)
+                && masterStack
+                        .stackTagCompound
+                        .getCompoundTag(SECONDARY_HINT_TAG)
+                        .hasKey(channel, NBT.TAG_INT);
+    }
+
+    public static int getChannelData(ItemStack masterStack, String channel) {
+        if (channel == null || channel.isEmpty()) throw new IllegalArgumentException();
+        if (StructureLib.DEBUG_MODE && !channel.toLowerCase(Locale.ROOT).equals(channel))
+            throw new IllegalArgumentException("Channel name can be lower case ONLY");
+        if (!masterStack.hasTagCompound()
+                || !masterStack.stackTagCompound.hasKey(SECONDARY_HINT_TAG, TAG_COMPOUND)
+                || !masterStack
+                        .stackTagCompound
+                        .getCompoundTag(SECONDARY_HINT_TAG)
+                        .hasKey(channel, NBT.TAG_INT)) return masterStack.stackSize;
+        return masterStack.stackTagCompound.getCompoundTag(SECONDARY_HINT_TAG).getInteger(channel);
+    }
+
+    public static void setChannelData(ItemStack masterStack, String channel, int data) {
+        if (channel == null || channel.isEmpty()) throw new IllegalArgumentException();
+        if (StructureLib.DEBUG_MODE && !channel.toLowerCase(Locale.ROOT).equals(channel))
+            throw new IllegalArgumentException("Channel name can be lower case ONLY");
+        if (data <= 0) throw new IllegalArgumentException();
+        if (masterStack.stackTagCompound == null) masterStack.stackTagCompound = new NBTTagCompound();
+        NBTTagCompound main = masterStack.stackTagCompound;
+        if (!main.hasKey(SECONDARY_HINT_TAG, TAG_COMPOUND)) main.setTag(SECONDARY_HINT_TAG, new NBTTagCompound());
+        main.getCompoundTag(SECONDARY_HINT_TAG).setInteger(channel, data);
+    }
+
+    public static void unsetChannelData(ItemStack masterStack, String channel) {
+        if (channel == null || channel.isEmpty()) throw new IllegalArgumentException();
+        if (StructureLib.DEBUG_MODE && !channel.toLowerCase(Locale.ROOT).equals(channel))
+            throw new IllegalArgumentException("Channel name can be lower case ONLY");
+        if (masterStack.stackTagCompound == null) masterStack.stackTagCompound = new NBTTagCompound();
+        NBTTagCompound main = masterStack.stackTagCompound;
+        if (!main.hasKey(SECONDARY_HINT_TAG, TAG_COMPOUND)) main.setTag(SECONDARY_HINT_TAG, new NBTTagCompound());
+        NBTTagCompound tag = main.getCompoundTag(SECONDARY_HINT_TAG);
+        tag.removeTag(channel);
+        if (tag.hasNoTags()) main.removeTag(SECONDARY_HINT_TAG);
+        if (main.hasNoTags()) masterStack.stackTagCompound = null;
+    }
+
+    public static void wipeChannelData(ItemStack masterStack) {
+        if (masterStack.stackTagCompound != null) masterStack.stackTagCompound.removeTag(SECONDARY_HINT_TAG);
+    }
+
+    public static Stream<Entry<String, Integer>> iterateChannelData(ItemStack masterStack) {
+        if (!hasSubChannel(masterStack)) return Stream.empty();
+        NBTTagCompound tag = masterStack.stackTagCompound.getCompoundTag(SECONDARY_HINT_TAG);
+        return getTagKeys(tag).stream().map(s -> new ImmutablePair<>(s, tag.getInteger(s)));
+    }
+
+    public static int countChannelData(ItemStack masterStack) {
+        if (!hasSubChannel(masterStack)) return 0;
+        NBTTagCompound tag = masterStack.stackTagCompound.getCompoundTag(SECONDARY_HINT_TAG);
+        return tag.func_150296_c().size();
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/alignment/constructable/ConstructableUtility.java

@@ -1,14 +1,15 @@
 package com.gtnewhorizon.structurelib.alignment.constructable;
 
+import com.gtnewhorizon.structurelib.ConfigurationHandler;
 import com.gtnewhorizon.structurelib.StructureLib;
 import com.gtnewhorizon.structurelib.StructureLibAPI;
 import com.gtnewhorizon.structurelib.alignment.IAlignment;
 import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing;
 import com.gtnewhorizon.structurelib.structure.IItemSource;
+import java.util.WeakHashMap;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.tileentity.TileEntity;
 import net.minecraft.util.ChatComponentTranslation;
 import net.minecraft.world.World;
@@ -17,10 +18,8 @@ import net.minecraftforge.common.util.ForgeDirection;
 
 public class ConstructableUtility {
 
-    // TODO make these configurable and expose this to external world
-    public static final int COOLDOWN = 5;
-    private static final int BUDGET = 25;
-    public static boolean redBrokenOne = true; // TODO this is horrible
+    private static final WeakHashMap<EntityPlayerMP, Long> lastUse = new WeakHashMap<>();
+    private static long clientSideLastUse = 0;
 
     private ConstructableUtility() {}
 
@@ -42,10 +41,11 @@ public class ConstructableUtility {
             // not sneaking - client side will generate hologram. nothing to do on server side
             if (!aPlayer.isSneaking()) return true;
 
-            long timePast = StructureLib.getOverworldTime() - getLastUseTick(aStack);
-            if (timePast < COOLDOWN) {
+            long timePast = System.currentTimeMillis() - getLastUseMilis(aPlayer);
+            if (timePast < ConfigurationHandler.INSTANCE.getAutoPlaceInterval()) {
                 aPlayer.addChatComponentMessage(new ChatComponentTranslation(
-                        "item.structurelib.constructableTrigger.too_fast", COOLDOWN - timePast));
+                        "item.structurelib.constructableTrigger.too_fast",
+                        ConfigurationHandler.INSTANCE.getAutoPlaceInterval() - timePast));
                 return true;
             }
         } else if (!StructureLib.isCurrentPlayer(aPlayer)) {
@@ -75,15 +75,17 @@ public class ConstructableUtility {
                 constructable.construct(aStack, false);
             } else if (constructable instanceof ISurvivalConstructable) {
                 int built = ((ISurvivalConstructable) constructable)
-                        .survivalConstruct(aStack, BUDGET, IItemSource.fromPlayer(playerMP), playerMP);
-                if (built > 0)
-                    // TODO somehow notify extensions that their inventory might have been modified and need to be
-                    // synced to client or saved
-                    playerMP.inventory.markDirty();
-                else if (built == -1) {
+                        .survivalConstruct(
+                                aStack,
+                                ConfigurationHandler.INSTANCE.getAutoPlaceBudget(),
+                                IItemSource.fromPlayer(playerMP),
+                                playerMP);
+                if (built > 0) {
+                    playerMP.addChatMessage(new ChatComponentTranslation("structurelib.autoplace.built_stat", built));
+                } else if (built == -1) {
                     playerMP.addChatMessage(new ChatComponentTranslation("structurelib.autoplace.complete"));
                 }
-                setLastUseTickToStackTag(aStack);
+                setLastUseMilis(aPlayer);
             } else {
                 playerMP.addChatMessage(new ChatComponentTranslation("structurelib.autoplace.error.not_enabled"));
             }
@@ -92,19 +94,23 @@ public class ConstructableUtility {
         // client side
         // particles and text
         constructable.construct(aStack, true);
-        if (getLastUseTick(aStack) == 0)
+        if (System.currentTimeMillis() - getLastUseMilis(aPlayer) >= 300)
             StructureLib.addClientSideChatMessages(constructable.getStructureDescription(aStack));
+        setLastUseMilis(aPlayer);
         return false;
     }
 
-    private static long getLastUseTick(ItemStack aStack) {
-        return aStack.hasTagCompound() ? aStack.getTagCompound().getLong("LastUse") : 0;
+    private static void setLastUseMilis(EntityPlayer aPlayer) {
+        if (!(aPlayer instanceof EntityPlayerMP))
+            // assume client side
+            clientSideLastUse = System.currentTimeMillis();
+        else lastUse.put((EntityPlayerMP) aPlayer, System.currentTimeMillis());
     }
 
-    private static void setLastUseTickToStackTag(ItemStack aStack) {
-        NBTTagCompound tag = aStack.stackTagCompound;
-        if (tag == null) tag = aStack.stackTagCompound = new NBTTagCompound();
-        // here we force use the overworld tick time, in case the current world is over
-        tag.setLong("LastUse", StructureLib.getOverworldTime());
+    private static long getLastUseMilis(EntityPlayer aPlayer) {
+        if (!(aPlayer instanceof EntityPlayerMP))
+            // assume client side
+            return clientSideLastUse;
+        return lastUse.getOrDefault(aPlayer, 0L);
     }
 }

src/main/java/com/gtnewhorizon/structurelib/command/CommandConfigureChannels.java

@@ -0,0 +1,121 @@
+package com.gtnewhorizon.structurelib.command;
+
+import com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor;
+import com.gtnewhorizon.structurelib.item.ItemConstructableTrigger;
+import java.util.Arrays;
+import java.util.List;
+import java.util.stream.Collectors;
+import net.minecraft.command.CommandBase;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.command.WrongUsageException;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.ChatComponentText;
+import net.minecraft.util.ChatComponentTranslation;
+
+public class CommandConfigureChannels extends CommandBase {
+    @Override
+    public String getCommandName() {
+        return "sl_channel";
+    }
+
+    @Override
+    public String getCommandUsage(ICommandSender p_71518_1_) {
+        return "/sl_channel <wipe/getall>\n" + "/sl_channel <get/unset> <channel name>\n"
+                + "/sl_channel <set> <channel name> <value>\n"
+                + "<channel name> can have space in it. <value> must be positive integer";
+    }
+
+    @Override
+    public int getRequiredPermissionLevel() {
+        return 0;
+    }
+
+    @Override
+    public List<?> addTabCompletionOptions(ICommandSender p_71516_1_, String[] p_71516_2_) {
+        if (p_71516_2_.length == 1)
+            return getListOfStringsMatchingLastWord(p_71516_2_, "get", "set", "unset", "wipe", "getall");
+        return null;
+    }
+
+    @Override
+    public void processCommand(ICommandSender sender, String[] args) {
+        if (args.length == 0) throw new WrongUsageException(getCommandUsage(sender));
+
+        if (!(sender instanceof EntityPlayerMP)) throw new WrongUsageException("must be a player");
+
+        EntityPlayerMP player = (EntityPlayerMP) sender;
+
+        ItemStack heldItem = player.getHeldItem();
+        if (heldItem == null || !(heldItem.getItem() instanceof ItemConstructableTrigger)) {
+            throw new WrongUsageException("must hold a hologram");
+        }
+
+        String channel;
+
+        switch (args[0]) {
+            case "getall":
+                if (!ChannelDataAccessor.hasSubChannel(heldItem)) {
+                    sender.addChatMessage(new ChatComponentText("No subchannel"));
+                } else {
+                    sender.addChatMessage(new ChatComponentTranslation(
+                            "item.structurelib.constructableTrigger.desc.lshift.0",
+                            ChannelDataAccessor.countChannelData(heldItem)));
+                    ChannelDataAccessor.iterateChannelData(heldItem)
+                            .map(e -> e.getKey() + ": " + e.getValue())
+                            .map(ChatComponentText::new)
+                            .forEach(player::addChatMessage);
+                }
+                return;
+            case "wipe":
+                ChannelDataAccessor.wipeChannelData(heldItem);
+                return;
+            case "get":
+            case "unset":
+                if (args.length < 2) throw new WrongUsageException(getCommandUsage(sender));
+                channel =
+                        args.length == 2 ? args[1] : Arrays.stream(args).skip(1).collect(Collectors.joining());
+                break;
+            case "set":
+                if (args.length < 3) throw new WrongUsageException(getCommandUsage(sender));
+                channel = args.length == 3
+                        ? args[1]
+                        : Arrays.stream(args).skip(1).limit(args.length - 2).collect(Collectors.joining());
+                break;
+            default:
+                throw new WrongUsageException(getCommandUsage(sender));
+        }
+
+        switch (args[0]) {
+            case "get":
+                if (ChannelDataAccessor.hasSubChannel(heldItem, channel))
+                    sender.addChatMessage(new ChatComponentText(
+                            channel + " value: " + ChannelDataAccessor.getChannelData(heldItem, channel)));
+                else sender.addChatMessage(new ChatComponentText(channel + " value: N/A"));
+                break;
+            case "clear":
+                if (ChannelDataAccessor.hasSubChannel(heldItem, channel))
+                    sender.addChatMessage(new ChatComponentText(channel + " no value"));
+                else {
+                    ChannelDataAccessor.unsetChannelData(heldItem, channel);
+                    sender.addChatMessage(new ChatComponentText(channel + " cleared"));
+                    player.inventoryContainer.detectAndSendChanges();
+                }
+                break;
+            case "set":
+                int value;
+                try {
+                    value = Integer.parseInt(args[args.length - 1]);
+                } catch (NumberFormatException e) {
+                    throw new WrongUsageException("%s not a valid value", args[args.length - 1]);
+                }
+
+                if (value <= 0) throw new WrongUsageException("%s not a valid value", args[args.length - 1]);
+
+                ChannelDataAccessor.setChannelData(heldItem, channel, value);
+                player.inventoryContainer.detectAndSendChanges();
+                sender.addChatMessage(new ChatComponentText(channel + " value: " + value));
+                break;
+        }
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/gui/GuiScreenConfigureChannels.java

@@ -0,0 +1,400 @@
+package com.gtnewhorizon.structurelib.gui;
+
+import com.gtnewhorizon.structurelib.StructureLib;
+import com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor;
+import com.gtnewhorizon.structurelib.gui.GuiScrollableList.IGuiScreen;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map.Entry;
+import java.util.stream.Collectors;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.gui.GuiTextField;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumChatFormatting;
+import net.minecraft.util.ResourceLocation;
+import org.apache.commons.lang3.StringUtils;
+import org.lwjgl.input.Keyboard;
+import org.lwjgl.input.Mouse;
+import org.lwjgl.opengl.GL11;
+
+public class GuiScreenConfigureChannels extends GuiScreen implements IGuiScreen {
+    private static final int KEY_MAX_WIDTH = 50;
+    private final ItemStack trigger;
+    private final GuiChannelsList list;
+    private GuiTextField key, value;
+    protected int guiTop, guiLeft;
+
+    public GuiScreenConfigureChannels(ItemStack trigger) {
+        this.trigger = trigger;
+        list = new GuiChannelsList(152, 100, 12, 12, 14);
+        list.addSelectionListener((list, selectedIndex) -> {
+            Entry<String, Integer> e = list.getElementAt(selectedIndex);
+            key.setText(e.getKey());
+            value.setText(e.getValue().toString());
+            updateButtons();
+        });
+    }
+
+    @Override
+    public void initGui() {
+        super.initGui();
+        // so you can keep holding backspace to delete a long sequence of chars
+        Keyboard.enableRepeatEvents(true);
+
+        guiLeft = (this.width - this.getXSize()) / 2;
+        guiTop = (this.height - this.getYSize()) / 2;
+
+        key = new GuiTextField(fontRendererObj, guiLeft + 45, guiTop + 119, 151 + 12 - 45, 12) {
+            @Override
+            public void writeText(String text) {
+                // force lower case
+                super.writeText(text.toLowerCase(Locale.ROOT));
+                updateButtons();
+            }
+
+            @Override
+            public void mouseClicked(int p_146192_1_, int p_146192_2_, int p_146192_3_) {
+                super.mouseClicked(p_146192_1_, p_146192_2_, p_146192_3_);
+                boolean flag = p_146192_1_ >= this.xPosition
+                        && p_146192_1_ < this.xPosition + this.width
+                        && p_146192_2_ >= this.yPosition
+                        && p_146192_2_ < this.yPosition + this.height;
+                if (flag && p_146192_3_ == 1) {
+                    key.setText("");
+                    value.setText("");
+                }
+            }
+
+            @Override
+            public void setText(String p_146180_1_) {
+                super.setText(p_146180_1_);
+                updateButtons();
+            }
+        };
+        value = new GuiTextField(fontRendererObj, guiLeft + 45, guiTop + 139, 151 + 12 - 45, 12) {
+            @Override
+            public void writeText(String text) {
+                // ignore write requests containing non digit characters.
+                // we don't accept decimals or negative numbers, so we can safely use isDigit instead of something more
+                // advanced
+                // use codePoints() in case someone pasted an emoji by mistake
+                if (text != null && text.codePoints().allMatch(Character::isDigit)) {
+                    super.writeText(text);
+                    updateButtons();
+                }
+            }
+
+            @Override
+            public void setFocused(boolean p_146195_1_) {
+                if (!p_146195_1_ && isFocused() && !StringUtils.isBlank(getText())) {
+                    int result;
+                    try {
+                        result = Math.max(Integer.parseInt(getText()), 1);
+                    } catch (NumberFormatException e) {
+                        result = 1;
+                    }
+                    setText(String.valueOf(result));
+                }
+                super.setFocused(p_146195_1_);
+            }
+
+            @Override
+            public void mouseClicked(int p_146192_1_, int p_146192_2_, int p_146192_3_) {
+                super.mouseClicked(p_146192_1_, p_146192_2_, p_146192_3_);
+                boolean flag = p_146192_1_ >= this.xPosition
+                        && p_146192_1_ < this.xPosition + this.width
+                        && p_146192_2_ >= this.yPosition
+                        && p_146192_2_ < this.yPosition + this.height;
+                if (flag && p_146192_3_ == 1) {
+                    setText("");
+                }
+            }
+
+            @Override
+            public void setText(String p_146180_1_) {
+                super.setText(p_146180_1_);
+                updateButtons();
+            }
+        };
+
+        list.onGuiInit(this);
+
+        addButton(new GuiButton(
+                0, guiLeft + 12, guiTop + 157, 47, 20, I18n.format("item.structurelib.constructableTrigger.gui.add")));
+        addButton(new GuiButton(
+                1,
+                guiLeft + 65,
+                guiTop + 157,
+                47,
+                20,
+                I18n.format("item.structurelib.constructableTrigger.gui.unset")));
+        addButton(new GuiButton(
+                2,
+                guiLeft + 118,
+                guiTop + 157,
+                47,
+                20,
+                I18n.format("item.structurelib.constructableTrigger.gui.wipe")));
+
+        updateButtons();
+    }
+
+    @Override
+    public int getGuiLeft() {
+        return guiLeft;
+    }
+
+    @Override
+    public int getGuiTop() {
+        return guiTop;
+    }
+
+    @Override
+    public int getXSize() {
+        return 176;
+    }
+
+    @Override
+    public int getYSize() {
+        return 188;
+    }
+
+    @Override
+    public void addButton(GuiButton button) {
+        getButtonList().add(button);
+    }
+
+    @Override
+    public void removeButton(GuiButton button) {
+        getButtonList().remove(button);
+    }
+
+    @Override
+    public int getOverlayOffsetX() {
+        return 0;
+    }
+
+    @Override
+    public void doActionPerformed(GuiButton but) {
+        actionPerformed(but);
+    }
+
+    @SuppressWarnings("unchecked")
+    private List<GuiButton> getButtonList() {
+        return buttonList;
+    }
+
+    @Override
+    public void handleMouseInput() {
+        int delta = Mouse.getEventDWheel();
+        if (delta != 0) list.handleDWheel(delta);
+        super.handleMouseInput();
+    }
+
+    @Override
+    protected void mouseClicked(int mX, int mY, int button) {
+        key.mouseClicked(mX, mY, button);
+        value.mouseClicked(mX, mY, button);
+        super.mouseClicked(mX, mY, button);
+    }
+
+    @Override
+    protected void keyTyped(char aChar, int aKey) {
+        switch (aKey) {
+            case Keyboard.KEY_TAB:
+                if (key.isFocused()) {
+                    key.setFocused(false);
+                    value.setFocused(true);
+                } else {
+                    key.setFocused(true);
+                    value.setFocused(false);
+                }
+                return;
+            case Keyboard.KEY_RETURN:
+            case Keyboard.KEY_NUMPADENTER:
+                GuiButton add = getButtonList().get(0);
+                if (add.enabled) doActionPerformed(add);
+                return;
+            case Keyboard.KEY_UP:
+                if (list.selectedIndex > 0) list.setSelection(list.selectedIndex - 1);
+                return;
+            case Keyboard.KEY_DOWN:
+                if (list.selectedIndex < list.getNumElements() - 1) list.setSelection(list.selectedIndex + 1);
+                return;
+        }
+        if (key.textboxKeyTyped(aChar, aKey)) {
+            updateButtons();
+            return;
+        }
+        if (value.textboxKeyTyped(aChar, aKey)) return;
+        super.keyTyped(aChar, aKey);
+    }
+
+    private void updateButtons() {
+        // this will be called from setText of key and value. NEVER UPDATE THE VALUE OF THESE HERE OR GET A
+        // STACKOVERFLOW!
+        boolean existing = ChannelDataAccessor.hasSubChannel(trigger, key.getText());
+        getButtonList().get(0).displayString = existing
+                ? I18n.format("item.structurelib.constructableTrigger.gui.set")
+                : I18n.format("item.structurelib.constructableTrigger.gui.add");
+        getButtonList().get(0).enabled = !StringUtils.isBlank(value.getText());
+        getButtonList().get(1).enabled = existing && !StringUtils.isBlank(value.getText());
+    }
+
+    private int getValue() {
+        try {
+            return Integer.parseInt(value.getText());
+        } catch (NumberFormatException e) {
+            return -1;
+        }
+    }
+
+    @Override
+    protected void actionPerformed(GuiButton btn) {
+        if (btn == null) return;
+        switch (btn.id) {
+            case 0:
+                int value = getValue();
+                if (value <= 0) return;
+                ChannelDataAccessor.setChannelData(trigger, key.getText(), value);
+                break;
+            case 1:
+                ChannelDataAccessor.unsetChannelData(trigger, key.getText());
+                break;
+            case 2:
+                ChannelDataAccessor.wipeChannelData(trigger);
+                break;
+        }
+        super.actionPerformed(btn);
+    }
+
+    @Override
+    public void onGuiClosed() {
+        super.onGuiClosed();
+        Keyboard.enableRepeatEvents(false);
+        StructureLib.instance().proxy().uploadChannels(trigger);
+    }
+
+    @Override
+    public void updateScreen() {
+        super.updateScreen();
+        key.updateCursorCounter();
+        value.updateCursorCounter();
+    }
+
+    @Override
+    public boolean doesGuiPauseGame() {
+        return false;
+    }
+
+    @Override
+    public void drawScreen(int mX, int mY, float partialTick) {
+        mc.renderEngine.bindTexture(new ResourceLocation("structurelib", "textures/gui/channels.png"));
+        int topLeftX = (this.width - this.getXSize()) / 2;
+        int topLeftY = (this.height - this.getYSize()) / 2;
+        drawTexturedModalRect(topLeftX, topLeftY, 0, 0, getXSize(), getYSize());
+        super.drawScreen(mX, mY, partialTick);
+        list.drawScreen(mX, mY, partialTick);
+        fontRendererObj.drawString(
+                I18n.format("item.structurelib.constructableTrigger.gui.key"), guiLeft + 12, guiTop + 122, 0);
+        key.drawTextBox();
+        fontRendererObj.drawString(
+                I18n.format("item.structurelib.constructableTrigger.gui.value"), guiLeft + 12, guiTop + 142, 0);
+        value.drawTextBox();
+    }
+
+    private class GuiChannelsList extends GuiScrollableList<Entry<String, Integer>> {
+        private List<Entry<String, Integer>> cache;
+
+        public GuiChannelsList(int width, int height, int originX, int originY, int slotHeight) {
+            super(width, height, originX, originY, slotHeight);
+        }
+
+        @Override
+        public Entry<String, Integer> getElementAt(int index) {
+            return ChannelDataAccessor.iterateChannelData(trigger)
+                    .sorted()
+                    .skip(index)
+                    .findFirst()
+                    .orElse(null);
+        }
+
+        @Override
+        public int getNumElements() {
+            return ChannelDataAccessor.countChannelData(trigger);
+        }
+
+        @Override
+        protected boolean elementClicked(int elementIndex, boolean doubleClick, int mXRelative, int mYRelative) {
+            if (mXRelative >= margin + 1
+                    && mXRelative <= margin + 5
+                    && mYRelative >= margin / 2 + 1
+                    && mYRelative <= margin / 2 + 5) {
+                Entry<String, Integer> e = getElementAt(elementIndex);
+                if (e != null) {
+                    ChannelDataAccessor.unsetChannelData(trigger, e.getKey());
+                    return false;
+                }
+            }
+            return super.elementClicked(elementIndex, doubleClick, mXRelative, mYRelative);
+        }
+
+        @Override
+        protected void prepareDrawElements() {
+            cache = ChannelDataAccessor.iterateChannelData(trigger).sorted().collect(Collectors.toList());
+        }
+
+        @Override
+        protected void drawElement(
+                int elementIndex, int x, int y, int height, Tessellator tessellator, boolean isHovering) {
+            if (elementIndex < 0 || elementIndex >= cache.size()) {
+                return;
+            }
+            Entry<String, Integer> e = cache.get(elementIndex);
+            if (e == null) return;
+            if (elementIndex > 0) {
+                // args x1, x2, y1, color
+                drawHorizontalLine(minX + 1, maxX - 1, y - 2, 0xffaaaaaa);
+            }
+            int keyMaxWidth = KEY_MAX_WIDTH * 2;
+            if (isHovering) {
+                mc.renderEngine.bindTexture(new ResourceLocation("structurelib", "textures/gui/channels.png"));
+                GL11.glColor4f(1, 1, 1, 1);
+                drawTexturedModalRect(x + margin + 1, y + margin / 2 + 1, 251, 251, 5, 5);
+            }
+            fontRendererObj.drawString(trim(e.getKey(), keyMaxWidth - 9), x + margin + 8, y + margin / 2, 0xffffff);
+            int valueX = x + margin + keyMaxWidth + margin;
+            fontRendererObj.drawString(trim(e.getValue().toString(), maxX - valueX), valueX, y + margin / 2, 0xffffff);
+        }
+
+        @Override
+        public void drawScreen(int mX, int mY, float partialTick) {
+            super.drawScreen(mX, mY, partialTick);
+            // args x1, y1, y2, color
+            drawVerticalLine(minX + margin + margin / 2 + KEY_MAX_WIDTH * 2, minY + 1, maxY - 1, 0xffaaaaaa);
+        }
+
+        public String trim(String e, int keyMaxWidth) {
+            // TODO optimize this to not create a billion string, or maybe cache this
+            String s = fontRendererObj.trimStringToWidth(e, keyMaxWidth);
+            if (s.length() != e.length()) {
+                StringBuilder buffer =
+                        new StringBuilder(s).deleteCharAt(s.length() - 1).append("...");
+                while ((s = fontRendererObj.trimStringToWidth(buffer.toString(), keyMaxWidth)).length()
+                        != buffer.length())
+                    // drop last original char
+                    buffer.deleteCharAt(s.length() - 4);
+                do {
+                    buffer.append('.');
+                } while (fontRendererObj.getStringWidth(buffer.toString()) <= keyMaxWidth);
+                s = buffer.deleteCharAt(s.length() - 1)
+                        .insert(s.length() - 3, EnumChatFormatting.GRAY)
+                        .toString();
+            }
+            return s;
+        }
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/gui/GuiScrollableList.java

@@ -0,0 +1,443 @@
+package com.gtnewhorizon.structurelib.gui;
+
+import java.util.List;
+import java.util.concurrent.CopyOnWriteArrayList;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.client.renderer.Tessellator;
+import org.lwjgl.input.Mouse;
+import org.lwjgl.opengl.GL11;
+
+/**
+ * Shamelessly stolen from EnderCore, with some amount of edit to fit in one file. Original code from CrazyPants.
+ * <p>
+ * As the code has been released into public domain, it is now LGPL as part of this library as a whole.
+ * You can go to EnderCore's repository to obtain a public domain copy though
+ *
+ * Major edits
+ * <ul>
+ *     <li>Separate dwheel handling to handleDWheel. The next event calls often cause the mouse click event to
+ *     not fire on other widgets</li>
+ *     <li>scrollbar are now rendered within width</li>
+ *     <li>added prepareDrawElements</li>
+ * </ul>
+ *
+ * @author CrazyPants
+ * @author glee8e
+ */
+public abstract class GuiScrollableList<T> {
+    protected final int slotHeight;
+    private final Minecraft mc = Minecraft.getMinecraft();
+    protected int originX;
+    protected int originY;
+    protected int width;
+    protected int height;
+    protected int minY;
+    protected int maxY;
+    protected int minX;
+    protected int maxX;
+    protected int mouseX;
+    protected int mouseY;
+    protected int selectedIndex = -1;
+    protected int margin = 4;
+    protected List<ListSelectionListener<T>> listeners = new CopyOnWriteArrayList<>();
+    private int scrollUpButtonID;
+    private int scrollDownButtonID;
+    private float initialClickY = -2.0F;
+    private float scrollMultiplier;
+    private float amountScrolled;
+    private long lastClickedTime;
+
+    private boolean showSelectionBox = true;
+
+    public GuiScrollableList(int width, int height, int originX, int originY, int slotHeight) {
+        this.width = width;
+        this.height = height;
+        this.originX = originX;
+        this.originY = originY;
+        this.slotHeight = slotHeight;
+
+        minY = originY;
+        maxY = minY + height;
+        minX = originX;
+        maxX = minX + width;
+    }
+
+    public void onGuiInit(IGuiScreen gui) {
+        minY = originY + gui.getGuiTop();
+        maxY = minY + height;
+        minX = originX + gui.getGuiLeft();
+        maxX = minX + width;
+    }
+
+    public void addSelectionListener(ListSelectionListener<T> listener) {
+        listeners.add(listener);
+    }
+
+    public void removeSelectionListener(ListSelectionListener<T> listener) {
+        listeners.remove(listener);
+    }
+
+    public T getSelectedElement() {
+        return getElementAt(selectedIndex);
+    }
+
+    public void setSelection(T selection) {
+        setSelection(getIndexOf(selection));
+    }
+
+    public void setSelection(int index) {
+        if (index == selectedIndex) {
+            return;
+        }
+        selectedIndex = index;
+        for (ListSelectionListener<T> listener : listeners) {
+            listener.selectionChanged(this, selectedIndex);
+        }
+    }
+
+    public int getIndexOf(T element) {
+        if (element == null) {
+            return -1;
+        }
+        for (int i = 0; i < getNumElements(); i++) {
+            if (element.equals(getElementAt(i))) {
+                return i;
+            }
+        }
+        return -1;
+    }
+
+    public abstract T getElementAt(int index);
+
+    public abstract int getNumElements();
+
+    protected abstract void drawElement(
+            int elementIndex, int x, int y, int height, Tessellator tessellator, boolean isHovering);
+
+    protected boolean elementClicked(int elementIndex, boolean doubleClick, int mXRelative, int mYRelative) {
+        return true;
+    }
+
+    public void setShowSelectionBox(boolean val) {
+        showSelectionBox = val;
+    }
+
+    protected int getContentHeight() {
+        return getNumElements() * slotHeight;
+    }
+
+    public void setScrollButtonIds(int scrollUpButtonID, int scrollDownButtonID) {
+        this.scrollUpButtonID = scrollUpButtonID;
+        this.scrollDownButtonID = scrollDownButtonID;
+    }
+
+    private void clampScrollToBounds() {
+        int i = getContentOverhang();
+        if (i < 0) {
+            i *= -1;
+        }
+        if (amountScrolled < 0.0F) {
+            amountScrolled = 0.0F;
+        }
+        if (amountScrolled > i) {
+            amountScrolled = i;
+        }
+    }
+
+    public int getContentOverhang() {
+        return getContentHeight() - (height - margin);
+    }
+
+    public void actionPerformed(GuiButton b) {
+        if (b.enabled) {
+            if (b.id == scrollUpButtonID) {
+                amountScrolled -= slotHeight * 2 / 3;
+                initialClickY = -2.0F;
+                clampScrollToBounds();
+            } else if (b.id == scrollDownButtonID) {
+                amountScrolled += slotHeight * 2 / 3;
+                initialClickY = -2.0F;
+                clampScrollToBounds();
+            }
+        }
+    }
+
+    /**
+     * draws the slot to the screen, pass in mouse's current x and y and partial
+     * ticks
+     */
+    public void drawScreen(int mX, int mY, float partialTick) {
+        this.mouseX = mX;
+        this.mouseY = mY;
+
+        processMouseEvents();
+
+        if (getContentOverhang() > 0) maxX = minX + width - 6;
+        else maxX = minX + width;
+
+        clampScrollToBounds();
+
+        GL11.glDisable(GL11.GL_LIGHTING);
+        GL11.glDisable(GL11.GL_FOG);
+
+        ScaledResolution sr = new ScaledResolution(mc, mc.displayWidth, mc.displayHeight);
+        int sx = minX * sr.getScaleFactor();
+        int sw = width * sr.getScaleFactor();
+        int sy = mc.displayHeight - (maxY * sr.getScaleFactor());
+        int sh = height * sr.getScaleFactor();
+        GL11.glEnable(GL11.GL_SCISSOR_TEST);
+        GL11.glScissor(sx, sy, sw, sh);
+
+        Tessellator tessellator = Tessellator.instance;
+        drawContainerBackground(tessellator);
+
+        int amountScrolled = (int) this.amountScrolled;
+        int contentYOffset = this.minY + margin - amountScrolled;
+
+        boolean hoveringPrecondition = mX >= minX && mX <= maxX && mY >= minY && mY <= maxY;
+
+        prepareDrawElements();
+
+        for (int i = 0; i < getNumElements(); ++i) {
+
+            int elementY = contentYOffset + i * this.slotHeight;
+            int slotHeight = this.slotHeight - margin;
+
+            if (elementY <= maxY && elementY + slotHeight >= minY) {
+
+                if (showSelectionBox && i == selectedIndex) {
+                    GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+                    GL11.glDisable(GL11.GL_TEXTURE_2D);
+                    tessellator.startDrawingQuads();
+                    tessellator.setColorOpaque_I(8421504);
+                    tessellator.addVertexWithUV(minX, elementY + slotHeight + 2, 0.0D, 0.0D, 1.0D);
+                    tessellator.addVertexWithUV(maxX, elementY + slotHeight + 2, 0.0D, 1.0D, 1.0D);
+                    tessellator.addVertexWithUV(maxX, elementY - 2, 0.0D, 1.0D, 0.0D);
+                    tessellator.addVertexWithUV(minX, elementY - 2, 0.0D, 0.0D, 0.0D);
+                    tessellator.setColorOpaque_I(0);
+                    tessellator.addVertexWithUV(minX + 1, elementY + slotHeight + 1, 0.0D, 0.0D, 1.0D);
+                    tessellator.addVertexWithUV(maxX - 1, elementY + slotHeight + 1, 0.0D, 1.0D, 1.0D);
+                    tessellator.addVertexWithUV(maxX - 1, elementY - 1, 0.0D, 1.0D, 0.0D);
+                    tessellator.addVertexWithUV(minX + 1, elementY - 1, 0.0D, 0.0D, 0.0D);
+                    tessellator.draw();
+                    GL11.glEnable(GL11.GL_TEXTURE_2D);
+                }
+
+                boolean isHovering = hoveringPrecondition && elementY - 2 <= mY && mY < elementY + slotHeight + 2;
+                drawElement(i, minX, elementY, slotHeight, tessellator, isHovering);
+            }
+        }
+
+        GL11.glDisable(GL11.GL_SCISSOR_TEST);
+
+        GL11.glDisable(GL11.GL_DEPTH_TEST);
+        GL11.glEnable(GL11.GL_BLEND);
+        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        GL11.glDisable(GL11.GL_ALPHA_TEST);
+        GL11.glShadeModel(GL11.GL_SMOOTH);
+        GL11.glDisable(GL11.GL_TEXTURE_2D);
+
+        tessellator.startDrawingQuads();
+        tessellator.setColorRGBA_I(0, 0);
+        tessellator.addVertexWithUV(this.minX, this.minY + margin, 0.0D, 0.0D, 1.0D);
+        tessellator.addVertexWithUV(this.maxX, this.minY + margin, 0.0D, 1.0D, 1.0D);
+        tessellator.setColorRGBA_I(0, 255);
+        tessellator.addVertexWithUV(this.maxX, this.minY, 0.0D, 1.0D, 0.0D);
+        tessellator.addVertexWithUV(this.minX, this.minY, 0.0D, 0.0D, 0.0D);
+        tessellator.draw();
+        tessellator.startDrawingQuads();
+        tessellator.setColorRGBA_I(0, 255);
+        tessellator.addVertexWithUV(this.minX, this.maxY, 0.0D, 0.0D, 1.0D);
+        tessellator.addVertexWithUV(this.maxX, this.maxY, 0.0D, 1.0D, 1.0D);
+        tessellator.setColorRGBA_I(0, 0);
+        tessellator.addVertexWithUV(this.maxX, this.maxY - margin, 0.0D, 1.0D, 0.0D);
+        tessellator.addVertexWithUV(this.minX, this.maxY - margin, 0.0D, 0.0D, 0.0D);
+        tessellator.draw();
+
+        renderScrollBar(tessellator);
+
+        GL11.glEnable(GL11.GL_TEXTURE_2D);
+        GL11.glShadeModel(GL11.GL_FLAT);
+        GL11.glEnable(GL11.GL_ALPHA_TEST);
+        GL11.glDisable(GL11.GL_BLEND);
+    }
+
+    protected void prepareDrawElements() {}
+
+    protected void renderScrollBar(Tessellator tessellator) {
+
+        int contentHeightOverBounds = getContentOverhang();
+        if (contentHeightOverBounds > 0) {
+
+            int clear = (maxY - minY) * (maxY - minY) / getContentHeight();
+
+            if (clear < 32) {
+                clear = 32;
+            }
+
+            if (clear > maxY - minY - 8) {
+                clear = maxY - minY - 8;
+            }
+
+            int y = (int) this.amountScrolled * (maxY - minY - clear) / contentHeightOverBounds + minY;
+            if (y < minY) {
+                y = minY;
+            }
+
+            GL11.glDisable(GL11.GL_TEXTURE_2D);
+            int scrollBarMinX = getScrollBarX();
+            int scrollBarMaxX = scrollBarMinX + 6;
+            tessellator.startDrawingQuads();
+
+            tessellator.setColorRGBA_I(0, 255);
+            tessellator.addVertexWithUV(scrollBarMinX, maxY, 0.0D, 0.0D, 1.0D);
+            tessellator.addVertexWithUV(scrollBarMaxX, maxY, 0.0D, 1.0D, 1.0D);
+            tessellator.addVertexWithUV(scrollBarMaxX, minY, 0.0D, 1.0D, 0.0D);
+            tessellator.addVertexWithUV(scrollBarMinX, minY, 0.0D, 0.0D, 0.0D);
+
+            tessellator.setColorRGBA_F(0.3f, 0.3f, 0.3f, 1);
+            tessellator.addVertexWithUV(scrollBarMinX, (y + clear), 0.0D, 0.0D, 1.0D);
+            tessellator.addVertexWithUV(scrollBarMaxX, (y + clear), 0.0D, 1.0D, 1.0D);
+            tessellator.addVertexWithUV(scrollBarMaxX, y, 0.0D, 1.0D, 0.0D);
+            tessellator.addVertexWithUV(scrollBarMinX, y, 0.0D, 0.0D, 0.0D);
+
+            tessellator.setColorRGBA_F(0.7f, 0.7f, 0.7f, 1);
+            tessellator.addVertexWithUV(scrollBarMinX, (y + clear - 1), 0.0D, 0.0D, 1.0D);
+            tessellator.addVertexWithUV((scrollBarMaxX - 1), (y + clear - 1), 0.0D, 1.0D, 1.0D);
+            tessellator.addVertexWithUV((scrollBarMaxX - 1), y, 0.0D, 1.0D, 0.0D);
+            tessellator.addVertexWithUV(scrollBarMinX, y, 0.0D, 0.0D, 0.0D);
+
+            tessellator.draw();
+            GL11.glEnable(GL11.GL_TEXTURE_2D);
+        }
+    }
+
+    private void processMouseEvents() {
+        if (Mouse.isButtonDown(0)) {
+            processMouseBown();
+        } else {
+            initialClickY = -1.0F;
+        }
+    }
+
+    public void handleDWheel(int mouseWheelDelta) {
+        if (!Mouse.isButtonDown(0)) {
+            if (mouseWheelDelta > 0) {
+                amountScrolled -= slotHeight / 2;
+            } else /* if (mouseWheelDelta < 0) */ {
+                amountScrolled += slotHeight / 2;
+            }
+        }
+    }
+
+    private void processMouseBown() {
+        int contentHeightOverBounds;
+        if (initialClickY == -1.0F) {
+
+            if (mouseY >= minY && mouseY <= maxY && mouseX >= minX && mouseX <= maxX + 6) {
+
+                boolean clickInBounds = true;
+
+                int y = mouseY - minY + (int) amountScrolled - margin;
+                int mouseOverElement = y / slotHeight;
+
+                if (mouseX >= minX
+                        && mouseX <= maxX
+                        && mouseOverElement >= 0
+                        && y >= 0
+                        && mouseOverElement < getNumElements()) {
+                    boolean doubleClick =
+                            mouseOverElement == selectedIndex && Minecraft.getSystemTime() - lastClickedTime < 250L;
+                    if (elementClicked(
+                            mouseOverElement, doubleClick, mouseX - minX, y - slotHeight * mouseOverElement)) {
+                        setSelection(mouseOverElement);
+                        lastClickedTime = Minecraft.getSystemTime();
+                    }
+                } else if (mouseX >= minX && mouseX <= maxX && y < 0) {
+                    clickInBounds = false;
+                }
+
+                int scrollBarMinX = getScrollBarX();
+                int scrollBarMaxX = scrollBarMinX + 6;
+                if (mouseX >= scrollBarMinX && mouseX <= scrollBarMaxX) {
+
+                    scrollMultiplier = -1.0F;
+                    contentHeightOverBounds = getContentOverhang();
+
+                    if (contentHeightOverBounds < 1) {
+                        contentHeightOverBounds = 1;
+                    }
+
+                    int empty = (int) ((float) ((maxY - minY) * (maxY - minY)) / (float) getContentHeight());
+                    if (empty < 32) {
+                        empty = 32;
+                    }
+                    if (empty > maxY - minY - 8) {
+                        empty = maxY - minY - 8;
+                    }
+                    scrollMultiplier /= (float) (maxY - minY - empty) / (float) contentHeightOverBounds;
+
+                } else {
+                    scrollMultiplier = 1.0F;
+                }
+
+                if (clickInBounds) {
+                    initialClickY = mouseY;
+                } else {
+                    initialClickY = -2.0F;
+                }
+
+            } else {
+                initialClickY = -2.0F;
+            }
+
+        } else if (initialClickY >= 0.0F) {
+            // Scrolling
+            amountScrolled -= (mouseY - initialClickY) * scrollMultiplier;
+            initialClickY = mouseY;
+        }
+    }
+
+    protected int getScrollBarX() {
+        return maxX;
+    }
+
+    protected void drawContainerBackground(Tessellator tess) {
+        GL11.glColor4f(1.0F, 1.0F, 1.0F, 1.0F);
+        GL11.glDisable(GL11.GL_TEXTURE_2D);
+        tess.startDrawingQuads();
+        tess.setColorOpaque_I(2105376);
+        tess.addVertex(minX, maxY, 0.0D);
+        tess.addVertex(maxX, maxY, 0.0D);
+        tess.addVertex(maxX, minY, 0.0D);
+        tess.addVertex(minX, minY, 0.0D);
+        tess.draw();
+        GL11.glEnable(GL11.GL_TEXTURE_2D);
+    }
+
+    public interface IGuiScreen {
+
+        int getGuiLeft();
+
+        int getGuiTop();
+
+        int getXSize();
+
+        int getYSize();
+
+        void addButton(GuiButton button);
+
+        void removeButton(GuiButton button);
+
+        int getOverlayOffsetX();
+
+        void doActionPerformed(GuiButton but);
+    }
+
+    public interface ListSelectionListener<T> {
+
+        void selectionChanged(GuiScrollableList<T> list, int selectedIndex);
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/item/ItemConstructableTrigger.java

@@ -3,16 +3,17 @@ package com.gtnewhorizon.structurelib.item;
 import static com.gtnewhorizon.structurelib.StructureLibAPI.MOD_ID;
 import static net.minecraft.util.EnumChatFormatting.BLUE;
 import static net.minecraft.util.StatCollector.translateToLocal;
+import static net.minecraft.util.StatCollector.translateToLocalFormatted;
 
 import com.gtnewhorizon.structurelib.StructureLib;
+import com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor;
 import com.gtnewhorizon.structurelib.alignment.constructable.ConstructableUtility;
 import java.util.List;
-import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.world.World;
+import org.lwjgl.input.Keyboard;
 
 public class ItemConstructableTrigger extends Item {
     public ItemConstructableTrigger() {
@@ -21,6 +22,13 @@ public class ItemConstructableTrigger extends Item {
         setCreativeTab(StructureLib.creativeTab);
     }
 
+    @Override
+    public ItemStack onItemRightClick(ItemStack stack, World world, EntityPlayer player) {
+        if (world.isRemote && getMovingObjectPositionFromPlayer(world, player, true) == null)
+            player.openGui(StructureLib.instance(), 0, world, player.inventory.currentItem, 0, 0);
+        return super.onItemRightClick(stack, world, player);
+    }
+
     @Override
     public boolean onItemUseFirst(
             ItemStack stack,
@@ -39,34 +47,30 @@ public class ItemConstructableTrigger extends Item {
     @SuppressWarnings("unchecked")
     @Override
     public void addInformation(ItemStack aStack, EntityPlayer ep, List aList, boolean boo) {
-        aList.add(
-                translateToLocal("item.structurelib.constructableTrigger.desc.0")); // Triggers Constructable Interface
-        aList.add(BLUE
-                + translateToLocal(
-                        "item.structurelib.constructableTrigger.desc.1")); // Shows multiblock construction details,
-        aList.add(BLUE
-                + translateToLocal(
-                        "item.structurelib.constructableTrigger.desc.2")); // just Use on a multiblock controller.
-        aList.add(BLUE
-                + translateToLocal(
-                        "item.structurelib.constructableTrigger.desc.3")); // (Sneak Use in creative to build)
-        aList.add(BLUE
-                + translateToLocal("item.structurelib.constructableTrigger.desc.4")); // Quantity affects tier/mode/type
-    }
-
-    @Override
-    public void onUpdate(
-            ItemStack p_77663_1_, World p_77663_2_, Entity p_77663_3_, int p_77663_4_, boolean p_77663_5_) {
-        // remove LastUse tags if it times out,
-        // so it can stack with other trigger item stacks
-        // don't remove it too soon though, to prevent chat spam
-        // this might be perceived as a hack, but ok this is simple enough to implement
-        if (p_77663_1_.hasTagCompound()
-                && p_77663_1_.getTagCompound().getLong("LastUse") + ConstructableUtility.COOLDOWN * 2
-                        < StructureLib.getOverworldTime()) {
-            NBTTagCompound tag = p_77663_1_.getTagCompound();
-            tag.removeTag("LastUse");
-            if (tag.hasNoTags()) p_77663_1_.setTagCompound(null);
+        if (Keyboard.isKeyDown(Keyboard.KEY_LSHIFT)) {
+            aList.add(translateToLocalFormatted(
+                    "item.structurelib.constructableTrigger.desc.lshift.0",
+                    ChannelDataAccessor.countChannelData(aStack)));
+            ChannelDataAccessor.iterateChannelData(aStack)
+                    .map(e -> e.getKey() + ": " + e.getValue())
+                    .forEach(aList::add);
+        } else {
+            aList.add(translateToLocal(
+                    "item.structurelib.constructableTrigger.desc.0")); // Triggers Constructable Interface
+            aList.add(BLUE
+                    + translateToLocal(
+                            "item.structurelib.constructableTrigger.desc.1")); // Shows multiblock construction details,
+            aList.add(BLUE
+                    + translateToLocal(
+                            "item.structurelib.constructableTrigger.desc.2")); // just Use on a multiblock controller.
+            aList.add(BLUE
+                    + translateToLocal(
+                            "item.structurelib.constructableTrigger.desc.3")); // (Sneak Use in creative to build)
+            aList.add(BLUE
+                    + translateToLocal(
+                            "item.structurelib.constructableTrigger.desc.4")); // Quantity affects tier/mode/type
+            if (ChannelDataAccessor.hasSubChannel(aStack))
+                aList.add(translateToLocal("item.structurelib.constructableTrigger.desc.5"));
         }
     }
 }

src/main/java/com/gtnewhorizon/structurelib/net/SetChannelDataMessage.java

@@ -0,0 +1,67 @@
+package com.gtnewhorizon.structurelib.net;
+
+import com.gtnewhorizon.structurelib.StructureLib;
+import com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor;
+import com.gtnewhorizon.structurelib.item.ItemConstructableTrigger;
+import cpw.mods.fml.common.network.ByteBufUtils;
+import cpw.mods.fml.common.network.simpleimpl.IMessage;
+import cpw.mods.fml.common.network.simpleimpl.IMessageHandler;
+import cpw.mods.fml.common.network.simpleimpl.MessageContext;
+import io.netty.buffer.ByteBuf;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import org.apache.commons.lang3.tuple.Pair;
+
+public class SetChannelDataMessage implements IMessage {
+    private List<Map.Entry<String, Integer>> data = new ArrayList<>();
+
+    public SetChannelDataMessage() {}
+
+    public SetChannelDataMessage(ItemStack trigger) {
+        ChannelDataAccessor.iterateChannelData(trigger).forEach(data::add);
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        data.clear();
+        int size = ByteBufUtils.readVarShort(buf);
+        for (int i = 0; i < size; i++) {
+            data.add(Pair.of(ByteBufUtils.readUTF8String(buf), ByteBufUtils.readVarInt(buf, 4)));
+        }
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        ByteBufUtils.writeVarShort(buf, data.size());
+        for (Entry<String, Integer> e : data) {
+            ByteBufUtils.writeUTF8String(buf, e.getKey());
+            ByteBufUtils.writeVarInt(buf, e.getValue(), 4);
+        }
+    }
+
+    public static class Handler implements IMessageHandler<SetChannelDataMessage, IMessage> {
+        @Override
+        public IMessage onMessage(SetChannelDataMessage message, MessageContext ctx) {
+            EntityPlayerMP player = ctx.getServerHandler().playerEntity;
+            ItemStack heldItem = player.getHeldItem();
+            if (heldItem != null && heldItem.getItem() instanceof ItemConstructableTrigger) {
+                ChannelDataAccessor.wipeChannelData(heldItem);
+                for (Entry<String, Integer> e : message.data) {
+                    ChannelDataAccessor.setChannelData(heldItem, e.getKey(), e.getValue());
+                }
+                // since this is a set all channel request from the client, we would assume client already know
+                // what this would look like on the client, so no sync
+            } else {
+                StructureLib.LOGGER.warn(
+                        "{} trying to set channel data on {}, which is not a hologram projector!",
+                        player.getUniqueID(),
+                        heldItem);
+            }
+            return null;
+        }
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/structure/IStructureDefinition.java

@@ -1,10 +1,11 @@
 package com.gtnewhorizon.structurelib.structure;
 
 import static com.gtnewhorizon.structurelib.StructureLib.DEBUG_MODE;
+import static com.gtnewhorizon.structurelib.structure.IStructureWalker.ignoreBlockUnloaded;
+import static com.gtnewhorizon.structurelib.structure.IStructureWalker.skipBlockUnloaded;
 
 import com.gtnewhorizon.structurelib.StructureLib;
 import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing;
-import java.util.Arrays;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.world.World;
@@ -196,135 +197,73 @@ public interface IStructureDefinition<T> {
             return false;
         }
 
-        // change base position to base offset
-        basePositionA = -basePositionA;
-        basePositionB = -basePositionB;
-        basePositionC = -basePositionC;
-
-        int[] abc = new int[] {basePositionA, basePositionB, basePositionC};
-        int[] xyz = new int[3];
-
         if (checkBlocksIfNotNullForceCheckAllIfTrue != null) {
+            boolean success;
             if (checkBlocksIfNotNullForceCheckAllIfTrue) {
-                for (IStructureElement<T> element : elements) {
-                    if (element.isNavigating()) {
-                        abc[0] = (element.resetA() ? basePositionA : abc[0]) + element.getStepA();
-                        abc[1] = (element.resetB() ? basePositionB : abc[1]) + element.getStepB();
-                        abc[2] = (element.resetC() ? basePositionC : abc[2]) + element.getStepC();
-                    } else {
-                        extendedFacing.getWorldOffset(abc, xyz);
-                        xyz[0] += basePositionX;
-                        xyz[1] += basePositionY;
-                        xyz[2] += basePositionZ;
-
-                        StructureLib.LOGGER.info(
-                                "Multi [{}, {}, {}] step @ {} {}",
-                                basePositionX,
-                                basePositionY,
-                                basePositionZ,
-                                Arrays.toString(xyz),
-                                Arrays.toString(abc));
-
-                        if (world.blockExists(xyz[0], xyz[1], xyz[2])) {
-                            if (!element.check(object, world, xyz[0], xyz[1], xyz[2])) {
-                                if (DEBUG_MODE) {
-                                    StructureLib.LOGGER.info("Multi [" + basePositionX + ", " + basePositionY + ", "
-                                            + basePositionZ + "] failed @ " + Arrays.toString(xyz) + " "
-                                            + Arrays.toString(abc));
-                                }
-                                return false;
-                            }
-                        } else {
-                            if (DEBUG_MODE) {
-                                StructureLib.LOGGER.info("Multi [" + basePositionX + ", " + basePositionY + ", "
-                                        + basePositionZ + "] !blockExists @ " + Arrays.toString(xyz) + " "
-                                        + Arrays.toString(abc));
-                            }
-                            return false;
-                        }
-                        abc[0] += 1;
-                    }
-                }
+                success = StructureUtility.iterateV2(
+                        elements,
+                        world,
+                        extendedFacing,
+                        basePositionX,
+                        basePositionY,
+                        basePositionZ,
+                        basePositionA,
+                        basePositionB,
+                        basePositionC,
+                        (e, w, x, y, z) -> e.check(object, w, x, y, z),
+                        "check");
             } else {
-                for (IStructureElement<T> element : elements) {
-                    if (element.isNavigating()) {
-                        abc[0] = (element.resetA() ? basePositionA : abc[0]) + element.getStepA();
-                        abc[1] = (element.resetB() ? basePositionB : abc[1]) + element.getStepB();
-                        abc[2] = (element.resetC() ? basePositionC : abc[2]) + element.getStepC();
-                    } else {
-                        extendedFacing.getWorldOffset(abc, xyz);
-                        xyz[0] += basePositionX;
-                        xyz[1] += basePositionY;
-                        xyz[2] += basePositionZ;
-
-                        StructureLib.LOGGER.info(
-                                "Multi [{}, {}, {}] step @ {} {}",
-                                basePositionX,
-                                basePositionY,
-                                basePositionZ,
-                                Arrays.toString(xyz),
-                                Arrays.toString(abc));
-
-                        if (world.blockExists(xyz[0], xyz[1], xyz[2])) {
-                            if (!element.check(object, world, xyz[0], xyz[1], xyz[2])) {
-                                if (DEBUG_MODE) {
-                                    StructureLib.LOGGER.info("Multi [" + basePositionX + ", " + basePositionY + ", "
-                                            + basePositionZ + "] failed @ " + Arrays.toString(xyz) + " "
-                                            + Arrays.toString(abc));
-                                }
-                                return false;
-                            }
-                        } else {
-                            if (DEBUG_MODE) {
-                                StructureLib.LOGGER.info("Multi [" + basePositionX + ", " + basePositionY + ", "
-                                        + basePositionZ + "] !blockExists @ " + Arrays.toString(xyz) + " "
-                                        + Arrays.toString(abc));
-                            }
-                        }
-                        abc[0] += 1;
-                    }
-                }
+                success = StructureUtility.iterateV2(
+                        elements,
+                        world,
+                        extendedFacing,
+                        basePositionX,
+                        basePositionY,
+                        basePositionZ,
+                        basePositionA,
+                        basePositionB,
+                        basePositionC,
+                        skipBlockUnloaded((e, w, x, y, z) -> e.check(object, w, x, y, z)),
+                        "check force");
             }
-            if (DEBUG_MODE) {
+            if (DEBUG_MODE && success) {
                 StructureLib.LOGGER.info(
                         "Multi [" + basePositionX + ", " + basePositionY + ", " + basePositionZ + "] pass");
             }
+            return success;
         } else {
             if (hintsOnly) {
-                for (IStructureElement<T> element : elements) {
-                    if (element.isNavigating()) {
-                        abc[0] = (element.resetA() ? basePositionA : abc[0]) + element.getStepA();
-                        abc[1] = (element.resetB() ? basePositionB : abc[1]) + element.getStepB();
-                        abc[2] = (element.resetC() ? basePositionC : abc[2]) + element.getStepC();
-                    } else {
-                        extendedFacing.getWorldOffset(abc, xyz);
-                        xyz[0] += basePositionX;
-                        xyz[1] += basePositionY;
-                        xyz[2] += basePositionZ;
-
-                        element.spawnHint(object, world, xyz[0], xyz[1], xyz[2], trigger);
-
-                        abc[0] += 1;
-                    }
-                }
+                StructureUtility.iterateV2(
+                        elements,
+                        world,
+                        extendedFacing,
+                        basePositionX,
+                        basePositionY,
+                        basePositionZ,
+                        basePositionA,
+                        basePositionB,
+                        basePositionC,
+                        ignoreBlockUnloaded((e, w, x, y, z) -> {
+                            e.spawnHint(object, world, x, y, z, trigger);
+                            return true;
+                        }),
+                        "spawnHint");
             } else {
-                for (IStructureElement<T> element : elements) {
-                    if (element.isNavigating()) {
-                        abc[0] = (element.resetA() ? basePositionA : abc[0]) + element.getStepA();
-                        abc[1] = (element.resetB() ? basePositionB : abc[1]) + element.getStepB();
-                        abc[2] = (element.resetC() ? basePositionC : abc[2]) + element.getStepC();
-                    } else {
-                        extendedFacing.getWorldOffset(abc, xyz);
-                        xyz[0] += basePositionX;
-                        xyz[1] += basePositionY;
-                        xyz[2] += basePositionZ;
-
-                        if (world.blockExists(xyz[0], xyz[1], xyz[2])) {
-                            element.placeBlock(object, world, xyz[0], xyz[1], xyz[2], trigger);
-                        }
-                        abc[0] += 1;
-                    }
-                }
+                StructureUtility.iterateV2(
+                        elements,
+                        world,
+                        extendedFacing,
+                        basePositionX,
+                        basePositionY,
+                        basePositionZ,
+                        basePositionA,
+                        basePositionB,
+                        basePositionC,
+                        ignoreBlockUnloaded((e, w, x, y, z) -> {
+                            e.placeBlock(object, world, x, y, z, trigger);
+                            return true;
+                        }),
+                        "placeBlock");
             }
         }
         return true;

src/main/java/com/gtnewhorizon/structurelib/structure/IStructureWalker.java

@@ -4,4 +4,36 @@ import net.minecraft.world.World;
 
 public interface IStructureWalker<T> {
     boolean visit(IStructureElement<T> element, World world, int x, int y, int z);
+
+    default boolean blockNotLoaded(IStructureElement<T> element, World world, int x, int y, int z) {
+        return false;
+    }
+
+    static <T> IStructureWalker<T> ignoreBlockUnloaded(IStructureWalker<T> walker) {
+        return new IStructureWalker<T>() {
+            @Override
+            public boolean visit(IStructureElement<T> element, World world, int x, int y, int z) {
+                return walker.visit(element, world, x, y, z);
+            }
+
+            @Override
+            public boolean blockNotLoaded(IStructureElement<T> element, World world, int x, int y, int z) {
+                return walker.visit(element, world, x, y, z);
+            }
+        };
+    }
+
+    static <T> IStructureWalker<T> skipBlockUnloaded(IStructureWalker<T> walker) {
+        return new IStructureWalker<T>() {
+            @Override
+            public boolean visit(IStructureElement<T> element, World world, int x, int y, int z) {
+                return walker.visit(element, world, x, y, z);
+            }
+
+            @Override
+            public boolean blockNotLoaded(IStructureElement<T> element, World world, int x, int y, int z) {
+                return true;
+            }
+        };
+    }
 }

src/main/java/com/gtnewhorizon/structurelib/structure/StructureUtility.java

@@ -5,6 +5,7 @@ import static java.lang.Integer.MIN_VALUE;
 
 import com.gtnewhorizon.structurelib.StructureLib;
 import com.gtnewhorizon.structurelib.StructureLibAPI;
+import com.gtnewhorizon.structurelib.alignment.constructable.ChannelDataAccessor;
 import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing;
 import com.gtnewhorizon.structurelib.structure.IStructureElement.PlaceResult;
 import com.gtnewhorizon.structurelib.structure.adders.IBlockAdder;
@@ -16,6 +17,7 @@ import java.util.*;
 import java.util.function.*;
 import javax.annotation.Nullable;
 import net.minecraft.block.Block;
+import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.init.Blocks;
 import net.minecraft.item.Item;
@@ -427,9 +429,16 @@ public class StructureUtility {
                     IItemSource s,
                     EntityPlayerMP actor,
                     Consumer<IChatComponent> chatter) {
-                if (check(t, world, x, y, z)) return PlaceResult.SKIP;
                 Pair<Block, Integer> hint = getHint(trigger);
                 if (hint == null) return PlaceResult.REJECT; // TODO or SKIP?
+                Block block = world.getBlock(x, y, z);
+                int meta = world.getBlockMetadata(x, y, z);
+                TIER tier = tierExtractor.convert(block, meta);
+                if (!Objects.equals(tier, notSet)) {
+                    return Objects.equals(tier, tierExtractor.convert(hint.getKey(), hint.getValue()))
+                            ? PlaceResult.SKIP
+                            : PlaceResult.REJECT;
+                }
                 return StructureUtility.survivalPlaceBlock(
                         hint.getKey(), hint.getValue(), world, x, y, z, s, actor, chatter);
             }
@@ -1888,6 +1897,57 @@ public class StructureUtility {
 
     // endregion
 
+    // region channels
+
+    /**
+     * See channels.md in docs folder
+     */
+    public static <T> IStructureElement<T> withChannel(String channel, IStructureElement<T> backing) {
+        return new IStructureElement<T>() {
+            public boolean check(T t, World world, int x, int y, int z) {
+                return backing.check(t, world, x, y, z);
+            }
+
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                ItemStack newTrigger = ChannelDataAccessor.withChannel(trigger, channel);
+                // We know spawnHint will only be called on client side, so the lack of player isn't quite an issue
+                // we check if it's null again just in case.
+                if (newTrigger == trigger && StructureLib.getCurrentPlayer() != null)
+                    warnNoExplicitSubChannel(StructureLib.getCurrentPlayer());
+                return backing.spawnHint(t, world, x, y, z, newTrigger);
+            }
+
+            private void warnNoExplicitSubChannel(EntityPlayer currentPlayer) {
+                currentPlayer.addChatComponentMessage(
+                        new ChatComponentTranslation("structurelib.autoplace.warning.no_explicit_channel", channel));
+            }
+
+            public boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
+                // I hope a CREATIVE player know what he is doing...
+                return backing.placeBlock(t, world, x, y, z, ChannelDataAccessor.withChannel(trigger, channel));
+            }
+
+            public PlaceResult survivalPlaceBlock(
+                    T t,
+                    World world,
+                    int x,
+                    int y,
+                    int z,
+                    ItemStack trigger,
+                    IItemSource s,
+                    EntityPlayerMP actor,
+                    Consumer<IChatComponent> chatter) {
+                ItemStack newTrigger = ChannelDataAccessor.withChannel(trigger, channel);
+                if (newTrigger == trigger)
+                    // we will bypass the chatter filter here, as this is a warning that player definitively want to see
+                    // instead of some false positive error messages like item not find
+                    warnNoExplicitSubChannel(actor);
+                return backing.survivalPlaceBlock(t, world, x, y, z, newTrigger, s, actor, chatter);
+            }
+        };
+    }
+    // endregion
+
     /**
      * Used internally, to generate skips for structure definitions
      */
@@ -2244,7 +2304,7 @@ public class StructureUtility {
                                 Arrays.toString(xyz),
                                 Arrays.toString(abc));
                     }
-                    return false;
+                    if (!predicate.blockNotLoaded(element, world, xyz[0], xyz[1], xyz[2])) return false;
                 }
                 abc[0] += 1;
             }

src/main/java/com/gtnewhorizon/structurelib/structure/SurvivalBuildStructureWalker.java

@@ -1,7 +1,6 @@
 package com.gtnewhorizon.structurelib.structure;
 
 import com.gtnewhorizon.structurelib.StructureLibAPI;
-import com.gtnewhorizon.structurelib.alignment.constructable.ConstructableUtility;
 import com.gtnewhorizon.structurelib.structure.IStructureElement.PlaceResult;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
@@ -38,8 +37,7 @@ class SurvivalBuildStructureWalker<T> implements IStructureWalker<T> {
                 if (check) element.check(object, world, x, y, z);
                 return ++built < elementBudget;
             case REJECT:
-                if (ConstructableUtility.redBrokenOne)
-                    StructureLibAPI.updateHintParticleTint(actor, world, x, y, z, new short[] {255, 128, 128, 0});
+                StructureLibAPI.updateHintParticleTint(actor, world, x, y, z, new short[] {255, 128, 128, 0});
                 return false;
             case ACCEPT_STOP:
                 if (check) element.check(object, world, x, y, z);

src/main/java/com/gtnewhorizon/structurelib/util/InventoryUtility.java

@@ -18,6 +18,7 @@
  */
 package com.gtnewhorizon.structurelib.util;
 
+import com.gtnewhorizon.gtnhlib.util.map.ItemStackMap;
 import com.gtnewhorizon.structurelib.util.InventoryUtility.ItemStackExtractor.APIType;
 import com.gtnewhorizon.structurelib.util.ItemStackPredicate.NBTMode;
 import java.util.*;
@@ -375,7 +376,7 @@ public class InventoryUtility {
     }
 
     private static class ItemStackCounterImpl implements ItemStackCounter {
-        private final Map<ItemStack, Integer> store = new ItemStackMap<>();
+        private final Map<ItemStack, Integer> store = new ItemStackMap<>(true);
 
         @Override
         public void add(ItemStack stack, int stackSize) {

src/main/java/com/gtnewhorizon/structurelib/util/ItemStackMap.java

@@ -1,464 +0,0 @@
-/*
- * Copyright (c) 2021, glee8e, Code Chicken.
- *
- * This file is originally part of NotEnoughtItem by Code Chicken.
- * It is adapted to implement the standard Map interface by glease
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU Lesser General Public License as published by
- * the Free Software Foundation, either version 2.1 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU Lesser General Public License for more details.
- *
- * You should have received a copy of the GNU Lesser General Public License
- * along with this program. If not, see <http://www.gnu.org/licenses/>.
- */
-package com.gtnewhorizon.structurelib.util;
-
-import static net.minecraftforge.oredict.OreDictionary.WILDCARD_VALUE;
-
-import com.google.common.base.Objects;
-import com.google.common.collect.Iterators;
-import java.util.AbstractMap;
-import java.util.AbstractSet;
-import java.util.HashMap;
-import java.util.Iterator;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-import net.minecraft.init.Items;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-
-/**
- * A map class for ItemStack keys with wildcard damage/NBT. Optimised for lookup.
- * <p>
- * This map does NOT support null values or null keys! null will be silently ignored!
- * <p>
- * Originally created by CodeChicken for NotEnoughItems. Adapted to {@code Map<ItemStack, T>} interface by glee8e
- * @author CodeChiken
- * @author glee8e
- */
-public final class ItemStackMap<T> extends AbstractMap<ItemStack, T> {
-    public static final NBTTagCompound WILDCARD_TAG;
-
-    static {
-        WILDCARD_TAG = new NBTTagCompound();
-        WILDCARD_TAG.setBoolean("*", true);
-    }
-
-    private final HashMap<Item, DetailMap> itemMap = new HashMap<>();
-    private int size;
-
-    static ItemStack newItemStack(Item item, int size, int damage, NBTTagCompound tag) {
-        ItemStack stack = new ItemStack(item, size, damage);
-        stack.stackTagCompound = tag;
-        return stack;
-    }
-
-    static int actualDamage(ItemStack stack) {
-        return Items.diamond.getDamage(stack);
-    }
-
-    static int getKeyType(int damage, NBTTagCompound tag) {
-        int i = 0;
-        if (isWildcard(damage)) i = 1;
-        if (isWildcard(tag)) i |= 2;
-        return i;
-    }
-
-    static ItemStack wildcard(Item item) {
-        return newItemStack(item, 1, WILDCARD_VALUE, WILDCARD_TAG);
-    }
-
-    static boolean isWildcard(int damage) {
-        return damage == WILDCARD_VALUE;
-    }
-
-    static boolean isWildcard(NBTTagCompound tag) {
-        return tag != null && tag.getBoolean("*");
-    }
-
-    @Override
-    public T get(Object key) {
-        if (!(key instanceof ItemStack)) return null;
-        ItemStack stack = ((ItemStack) key);
-        if (stack.getItem() == null) return null;
-        DetailMap map = itemMap.get(stack.getItem());
-        return map == null ? null : map.get(stack);
-    }
-
-    @Override
-    public T put(ItemStack key, T value) {
-        if (key == null || key.getItem() == null || value == null) return null;
-        return itemMap.computeIfAbsent(key.getItem(), k -> new DetailMap()).put(key, value);
-    }
-
-    @Override
-    public T remove(Object key) {
-        if (!(key instanceof ItemStack)) return null;
-        ItemStack stack = ((ItemStack) key);
-        if (stack.getItem() == null) return null;
-        DetailMap map = itemMap.get(stack.getItem());
-        return map == null ? null : map.remove(stack);
-    }
-
-    @Override
-    public boolean containsKey(Object key) {
-        if (!(key instanceof ItemStack)) return false;
-        ItemStack stack = ((ItemStack) key);
-        if (stack.getItem() == null) return false;
-        DetailMap map = itemMap.get(stack.getItem());
-        return map != null && map.get(stack) != null;
-    }
-
-    @Override
-    public void clear() {
-        itemMap.clear();
-        size = 0;
-    }
-
-    @Override
-    public Set<Map.Entry<ItemStack, T>> entrySet() {
-        return new SetView();
-    }
-
-    private static class StackMetaKey {
-        public final int damage;
-        public final NBTTagCompound tag;
-
-        public StackMetaKey(int damage, NBTTagCompound tag) {
-            this.damage = damage;
-            this.tag = tag;
-        }
-
-        public StackMetaKey(ItemStack key) {
-            this(actualDamage(key), key.stackTagCompound);
-        }
-
-        public int hashCode() {
-            return Objects.hashCode(damage, tag);
-        }
-
-        public boolean equals(Object o) {
-            if (!(o instanceof StackMetaKey)) return false;
-            StackMetaKey t = (StackMetaKey) o;
-            return damage == t.damage && Objects.equal(tag, t.tag);
-        }
-    }
-
-    private static class DetailIter<T> implements Iterator<Map.Entry<ItemStack, T>> {
-        private final Item owner;
-        private final ItemStackMap<T>.DetailMap backing;
-
-        @Nullable
-        private final Iterator<Map.Entry<Integer, T>> damageIter;
-
-        @Nullable
-        private final Iterator<Map.Entry<NBTTagCompound, T>> tagIter;
-
-        @Nullable
-        private final Iterator<Map.Entry<StackMetaKey, T>> metaIter;
-
-        private DetailIterState state = DetailIterState.NOT_STARTED;
-        private boolean removed = false;
-
-        private DetailIter(Map.Entry<Item, ItemStackMap<T>.DetailMap> input) {
-            this.owner = input.getKey();
-            this.backing = input.getValue();
-            damageIter =
-                    backing.damageMap != null ? backing.damageMap.entrySet().iterator() : null;
-            tagIter = backing.tagMap != null ? backing.tagMap.entrySet().iterator() : null;
-            metaIter = backing.metaMap != null ? backing.metaMap.entrySet().iterator() : null;
-        }
-
-        private DetailIterState nextState() {
-            switch (state) {
-                case NOT_STARTED:
-                    if (backing.hasWildcard) return DetailIterState.WILDCARD;
-                case WILDCARD:
-                case DAMAGE:
-                    if (damageIter != null && damageIter.hasNext()) return DetailIterState.DAMAGE;
-                case TAG:
-                    if (tagIter != null && tagIter.hasNext()) return DetailIterState.TAG;
-                case META:
-                    if (metaIter != null && metaIter.hasNext()) return DetailIterState.META;
-                case DONE:
-                    return DetailIterState.DONE;
-                default:
-                    throw new IllegalStateException("Unexpected value: " + state);
-            }
-        }
-
-        @Override
-        public void remove() {
-            if (removed) throw new IllegalStateException("remove() called twice");
-            state.remove(this);
-            removed = true;
-        }
-
-        @Override
-        public boolean hasNext() {
-            return nextState() != DetailIterState.DONE;
-        }
-
-        @Override
-        public Map.Entry<ItemStack, T> next() {
-            DetailIterState nextState = nextState();
-            if (nextState == DetailIterState.DONE) throw new NoSuchElementException();
-            state = nextState;
-            removed = false;
-            return nextState.get(this);
-        }
-
-        private enum DetailIterState {
-            NOT_STARTED {
-                @Override
-                <T> Map.Entry<ItemStack, T> get(DetailIter<T> iter) {
-                    throw new AssertionError("Should not call get on NOT_STARTED");
-                }
-
-                @Override
-                <T> void remove(DetailIter<T> iter) {
-                    throw new IllegalStateException("next() never called");
-                }
-            },
-            WILDCARD {
-                @Override
-                <T> Map.Entry<ItemStack, T> get(DetailIter<T> iter) {
-                    return new Map.Entry<ItemStack, T>() {
-                        private final ItemStack key = wildcard(iter.owner);
-
-                        @Override
-                        public ItemStack getKey() {
-                            return key;
-                        }
-
-                        @Override
-                        public T getValue() {
-                            return iter.backing.wildcard;
-                        }
-
-                        @Override
-                        public T setValue(T value) {
-                            return iter.backing.wildcard = value;
-                        }
-                    };
-                }
-
-                @Override
-                <T> void remove(DetailIter<T> iter) {
-                    assert iter.backing.hasWildcard;
-                    iter.backing.wildcard = null;
-                    iter.backing.hasWildcard = false;
-                }
-            },
-            DAMAGE {
-                @Override
-                <T> Map.Entry<ItemStack, T> get(DetailIter<T> iter) {
-                    assert iter.damageIter != null;
-                    Map.Entry<Integer, T> entry = iter.damageIter.next();
-                    return new ItemStackEntry<>(newItemStack(iter.owner, 1, entry.getKey(), WILDCARD_TAG), entry);
-                }
-
-                @Override
-                <T> void remove(DetailIter<T> iter) {
-                    assert iter.damageIter != null;
-                    iter.damageIter.remove();
-                }
-            },
-            TAG {
-                @Override
-                <T> Map.Entry<ItemStack, T> get(DetailIter<T> iter) {
-                    assert iter.tagIter != null;
-                    Map.Entry<NBTTagCompound, T> entry = iter.tagIter.next();
-                    return new ItemStackEntry<>(newItemStack(iter.owner, 1, WILDCARD_VALUE, entry.getKey()), entry);
-                }
-
-                @Override
-                <T> void remove(DetailIter<T> iter) {
-                    assert iter.tagIter != null;
-                    iter.tagIter.remove();
-                }
-            },
-            META {
-                @Override
-                <T> Map.Entry<ItemStack, T> get(DetailIter<T> iter) {
-                    assert iter.metaIter != null;
-                    Map.Entry<StackMetaKey, T> entry = iter.metaIter.next();
-                    return new ItemStackEntry<>(
-                            newItemStack(iter.owner, 1, entry.getKey().damage, entry.getKey().tag), entry);
-                }
-
-                @Override
-                <T> void remove(DetailIter<T> iter) {
-                    assert iter.metaIter != null;
-                    iter.metaIter.remove();
-                }
-            },
-            DONE {
-                @Override
-                <T> Map.Entry<ItemStack, T> get(DetailIter<T> iter) {
-                    throw new AssertionError("Should not call get on DONE");
-                }
-
-                @Override
-                <T> void remove(DetailIter<T> iter) {
-                    throw new AssertionError("Should not call remove on DONE");
-                }
-            };
-
-            abstract <T> Map.Entry<ItemStack, T> get(DetailIter<T> iter);
-
-            abstract <T> void remove(DetailIter<T> iter);
-
-            private static class ItemStackEntry<T> implements Map.Entry<ItemStack, T> {
-                private final ItemStack key;
-                private final Map.Entry<?, T> entry;
-
-                public ItemStackEntry(ItemStack key, Map.Entry<?, T> entry) {
-                    this.key = key;
-                    this.entry = entry;
-                }
-
-                @Override
-                public ItemStack getKey() {
-                    return key;
-                }
-
-                @Override
-                public T getValue() {
-                    return entry.getValue();
-                }
-
-                @Override
-                public T setValue(T value) {
-                    return entry.setValue(value);
-                }
-            }
-        }
-    }
-
-    private class DetailMap {
-        private boolean hasWildcard;
-        private T wildcard;
-        private HashMap<Integer, T> damageMap;
-        private HashMap<NBTTagCompound, T> tagMap;
-        private HashMap<StackMetaKey, T> metaMap;
-        private int size;
-
-        public T get(ItemStack key) {
-            if (wildcard != null) return wildcard;
-
-            if (damageMap != null) {
-                final T ret = damageMap.get(actualDamage(key));
-                if (ret != null) return ret;
-            }
-            if (tagMap != null) {
-                final T ret = tagMap.get(key.stackTagCompound);
-                if (ret != null) return ret;
-            }
-            if (metaMap != null) return metaMap.get(new StackMetaKey(key));
-
-            return null;
-        }
-
-        public T put(ItemStack key, T value) {
-            try {
-                switch (getKeyType(actualDamage(key), key.stackTagCompound)) {
-                    case 0:
-                        if (metaMap == null) metaMap = new HashMap<>();
-                        return metaMap.put(new StackMetaKey(key), value);
-                    case 1:
-                        if (tagMap == null) tagMap = new HashMap<>();
-                        return tagMap.put(key.stackTagCompound, value);
-                    case 2:
-                        if (damageMap == null) damageMap = new HashMap<>();
-                        return damageMap.put(actualDamage(key), value);
-                    case 3:
-                        T ret = wildcard;
-                        wildcard = value;
-                        hasWildcard = true;
-                        return ret;
-                }
-            } finally {
-                updateSize();
-            }
-            return null;
-        }
-
-        public T remove(ItemStack key) {
-            try {
-                switch (getKeyType(actualDamage(key), key.stackTagCompound)) {
-                    case 0:
-                        return metaMap != null ? metaMap.remove(new StackMetaKey(key)) : null;
-                    case 1:
-                        return tagMap != null ? tagMap.remove(key.stackTagCompound) : null;
-                    case 2:
-                        return damageMap != null ? damageMap.remove(actualDamage(key)) : null;
-                    case 3:
-                        T ret = wildcard;
-                        wildcard = null;
-                        hasWildcard = false;
-                        return ret;
-                }
-            } finally {
-                updateSize();
-            }
-            return null;
-        }
-
-        private void updateSize() {
-            int newSize = (hasWildcard ? 1 : 0)
-                    + (metaMap != null ? metaMap.size() : 0)
-                    + (tagMap != null ? tagMap.size() : 0)
-                    + (damageMap != null ? damageMap.size() : 0);
-
-            if (newSize != size) {
-                ItemStackMap.this.size += newSize - size;
-                size = newSize;
-            }
-        }
-    }
-
-    private class SetView extends AbstractSet<Map.Entry<ItemStack, T>> {
-        @Override
-        public boolean contains(Object o) {
-            if (!(o instanceof Map.Entry)) return false;
-            Map.Entry<?, ?> entry = (Map.Entry<?, ?>) o;
-            return java.util.Objects.equals(get(entry.getKey()), entry.getValue());
-        }
-
-        @Override
-        public boolean add(Map.Entry<ItemStack, T> itemStackTEntry) {
-            return itemStackTEntry.getKey() != null
-                    && itemStackTEntry.getValue() != null
-                    && put(itemStackTEntry.getKey(), itemStackTEntry.getValue()) == null;
-        }
-
-        @Override
-        public boolean remove(Object o) {
-            if (!(o instanceof Map.Entry)) return false;
-            Map.Entry<?, ?> entry = (Map.Entry<?, ?>) o;
-            return ItemStackMap.this.remove(entry.getKey(), entry.getValue());
-        }
-
-        @Nonnull
-        @Override
-        public Iterator<Map.Entry<ItemStack, T>> iterator() {
-            return Iterators.concat(Iterators.transform(itemMap.entrySet().iterator(), DetailIter::new));
-        }
-
-        @Override
-        public int size() {
-            return size;
-        }
-    }
-}

src/main/resources/assets/structurelib/lang/en_US.lang

@@ -26,12 +26,22 @@ item.structurelib.constructableTrigger.desc.1=Shows multiblock construction sche
 item.structurelib.constructableTrigger.desc.2=use on the multiblock controller.
 item.structurelib.constructableTrigger.desc.3=(Sneak use on controller to build)
 item.structurelib.constructableTrigger.desc.4=Quantity of schematics in item stack affects tier/mode/type
-item.structurelib.constructableTrigger.too_fast=Please wait %d ticks before another autoplace...
+item.structurelib.constructableTrigger.desc.5=Hold §l[LSHIFT]§r to display channel data
+item.structurelib.constructableTrigger.desc.lshift.0=Contain %d sub channel.
+item.structurelib.constructableTrigger.too_fast=Please wait %d milliseconds before another autoplace...
+item.structurelib.constructableTrigger.gui.key=Key:
+item.structurelib.constructableTrigger.gui.value=Value:
+item.structurelib.constructableTrigger.gui.add=Add
+item.structurelib.constructableTrigger.gui.set=Set
+item.structurelib.constructableTrigger.gui.unset=Unset
+item.structurelib.constructableTrigger.gui.wipe=§4Wipe
 
+structurelib.autoplace.built_stat=Built %s blocks
 structurelib.autoplace.complete=§aThis multiblock has completed!
 structurelib.autoplace.error.not_enabled=§cThis multiblock does not support autoplace in survival!
 structurelib.autoplace.error.no_simple_block=§cSuggested to place §r%s§c but none was found
 structurelib.autoplace.error.no_item_stack=§cSuggested to place block by using §r%s§c but none was found
+structurelib.autoplace.warning.no_explicit_channel=§6This structure depends on nonexistent sub channel §r%s§c. Using master channel instead.
 
 structurelib.blockhint.desc.0=Helps while building
 structurelib.blockhint.0.name=Hint 1 dot

src/main/resources/assets/structurelib/lang/zh_CN.lang

@@ -26,8 +26,17 @@ item.structurelib.constructableTrigger.desc.1=只能在多方块主机上使用
 item.structurelib.constructableTrigger.desc.2=结构的示意图。 (译者注：请搭高使用)
 item.structurelib.constructableTrigger.desc.3= (潜行右键可以直接完成搭建)
 item.structurelib.constructableTrigger.desc.4=此物品堆叠数量会影响显示的机器等级/模式/类型
-item.structurelib.constructableTrigger.too_fast=请在下一次自动搭建前等待%dtick...
+item.structurelib.constructableTrigger.desc.5=按下 §l[左SHIFT]§r 以显示子信道
+item.structurelib.constructableTrigger.desc.lshift.0=包含 %d 个子信道
+item.structurelib.constructableTrigger.too_fast=请在下一次自动搭建前等待%d毫秒...
+item.structurelib.constructableTrigger.gui.key=信道名:
+item.structurelib.constructableTrigger.gui.value=值:
+item.structurelib.constructableTrigger.gui.add=添加
+item.structurelib.constructableTrigger.gui.set=替换
+item.structurelib.constructableTrigger.gui.unset=删除
+item.structurelib.constructableTrigger.gui.wipe=§4全部清空
 
+structurelib.autoplace.built_stat=已放置 %s 个方块
 structurelib.autoplace.complete=§a这个多方块结构已经完成自动搭建！
 structurelib.autoplace.error.not_enabled=§c这个多方块结构不支持在生存模式下自动搭建！
 structurelib.autoplace.error.no_simple_block=§c建议放置§r%s§c，但没有找到它