Implement autoplace (#6)

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

@@ -1,31 +1,29 @@
-package com.gtnewhorizon.structurelib.proxy;
+package com.gtnewhorizon.structurelib;
 
 import com.google.common.collect.BiMap;
 import com.google.common.collect.HashBiMap;
-import com.gtnewhorizon.structurelib.ConfigurationHandler;
 import com.gtnewhorizon.structurelib.entity.fx.EntityFXBlockHint;
-import com.gtnewhorizon.structurelib.entity.fx.WeightlessParticleFX;
 import cpw.mods.fml.common.event.FMLPreInitializationEvent;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.LinkedList;
+import java.util.List;
 import net.minecraft.block.Block;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiNewChat;
-import net.minecraft.client.particle.EntityFX;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.util.ChatComponentText;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.World;
 import net.minecraftforge.common.MinecraftForge;
 import net.minecraftforge.event.world.WorldEvent;
 
-import java.util.ArrayList;
-import java.util.Iterator;
-import java.util.LinkedList;
-import java.util.List;
-
-import static com.gtnewhorizon.structurelib.StructureLib.RANDOM;
-
 public class ClientProxy extends CommonProxy {
+
+    private static final short[] NO_TINT = {255, 255, 255, 0};
+
     @Override
     public void hintParticleTinted(World w, int x, int y, int z, IIcon[] icons, short[] RGBa) {
         EntityFXBlockHint hint = new EntityFXBlockHint(w, x, y, z, icons).withColorTint(RGBa);
@@ -46,10 +44,6 @@ public class ClientProxy extends CommonProxy {
             allHints.forcePut(hint, info);
         }
         currentHints.add(hint);
-
-        EntityFX particle = new WeightlessParticleFX(w, x + RANDOM.nextFloat() * 0.5F, y + RANDOM.nextFloat() * 0.5F, z + RANDOM.nextFloat() * 0.5F, 0, 0, 0);
-        particle.setRBGColorF(0, 0.6F * RANDOM.nextFloat(), 0.8f);
-        Minecraft.getMinecraft().effectRenderer.addEffect(particle);
     }
 
     @Override
@@ -59,12 +53,25 @@ public class ClientProxy extends CommonProxy {
 
     @Override
     public void hintParticle(World w, int x, int y, int z, IIcon[] icons) {
-        hintParticleTinted(w, x, y, z, icons, new short[]{255, 255, 255, 0});
+        hintParticleTinted(w, x, y, z, icons, NO_TINT);
     }
 
     @Override
     public void hintParticle(World w, int x, int y, int z, Block block, int meta) {
-        hintParticleTinted(w, x, y, z, createIIconFromBlock(block, meta), new short[]{255, 255, 255, 0});
+        hintParticleTinted(w, x, y, z, createIIconFromBlock(block, meta), NO_TINT);
+    }
+
+    @Override
+    public boolean updateHintParticleTint(EntityPlayer player, World w, int x, int y, int z, short[] rgBa) {
+        if (player instanceof EntityPlayerMP) return super.updateHintParticleTint(player, w, x, y, z, rgBa);
+        if (player != getCurrentPlayer()) return false; // how?
+        HintParticleInfo info = new HintParticleInfo(x, y, z, null);
+        EntityFXBlockHint existing = allHints.inverse().get(info);
+        if (existing != null) {
+            existing.withColorTint(rgBa);
+            return true;
+        }
+        return false;
     }
 
     private static IIcon[] createIIconFromBlock(Block block, int meta) {
@@ -98,13 +105,11 @@ public class ClientProxy extends CommonProxy {
     private static List<EntityFXBlockHint> currentHints;
 
     public static void onHintDead(EntityFXBlockHint fx) {
-        if (ConfigurationHandler.INSTANCE.isRemoveCollidingHologram())
-            allHints.remove(fx);
+        if (ConfigurationHandler.INSTANCE.isRemoveCollidingHologram()) allHints.remove(fx);
         for (Iterator<List<EntityFXBlockHint>> iterator = hintOwners.iterator(); iterator.hasNext(); ) {
             List<EntityFXBlockHint> list = iterator.next();
             if (list.remove(fx)) {
-                if (list.isEmpty())
-                    iterator.remove();
+                if (list.isEmpty()) iterator.remove();
                 break;
             }
         }
@@ -112,29 +117,24 @@ public class ClientProxy extends CommonProxy {
 
     @Override
     public void startHinting(World w) {
-        if (!w.isRemote)
-            return;
-        if (currentHints != null)
-            hintOwners.add(currentHints);
+        if (!w.isRemote) return;
+        if (currentHints != null) hintOwners.add(currentHints);
         currentHints = new LinkedList<>();
     }
 
     private void ensureHinting() {
-        if (currentHints == null)
-            currentHints = new LinkedList<>();
+        if (currentHints == null) currentHints = new LinkedList<>();
     }
 
     @Override
     public void endHinting(World w) {
-        if (!w.isRemote)
-            return;
+        if (!w.isRemote) return;
         while (!hintOwners.isEmpty() && hintOwners.size() >= ConfigurationHandler.INSTANCE.getMaxCoexistingHologram()) {
             List<EntityFXBlockHint> list = hintOwners.remove(0);
             list.forEach(EntityFXBlockHint::setDead);
             list.clear();
         }
-        if (!currentHints.isEmpty())
-            hintOwners.add(currentHints);
+        if (!currentHints.isEmpty()) hintOwners.add(currentHints);
         currentHints = null;
     }
 
@@ -143,6 +143,12 @@ public class ClientProxy extends CommonProxy {
         MinecraftForge.EVENT_BUS.register(new ForgeEventHandler());
     }
 
+    @Override
+    public long getOverworldTime() {
+        // there is no overworld, better just hope current world time is ok...
+        return Minecraft.getMinecraft().theWorld.getTotalWorldTime();
+    }
+
     private static class HintParticleInfo {
         private final int x, y, z;
         private final List<EntityFXBlockHint> owner;

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

@@ -0,0 +1,51 @@
+package com.gtnewhorizon.structurelib;
+
+import com.gtnewhorizon.structurelib.net.UpdateHintParticleMessage;
+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.server.MinecraftServer;
+import net.minecraft.util.IIcon;
+import net.minecraft.world.World;
+
+public class CommonProxy {
+    public void hintParticleTinted(World w, int x, int y, int z, IIcon[] icons, short[] RGBa) {}
+
+    public void hintParticleTinted(World w, int x, int y, int z, Block block, int meta, short[] RGBa) {}
+
+    public void hintParticle(World w, int x, int y, int z, IIcon[] icons) {}
+
+    public void hintParticle(World w, int x, int y, int z, Block block, int meta) {}
+
+    public boolean updateHintParticleTint(EntityPlayer player, World w, int x, int y, int z, short[] rgBa) {
+        if (player instanceof EntityPlayerMP) { // just in case
+            StructureLib.net.sendTo(
+                    new UpdateHintParticleMessage(x, (short) y, z, rgBa[0], rgBa[1], rgBa[2], rgBa[3]),
+                    (EntityPlayerMP) player);
+            return true;
+        } else {
+            return false;
+        }
+    }
+
+    public EntityPlayer getCurrentPlayer() {
+        return null;
+    }
+
+    public boolean isCurrentPlayer(EntityPlayer player) {
+        return false;
+    }
+
+    public void addClientSideChatMessages(String... messages) {}
+
+    public void startHinting(World w) {}
+
+    public void endHinting(World w) {}
+
+    public void preInit(FMLPreInitializationEvent e) {}
+
+    public long getOverworldTime() {
+        return MinecraftServer.getServer().getEntityWorld().getTotalWorldTime();
+    }
+}

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

@@ -3,13 +3,12 @@ package com.gtnewhorizon.structurelib;
 import cpw.mods.fml.client.event.ConfigChangedEvent;
 import cpw.mods.fml.common.FMLCommonHandler;
 import cpw.mods.fml.common.eventhandler.SubscribeEvent;
+import java.io.File;
+import java.util.Map;
 import net.minecraftforge.common.config.ConfigCategory;
 import net.minecraftforge.common.config.Configuration;
 import net.minecraftforge.common.config.Property;
 
-import java.io.File;
-import java.util.Map;
-
 public enum ConfigurationHandler {
     INSTANCE;
 
@@ -39,8 +38,18 @@ public enum ConfigurationHandler {
     }
 
     private void loadConfig() {
-        maxCoexistingHologram = config.getInt("maxCoexisting", "client.hologram", 1, 1, 100, "An attempt will be made to prune old holograms when a new hologram is about to be projected");
-        removeCollidingHologram = config.getBoolean("removeColliding", "client.hologram", true, "An attempt will be made to remove an existing hologram if it collides with a new hologram.");
+        maxCoexistingHologram = config.getInt(
+                "maxCoexisting",
+                "client.hologram",
+                1,
+                1,
+                100,
+                "An attempt will be made to prune old holograms when a new hologram is about to be projected");
+        removeCollidingHologram = config.getBoolean(
+                "removeColliding",
+                "client.hologram",
+                true,
+                "An attempt will be made to remove an existing hologram if it collides with a new hologram.");
 
         if (config.hasChanged()) {
             config.save();

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

@@ -1,16 +1,14 @@
 package com.gtnewhorizon.structurelib;
 
-import net.minecraftforge.common.config.Configuration;
-
-import javax.annotation.Nullable;
 import java.util.Arrays;
 import java.util.Objects;
+import javax.annotation.Nullable;
+import net.minecraftforge.common.config.Configuration;
 
 enum ConfigurationVersion {
     V1 {
         @Override
-        protected void step(Configuration c) {
-        }
+        protected void step(Configuration c) {}
     };
 
     private static final ConfigurationVersion[] VALUES = values();
@@ -32,7 +30,10 @@ enum ConfigurationVersion {
     }
 
     public static ConfigurationVersion identify(Configuration c) {
-        return Arrays.stream(VALUES).filter(v -> Objects.equals(c.getLoadedConfigVersion(), v.getVersionMarker())).findFirst().orElse(V1);
+        return Arrays.stream(VALUES)
+                .filter(v -> Objects.equals(c.getLoadedConfigVersion(), v.getVersionMarker()))
+                .findFirst()
+                .orElse(V1);
     }
 
     @Nullable

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

@@ -1,15 +1,13 @@
 package com.gtnewhorizon.structurelib;
 
 import cpw.mods.fml.client.IModGuiFactory;
+import java.util.Set;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.gui.GuiScreen;
 
-import java.util.Set;
-
 public class GuiFactory implements IModGuiFactory {
     @Override
-    public void initialize(Minecraft minecraftInstance) {
-    }
+    public void initialize(Minecraft minecraftInstance) {}
 
     @Override
     public Class<? extends GuiScreen> mainConfigGuiClass() {
@@ -25,4 +23,4 @@ public class GuiFactory implements IModGuiFactory {
     public RuntimeOptionGuiHandler getHandlerFor(RuntimeOptionCategoryElement element) {
         return null;
     }
-}
+}

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

@@ -2,24 +2,30 @@ package com.gtnewhorizon.structurelib;
 
 import cpw.mods.fml.client.config.GuiConfig;
 import cpw.mods.fml.client.config.IConfigElement;
+import java.util.List;
+import java.util.stream.Collectors;
 import net.minecraft.client.gui.GuiScreen;
 import net.minecraftforge.common.config.ConfigElement;
 import net.minecraftforge.common.config.Configuration;
 
-import java.util.List;
-import java.util.stream.Collectors;
-
 public class GuiModConfig extends GuiConfig {
     public GuiModConfig(GuiScreen guiScreen) {
-        super(guiScreen, getConfigElements(), StructureLibAPI.MOD_ID, false, false, GuiConfig.getAbridgedConfigPath(ConfigurationHandler.INSTANCE.getConfig().toString()));
+        super(
+                guiScreen,
+                getConfigElements(),
+                StructureLibAPI.MOD_ID,
+                false,
+                false,
+                GuiConfig.getAbridgedConfigPath(
+                        ConfigurationHandler.INSTANCE.getConfig().toString()));
     }
 
     @SuppressWarnings("rawtypes")
     private static List<IConfigElement> getConfigElements() {
         final Configuration config = ConfigurationHandler.INSTANCE.getConfig();
         return config.getCategoryNames().stream()
-            .filter(name -> name.indexOf('.') == -1)
-            .map(name -> new ConfigElement(config.getCategory(name)))
-            .collect(Collectors.toList());
+                .filter(name -> name.indexOf('.') == -1)
+                .map(name -> new ConfigElement(config.getCategory(name)))
+                .collect(Collectors.toList());
     }
 }

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

@@ -1,11 +1,11 @@
 package com.gtnewhorizon.structurelib;
 
-import com.gtnewhorizon.structurelib.net.AlignmentMessage;
 import com.gtnewhorizon.structurelib.block.BlockHint;
 import com.gtnewhorizon.structurelib.item.ItemBlockHint;
 import com.gtnewhorizon.structurelib.item.ItemConstructableTrigger;
 import com.gtnewhorizon.structurelib.item.ItemFrontRotationTool;
-import com.gtnewhorizon.structurelib.proxy.CommonProxy;
+import com.gtnewhorizon.structurelib.net.AlignmentMessage;
+import com.gtnewhorizon.structurelib.net.UpdateHintParticleMessage;
 import com.gtnewhorizon.structurelib.util.XSTR;
 import cpw.mods.fml.common.Mod;
 import cpw.mods.fml.common.SidedProxy;
@@ -26,18 +26,29 @@ import org.apache.logging.log4j.Logger;
 /**
  * This class does not contain a stable API. Refrain from using this class.
  */
-@Mod(modid = StructureLibAPI.MOD_ID, name = "StructureLib", version = "GRADLETOKEN_VERSION", acceptableRemoteVersions = "*", guiFactory = "com.gtnewhorizon.structurelib.GuiFactory")
+@Mod(
+        modid = StructureLibAPI.MOD_ID,
+        name = "StructureLib",
+        version = "GRADLETOKEN_VERSION",
+        acceptableRemoteVersions = "*",
+        guiFactory = "com.gtnewhorizon.structurelib.GuiFactory")
 public class StructureLib {
     public static boolean DEBUG_MODE = Boolean.getBoolean("structurelib.debug");
+    public static boolean PANIC_MODE = Boolean.getBoolean("structurelib.panic");
     public static Logger LOGGER = LogManager.getLogger("StructureLib");
 
-    @SidedProxy(serverSide = "com.gtnewhorizon.structurelib.proxy.CommonProxy", clientSide = "com.gtnewhorizon.structurelib.proxy.ClientProxy")
+    @SidedProxy(
+            serverSide = "com.gtnewhorizon.structurelib.CommonProxy",
+            clientSide = "com.gtnewhorizon.structurelib.ClientProxy")
     static CommonProxy proxy;
+
     static SimpleNetworkWrapper net = NetworkRegistry.INSTANCE.newSimpleChannel(StructureLibAPI.MOD_ID);
 
     static {
-        net.registerMessage(AlignmentMessage.ServerHandler.class, AlignmentMessage.AlignmentQuery.class, 0, Side.SERVER);
+        net.registerMessage(
+                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);
     }
 
     public static final XSTR RANDOM = new XSTR();
@@ -59,8 +70,11 @@ public class StructureLib {
         ConfigurationHandler.INSTANCE.init(e.getSuggestedConfigurationFile());
         GameRegistry.registerBlock(blockHint = new BlockHint(), ItemBlockHint.class, "blockhint");
         itemBlockHint = ItemBlock.getItemFromBlock(StructureLibAPI.getBlockHint());
-        GameRegistry.registerItem(itemFrontRotationTool = new ItemFrontRotationTool(), itemFrontRotationTool.getUnlocalizedName());
-        GameRegistry.registerItem(itemConstructableTrigger = new ItemConstructableTrigger(), itemConstructableTrigger.getUnlocalizedName());
+        GameRegistry.registerItem(
+                itemFrontRotationTool = new ItemFrontRotationTool(), itemFrontRotationTool.getUnlocalizedName());
+        GameRegistry.registerItem(
+                itemConstructableTrigger = new ItemConstructableTrigger(),
+                itemConstructableTrigger.getUnlocalizedName());
         proxy.preInit(e);
     }
 
@@ -75,4 +89,8 @@ public class StructureLib {
     public static boolean isCurrentPlayer(EntityPlayer player) {
         return proxy.isCurrentPlayer(player);
     }
+
+    public static long getOverworldTime() {
+        return proxy.getOverworldTime();
+    }
 }

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

@@ -1,8 +1,11 @@
 package com.gtnewhorizon.structurelib;
 
-import com.gtnewhorizon.structurelib.net.AlignmentMessage;
+import static com.gtnewhorizon.structurelib.StructureLib.proxy;
+
 import com.gtnewhorizon.structurelib.alignment.IAlignmentProvider;
 import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing;
+import com.gtnewhorizon.structurelib.net.AlignmentMessage;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import cpw.mods.fml.common.network.NetworkRegistry;
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
@@ -12,8 +15,6 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.World;
 
-import static com.gtnewhorizon.structurelib.StructureLib.proxy;
-
 /**
  * A stable interface into the structure lib's internals. Backwards compatibility is maintained to the maximum extend possible.
  */
@@ -46,7 +47,7 @@ public class StructureLibAPI {
     }
 
     /**
-     * Start current batch of hinting. All hints particles generated during one batch will be considered to belong to one hologram.
+     * End current batch of hinting. All hints particles generated during one batch will be considered to belong to one hologram.
      * <p>
      * You don't need to call this unless your constructable tool didn't call {@link com.gtnewhorizon.structurelib.alignment.constructable.ConstructableUtility#handle(ItemStack, EntityPlayer, World, int, int, int, int)}
      */
@@ -70,6 +71,14 @@ public class StructureLibAPI {
         proxy.hintParticle(w, x, y, z, block, meta);
     }
 
+    /**
+     * Update the tint of given hint particle. Do nothing if particle not found.
+     * @return false if nothing updated. true if updated.
+     */
+    public static boolean updateHintParticleTint(EntityPlayer player, World w, int x, int y, int z, short[] RGBa) {
+        return proxy.updateHintParticleTint(player, w, x, y, z, RGBa);
+    }
+
     /**
      * Query the ExtendedFacing of this tile entity.
      * The ExtendedFacing will later be set onto given tile entity via {@link com.gtnewhorizon.structurelib.alignment.IAlignment#setExtendedFacing(ExtendedFacing)}
@@ -108,7 +117,6 @@ public class StructureLibAPI {
         StructureLib.net.sendToAllAround(new AlignmentMessage.AlignmentData(provider), targetPoint);
     }
 
-
     /**
      * Send the ExtendedFacing of this Tile Entity to all players in that dimension. Can be called on server side only.
      *
@@ -133,4 +141,15 @@ public class StructureLibAPI {
     public static void setDebugEnabled(boolean enabled) {
         StructureLib.DEBUG_MODE = enabled;
     }
+
+    /**
+     * Determines if given block can be replaced without much effort. The exact predicate clauses is not stable and
+     * will be changed, but the general idea will always stay the same.
+     *
+     * Use this in your {@link com.gtnewhorizon.structurelib.structure.IStructureElement#survivalPlaceBlock(Object, World, int, int, int, ItemStack, IItemSource, EntityPlayerMP, java.util.function.Consumer)}
+     */
+    public static boolean isBlockTriviallyReplaceable(World w, int x, int y, int z, EntityPlayerMP actor) {
+        // TODO extend this function a bit
+        return w.getBlock(x, y, z).isReplaceable(w, x, y, z);
+    }
 }

src/main/java/com/gtnewhorizon/structurelib/alignment/AlignmentUtility.java

@@ -7,8 +7,7 @@ import net.minecraft.world.World;
 import net.minecraftforge.common.util.FakePlayer;
 
 public class AlignmentUtility {
-    private AlignmentUtility() {
-    }
+    private AlignmentUtility() {}
 
     public static boolean handle(EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ) {
         TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);

src/main/java/com/gtnewhorizon/structurelib/alignment/IAlignment.java

@@ -57,7 +57,9 @@ public interface IAlignment extends IAlignmentLimits, IAlignmentProvider {
 
     default boolean toolSetDirection(ForgeDirection direction) {
         if (direction == null || direction == ForgeDirection.UNKNOWN) {
-            for (int i = 0, j = getDirection().ordinal() + 1, valuesLength = Direction.VALUES.length; i < valuesLength; i++) {
+            for (int i = 0, j = getDirection().ordinal() + 1, valuesLength = Direction.VALUES.length;
+                    i < valuesLength;
+                    i++) {
                 if (toolSetDirection(Direction.VALUES[(j + i) % valuesLength].getForgeDirection())) {
                     return true;
                 }
@@ -95,7 +97,8 @@ public interface IAlignment extends IAlignmentLimits, IAlignmentProvider {
             int rotations = Rotation.VALUES.length;
             for (int ii = 0, jj = getFlip().ordinal(); ii < flips; ii++) {
                 for (int i = 1, j = getRotation().ordinal(); i < rotations; i++) {
-                    if (checkedSetExtendedFacing(ExtendedFacing.of(getDirection(), Rotation.VALUES[(j + i) % rotations], Flip.VALUES[(jj + ii) % flips]))) {
+                    if (checkedSetExtendedFacing(ExtendedFacing.of(
+                            getDirection(), Rotation.VALUES[(j + i) % rotations], Flip.VALUES[(jj + ii) % flips]))) {
                         return true;
                     }
                 }
@@ -137,7 +140,9 @@ public interface IAlignment extends IAlignmentLimits, IAlignmentProvider {
 
     default boolean toolSetExtendedFacing(ExtendedFacing extendedFacing) {
         if (extendedFacing == null) {
-            for (int i = 0, j = getExtendedFacing().ordinal() + 1, valuesLength = ExtendedFacing.VALUES.length; i < valuesLength; i++) {
+            for (int i = 0, j = getExtendedFacing().ordinal() + 1, valuesLength = ExtendedFacing.VALUES.length;
+                    i < valuesLength;
+                    i++) {
                 if (checkedSetExtendedFacing(ExtendedFacing.VALUES[(j + i) % valuesLength])) {
                     return true;
                 }
@@ -179,9 +184,7 @@ public interface IAlignment extends IAlignmentLimits, IAlignmentProvider {
 
     @Override
     default boolean isNewExtendedFacingValid(ExtendedFacing alignment) {
-        return getAlignmentLimits().isNewExtendedFacingValid(
-            alignment.getDirection(),
-            alignment.getRotation(),
-            alignment.getFlip());
+        return getAlignmentLimits()
+                .isNewExtendedFacingValid(alignment.getDirection(), alignment.getRotation(), alignment.getFlip());
     }
 }

src/main/java/com/gtnewhorizon/structurelib/alignment/IAlignmentLimits.java

@@ -1,15 +1,14 @@
 package com.gtnewhorizon.structurelib.alignment;
 
+import static com.gtnewhorizon.structurelib.alignment.IAlignment.STATES_COUNT;
+
 import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing;
 import com.gtnewhorizon.structurelib.alignment.enumerable.Flip;
 import com.gtnewhorizon.structurelib.alignment.enumerable.Rotation;
-import net.minecraftforge.common.util.ForgeDirection;
-
 import java.util.Arrays;
 import java.util.Optional;
 import java.util.function.Function;
-
-import static com.gtnewhorizon.structurelib.alignment.IAlignment.STATES_COUNT;
+import net.minecraftforge.common.util.ForgeDirection;
 
 public interface IAlignmentLimits {
 
@@ -18,10 +17,7 @@ public interface IAlignmentLimits {
     boolean isNewExtendedFacingValid(ForgeDirection direction, Rotation rotation, Flip flip);
 
     default boolean isNewExtendedFacingValid(ExtendedFacing alignment) {
-        return isNewExtendedFacingValid(
-            alignment.getDirection(),
-            alignment.getRotation(),
-            alignment.getFlip());
+        return isNewExtendedFacingValid(alignment.getDirection(), alignment.getRotation(), alignment.getFlip());
     }
 
     static IAlignmentLimits allowOnly(ExtendedFacing... allowedFacings) {
@@ -43,8 +39,7 @@ public interface IAlignmentLimits {
     class Builder {
         protected final boolean[] validStates = new boolean[STATES_COUNT];
 
-        private Builder() {
-        }
+        private Builder() {}
 
         public static Builder allowAll() {
             Builder b = new Builder();
@@ -59,12 +54,16 @@ public interface IAlignmentLimits {
         }
 
         public Builder deny(ForgeDirection fd) {
-            ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = false);
+            ExtendedFacing.getAllWith(fd).stream()
+                    .mapToInt(ExtendedFacing::getIndex)
+                    .forEach(v -> validStates[v] = false);
             return this;
         }
 
         public Builder allow(ForgeDirection fd) {
-            ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = true);
+            ExtendedFacing.getAllWith(fd).stream()
+                    .mapToInt(ExtendedFacing::getIndex)
+                    .forEach(v -> validStates[v] = true);
             return this;
         }
 
@@ -79,22 +78,30 @@ public interface IAlignmentLimits {
         }
 
         public Builder deny(Rotation fd) {
-            ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = false);
+            ExtendedFacing.getAllWith(fd).stream()
+                    .mapToInt(ExtendedFacing::getIndex)
+                    .forEach(v -> validStates[v] = false);
             return this;
         }
 
         public Builder allow(Rotation fd) {
-            ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = true);
+            ExtendedFacing.getAllWith(fd).stream()
+                    .mapToInt(ExtendedFacing::getIndex)
+                    .forEach(v -> validStates[v] = true);
             return this;
         }
 
         public Builder deny(Flip fd) {
-            ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = false);
+            ExtendedFacing.getAllWith(fd).stream()
+                    .mapToInt(ExtendedFacing::getIndex)
+                    .forEach(v -> validStates[v] = false);
             return this;
         }
 
         public Builder allow(Flip fd) {
-            ExtendedFacing.getAllWith(fd).stream().mapToInt(ExtendedFacing::getIndex).forEach(v -> validStates[v] = true);
+            ExtendedFacing.getAllWith(fd).stream()
+                    .mapToInt(ExtendedFacing::getIndex)
+                    .forEach(v -> validStates[v] = true);
             return this;
         }
 

src/main/java/com/gtnewhorizon/structurelib/alignment/IAlignmentProvider.java

@@ -5,4 +5,4 @@ import javax.annotation.Nullable;
 public interface IAlignmentProvider {
     @Nullable
     IAlignment getAlignment();
-}
+}

src/main/java/com/gtnewhorizon/structurelib/alignment/IntegerAxisSwap.java

@@ -1,12 +1,12 @@
 package com.gtnewhorizon.structurelib.alignment;
 
-import com.gtnewhorizon.structurelib.util.Vec3Impl;
+import static java.lang.Math.abs;
+
 import com.gtnewhorizon.structurelib.alignment.enumerable.Direction;
+import com.gtnewhorizon.structurelib.util.Vec3Impl;
 import net.minecraft.util.Vec3;
 import net.minecraftforge.common.util.ForgeDirection;
 
-import static java.lang.Math.abs;
-
 public class IntegerAxisSwap {
     private final Vec3Impl forFirstAxis;
     private final Vec3Impl forSecondAxis;
@@ -16,46 +16,66 @@ public class IntegerAxisSwap {
         this.forFirstAxis = Direction.getAxisVector(forFirstAxis);
         this.forSecondAxis = Direction.getAxisVector(forSecondAxis);
         this.forThirdAxis = Direction.getAxisVector(forThirdAxis);
-        if (abs(this.forFirstAxis.get0()) + abs(this.forSecondAxis.get0()) + abs(this.forThirdAxis.get0()) != 1 ||
-            abs(this.forFirstAxis.get1()) + abs(this.forSecondAxis.get1()) + abs(this.forThirdAxis.get1()) != 1 ||
-            abs(this.forFirstAxis.get2()) + abs(this.forSecondAxis.get2()) + abs(this.forThirdAxis.get2()) != 1) {
-            throw new IllegalArgumentException("Axis are overlapping/missing! " +
-                forFirstAxis.name() + " " +
-                forSecondAxis.name() + " " +
-                forThirdAxis.name());
+        if (abs(this.forFirstAxis.get0()) + abs(this.forSecondAxis.get0()) + abs(this.forThirdAxis.get0()) != 1
+                || abs(this.forFirstAxis.get1()) + abs(this.forSecondAxis.get1()) + abs(this.forThirdAxis.get1()) != 1
+                || abs(this.forFirstAxis.get2()) + abs(this.forSecondAxis.get2()) + abs(this.forThirdAxis.get2())
+                        != 1) {
+            throw new IllegalArgumentException("Axis are overlapping/missing! " + forFirstAxis.name()
+                    + " " + forSecondAxis.name()
+                    + " " + forThirdAxis.name());
         }
     }
 
     public Vec3Impl translate(Vec3Impl point) {
         return new Vec3Impl(
-            forFirstAxis.get0() * point.get0() + forFirstAxis.get1() * point.get1() + forFirstAxis.get2() * point.get2(),
-            forSecondAxis.get0() * point.get0() + forSecondAxis.get1() * point.get1() + forSecondAxis.get2() * point.get2(),
-            forThirdAxis.get0() * point.get0() + forThirdAxis.get1() * point.get1() + forThirdAxis.get2() * point.get2()
-        );
+                forFirstAxis.get0() * point.get0()
+                        + forFirstAxis.get1() * point.get1()
+                        + forFirstAxis.get2() * point.get2(),
+                forSecondAxis.get0() * point.get0()
+                        + forSecondAxis.get1() * point.get1()
+                        + forSecondAxis.get2() * point.get2(),
+                forThirdAxis.get0() * point.get0()
+                        + forThirdAxis.get1() * point.get1()
+                        + forThirdAxis.get2() * point.get2());
     }
 
     public Vec3Impl inverseTranslate(Vec3Impl point) {
         return new Vec3Impl(
-            forFirstAxis.get0() * point.get0() + forSecondAxis.get0() * point.get1() + forThirdAxis.get0() * point.get2(),
-            forFirstAxis.get1() * point.get0() + forSecondAxis.get1() * point.get1() + forThirdAxis.get1() * point.get2(),
-            forFirstAxis.get2() * point.get0() + forSecondAxis.get2() * point.get1() + forThirdAxis.get2() * point.get2()
-        );
+                forFirstAxis.get0() * point.get0()
+                        + forSecondAxis.get0() * point.get1()
+                        + forThirdAxis.get0() * point.get2(),
+                forFirstAxis.get1() * point.get0()
+                        + forSecondAxis.get1() * point.get1()
+                        + forThirdAxis.get1() * point.get2(),
+                forFirstAxis.get2() * point.get0()
+                        + forSecondAxis.get2() * point.get1()
+                        + forThirdAxis.get2() * point.get2());
     }
 
     public Vec3 translate(Vec3 point) {
         return Vec3.createVectorHelper(
-            forFirstAxis.get0() * point.xCoord + forFirstAxis.get1() * point.yCoord + forFirstAxis.get2() * point.zCoord,
-            forSecondAxis.get0() * point.xCoord + forSecondAxis.get1() * point.yCoord + forSecondAxis.get2() * point.zCoord,
-            forThirdAxis.get0() * point.xCoord + forThirdAxis.get1() * point.yCoord + forThirdAxis.get2() * point.zCoord
-        );
+                forFirstAxis.get0() * point.xCoord
+                        + forFirstAxis.get1() * point.yCoord
+                        + forFirstAxis.get2() * point.zCoord,
+                forSecondAxis.get0() * point.xCoord
+                        + forSecondAxis.get1() * point.yCoord
+                        + forSecondAxis.get2() * point.zCoord,
+                forThirdAxis.get0() * point.xCoord
+                        + forThirdAxis.get1() * point.yCoord
+                        + forThirdAxis.get2() * point.zCoord);
     }
 
     public Vec3 inverseTranslate(Vec3 point) {
         return Vec3.createVectorHelper(
-            forFirstAxis.get0() * point.xCoord + forSecondAxis.get0() * point.yCoord + forThirdAxis.get0() * point.zCoord,
-            forFirstAxis.get1() * point.xCoord + forSecondAxis.get1() * point.yCoord + forThirdAxis.get1() * point.zCoord,
-            forFirstAxis.get2() * point.xCoord + forSecondAxis.get2() * point.yCoord + forThirdAxis.get2() * point.zCoord
-        );
+                forFirstAxis.get0() * point.xCoord
+                        + forSecondAxis.get0() * point.yCoord
+                        + forThirdAxis.get0() * point.zCoord,
+                forFirstAxis.get1() * point.xCoord
+                        + forSecondAxis.get1() * point.yCoord
+                        + forThirdAxis.get1() * point.zCoord,
+                forFirstAxis.get2() * point.xCoord
+                        + forSecondAxis.get2() * point.yCoord
+                        + forThirdAxis.get2() * point.zCoord);
     }
 
     public void translate(int[] point, int[] out) {

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

@@ -4,79 +4,107 @@ 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 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;
 import net.minecraftforge.common.util.FakePlayer;
 import net.minecraftforge.common.util.ForgeDirection;
 
 public class ConstructableUtility {
-    private 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
 
-    public static boolean handle(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide) {
+    private ConstructableUtility() {}
+
+    public static boolean handle(
+            ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide) {
         StructureLibAPI.startHinting(aWorld);
         boolean ret = handle0(aStack, aPlayer, aWorld, aX, aY, aZ, aSide);
         StructureLibAPI.endHinting(aWorld);
         return ret;
     }
 
-    private static boolean handle0(ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide) {
+    private static boolean handle0(
+            ItemStack aStack, EntityPlayer aPlayer, World aWorld, int aX, int aY, int aZ, int aSide) {
         TileEntity tTileEntity = aWorld.getTileEntity(aX, aY, aZ);
         if (tTileEntity == null || aPlayer instanceof FakePlayer) {
             return aPlayer instanceof EntityPlayerMP;
         }
         if (aPlayer instanceof EntityPlayerMP) {
-            //struct gen
-            if (aPlayer.isSneaking() && aPlayer.capabilities.isCreativeMode) {
-                if (tTileEntity instanceof IConstructableProvider) {
-                    IConstructable constructable = ((IConstructableProvider) tTileEntity).getConstructable();
-                    if (constructable != null) {
-                        constructable.construct(aStack, false);
-                    }
-                } else if (tTileEntity instanceof IConstructable) {
-                    ((IConstructable) tTileEntity).construct(aStack, false);
-                } else if (IMultiblockInfoContainer.contains(tTileEntity.getClass())) {
-                    IMultiblockInfoContainer<TileEntity> iMultiblockInfoContainer = IMultiblockInfoContainer.get(tTileEntity.getClass());
-                    if (tTileEntity instanceof IAlignment) {
-                        iMultiblockInfoContainer.construct(aStack, false, tTileEntity,
-                            ((IAlignment) tTileEntity).getExtendedFacing());
-                    } else {
-                        iMultiblockInfoContainer.construct(aStack, false, tTileEntity,
-                            ExtendedFacing.of(ForgeDirection.getOrientation(aSide)));
-                    }
+            // 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) {
+                aPlayer.addChatComponentMessage(new ChatComponentTranslation(
+                        "item.structurelib.constructableTrigger.too_fast", COOLDOWN - timePast));
+                return true;
+            }
+        } else if (!StructureLib.isCurrentPlayer(aPlayer)) {
+            return false;
+        }
+
+        IConstructable constructable = null;
+        if (tTileEntity instanceof IConstructableProvider)
+            constructable = ((IConstructableProvider) tTileEntity).getConstructable();
+        else if (tTileEntity instanceof IConstructable) {
+            constructable = (IConstructable) tTileEntity;
+        } else if (IMultiblockInfoContainer.contains(tTileEntity.getClass())) {
+            ExtendedFacing facing = tTileEntity instanceof IAlignment
+                    ? ((IAlignment) tTileEntity).getExtendedFacing()
+                    : ExtendedFacing.of(ForgeDirection.getOrientation(aSide));
+            constructable = IMultiblockInfoContainer.<TileEntity>get(tTileEntity.getClass())
+                    .toConstructable(tTileEntity, facing);
+        }
+
+        if (constructable == null) return false;
+
+        if (aPlayer instanceof EntityPlayerMP) {
+            EntityPlayerMP playerMP = (EntityPlayerMP) aPlayer;
+            // server side and sneaking (already checked above)
+            // do construct
+            if (aPlayer.capabilities.isCreativeMode) {
+                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) {
+                    playerMP.addChatMessage(new ChatComponentTranslation("structurelib.autoplace.complete"));
                 }
+                setLastUseTickToStackTag(aStack);
+            } else {
+                playerMP.addChatMessage(new ChatComponentTranslation("structurelib.autoplace.error.not_enabled"));
             }
             return true;
-        } else if (StructureLib.isCurrentPlayer(aPlayer)) {//particles and text client side
-            //if ((!aPlayer.isSneaking() || !aPlayer.capabilities.isCreativeMode)) {
-            if (tTileEntity instanceof IConstructableProvider) {
-                IConstructable constructable = ((IConstructableProvider) tTileEntity).getConstructable();
-                if (constructable != null) {
-                    constructable.construct(aStack, true);
-                    StructureLib.addClientSideChatMessages(constructable.getStructureDescription(aStack));
-                }
-            } else if (tTileEntity instanceof IConstructable) {
-                IConstructable constructable = (IConstructable) tTileEntity;
-                constructable.construct(aStack, true);
-                StructureLib.addClientSideChatMessages(constructable.getStructureDescription(aStack));
-                return false;
-            } else if (IMultiblockInfoContainer.contains(tTileEntity.getClass())) {
-                IMultiblockInfoContainer<TileEntity> iMultiblockInfoContainer = IMultiblockInfoContainer.get(tTileEntity.getClass());
-                if (tTileEntity instanceof IAlignment) {
-                    iMultiblockInfoContainer.construct(aStack, true, tTileEntity,
-                        ((IAlignment) tTileEntity).getExtendedFacing());
-                } else {
-                    iMultiblockInfoContainer.construct(aStack, true, tTileEntity,
-                        ExtendedFacing.of(ForgeDirection.getOrientation(aSide)));
-                }
-                StructureLib.addClientSideChatMessages(IMultiblockInfoContainer.get(tTileEntity.getClass()).getDescription(aStack));
-                return false;
-            }
         }
+        // client side
+        // particles and text
+        constructable.construct(aStack, true);
+        if (getLastUseTick(aStack) == 0)
+            StructureLib.addClientSideChatMessages(constructable.getStructureDescription(aStack));
         return false;
     }
+
+    private static long getLastUseTick(ItemStack aStack) {
+        return aStack.hasTagCompound() ? aStack.getTagCompound().getLong("LastUse") : 0;
+    }
+
+    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());
+    }
 }

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

@@ -13,4 +13,3 @@ public interface IConstructable {
     @SideOnly(Side.CLIENT)
     String[] getStructureDescription(ItemStack stackSize);
 }
-

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

@@ -1,12 +1,14 @@
 package com.gtnewhorizon.structurelib.alignment.constructable;
 
 import com.gtnewhorizon.structurelib.alignment.enumerable.ExtendedFacing;
+import com.gtnewhorizon.structurelib.structure.IItemSource;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import java.util.HashMap;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
 import net.minecraft.tileentity.TileEntity;
-
-import java.util.HashMap;
+import net.minecraft.world.World;
 
 /**
  * To implement IConstructable on not own TileEntities
@@ -33,6 +35,59 @@ public interface IMultiblockInfoContainer<T> {
 
     void construct(ItemStack stackSize, boolean hintsOnly, T tileEntity, ExtendedFacing aSide);
 
+    /**
+     * Construct the structure using {@link com.gtnewhorizon.structurelib.structure.IStructureElement#survivalPlaceBlock(Object, World, int, int, int, ItemStack, IItemSource, EntityPlayerMP, java.util.function.Consumer)}
+     * @return -1 if done, a helping pointer
+     */
+    default int survivalConstruct(
+            ItemStack stackSize,
+            int elementBudge,
+            IItemSource source,
+            EntityPlayerMP actorProfile,
+            T tileEntity,
+            ExtendedFacing aSide) {
+        return -1;
+    }
+
     @SideOnly(Side.CLIENT)
     String[] getDescription(ItemStack stackSize);
+
+    /**
+     * Override this and return {@link #toConstructable(IMultiblockInfoContainer, Object, ExtendedFacing)} if
+     * {@link #survivalConstruct(ItemStack, int, IItemSource, EntityPlayerMP, Object, ExtendedFacing)} isn't a stub
+     */
+    default IConstructable toConstructable(T tileEntity, ExtendedFacing aSide) {
+        return new IConstructable() {
+            @Override
+            public void construct(ItemStack stackSize, boolean hintsOnly) {
+                IMultiblockInfoContainer.this.construct(stackSize, hintsOnly, tileEntity, aSide);
+            }
+
+            @Override
+            public String[] getStructureDescription(ItemStack stackSize) {
+                return IMultiblockInfoContainer.this.getDescription(stackSize);
+            }
+        };
+    }
+
+    static <T> ISurvivalConstructable toConstructable(
+            IMultiblockInfoContainer<T> thiz, T tileEntity, ExtendedFacing aSide) {
+        return new ISurvivalConstructable() {
+            @Override
+            public int survivalConstruct(
+                    ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor) {
+                return thiz.survivalConstruct(stackSize, elementBudget, source, actor, tileEntity, aSide);
+            }
+
+            @Override
+            public void construct(ItemStack stackSize, boolean hintsOnly) {
+                thiz.construct(stackSize, hintsOnly, tileEntity, aSide);
+            }
+
+            @Override
+            public String[] getStructureDescription(ItemStack stackSize) {
+                return thiz.getDescription(stackSize);
+            }
+        };
+    }
 }

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

@@ -0,0 +1,17 @@
+package com.gtnewhorizon.structurelib.alignment.constructable;
+
+import com.gtnewhorizon.structurelib.structure.IItemSource;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.world.World;
+
+public interface ISurvivalConstructable extends IConstructable {
+    /**
+     * Construct the structure using {@link com.gtnewhorizon.structurelib.structure.IStructureElement#survivalPlaceBlock(Object, World, int, int, int, ItemStack, IItemSource, EntityPlayerMP, java.util.function.Consumer)}
+     *
+     * @param elementBudget The server configured element budget. You can tune this up a bit if the structure is too big, but
+     *                      generally should not be a 4 digits number to not overwhelm the server
+     * @return -1 if done, otherwise number of elements placed this round
+     */
+    int survivalConstruct(ItemStack stackSize, int elementBudget, IItemSource source, EntityPlayerMP actor);
+}

src/main/java/com/gtnewhorizon/structurelib/alignment/enumerable/ExtendedFacing.java

@@ -1,21 +1,20 @@
 package com.gtnewhorizon.structurelib.alignment.enumerable;
 
-import com.google.common.collect.ImmutableSet;
-import com.gtnewhorizon.structurelib.alignment.IAlignment;
-import com.gtnewhorizon.structurelib.alignment.IntegerAxisSwap;
-import com.gtnewhorizon.structurelib.util.Vec3Impl;
-import net.minecraft.util.StatCollector;
-import net.minecraft.util.Vec3;
-import net.minecraftforge.common.util.ForgeDirection;
-
-import java.util.*;
-
 import static com.gtnewhorizon.structurelib.alignment.IAlignment.FLIPS_COUNT;
 import static com.gtnewhorizon.structurelib.alignment.IAlignment.ROTATIONS_COUNT;
 import static java.lang.Math.abs;
 import static java.util.Arrays.stream;
 import static java.util.stream.Collectors.*;
 
+import com.google.common.collect.ImmutableSet;
+import com.gtnewhorizon.structurelib.alignment.IAlignment;
+import com.gtnewhorizon.structurelib.alignment.IntegerAxisSwap;
+import com.gtnewhorizon.structurelib.util.Vec3Impl;
+import java.util.*;
+import net.minecraft.util.StatCollector;
+import net.minecraft.util.Vec3;
+import net.minecraftforge.common.util.ForgeDirection;
+
 public enum ExtendedFacing {
     DOWN_NORMAL_NONE("down normal none"),
     DOWN_NORMAL_HORIZONTAL("down normal horizontal"),
@@ -120,20 +119,34 @@ public enum ExtendedFacing {
     public static final int STATES_COUNT = VALUES.length;
 
     static {
-        stream(values()).forEach(extendedFacing ->
-            FOR_FACING.compute(extendedFacing.direction, ((forgeDirection, extendedFacings) -> {
-                if (extendedFacings == null) {
-                    extendedFacings = new ArrayList<>();
-                }
-                extendedFacings.add(extendedFacing);
-                return extendedFacings;
-            })));
+        stream(values())
+                .forEach(extendedFacing ->
+                        FOR_FACING.compute(extendedFacing.direction, ((forgeDirection, extendedFacings) -> {
+                            if (extendedFacings == null) {
+                                extendedFacings = new ArrayList<>();
+                            }
+                            extendedFacings.add(extendedFacing);
+                            return extendedFacings;
+                        })));
     }
 
-    private static final Map<String, ExtendedFacing> NAME_LOOKUP = stream(VALUES).collect(toMap(ExtendedFacing::getName2, (extendedFacing) -> extendedFacing));
-    private static final EnumMap<ForgeDirection, ImmutableSet<ExtendedFacing>> LOOKUP_BY_DIRECTION = stream(VALUES).collect(groupingBy(ExtendedFacing::getDirection, () -> new EnumMap<>(ForgeDirection.class), collectingAndThen(toSet(), ImmutableSet::copyOf)));
-    private static final EnumMap<Rotation, ImmutableSet<ExtendedFacing>> LOOKUP_BY_ROTATION = stream(VALUES).collect(groupingBy(ExtendedFacing::getRotation, () -> new EnumMap<>(Rotation.class), collectingAndThen(toSet(), ImmutableSet::copyOf)));
-    private static final EnumMap<Flip, ImmutableSet<ExtendedFacing>> LOOKUP_BY_FLIP = stream(VALUES).collect(groupingBy(ExtendedFacing::getFlip, () -> new EnumMap<>(Flip.class), collectingAndThen(toSet(), ImmutableSet::copyOf)));
+    private static final Map<String, ExtendedFacing> NAME_LOOKUP =
+            stream(VALUES).collect(toMap(ExtendedFacing::getName2, (extendedFacing) -> extendedFacing));
+    private static final EnumMap<ForgeDirection, ImmutableSet<ExtendedFacing>> LOOKUP_BY_DIRECTION = stream(VALUES)
+            .collect(groupingBy(
+                    ExtendedFacing::getDirection,
+                    () -> new EnumMap<>(ForgeDirection.class),
+                    collectingAndThen(toSet(), ImmutableSet::copyOf)));
+    private static final EnumMap<Rotation, ImmutableSet<ExtendedFacing>> LOOKUP_BY_ROTATION = stream(VALUES)
+            .collect(groupingBy(
+                    ExtendedFacing::getRotation,
+                    () -> new EnumMap<>(Rotation.class),
+                    collectingAndThen(toSet(), ImmutableSet::copyOf)));
+    private static final EnumMap<Flip, ImmutableSet<ExtendedFacing>> LOOKUP_BY_FLIP = stream(VALUES)
+            .collect(groupingBy(
+                    ExtendedFacing::getFlip,
+                    () -> new EnumMap<>(Flip.class),
+                    collectingAndThen(toSet(), ImmutableSet::copyOf)));
     private final ForgeDirection direction;
     private final ForgeDirection a, b, c;
     private final Rotation rotation;
@@ -182,7 +195,7 @@ public enum ExtendedFacing {
             default:
                 throw new RuntimeException("Is impossible...");
         }
-        switch (flip) {//This duplicates some axis swaps since flip boolean would do, but seems more convenient to use
+        switch (flip) { // This duplicates some axis swaps since flip boolean would do, but seems more convenient to use
             case HORIZONTAL:
                 a = a.getOpposite();
                 break;
@@ -341,7 +354,6 @@ public enum ExtendedFacing {
         integerAxisSwap.inverseTranslate(point, out);
     }
 
-
     /**
      * Translates world offset  to  relative front facing offset
      *

src/main/java/com/gtnewhorizon/structurelib/alignment/enumerable/Flip.java

@@ -1,14 +1,14 @@
 package com.gtnewhorizon.structurelib.alignment.enumerable;
 
-import javax.annotation.Nonnull;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Random;
-
 import static java.lang.Math.abs;
 import static java.util.Arrays.stream;
 import static java.util.stream.Collectors.toMap;
 
+import java.util.Locale;
+import java.util.Map;
+import java.util.Random;
+import javax.annotation.Nonnull;
+
 public enum Flip {
     NONE(3, "none"),
     HORIZONTAL(2, "horizontal"),

src/main/java/com/gtnewhorizon/structurelib/alignment/enumerable/Rotation.java

@@ -1,14 +1,14 @@
 package com.gtnewhorizon.structurelib.alignment.enumerable;
 
-import javax.annotation.Nonnull;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Random;
-
 import static java.lang.Math.abs;
 import static java.util.Arrays.stream;
 import static java.util.stream.Collectors.toMap;
 
+import java.util.Locale;
+import java.util.Map;
+import java.util.Random;
+import javax.annotation.Nonnull;
+
 public enum Rotation {
     NORMAL(2, "normal"),
     CLOCKWISE(3, "clockwise"),
@@ -19,7 +19,8 @@ public enum Rotation {
     private final String name;
 
     public static final Rotation[] VALUES = values();
-    private static final Map<String, Rotation> NAME_LOOKUP = stream(VALUES).collect(toMap(Rotation::getName2, (rotation) -> rotation));
+    private static final Map<String, Rotation> NAME_LOOKUP =
+            stream(VALUES).collect(toMap(Rotation::getName2, (rotation) -> rotation));
 
     Rotation(int oppositeIn, String nameIn) {
         this.opposite = oppositeIn;

src/main/java/com/gtnewhorizon/structurelib/alignment/package-info.java

@@ -2,4 +2,4 @@
  * All public stuff in this package and its subpackages are considered part of the public API.
  * Backwards compatibility is maintained to the maximum extend possible.
  */
-package com.gtnewhorizon.structurelib.alignment;
+package com.gtnewhorizon.structurelib.alignment;

src/main/java/com/gtnewhorizon/structurelib/block/BlockHint.java

@@ -4,6 +4,7 @@ import com.gtnewhorizon.structurelib.StructureLib;
 import com.gtnewhorizon.structurelib.StructureLibAPI;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import java.util.List;
 import net.minecraft.block.Block;
 import net.minecraft.block.material.Material;
 import net.minecraft.client.renderer.texture.IIconRegister;
@@ -13,8 +14,6 @@ import net.minecraft.item.ItemStack;
 import net.minecraft.util.IIcon;
 import net.minecraft.world.IBlockAccess;
 
-import java.util.List;
-
 public class BlockHint extends Block {
     private static final IIcon[] hint = new IIcon[16];
 
@@ -26,7 +25,7 @@ public class BlockHint extends Block {
 
     @Override
     public void registerBlockIcons(IIconRegister aIconRegister) {
-        //super.registerBlockIcons(aIconRegister);
+        // super.registerBlockIcons(aIconRegister);
         hint[0] = aIconRegister.registerIcon(StructureLibAPI.MOD_ID + ":iconsets/HINT_0");
         hint[1] = aIconRegister.registerIcon(StructureLibAPI.MOD_ID + ":iconsets/HINT_1");
         hint[2] = aIconRegister.registerIcon(StructureLibAPI.MOD_ID + ":iconsets/HINT_2");

src/main/java/com/gtnewhorizon/structurelib/entity/fx/EntityFXBlockHint.java

@@ -1,7 +1,7 @@
 package com.gtnewhorizon.structurelib.entity.fx;
 
+import com.gtnewhorizon.structurelib.ClientProxy;
 import com.gtnewhorizon.structurelib.StructureLib;
-import com.gtnewhorizon.structurelib.proxy.ClientProxy;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
 import net.minecraft.block.Block;
@@ -59,7 +59,14 @@ public class EntityFXBlockHint extends EntityFX {
     }
 
     @Override
-    public void renderParticle(Tessellator tes, float subTickTime, float p_70539_3_, float p_70539_4_, float p_70539_5_, float p_70539_6_, float p_70539_7_) {
+    public void renderParticle(
+            Tessellator tes,
+            float subTickTime,
+            float p_70539_3_,
+            float p_70539_4_,
+            float p_70539_5_,
+            float p_70539_6_,
+            float p_70539_7_) {
         float size = .5f;
         float X = (float) (prevPosX + (posX - prevPosX) * (double) subTickTime - EntityFX.interpPosX);
         float Y = (float) (prevPosY + (posY - prevPosY) * (double) subTickTime - EntityFX.interpPosY) - size / 2;
@@ -68,8 +75,8 @@ public class EntityFXBlockHint extends EntityFX {
         GL11.glDepthMask(false);
         tes.setColorRGBA((int) (mRGBa[0] * .9F), (int) (mRGBa[1] * .95F), (int) (mRGBa[2] * 1F), 192);
 
-        //var8, var9 - X U
-        //var 10, var 11 - Y V
+        // var8, var9 - X U
+        // var 10, var 11 - Y V
         for (int i = 0; i < 6; i++) {
             if (icons[i] == null) {
                 continue;
@@ -78,7 +85,7 @@ public class EntityFXBlockHint extends EntityFX {
             double U = icons[i].getMaxU();
             double v = icons[i].getMinV();
             double V = icons[i].getMaxV();
-            switch (i) {//{DOWN, UP, NORTH, SOUTH, WEST, EAST}
+            switch (i) { // {DOWN, UP, NORTH, SOUTH, WEST, EAST}
                 case 0:
                     tes.addVertexWithUV(X, Y, Z + size, u, V);
                     tes.addVertexWithUV(X, Y, Z, u, v);

src/main/java/com/gtnewhorizon/structurelib/entity/fx/WeightlessParticleFX.java

@@ -7,7 +7,14 @@ import net.minecraft.world.World;
 
 @SideOnly(Side.CLIENT)
 public class WeightlessParticleFX extends EntityFX {
-    public WeightlessParticleFX(World p_i1205_1_, double p_i1205_2_, double p_i1205_4_, double p_i1205_6_, double p_i1205_8_, double p_i1205_10_, double p_i1205_12_) {
+    public WeightlessParticleFX(
+            World p_i1205_1_,
+            double p_i1205_2_,
+            double p_i1205_4_,
+            double p_i1205_6_,
+            double p_i1205_8_,
+            double p_i1205_10_,
+            double p_i1205_12_) {
         super(p_i1205_1_, p_i1205_2_, p_i1205_4_, p_i1205_6_, p_i1205_8_, p_i1205_10_, p_i1205_12_);
         this.motionX = p_i1205_8_ + (double) ((float) (Math.random() * 2.0D - 1.0D) * 0.05F);
         this.motionY = p_i1205_10_ + (double) ((float) (Math.random() * 2.0D - 1.0D) * 0.05F);
@@ -31,7 +38,7 @@ public class WeightlessParticleFX extends EntityFX {
         }
 
         this.setParticleTextureIndex(7 - this.particleAge * 8 / this.particleMaxAge);
-        //this.motionY += 0.004D;
+        // this.motionY += 0.004D;
         this.moveEntity(this.motionX, this.motionY, this.motionZ);
         this.motionX *= 0.8999999761581421D;
         this.motionY *= 0.8999999761581421D;

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

@@ -1,5 +1,8 @@
 package com.gtnewhorizon.structurelib.item;
 
+import static net.minecraft.util.StatCollector.translateToLocal;
+
+import java.util.List;
 import net.minecraft.block.Block;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.entity.player.EntityPlayer;
@@ -7,10 +10,6 @@ import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumChatFormatting;
 
-import java.util.List;
-
-import static net.minecraft.util.StatCollector.translateToLocal;
-
 public class ItemBlockHint extends ItemBlock {
     public ItemBlockHint(Block p_i45328_1_) {
         super(p_i45328_1_);
@@ -22,7 +21,7 @@ public class ItemBlockHint extends ItemBlock {
     @Override
     @SuppressWarnings("unchecked")
     public void addInformation(ItemStack aStack, EntityPlayer aPlayer, List aList, boolean aF3_H) {
-        aList.add(translateToLocal("structurelib.blockhint.desc.0"));//Helps while building
+        aList.add(translateToLocal("structurelib.blockhint.desc.0")); // Helps while building
         switch (aStack.getItemDamage()) {
             case 0:
             case 1:
@@ -36,21 +35,31 @@ public class ItemBlockHint extends ItemBlock {
             case 9:
             case 10:
             case 11:
-                aList.add(EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD + translateToLocal("structurelib.blockhint.desc.1"));//Placeholder for a certain group.
+                aList.add(EnumChatFormatting.AQUA.toString()
+                        + EnumChatFormatting.BOLD
+                        + translateToLocal("structurelib.blockhint.desc.1")); // Placeholder for a certain group.
                 break;
             case 12:
-                aList.add(EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD + translateToLocal("structurelib.blockhint.desc.2"));//General placeholder.
+                aList.add(EnumChatFormatting.AQUA.toString()
+                        + EnumChatFormatting.BOLD
+                        + translateToLocal("structurelib.blockhint.desc.2")); // General placeholder.
                 break;
             case 13:
-                aList.add(EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD + translateToLocal("structurelib.blockhint.desc.3"));//Make sure it contains Air material.
+                aList.add(EnumChatFormatting.AQUA.toString()
+                        + EnumChatFormatting.BOLD
+                        + translateToLocal("structurelib.blockhint.desc.3")); // Make sure it contains Air material.
                 break;
             case 14:
-                aList.add(EnumChatFormatting.AQUA.toString() + EnumChatFormatting.BOLD + translateToLocal("structurelib.blockhint.desc.4"));//Make sure it does not contain Air material.
+                aList.add(EnumChatFormatting.AQUA.toString()
+                        + EnumChatFormatting.BOLD
+                        + translateToLocal(
+                                "structurelib.blockhint.desc.4")); // Make sure it does not contain Air material.
                 break;
             case 15:
-                aList.add(EnumChatFormatting.BLUE.toString() + translateToLocal("structurelib.blockhint.desc.5"));//ERROR, what did u expect?
+                aList.add(EnumChatFormatting.BLUE.toString()
+                        + translateToLocal("structurelib.blockhint.desc.5")); // ERROR, what did u expect?
                 break;
-            default://WTF?
+            default: // WTF?
                 aList.add("Damn son where did you get that!?");
                 aList.add(EnumChatFormatting.BLUE.toString() + "From outer space... I guess...");
         }

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

@@ -1,18 +1,19 @@
 package com.gtnewhorizon.structurelib.item;
 
-import com.gtnewhorizon.structurelib.StructureLib;
-import com.gtnewhorizon.structurelib.alignment.constructable.ConstructableUtility;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.item.Item;
-import net.minecraft.item.ItemStack;
-import net.minecraft.world.World;
-
-import java.util.List;
-
 import static com.gtnewhorizon.structurelib.StructureLibAPI.MOD_ID;
 import static net.minecraft.util.EnumChatFormatting.BLUE;
 import static net.minecraft.util.StatCollector.translateToLocal;
 
+import com.gtnewhorizon.structurelib.StructureLib;
+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;
+
 public class ItemConstructableTrigger extends Item {
     public ItemConstructableTrigger() {
         setUnlocalizedName("structurelib.constructableTrigger");
@@ -21,17 +22,51 @@ public class ItemConstructableTrigger extends Item {
     }
 
     @Override
-    public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ) {
+    public boolean onItemUseFirst(
+            ItemStack stack,
+            EntityPlayer player,
+            World world,
+            int x,
+            int y,
+            int z,
+            int side,
+            float hitX,
+            float hitY,
+            float hitZ) {
         return ConstructableUtility.handle(stack, player, world, x, y, z, side);
     }
 
     @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
+        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);
+        }
     }
 }

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

@@ -1,20 +1,19 @@
 package com.gtnewhorizon.structurelib.item;
 
+import static com.gtnewhorizon.structurelib.StructureLibAPI.MOD_ID;
+import static net.minecraft.util.StatCollector.translateToLocal;
+
 import com.gtnewhorizon.structurelib.StructureLib;
 import com.gtnewhorizon.structurelib.alignment.AlignmentUtility;
 import cpw.mods.fml.relauncher.Side;
 import cpw.mods.fml.relauncher.SideOnly;
+import java.util.List;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumChatFormatting;
 import net.minecraft.world.World;
 
-import java.util.List;
-
-import static com.gtnewhorizon.structurelib.StructureLibAPI.MOD_ID;
-import static net.minecraft.util.StatCollector.translateToLocal;
-
 public class ItemFrontRotationTool extends Item {
     public ItemFrontRotationTool() {
         setMaxStackSize(1);
@@ -24,15 +23,27 @@ public class ItemFrontRotationTool extends Item {
     }
 
     @Override
-    public boolean onItemUseFirst(ItemStack stack, EntityPlayer player, World world, int x, int y, int z, int side, float hitX, float hitY, float hitZ) {
+    public boolean onItemUseFirst(
+            ItemStack stack,
+            EntityPlayer player,
+            World world,
+            int x,
+            int y,
+            int z,
+            int side,
+            float hitX,
+            float hitY,
+            float hitZ) {
         return AlignmentUtility.handle(player, world, x, y, z);
     }
 
     @Override
     @SideOnly(Side.CLIENT)
     public void addInformation(ItemStack p_77624_1_, EntityPlayer p_77624_2_, List aList, boolean p_77624_4_) {
-        aList.add(translateToLocal("item.structurelib.frontRotationTool.desc.0"));//Triggers Front Rotation Interface
-        aList.add(EnumChatFormatting.BLUE + translateToLocal("item.structurelib.frontRotationTool.desc.1"));//Rotates only the front panel,
-        aList.add(EnumChatFormatting.BLUE + translateToLocal("item.structurelib.frontRotationTool.desc.2"));//which allows structure rotation.
+        aList.add(translateToLocal("item.structurelib.frontRotationTool.desc.0")); // Triggers Front Rotation Interface
+        aList.add(EnumChatFormatting.BLUE
+                + translateToLocal("item.structurelib.frontRotationTool.desc.1")); // Rotates only the front panel,
+        aList.add(EnumChatFormatting.BLUE
+                + translateToLocal("item.structurelib.frontRotationTool.desc.2")); // which allows structure rotation.
     }
 }

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

@@ -21,8 +21,7 @@ public abstract class AlignmentMessage implements IMessage {
     int mPosD;
     int mAlign;
 
-    public AlignmentMessage() {
-    }
+    public AlignmentMessage() {}
 
     @Override
     public void fromBytes(ByteBuf pBuffer) {
@@ -47,11 +46,9 @@ public abstract class AlignmentMessage implements IMessage {
     }
 
     private AlignmentMessage(IAlignmentProvider provider) {
-        if (!(provider instanceof TileEntity))
-            throw new IllegalArgumentException("Provider must be a TileEntity");
+        if (!(provider instanceof TileEntity)) throw new IllegalArgumentException("Provider must be a TileEntity");
         IAlignment alignment = provider.getAlignment();
-        if (alignment == null)
-            throw new IllegalArgumentException("Passed in provider does not provide an alignment!");
+        if (alignment == null) throw new IllegalArgumentException("Passed in provider does not provide an alignment!");
         TileEntity base = (TileEntity) provider;
         mPosX = base.xCoord;
         mPosY = base.yCoord;
@@ -69,8 +66,7 @@ public abstract class AlignmentMessage implements IMessage {
     }
 
     public static class AlignmentQuery extends AlignmentMessage {
-        public AlignmentQuery() {
-        }
+        public AlignmentQuery() {}
 
         public AlignmentQuery(IAlignmentProvider provider) {
             super(provider);
@@ -82,8 +78,7 @@ public abstract class AlignmentMessage implements IMessage {
     }
 
     public static class AlignmentData extends AlignmentMessage {
-        public AlignmentData() {
-        }
+        public AlignmentData() {}
 
         private AlignmentData(AlignmentQuery query) {
             mPosX = query.mPosX;
@@ -106,7 +101,9 @@ public abstract class AlignmentMessage implements IMessage {
         @Override
         public IMessage onMessage(AlignmentData pMessage, MessageContext pCtx) {
             if (StructureLib.getCurrentPlayer().worldObj.provider.dimensionId == pMessage.mPosD) {
-                TileEntity te = StructureLib.getCurrentPlayer().worldObj.getTileEntity(pMessage.mPosX, pMessage.mPosY, pMessage.mPosZ);
+                TileEntity te = StructureLib.getCurrentPlayer()
+                        .worldObj
+                        .getTileEntity(pMessage.mPosX, pMessage.mPosY, pMessage.mPosZ);
                 if (te instanceof IAlignmentProvider) {
                     IAlignment alignment = ((IAlignmentProvider) te).getAlignment();
                     if (alignment != null) {
@@ -126,8 +123,7 @@ public abstract class AlignmentMessage implements IMessage {
                 TileEntity te = world.getTileEntity(pMessage.mPosX, pMessage.mPosY, pMessage.mPosZ);
                 if (te instanceof IAlignmentProvider) {
                     IAlignment alignment = ((IAlignmentProvider) te).getAlignment();
-                    if (alignment == null)
-                        return null;
+                    if (alignment == null) return null;
                     pMessage.mAlign = alignment.getExtendedFacing().getIndex();
                     return new AlignmentData(pMessage);
                 }
@@ -135,4 +131,4 @@ public abstract class AlignmentMessage implements IMessage {
             return null;
         }
     }
-}
+}

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

@@ -0,0 +1,77 @@
+package com.gtnewhorizon.structurelib.net;
+
+import static com.gtnewhorizon.structurelib.StructureLib.LOGGER;
+
+import com.gtnewhorizon.structurelib.StructureLib;
+import com.gtnewhorizon.structurelib.StructureLibAPI;
+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;
+
+public class UpdateHintParticleMessage implements IMessage {
+    private int x;
+    private short y;
+    private int z;
+    private short r;
+    private short g;
+    private short b;
+    private short a;
+
+    public UpdateHintParticleMessage() {}
+
+    public UpdateHintParticleMessage(int x, short y, int z, short r, short g, short b, short a) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+        this.r = r;
+        this.g = g;
+        this.b = b;
+        this.a = a;
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        x = buf.readInt();
+        y = buf.readShort();
+        z = buf.readInt();
+        r = buf.readUnsignedByte();
+        g = buf.readUnsignedByte();
+        b = buf.readUnsignedByte();
+        a = buf.readUnsignedByte();
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(x);
+        buf.writeShort(y);
+        buf.writeInt(z);
+        buf.writeByte(r);
+        buf.writeByte(g);
+        buf.writeByte(b);
+        buf.writeByte(a);
+    }
+
+    public static class Handler implements IMessageHandler<UpdateHintParticleMessage, IMessage> {
+        @Override
+        public IMessage onMessage(UpdateHintParticleMessage msg, MessageContext ctx) {
+            boolean updateResult = StructureLibAPI.updateHintParticleTint(
+                    StructureLib.getCurrentPlayer(),
+                    StructureLib.getCurrentPlayer().worldObj,
+                    msg.x,
+                    msg.y,
+                    msg.z,
+                    new short[] {
+                        msg.r, msg.g, msg.b, msg.a,
+                    });
+            if (StructureLib.DEBUG_MODE)
+                LOGGER.debug(
+                        "Server instructed to update hint particle at ({}, {}, {}), result {}!",
+                        msg.x,
+                        msg.y,
+                        msg.z,
+                        updateResult);
+            return null;
+        }
+    }
+}

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

@@ -1,41 +0,0 @@
-package com.gtnewhorizon.structurelib.proxy;
-
-import cpw.mods.fml.common.event.FMLPreInitializationEvent;
-import net.minecraft.block.Block;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.util.IIcon;
-import net.minecraft.world.World;
-
-public class CommonProxy {
-    public void hintParticleTinted(World w, int x, int y, int z, IIcon[] icons, short[] RGBa) {
-    }
-
-    public void hintParticleTinted(World w, int x, int y, int z, Block block, int meta, short[] RGBa) {
-    }
-
-    public void hintParticle(World w, int x, int y, int z, IIcon[] icons) {
-    }
-
-    public void hintParticle(World w, int x, int y, int z, Block block, int meta) {
-    }
-
-    public EntityPlayer getCurrentPlayer() {
-        return null;
-    }
-
-    public boolean isCurrentPlayer(EntityPlayer player) {
-        return false;
-    }
-
-    public void addClientSideChatMessages(String... messages) {
-    }
-
-    public void startHinting(World w) {
-    }
-
-    public void endHinting(World w) {
-    }
-
-    public void preInit(FMLPreInitializationEvent e) {
-    }
-}

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

@@ -0,0 +1,77 @@
+package com.gtnewhorizon.structurelib.structure;
+
+import com.gtnewhorizon.structurelib.util.InventoryIterable;
+import com.gtnewhorizon.structurelib.util.InventoryUtility;
+import com.gtnewhorizon.structurelib.util.ItemStackPredicate;
+import com.gtnewhorizon.structurelib.util.ItemStackPredicate.NBTMode;
+import java.util.Map;
+import java.util.function.Predicate;
+import javax.annotation.Nonnull;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+public interface IItemSource {
+    /**
+     * We are probably not going to need to get a lot of items from this method
+     * so I don't care about the overhead of storing all fetched items even if downstream code doesn't need it
+     */
+    @Nonnull
+    Map<ItemStack, Integer> take(Predicate<ItemStack> predicate, boolean simulate, int count);
+
+    default ItemStack takeOne(Predicate<ItemStack> predicate, boolean simulate) {
+        Map<ItemStack, Integer> take = take(predicate, simulate, 1);
+        return take.isEmpty() ? null : take.keySet().iterator().next();
+    }
+
+    default boolean takeAll(Predicate<ItemStack> predicate, boolean simulate, int count) {
+        // fast path for 1 item take requests
+        if (count == 1) return takeOne(predicate, simulate) != null;
+        Map<ItemStack, Integer> have = take(predicate, true, count);
+        if (have.values().stream().mapToInt(Integer::intValue).sum() < count) return false;
+        take(predicate, simulate, count);
+        return true;
+    }
+
+    default boolean takeOne(ItemStack stack, boolean simulate) {
+        if (stack == null || stack.getItem() == null || stack.stackSize != 1) throw new IllegalArgumentException();
+        ItemStack took = takeOne(ItemStackPredicate.from(stack, NBTMode.EXACT), simulate);
+        return took == null || took.stackSize <= 0;
+    }
+
+    default boolean takeAll(ItemStack stack, boolean simulate) {
+        // fast path for 1 item take requests
+        if (stack.stackSize == 1) return takeOne(stack, simulate);
+        ItemStackPredicate predicate = ItemStackPredicate.from(stack, NBTMode.EXACT);
+        Map<ItemStack, Integer> have = take(predicate, true, stack.stackSize);
+        if (have.values().stream().mapToInt(Integer::intValue).sum() < stack.stackSize) return false;
+        take(predicate, simulate, stack.stackSize);
+        return true;
+    }
+
+    static IItemSource fromPlayer(EntityPlayerMP player) {
+        return new IItemSource() {
+            @Nonnull
+            @Override
+            public Map<ItemStack, Integer> take(Predicate<ItemStack> p, boolean s, int c) {
+                return InventoryUtility.takeFromInventory(player, p, s, c);
+            }
+
+            @Override
+            public boolean takeOne(ItemStack stack, boolean simulate) {
+                if (stack == null || stack.getItem() == null || stack.stackSize != 1)
+                    throw new IllegalArgumentException();
+                return InventoryUtility.takeFromInventory(player, stack, simulate) == 1;
+            }
+
+            @Override
+            public boolean takeAll(ItemStack stack, boolean simulate) {
+                return InventoryUtility.takeFromInventory(player, stack, simulate) == stack.stackSize;
+            }
+        };
+    }
+
+    static IItemSource fromInventory(IInventory inv) {
+        return (p, s, c) -> InventoryUtility.takeFromInventory(new InventoryIterable<>(inv), p, s, c, true);
+    }
+}

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

@@ -0,0 +1,7 @@
+package com.gtnewhorizon.structurelib.structure;
+
+import net.minecraft.block.Block;
+
+public interface ISpecialItemBlock {
+    int getItemMetaFromBlockMeta(Block block, int blockMeta);
+}

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

@@ -1,14 +1,14 @@
 package com.gtnewhorizon.structurelib.structure;
 
+import static com.gtnewhorizon.structurelib.StructureLib.DEBUG_MODE;
+
 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;
 
-import java.util.Arrays;
-
-import static com.gtnewhorizon.structurelib.StructureLib.DEBUG_MODE;
-
 public interface IStructureDefinition<T> {
     /**
      * Used internally
@@ -21,50 +21,187 @@ public interface IStructureDefinition<T> {
      */
     IStructureElement<T>[] getStructureFor(String name);
 
-    default boolean check(T object, String piece, World world, ExtendedFacing extendedFacing,
-                          int basePositionX, int basePositionY, int basePositionZ,
-                          int basePositionA, int basePositionB, int basePositionC,
-                          boolean forceCheckAllBlocks) {
-        return iterate(object, null, getStructureFor(piece), world, extendedFacing, basePositionX, basePositionY, basePositionZ,
-            basePositionA, basePositionB, basePositionC, false, forceCheckAllBlocks);
+    default boolean check(
+            T object,
+            String piece,
+            World world,
+            ExtendedFacing extendedFacing,
+            int basePositionX,
+            int basePositionY,
+            int basePositionZ,
+            int basePositionA,
+            int basePositionB,
+            int basePositionC,
+            boolean forceCheckAllBlocks) {
+        return iterate(
+                object,
+                null,
+                getStructureFor(piece),
+                world,
+                extendedFacing,
+                basePositionX,
+                basePositionY,
+                basePositionZ,
+                basePositionA,
+                basePositionB,
+                basePositionC,
+                false,
+                forceCheckAllBlocks);
     }
 
-    default boolean hints(T object, ItemStack trigger, String piece, World world, ExtendedFacing extendedFacing,
-                          int basePositionX, int basePositionY, int basePositionZ,
-                          int basePositionA, int basePositionB, int basePositionC) {
-        return iterate(object, trigger, getStructureFor(piece), world, extendedFacing, basePositionX, basePositionY, basePositionZ,
-            basePositionA, basePositionB, basePositionC, true, null);
+    default boolean hints(
+            T object,
+            ItemStack trigger,
+            String piece,
+            World world,
+            ExtendedFacing extendedFacing,
+            int basePositionX,
+            int basePositionY,
+            int basePositionZ,
+            int basePositionA,
+            int basePositionB,
+            int basePositionC) {
+        return iterate(
+                object,
+                trigger,
+                getStructureFor(piece),
+                world,
+                extendedFacing,
+                basePositionX,
+                basePositionY,
+                basePositionZ,
+                basePositionA,
+                basePositionB,
+                basePositionC,
+                true,
+                null);
     }
 
-    default boolean build(T object, ItemStack trigger, String piece, World world, ExtendedFacing extendedFacing,
-                          int basePositionX, int basePositionY, int basePositionZ,
-                          int basePositionA, int basePositionB, int basePositionC) {
-        return iterate(object, trigger, getStructureFor(piece), world, extendedFacing, basePositionX, basePositionY, basePositionZ,
-            basePositionA, basePositionB, basePositionC, false, null);
+    default boolean build(
+            T object,
+            ItemStack trigger,
+            String piece,
+            World world,
+            ExtendedFacing extendedFacing,
+            int basePositionX,
+            int basePositionY,
+            int basePositionZ,
+            int basePositionA,
+            int basePositionB,
+            int basePositionC) {
+        return iterate(
+                object,
+                trigger,
+                getStructureFor(piece),
+                world,
+                extendedFacing,
+                basePositionX,
+                basePositionY,
+                basePositionZ,
+                basePositionA,
+                basePositionB,
+                basePositionC,
+                false,
+                null);
     }
 
-    default boolean buildOrHints(T object, ItemStack trigger, String piece, World world, ExtendedFacing extendedFacing,
-                                 int basePositionX, int basePositionY, int basePositionZ,
-                                 int basePositionA, int basePositionB, int basePositionC,
-                                 boolean hintsOnly) {
-        return iterate(object, trigger, getStructureFor(piece), world, extendedFacing, basePositionX, basePositionY, basePositionZ,
-            basePositionA, basePositionB, basePositionC, hintsOnly, null);
+    default boolean buildOrHints(
+            T object,
+            ItemStack trigger,
+            String piece,
+            World world,
+            ExtendedFacing extendedFacing,
+            int basePositionX,
+            int basePositionY,
+            int basePositionZ,
+            int basePositionA,
+            int basePositionB,
+            int basePositionC,
+            boolean hintsOnly) {
+        return iterate(
+                object,
+                trigger,
+                getStructureFor(piece),
+                world,
+                extendedFacing,
+                basePositionX,
+                basePositionY,
+                basePositionZ,
+                basePositionA,
+                basePositionB,
+                basePositionC,
+                hintsOnly,
+                null);
     }
 
-    static <T> boolean iterate(T object, ItemStack trigger, IStructureElement<T>[] elements, World world, ExtendedFacing extendedFacing,
-                               int basePositionX, int basePositionY, int basePositionZ,
-                               int basePositionA, int basePositionB, int basePositionC,
-                               boolean hintsOnly, Boolean checkBlocksIfNotNullForceCheckAllIfTrue) {
+    /**
+     * @param elementBudget build up to this many elements
+     * @param source        from where to drain resource
+     * @param actor         source of action
+     * @param check         whether {@link IStructureElement#check(Object, World, int, int, int)} should be called if anything
+     *                      would be placed. use with caution.
+     *                      if in doubt, call {@link #check(Object, String, World, ExtendedFacing, int, int, int, int, int, int, boolean)}
+     *                      after this call and set this parameter to false
+     * @return number of elements built, or -1 if structure done
+     * @see #build(Object, ItemStack, String, World, ExtendedFacing, int, int, int, int, int, int)
+     */
+    default int survivalBuild(
+            T object,
+            ItemStack trigger,
+            String piece,
+            World world,
+            ExtendedFacing extendedFacing,
+            int basePositionX,
+            int basePositionY,
+            int basePositionZ,
+            int basePositionA,
+            int basePositionB,
+            int basePositionC,
+            int elementBudget,
+            IItemSource source,
+            EntityPlayerMP actor,
+            boolean check) {
+        SurvivalBuildStructureWalker<T> walker =
+                new SurvivalBuildStructureWalker<>(object, trigger, source, actor, elementBudget, check);
+        StructureUtility.iterateV2(
+                getStructureFor(piece),
+                world,
+                extendedFacing,
+                basePositionX,
+                basePositionY,
+                basePositionZ,
+                basePositionA,
+                basePositionB,
+                basePositionC,
+                walker,
+                "survivalBuild");
+        return walker.getBuilt();
+    }
+
+    static <T> boolean iterate(
+            T object,
+            ItemStack trigger,
+            IStructureElement<T>[] elements,
+            World world,
+            ExtendedFacing extendedFacing,
+            int basePositionX,
+            int basePositionY,
+            int basePositionZ,
+            int basePositionA,
+            int basePositionB,
+            int basePositionC,
+            boolean hintsOnly,
+            Boolean checkBlocksIfNotNullForceCheckAllIfTrue) {
         if (world.isRemote ^ hintsOnly) {
             return false;
         }
 
-        //change base position to base offset
+        // change base position to base offset
         basePositionA = -basePositionA;
         basePositionB = -basePositionB;
         basePositionC = -basePositionC;
 
-        int[] abc = new int[]{basePositionA, basePositionB, basePositionC};
+        int[] abc = new int[] {basePositionA, basePositionB, basePositionC};
         int[] xyz = new int[3];
 
         if (checkBlocksIfNotNullForceCheckAllIfTrue != null) {
@@ -80,18 +217,28 @@ public interface IStructureDefinition<T> {
                         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));
+                                    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));
+                                StructureLib.LOGGER.info("Multi [" + basePositionX + ", " + basePositionY + ", "
+                                        + basePositionZ + "] !blockExists @ " + Arrays.toString(xyz) + " "
+                                        + Arrays.toString(abc));
                             }
                             return false;
                         }
@@ -110,18 +257,28 @@ public interface IStructureDefinition<T> {
                         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));
+                                    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));
+                                StructureLib.LOGGER.info("Multi [" + basePositionX + ", " + basePositionY + ", "
+                                        + basePositionZ + "] !blockExists @ " + Arrays.toString(xyz) + " "
+                                        + Arrays.toString(abc));
                             }
                         }
                         abc[0] += 1;
@@ -129,7 +286,8 @@ public interface IStructureDefinition<T> {
                 }
             }
             if (DEBUG_MODE) {
-                StructureLib.LOGGER.info("Multi [" + basePositionX + ", " + basePositionY + ", " + basePositionZ + "] pass");
+                StructureLib.LOGGER.info(
+                        "Multi [" + basePositionX + ", " + basePositionY + ", " + basePositionZ + "] pass");
             }
         } else {
             if (hintsOnly) {

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

@@ -1,6 +1,14 @@
 package com.gtnewhorizon.structurelib.structure;
 
+import static com.gtnewhorizon.structurelib.StructureLib.DEBUG_MODE;
+import static com.gtnewhorizon.structurelib.StructureLib.LOGGER;
+import static com.gtnewhorizon.structurelib.StructureLib.PANIC_MODE;
+
+import com.gtnewhorizon.structurelib.StructureLibAPI;
+import java.util.function.Consumer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.IChatComponent;
 import net.minecraft.world.World;
 
 /**
@@ -13,6 +21,50 @@ public interface IStructureElement<T> {
 
     boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger);
 
+    /**
+     * Try place the block by taking resource from given IItemSource.
+     *
+     * @param s       drain resources from this place
+     * @param actor   source of action.
+     * @param chatter
+     */
+    default PlaceResult survivalPlaceBlock(
+            T t,
+            World world,
+            int x,
+            int y,
+            int z,
+            ItemStack trigger,
+            IItemSource s,
+            EntityPlayerMP actor,
+            Consumer<IChatComponent> chatter) {
+        if (PANIC_MODE) throw new RuntimeException("Panic Tripwire hit");
+        if (DEBUG_MODE)
+            LOGGER.error(
+                    "Default implementation of survivalPlaceBlock hit! Things aren't going to work well! IStructureElement class: {}",
+                    getClass().getName());
+        if (!StructureLibAPI.isBlockTriviallyReplaceable(world, x, y, z, actor)) return PlaceResult.REJECT;
+        return PlaceResult.SKIP;
+    }
+
+    /**
+     * Forget the messed up class dependency graph for now. this is just so convenient.
+     */
+    default IStructureElementNoPlacement<T> noPlacement() {
+        return new IStructureElementNoPlacement<T>() {
+
+            @Override
+            public boolean check(T t, World world, int x, int y, int z) {
+                return IStructureElement.this.check(t, world, x, y, z);
+            }
+
+            @Override
+            public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
+                return IStructureElement.this.spawnHint(t, world, x, y, z, trigger);
+            }
+        };
+    }
+
     default int getStepA() {
         return 1;
     }
@@ -40,4 +92,31 @@ public interface IStructureElement<T> {
     default boolean isNavigating() {
         return false;
     }
+
+    enum PlaceResult {
+        /**
+         * This element either exists already, or does not yet have an implementation for survivalPlaceBlock, or
+         * some other unforeseen situations.
+         */
+        SKIP,
+        /**
+         * This element's space is occupied by other stuff and require player attention, or player missing required resource,
+         * or the block cannot be placed due to obscure mechanisms, or some other unforeseen situations.
+         */
+        REJECT,
+        /**
+         * Autoplace cannot proceed within this tick. To proceed further would require stopping the placement and wait for next round.
+         */
+        STOP,
+        /**
+         * Element placed successfully.
+         */
+        ACCEPT,
+        /**
+         * Combination of ACCEPT and STOP.
+         *
+         * Element placed successfully. To proceed further would require stopping the placement and wait for next round.
+         */
+        ACCEPT_STOP;
+    }
 }

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

@@ -1,6 +1,11 @@
 package com.gtnewhorizon.structurelib.structure;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.IChatComponent;
 import net.minecraft.world.World;
 
 /**
@@ -38,4 +43,35 @@ public interface IStructureElementChain<T> extends IStructureElement<T> {
         }
         return false;
     }
+
+    @Override
+    default PlaceResult survivalPlaceBlock(
+            T t,
+            World world,
+            int x,
+            int y,
+            int z,
+            ItemStack trigger,
+            IItemSource s,
+            EntityPlayerMP actor,
+            Consumer<IChatComponent> chatter) {
+        boolean haveSkip = false;
+        List<IChatComponent> bufferedNoise = new ArrayList<>();
+        for (IStructureElement<T> fallback : fallbacks()) {
+            PlaceResult result = fallback.survivalPlaceBlock(t, world, x, y, z, trigger, s, actor, bufferedNoise::add);
+            switch (result) {
+                case REJECT:
+                    break;
+                case SKIP:
+                    haveSkip = true;
+                    break;
+                default:
+                    return result;
+            }
+        }
+        // dump all that noise back into upstream
+        bufferedNoise.forEach(chatter);
+        // TODO need reconsider to ensure this is the right course of action
+        return haveSkip ? PlaceResult.SKIP : PlaceResult.REJECT;
+    }
 }

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

@@ -1,6 +1,9 @@
 package com.gtnewhorizon.structurelib.structure;
 
+import java.util.function.Consumer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.IChatComponent;
 import net.minecraft.world.World;
 
 public interface IStructureElementCheckOnly<T> extends IStructureElement<T> {
@@ -13,4 +16,18 @@ public interface IStructureElementCheckOnly<T> extends IStructureElement<T> {
     default boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
         return false;
     }
+
+    @Override
+    default PlaceResult survivalPlaceBlock(
+            T t,
+            World world,
+            int x,
+            int y,
+            int z,
+            ItemStack trigger,
+            IItemSource s,
+            EntityPlayerMP actor,
+            Consumer<IChatComponent> chatter) {
+        return PlaceResult.SKIP;
+    }
 }

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

@@ -3,5 +3,4 @@ package com.gtnewhorizon.structurelib.structure;
 /**
  * Use StructureUtility to instantiate
  */
-public interface IStructureElementDeferred<T> extends IStructureElement<T> {
-}
+public interface IStructureElementDeferred<T> extends IStructureElement<T> {}

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

@@ -1,6 +1,9 @@
 package com.gtnewhorizon.structurelib.structure;
 
+import java.util.function.Consumer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.IChatComponent;
 import net.minecraft.world.World;
 
 public interface IStructureElementNoPlacement<T> extends IStructureElement<T> {
@@ -8,4 +11,23 @@ public interface IStructureElementNoPlacement<T> extends IStructureElement<T> {
     default boolean placeBlock(T t, World world, int x, int y, int z, ItemStack trigger) {
         return false;
     }
+
+    @Override
+    default PlaceResult survivalPlaceBlock(
+            T t,
+            World world,
+            int x,
+            int y,
+            int z,
+            ItemStack trigger,
+            IItemSource s,
+            EntityPlayerMP actor,
+            Consumer<IChatComponent> chatter) {
+        return PlaceResult.REJECT;
+    }
+
+    @Override
+    default IStructureElementNoPlacement<T> noPlacement() {
+        return this;
+    }
 }

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

@@ -1,6 +1,9 @@
 package com.gtnewhorizon.structurelib.structure;
 
+import java.util.function.Consumer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.ItemStack;
+import net.minecraft.util.IChatComponent;
 import net.minecraft.world.World;
 
 /**
@@ -22,6 +25,20 @@ interface IStructureNavigate<T> extends IStructureElement<T> {
         return true;
     }
 
+    @Override
+    default PlaceResult survivalPlaceBlock(
+            T t,
+            World world,
+            int x,
+            int y,
+            int z,
+            ItemStack trigger,
+            IItemSource s,
+            EntityPlayerMP actor,
+            Consumer<IChatComponent> chatter) {
+        return PlaceResult.SKIP;
+    }
+
     default boolean isNavigating() {
         return true;
     }

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

@@ -0,0 +1,7 @@
+package com.gtnewhorizon.structurelib.structure;
+
+import net.minecraft.world.World;
+
+public interface IStructureWalker<T> {
+    boolean visit(IStructureElement<T> element, World world, int x, int y, int z);
+}

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

@@ -1,9 +1,11 @@
 package com.gtnewhorizon.structurelib.structure;
 
-import net.minecraft.item.ItemStack;
-import net.minecraft.world.World;
-
+import java.util.function.Consumer;
 import java.util.function.Function;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.IChatComponent;
+import net.minecraft.world.World;
 
 class LazyStructureElement<T> implements IStructureElementDeferred<T> {
     private Function<T, IStructureElement<T>> to;
@@ -35,4 +37,18 @@ class LazyStructureElement<T> implements IStructureElementDeferred<T> {
     public boolean spawnHint(T t, World world, int x, int y, int z, ItemStack trigger) {
         return get(t).spawnHint(t, world, x, y, z, trigger);
     }
+
+    @Override
+    public PlaceResult survivalPlaceBlock(
+            T t,
+            World world,
+            int x,
+            int y,
+            int z,
+            ItemStack trigger,
+            IItemSource s,
+            EntityPlayerMP actor,
+            Consumer<IChatComponent> chatter) {
+        return get(t).survivalPlaceBlock(t, world, x, y, z, trigger, s, actor, chatter);
+    }
 }

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

@@ -1,13 +1,12 @@
 package com.gtnewhorizon.structurelib.structure;
 
-import com.gtnewhorizon.structurelib.util.Vec3Impl;
-
-import java.util.*;
-import java.util.stream.Collectors;
-
 import static com.gtnewhorizon.structurelib.StructureLib.DEBUG_MODE;
 import static com.gtnewhorizon.structurelib.structure.StructureUtility.*;
 
+import com.gtnewhorizon.structurelib.util.Vec3Impl;
+import java.util.*;
+import java.util.stream.Collectors;
+
 public class StructureDefinition<T> implements IStructureDefinition<T> {
     private final Map<Character, IStructureElement<T>> elements;
     private final Map<String, String> shapes;
@@ -18,9 +17,9 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
     }
 
     private StructureDefinition(
-        Map<Character, IStructureElement<T>> elements,
-        Map<String, String> shapes,
-        Map<String, IStructureElement<T>[]> structures) {
+            Map<Character, IStructureElement<T>> elements,
+            Map<String, String> shapes,
+            Map<String, IStructureElement<T>[]> structures) {
         this.elements = elements;
         this.shapes = shapes;
         this.structures = structures;
@@ -142,17 +141,15 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
         private Map<String, IStructureElement<T>[]> compileElementSetMap() {
             Set<Integer> missing = findMissing();
             if (missing.isEmpty()) {
-                return shapes.entrySet().stream()
-                    .collect(Collectors.toMap(Map.Entry::getKey,
-                        e -> e.getValue().chars()
-                            .mapToObj(c -> (char) c)
-                            .distinct()
-                            .map(elements::get)
-                            .toArray(IStructureElement[]::new)
-                    ));
+                return shapes.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue()
+                        .chars()
+                        .mapToObj(c -> (char) c)
+                        .distinct()
+                        .map(elements::get)
+                        .toArray(IStructureElement[]::new)));
             } else {
-                throw new RuntimeException("Missing Structure Element bindings for (chars as integers): " +
-                    Arrays.toString(missing.toArray()));
+                throw new RuntimeException("Missing Structure Element bindings for (chars as integers): "
+                        + Arrays.toString(missing.toArray()));
             }
         }
 
@@ -160,22 +157,22 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
         private Map<String, IStructureElement<T>[]> compileStructureMap() {
             Set<Integer> missing = findMissing();
             if (missing.isEmpty()) {
-                return shapes.entrySet().stream()
-                    .collect(Collectors.toMap(Map.Entry::getKey,
-                        e -> e.getValue().chars().mapToObj(c -> elements.get((char) c)).toArray(IStructureElement[]::new)
-                    ));
+                return shapes.entrySet().stream().collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue()
+                        .chars()
+                        .mapToObj(c -> elements.get((char) c))
+                        .toArray(IStructureElement[]::new)));
             } else {
-                throw new RuntimeException("Missing Structure Element bindings for (chars as integers): " +
-                    Arrays.toString(missing.toArray()));
+                throw new RuntimeException("Missing Structure Element bindings for (chars as integers): "
+                        + Arrays.toString(missing.toArray()));
             }
         }
 
         private Set<Integer> findMissing() {
             return shapes.values().stream()
-                .flatMapToInt(CharSequence::chars)
-                .filter(i -> !elements.containsKey((char) i))
-                .boxed()
-                .collect(Collectors.toSet());
+                    .flatMapToInt(CharSequence::chars)
+                    .filter(i -> !elements.containsKey((char) i))
+                    .boxed()
+                    .collect(Collectors.toSet());
         }
     }
 
@@ -194,8 +191,7 @@ public class StructureDefinition<T> implements IStructureDefinition<T> {
     @Override
     public IStructureElement<T>[] getStructureFor(String name) {
         IStructureElement<T>[] elements = structures.get(name);
-        if (elements == null)
-            throw new NoSuchElementException(name);
+        if (elements == null) throw new NoSuchElementException(name);
         return elements;
     }
 }

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

@@ -0,0 +1,58 @@
+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;
+import net.minecraft.world.World;
+
+class SurvivalBuildStructureWalker<T> implements IStructureWalker<T> {
+    private final T object;
+    private final ItemStack trigger;
+    private final IItemSource source;
+    private final EntityPlayerMP actor;
+    private final int elementBudget;
+    private final boolean check;
+    private int built = -1;
+
+    public SurvivalBuildStructureWalker(
+            T object, ItemStack trigger, IItemSource source, EntityPlayerMP actor, int elementBudget, boolean check) {
+        this.object = object;
+        this.trigger = trigger;
+        this.source = source;
+        this.actor = actor;
+        this.elementBudget = elementBudget;
+        this.check = check;
+    }
+
+    @Override
+    public boolean visit(IStructureElement<T> element, World world, int x, int y, int z) {
+        PlaceResult placeResult = element.survivalPlaceBlock(
+                object, world, x, y, z, trigger, source, actor, actor::addChatComponentMessage);
+        if (placeResult != PlaceResult.SKIP && built == -1) built = 0;
+        switch (placeResult) {
+            case SKIP:
+                return true;
+            case ACCEPT:
+                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});
+                return false;
+            case ACCEPT_STOP:
+                if (check) element.check(object, world, x, y, z);
+                built += 1;
+                // intentional fallthrough
+            case STOP:
+                return false;
+            default:
+                throw new NullPointerException();
+        }
+    }
+
+    public int getBuilt() {
+        return built;
+    }
+}

src/main/java/com/gtnewhorizon/structurelib/structure/adders/IBlockAdder.java

@@ -1,6 +1,5 @@
 package com.gtnewhorizon.structurelib.structure.adders;
 
-
 import net.minecraft.block.Block;
 
 public interface IBlockAdder<T> {

src/main/java/com/gtnewhorizon/structurelib/structure/package-info.java

@@ -2,4 +2,4 @@
  * All public stuff in this package and its subpackages are considered part of the public API.
  * Backwards compatibility is maintained to the maximum extend possible.
  */
-package com.gtnewhorizon.structurelib.structure;
+package com.gtnewhorizon.structurelib.structure;

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

@@ -0,0 +1,47 @@
+package com.gtnewhorizon.structurelib.util;
+
+import java.util.Iterator;
+import java.util.NoSuchElementException;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.item.ItemStack;
+
+public class InventoryIterable<Inv extends IInventory> implements Iterable<ItemStack> {
+    private final Inv inv;
+    private final int maxSlot;
+
+    public InventoryIterable(Inv inv) {
+        this(inv, -1);
+    }
+
+    InventoryIterable(Inv inv, int maxSlot) {
+        this.inv = inv;
+        this.maxSlot = maxSlot;
+    }
+
+    public Inv getInventory() {
+        return inv;
+    }
+
+    @Override
+    public Iterator<ItemStack> iterator() {
+        return new Iterator<ItemStack>() {
+            private int ptr = 0;
+
+            @Override
+            public boolean hasNext() {
+                return ptr < inv.getSizeInventory() && (maxSlot == -1 || ptr < maxSlot);
+            }
+
+            @Override
+            public ItemStack next() {
+                if (!hasNext()) throw new NoSuchElementException();
+                return inv.getStackInSlot(ptr++);
+            }
+
+            @Override
+            public void remove() {
+                inv.setInventorySlotContents(ptr - 1, null);
+            }
+        };
+    }
+}

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

@@ -0,0 +1,390 @@
+/**
+ * Copyright (c) 2022, glee8e
+ * This file is part of StructureLib.
+ * <p>
+ * StructureLib 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 of the License, or
+ * (at your option) any later version.
+ * <p>
+ * StructureLib 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.
+ * <p>
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with Foobar; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+ */
+package com.gtnewhorizon.structurelib.util;
+
+import com.gtnewhorizon.structurelib.util.InventoryUtility.ItemStackExtractor.APIType;
+import com.gtnewhorizon.structurelib.util.ItemStackPredicate.NBTMode;
+import java.util.*;
+import java.util.concurrent.CopyOnWriteArrayList;
+import java.util.function.Function;
+import java.util.function.Predicate;
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.init.Items;
+import net.minecraft.inventory.IInventory;
+import net.minecraft.inventory.InventoryEnderChest;
+import net.minecraft.item.ItemStack;
+
+/**
+ * This class is part of API, but is not stable. Use at your own risk.
+ */
+public class InventoryUtility {
+    private static final SortedRegistry<ItemStackExtractor> stackExtractors = new SortedRegistry<>();
+    private static final List<Predicate<? super EntityPlayerMP>> enableEnder = new CopyOnWriteArrayList<>();
+    /**
+     * The remove() of the Iterable returned must be implemented!
+     */
+    private static final SortedRegistry<InventoryProvider<?>> inventoryProviders = new SortedRegistry<>();
+
+    static {
+        inventoryProviders.register("5000-main-inventory", new InventoryProvider<InventoryIterable<InventoryPlayer>>() {
+            @Override
+            public InventoryIterable<InventoryPlayer> getInventory(EntityPlayerMP player) {
+                return new InventoryIterable<>(player.inventory, player.inventory.mainInventory.length);
+            }
+
+            @Override
+            public void markDirty(InventoryIterable<InventoryPlayer> inv) {
+                // player save its content using means other than inv.markDirty()
+                // here we only need to sync it to client
+                inv.getInventory().player.inventoryContainer.detectAndSendChanges();
+            }
+        });
+        inventoryProviders.register(
+                "7000-ender-inventory", new InventoryProvider<InventoryIterable<InventoryEnderChest>>() {
+                    @Override
+                    public InventoryIterable<InventoryEnderChest> getInventory(EntityPlayerMP player) {
+                        if (enableEnder.stream().anyMatch(p -> p.test(player)))
+                            return new InventoryIterable<>(player.getInventoryEnderChest());
+                        return null;
+                    }
+
+                    @Override
+                    public void markDirty(InventoryIterable<InventoryEnderChest> inv) {
+                        // inv.getInventory().markDirty();
+                        // TODO this seems to be a noop
+                    }
+                });
+    }
+
+    public static void registerEnableEnderCondition(Predicate<? super EntityPlayerMP> predicate) {
+        enableEnder.add(predicate);
+    }
+
+    public static void registerStackExtractor(String key, ItemStackExtractor val) {
+        if (Arrays.stream(APIType.values()).noneMatch(val::isAPIImplemented))
+            throw new IllegalArgumentException("Must implement at least one API");
+        stackExtractors.register(key, val);
+    }
+
+    public static <Inv extends IInventory> void registerStackExtractor(
+            String key, Function<ItemStack, ? extends Inv> extractor) {
+        registerStackExtractor(key, newItemStackProvider(extractor));
+    }
+
+    public static void registerInventoryProvider(String key, InventoryProvider<?> val) {
+        inventoryProviders.register(key, val);
+    }
+
+    public static <Inv extends IInventory> void registerInventoryProvider(
+            String key, Function<EntityPlayerMP, ? extends Inv> extractor) {
+        registerInventoryProvider(key, newInventoryProvider(extractor));
+    }
+
+    public static Iterator<? extends ItemStackExtractor> getStackExtractors() {
+        return stackExtractors.iterator();
+    }
+
+    public static <Inv extends IInventory> InventoryProvider<InventoryIterable<Inv>> newInventoryProvider(
+            Function<EntityPlayerMP, ? extends Inv> extractor) {
+        return new InventoryProvider<InventoryIterable<Inv>>() {
+            @Override
+            public InventoryIterable<Inv> getInventory(EntityPlayerMP player) {
+                Inv inv = extractor.apply(player);
+                return inv != null ? new InventoryIterable<>(inv) : null;
+            }
+
+            @Override
+            public void markDirty(InventoryIterable<Inv> inv) {
+                inv.getInventory().markDirty();
+            }
+        };
+    }
+
+    public static ItemStackExtractor newItemStackProvider(Function<ItemStack, ? extends IInventory> extractor) {
+        return new ItemStackExtractor() {
+            @Override
+            public boolean isAPIImplemented(APIType type) {
+                return type == APIType.MAIN;
+            }
+
+            @Override
+            public int takeFromStack(
+                    Predicate<ItemStack> predicate,
+                    boolean simulate,
+                    int count,
+                    ItemStackCounter store,
+                    ItemStack stack,
+                    ItemStack filter,
+                    EntityPlayerMP player) {
+                IInventory inv = extractor.apply(stack);
+                if (inv == null) return 0;
+                int found = takeFromInventory(
+                        new InventoryIterable<>(inv), predicate, simulate, count, store, filter, player, false);
+                if (found > 0) inv.markDirty();
+                return found;
+            }
+        };
+    }
+
+    /**
+     * take count amount of stacks that matches given filter. might take partial amount of stuff, so simulation is suggested
+     * if you ever need to take more than one.
+     *
+     * @param player    source of stacks
+     * @param predicate item stack filter
+     * @param simulate  whether to do removal
+     * @param count     let's hope int size is enough...
+     * @return amount taken. never negative nor bigger than count...
+     */
+    public static Map<ItemStack, Integer> takeFromInventory(
+            EntityPlayerMP player, Predicate<ItemStack> predicate, boolean simulate, int count) {
+        ItemStackCounterImpl store = new ItemStackCounterImpl();
+        int sum = 0;
+        for (InventoryProvider<?> provider : inventoryProviders) {
+            sum += takeFromPlayer(player, predicate, simulate, count - sum, store, provider, null);
+            if (sum >= count) return store.getStore();
+        }
+        return store.getStore();
+    }
+
+    /**
+     * take count amount of stacks that matches given filter. might take partial amount of stuff, so simulation is suggested
+     * if you ever need to take more than one.
+     *
+     * @param player   source of stacks
+     * @param filter   the precise type of item to extract. stackSize matters
+     * @param simulate whether to do removal
+     * @return amount taken. never negative nor bigger than count...
+     */
+    public static int takeFromInventory(EntityPlayerMP player, ItemStack filter, boolean simulate) {
+        int sum = 0;
+        int count = filter.stackSize;
+        ItemStackPredicate predicate = ItemStackPredicate.from(filter, NBTMode.EXACT);
+        ItemStackCounterImpl store = new ItemStackCounterImpl();
+        for (InventoryProvider<?> provider : inventoryProviders) {
+            sum += takeFromPlayer(player, predicate, simulate, count - sum, store, provider, filter);
+            if (sum >= count) return sum;
+        }
+        return sum;
+    }
+
+    // workaround java generics issue
+    private static <R extends Iterable<ItemStack>> int takeFromPlayer(
+            EntityPlayerMP player,
+            Predicate<ItemStack> predicate,
+            boolean simulate,
+            int count,
+            ItemStackCounterImpl store,
+            InventoryProvider<R> provider,
+            ItemStack filter) {
+        R inv = provider.getInventory(player);
+        if (inv == null) return 0;
+        int taken = takeFromInventory(inv, predicate, simulate, count, store, filter, player, true);
+        if (taken > 0) provider.markDirty(inv);
+        return taken;
+    }
+
+    /**
+     * take count amount of stacks that matches given filter. Will do 1 level of recursion to try find more stacks....
+     * e.g. from backpacks...
+     *
+     * @param inv       source of stacks
+     * @param predicate item stack filter
+     * @param simulate  whether to do removal
+     * @param count     let's hope int size is enough...
+     * @param recursive do recursive lookup using {@link #getStackExtractors() stack extractors}
+     * @return amount taken. never negative nor bigger than count...
+     */
+    public static Map<ItemStack, Integer> takeFromInventory(
+            Iterable<ItemStack> inv, Predicate<ItemStack> predicate, boolean simulate, int count, boolean recursive) {
+        ItemStackCounterImpl store = new ItemStackCounterImpl();
+        takeFromInventory(inv, predicate, simulate, count, store, null, null, recursive);
+        return store.getStore();
+    }
+
+    private static int takeFromInventory(
+            @Nonnull Iterable<ItemStack> inv,
+            @Nonnull Predicate<ItemStack> predicate,
+            boolean simulate,
+            int count,
+            @Nonnull ItemStackCounter store,
+            @Nullable ItemStack filter,
+            @Nullable EntityPlayerMP player,
+            boolean recursive) {
+        int found = 0;
+        ItemStack copiedFilter = null;
+        if (filter != null) {
+            copiedFilter = new ItemStack(filter.getItem(), filter.stackSize, Items.feather.getDamage(filter));
+            copiedFilter.setTagCompound(filter.stackTagCompound);
+        }
+        for (Iterator<ItemStack> iterator = inv.iterator(); iterator.hasNext(); ) {
+            ItemStack stack = iterator.next();
+            // invalid stack
+            if (stack == null || stack.getItem() == null || stack.stackSize <= 0) continue;
+
+            if (predicate.test(stack)) {
+                found += stack.stackSize;
+                if (found > count) {
+                    int surplus = found - count;
+                    store.add(stack, stack.stackSize - surplus);
+                    if (!simulate) {
+                        // leave the surplus in its place
+                        stack.stackSize = surplus;
+                    }
+                    return count;
+                }
+                store.add(stack, stack.stackSize);
+                if (!simulate) iterator.remove();
+                if (found == count) return count;
+            }
+            if (!recursive) continue;
+            for (ItemStackExtractor f : stackExtractors) {
+                if (filter != null && f.isAPIImplemented(APIType.EXTRACT_ONE_STACK)) {
+                    copiedFilter.stackSize = count - found;
+                    found += f.getItem(stack, copiedFilter, simulate, player);
+                } else {
+                    found += f.takeFromStack(predicate, simulate, count - found, store, stack, filter, player);
+                }
+                if (found >= count) return found;
+            }
+        }
+        return found;
+    }
+
+    public interface OptimizedExtractor {
+        /**
+         * Extract a particular type of item. The extractor can choose to not return all items contained within this item
+         * as long as it makes sense, but the author should inform the player of this.
+         * <p>
+         * Whether optimized extractor do recursive extraction is at the discretion of implementor.
+         *
+         * @param source    from where an extraction should be attempted
+         * @param toExtract stack to extract. should not be mutated! match the NBT tag using EXACT mode.
+         * @param simulate  true if only query but does not actually remove
+         * @param player    executor of extraction, or null if from a machine
+         * @return amount extracted
+         */
+        int extract(ItemStack source, ItemStack toExtract, boolean simulate, EntityPlayerMP player);
+    }
+
+    public interface InventoryProvider<R extends Iterable<ItemStack>> {
+        R getInventory(EntityPlayerMP player);
+
+        void markDirty(R inv);
+    }
+
+    public interface ItemStackExtractor {
+        enum APIType {
+            MAIN,
+            EXTRACT_ONE_STACK,
+        }
+
+        boolean isAPIImplemented(APIType type);
+
+        /**
+         * Extract a particular type of item. The extractor can choose to not return all items contained within this item
+         * as long as it makes sense, but the author should inform the player of this.
+         * <p>
+         * Whether this method does recursive extraction is at the discretion of implementor.
+         *
+         * @param predicate the main filtering predicate. never null. It's assumed predicate always returns true on filter,
+         *                  if that is not null
+         * @param store     where to store extracted items. Should increment the
+         * @param source    from where an extraction should be attempted
+         * @param filter    stack to extract. should not be mutated! match the NBT tag using EXACT mode. might be null.
+         * @param simulate  true if only query but does not actually remove
+         * @param player    executor of extraction, or null if from a machine
+         * @return amount extracted, or -1 if this is not implemented
+         */
+        int takeFromStack(
+                Predicate<ItemStack> predicate,
+                boolean simulate,
+                int count,
+                ItemStackCounter store,
+                ItemStack source,
+                ItemStack filter,
+                EntityPlayerMP player);
+
+        /**
+         * Extract a particular type of item. The extractor can choose to not return all items contained within this item
+         * as long as it makes sense, but the author should inform the player of this.
+         * <p>
+         * Whether this method does recursive extraction is at the discretion of implementor.
+         *
+         * @param source    from where an extraction should be attempted
+         * @param toExtract stack to extract. should not be mutated! match the NBT tag using EXACT mode.
+         * @param simulate  true if only query but does not actually remove
+         * @param player    executor of extraction, or null if from a machine
+         * @return amount extracted, or -1 if this is not implemented
+         */
+        default int getItem(ItemStack source, ItemStack toExtract, boolean simulate, EntityPlayerMP player) {
+            return -1;
+        }
+
+        static ItemStackExtractor createOnlyOptimized(@Nonnull OptimizedExtractor optimizedExtractor) {
+            return new ItemStackExtractor() {
+                @Override
+                public boolean isAPIImplemented(APIType type) {
+                    return type == APIType.EXTRACT_ONE_STACK;
+                }
+
+                @Override
+                public int takeFromStack(
+                        Predicate<ItemStack> predicate,
+                        boolean simulate,
+                        int count,
+                        ItemStackCounter store,
+                        ItemStack stack,
+                        ItemStack filter,
+                        EntityPlayerMP player) {
+                    return 0;
+                }
+
+                @Override
+                public int getItem(ItemStack source, ItemStack toExtract, boolean simulate, EntityPlayerMP player) {
+                    return optimizedExtractor.extract(source, toExtract, simulate, player);
+                }
+            };
+        }
+    }
+
+    public interface ItemStackCounter {
+        /**
+         * Add some amount of stack. Note stackSize is used instead of stack.stackSize.
+         */
+        void add(ItemStack stack, int stackSize);
+    }
+
+    private static class ItemStackCounterImpl implements ItemStackCounter {
+        private final Map<ItemStack, Integer> store = new ItemStackMap<>();
+
+        @Override
+        public void add(ItemStack stack, int stackSize) {
+            if (stack == null || stack.getItem() == null || stackSize <= 0) throw new IllegalArgumentException();
+            store.merge(stack, stackSize, Integer::sum);
+        }
+
+        public Map<ItemStack, Integer> getStore() {
+            return store;
+        }
+    }
+}

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

@@ -0,0 +1,38 @@
+package com.gtnewhorizon.structurelib.util;
+
+import java.util.Iterator;
+import net.minecraft.item.ItemStack;
+
+public class ItemStackArrayIterable implements Iterable<ItemStack> {
+    private final ItemStack[] stacks;
+
+    public ItemStackArrayIterable(ItemStack[] stacks) {
+        this.stacks = stacks;
+    }
+
+    public ItemStack[] getStacks() {
+        return stacks;
+    }
+
+    @Override
+    public Iterator<ItemStack> iterator() {
+        return new Iterator<ItemStack>() {
+            private int ptr = 0;
+
+            @Override
+            public boolean hasNext() {
+                return ptr < stacks.length;
+            }
+
+            @Override
+            public ItemStack next() {
+                return stacks[ptr++];
+            }
+
+            @Override
+            public void remove() {
+                stacks[ptr - 1] = null;
+            }
+        };
+    }
+}

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

@@ -0,0 +1,464 @@
+/*
+ * 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/java/com/gtnewhorizon/structurelib/util/ItemStackPredicate.java

@@ -0,0 +1,112 @@
+package com.gtnewhorizon.structurelib.util;
+
+import java.util.Objects;
+import java.util.function.BiPredicate;
+import java.util.function.Predicate;
+import net.minecraft.block.Block;
+import net.minecraft.init.Items;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+
+public final class ItemStackPredicate implements Predicate<ItemStack> {
+    public static ItemStackPredicate from(Item item) {
+        return new ItemStackPredicate(item);
+    }
+
+    public static ItemStackPredicate from(ItemStack itemStack) {
+        return new ItemStackPredicate(itemStack.getItem()).setMeta(Items.feather.getDamage(itemStack));
+    }
+
+    public static ItemStackPredicate from(ItemStack itemStack, NBTMode mode) {
+        return new ItemStackPredicate(itemStack.getItem())
+                .setMeta(Items.feather.getDamage(itemStack))
+                .setTag(mode, itemStack.stackTagCompound);
+    }
+
+    public static ItemStackPredicate from(Block block) {
+        return new ItemStackPredicate(Item.getItemFromBlock(block));
+    }
+
+    private final Item item;
+    private int meta = -1;
+
+    private NBTTagCompound tag;
+    private NBTMode mode = NBTMode.IGNORE;
+
+    private ItemStackPredicate(Item item) {
+        this.item = item;
+    }
+
+    public ItemStackPredicate ignoreMeta() {
+        this.meta = -1;
+        return this;
+    }
+
+    public ItemStackPredicate setMeta(int meta) {
+        this.meta = meta;
+        return this;
+    }
+
+    public ItemStackPredicate setTag(NBTMode mode, NBTTagCompound tag) {
+        this.mode = mode;
+        this.tag = tag;
+        return this;
+    }
+
+    @Override
+    public boolean test(ItemStack itemStack) {
+        if (item != null) if (itemStack.getItem() != item) return false;
+        if (meta != -1) if (Items.feather.getDamage(itemStack) != meta) return false;
+        return mode.test(tag, itemStack.stackTagCompound);
+    }
+
+    public enum NBTMode implements BiPredicate<NBTTagCompound, NBTTagCompound> {
+        IGNORE {
+            @Override
+            public boolean test(NBTTagCompound lhs, NBTTagCompound rhs) {
+                return true;
+            }
+        },
+        IN {
+            @Override
+            public boolean test(NBTTagCompound lhs, NBTTagCompound rhs) {
+                if (lhs == null || lhs.hasNoTags()) return true;
+                if (rhs == null || rhs.hasNoTags()) return false;
+                for (String key : MiscUtils.getTagKeys(lhs)) {
+                    if (!rhs.hasKey(key, lhs.func_150299_b(key))) return false;
+                    NBTBase tag = lhs.getTag(key);
+                    if (tag instanceof NBTTagCompound) {
+                        if (!test((NBTTagCompound) tag, rhs.getCompoundTag(key))) return false;
+                    } else {
+                        if (!tag.equals(rhs.getTag(key))) return false;
+                    }
+                }
+                return true;
+            }
+        },
+        EXACT {
+            @Override
+            public boolean test(NBTTagCompound lhs, NBTTagCompound rhs) {
+                if (lhs != null && lhs.hasNoTags()) lhs = null;
+                if (rhs != null && rhs.hasNoTags()) rhs = null;
+                return Objects.equals(lhs, rhs);
+            }
+        },
+        IGNORE_KNOWN_INSIGNIFICANT_TAGS {
+            @Override
+            public boolean test(NBTTagCompound lhs, NBTTagCompound rhs) {
+                // fast path for empty tags
+                if (rhs == null || rhs.hasNoTags()) return lhs == null || lhs.hasNoTags();
+                // TODO make an implementation without copying a potentially huge tag
+                rhs = (NBTTagCompound) rhs.copy();
+                for (String s : KNOWN_INSIGNIFICANT_TAGS) rhs.removeTag(s);
+                return EXACT.test(lhs, rhs);
+            }
+        };
+        private static final String[] KNOWN_INSIGNIFICANT_TAGS = {
+            "display", // TODO expand/refine this
+        };
+    }
+}

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

@@ -0,0 +1,16 @@
+package com.gtnewhorizon.structurelib.util;
+
+import java.util.Set;
+import net.minecraft.nbt.NBTTagCompound;
+
+/**
+ * not related to a certain mod!
+ */
+public class MiscUtils {
+    private MiscUtils() {}
+
+    @SuppressWarnings("unchecked")
+    public static Set<String> getTagKeys(NBTTagCompound tag) {
+        return tag.func_150296_c();
+    }
+}

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

@@ -0,0 +1,57 @@
+package com.gtnewhorizon.structurelib.util;
+
+import java.util.*;
+import java.util.function.Consumer;
+
+public class SortedRegistry<V> implements Iterable<V> {
+    private final NavigableMap<String, V> store = new TreeMap<>();
+    /**
+     * Store stuff in an array for faster iteration access than a red black tree
+     */
+    private List<V> baked = Collections.emptyList();
+
+    public void register(String key, V val) {
+        if (key == null || val == null) throw new NullPointerException();
+        V old = store.putIfAbsent(key, val);
+        if (old != null) {
+            throw new IllegalArgumentException("Duplicate key: " + key);
+        }
+        // TODO allow a user to edit the order with a configuration file
+        baked = new ArrayList<>(store.values());
+    }
+
+    public int size() {
+        return store.size();
+    }
+
+    public boolean isEmpty() {
+        return store.isEmpty();
+    }
+
+    public boolean containsKey(String key) {
+        return store.containsKey(key);
+    }
+
+    public boolean containsValue(V value) {
+        return store.containsValue(value);
+    }
+
+    public V get(String key) {
+        return store.get(key);
+    }
+
+    @Override
+    public Iterator<V> iterator() {
+        return baked.iterator();
+    }
+
+    @Override
+    public void forEach(Consumer<? super V> action) {
+        baked.forEach(action);
+    }
+
+    @Override
+    public Spliterator<V> spliterator() {
+        return baked.spliterator();
+    }
+}

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

@@ -57,7 +57,9 @@ public class Vec3Impl implements Comparable<Vec3Impl> {
     }
 
     public Vec3Impl offset(ForgeDirection facing, int n) {
-        return n == 0 ? this : new Vec3Impl(val0 + facing.offsetX * n, val1 + facing.offsetY * n, val2 + facing.offsetZ * n);
+        return n == 0
+                ? this
+                : new Vec3Impl(val0 + facing.offsetX * n, val1 + facing.offsetY * n, val2 + facing.offsetZ * n);
     }
 
     public Vec3Impl add(Vec3Impl pos) {
@@ -77,8 +79,10 @@ public class Vec3Impl implements Comparable<Vec3Impl> {
     }
 
     public Vec3Impl crossProduct(Vec3Impl vec) {
-        return new Vec3Impl(val1 * vec.val2 - val2 * vec.val1, val2 * vec.val0 - val0 * vec.val2,
-            val0 * vec.val1 - val1 * vec.val0);
+        return new Vec3Impl(
+                val1 * vec.val2 - val2 * vec.val1,
+                val2 * vec.val0 - val0 * vec.val2,
+                val0 * vec.val1 - val1 * vec.val0);
     }
 
     public boolean withinDistance(Vec3Impl to, double distance) {

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

@@ -1,28 +1,28 @@
 package com.gtnewhorizon.structurelib.util;
 /*
-  A subclass of java.util.random that implements the Xorshift random number
-  generator
-  <p>
-  - it is 30% faster than the generator from Java's library - it produces
-  random sequences of higher quality than java.util.Random - this class also
-  provides a clone() function
-  <p>
-  Usage: XSRandom rand = new XSRandom(); //Instantiation x = rand.nextInt();
-  //pull a random number
-  <p>
-  To use the class in legacy code, you may also instantiate an XSRandom object
-  and assign it to a java.util.Random object: java.util.Random rand = new
-  XSRandom();
-  <p>
-  for an explanation of the algorithm, see
-  http://demesos.blogspot.com/2011/09/pseudo-random-number-generators.html
+ A subclass of java.util.random that implements the Xorshift random number
+ generator
+ <p>
+ - it is 30% faster than the generator from Java's library - it produces
+ random sequences of higher quality than java.util.Random - this class also
+ provides a clone() function
+ <p>
+ Usage: XSRandom rand = new XSRandom(); //Instantiation x = rand.nextInt();
+ //pull a random number
+ <p>
+ To use the class in legacy code, you may also instantiate an XSRandom object
+ and assign it to a java.util.Random object: java.util.Random rand = new
+ XSRandom();
+ <p>
+ for an explanation of the algorithm, see
+ http://demesos.blogspot.com/2011/09/pseudo-random-number-generators.html
 
-  @author Wilfried Elmenreich University of Klagenfurt/Lakeside Labs
- * http://www.elmenreich.tk
- * <p>
- * This code is released under the GNU Lesser General Public License Version 3
- * http://www.gnu.org/licenses/lgpl-3.0.txt
- */
+ @author Wilfried Elmenreich University of Klagenfurt/Lakeside Labs
+* http://www.elmenreich.tk
+* <p>
+* This code is released under the GNU Lesser General Public License Version 3
+* http://www.gnu.org/licenses/lgpl-3.0.txt
+*/
 
 import java.util.Random;
 import java.util.concurrent.atomic.AtomicLong;
@@ -40,7 +40,7 @@ public class XSTR extends Random {
     private static final long GAMMA = 0x9e3779b97f4a7c15L;
     private static final int PROBE_INCREMENT = 0x9e3779b9;
     private static final long SEEDER_INCREMENT = 0xbb67ae8584caa73bL;
-    private static final double DOUBLE_UNIT = 0x1.0p-53;  // 1.0  / (1L << 53)
+    private static final double DOUBLE_UNIT = 0x1.0p-53; // 1.0  / (1L << 53)
     private static final float FLOAT_UNIT = 0x1.0p-24f; // 1.0f / (1 << 24)
     private static final AtomicLong seedUniquifier = new AtomicLong(8682522807148012L);
     public static final XSTR XSTR_INSTANCE = new XSTR() {
@@ -53,9 +53,9 @@ public class XSTR extends Random {
     };
 
     /*
-     MODIFIED BY: Robotia
-     Modification: Implemented Random class seed generator
-     */
+    MODIFIED BY: Robotia
+    Modification: Implemented Random class seed generator
+    */
 
     /**
      * Creates a new pseudo random number generator. The seed is initialized to
@@ -226,9 +226,9 @@ public class XSTR extends Random {
      */
     @Override
     public int nextInt(int bound) {
-        //if (bound <= 0) {
-        //throw new RuntimeException("BadBound");
-        //}
+        // if (bound <= 0) {
+        // throw new RuntimeException("BadBound");
+        // }
 
         /*int r = next(31);
         int m = bound - 1;
@@ -242,7 +242,7 @@ public class XSTR extends Random {
                 ;
         }
         return r;*/
-        //speedup, new nextInt ~+40%
+        // speedup, new nextInt ~+40%
         long last = seed ^ seed << 21;
         last ^= last >>> 35;
         last ^= last << 4;
@@ -270,7 +270,9 @@ public class XSTR extends Random {
     @Override
     public void nextBytes(byte[] bytes_arr) {
         for (int iba = 0, lenba = bytes_arr.length; iba < lenba; ) {
-            for (int rndba = nextInt(), nba = Math.min(lenba - iba, Integer.SIZE / Byte.SIZE); nba-- > 0; rndba >>= Byte.SIZE) {
+            for (int rndba = nextInt(), nba = Math.min(lenba - iba, Integer.SIZE / Byte.SIZE);
+                    nba-- > 0;
+                    rndba >>= Byte.SIZE) {
                 bytes_arr[iba++] = (byte) rndba;
             }
         }