Added circle, cylinder and sphere buildmodes. Refactored buildmodes to use hierarchy classes, much less code duplication. Added support for multiple options per build mode.

Added alternative placement key (ctrl) that toggles between first two actions of first option.
Fixed crash when placing ladders.

README.md

@@ -0,0 +1,3 @@
+This is the version for Minecraft 1.12.
+
+1.13 can be found here: https://bitbucket.org/Requios/effortless-building-1.13/src/master/

build.gradle

@@ -11,7 +11,7 @@ apply plugin: 'net.minecraftforge.gradle.forge'
 //Only edit below this line, the above code adds and enables the necessary things for Forge to be setup.
 
 
-version = "0.1.1"
+version = "1.12.2-2.16"
 group = "nl.requios.effortlessbuilding" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
 archivesBaseName = "effortlessbuilding"
 
@@ -21,7 +21,7 @@ compileJava {
 }
 
 minecraft {
-    version = "1.12.2-14.23.4.2705"
+    version = "1.12.2-14.23.5.2825"
     runDir = "run"
     
     // the mappings can be changed at any time, and must be in the following format.
@@ -29,10 +29,14 @@ minecraft {
     // stable_#            stables are built at the discretion of the MCP team.
     // Use non-default mappings at your own risk. they may not always work.
     // simply re-run your setup task after changing the mappings to update your workspace.
-    mappings = "snapshot_20171003"
+    mappings = "stable_39"
     // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
 }
 
+repositories {
+	flatDir { dirs 'libs' }
+}
+
 dependencies {
     // you may put jars on which you depend on in ./libs
     // or you may define them like so..
@@ -50,6 +54,7 @@ dependencies {
     // except that these dependencies get remapped to your current MCP mappings
     //deobfCompile 'com.mod-buildcraft:buildcraft:6.0.8:dev'
     //deobfProvided 'com.mod-buildcraft:buildcraft:6.0.8:dev'
+	provided 'mod.chiselsandbits:chiselsandbits:14.30'
 
     // for more info...
     // http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +1,5 @@
-#Mon Sep 14 12:28:28 PDT 2015
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.8.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-2.14-bin.zip

gradlew

@@ -1,4 +1,4 @@
-#!/usr/bin/env bash
+#!/usr/bin/env sh
 
 ##############################################################################
 ##
@@ -6,12 +6,30 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+# Attempt to set APP_HOME
-DEFAULT_JVM_OPTS=""
+# Resolve links: $0 may be a link
+PRG="$0"
+# Need this for relative symlinks.
+while [ -h "$PRG" ] ; do
+    ls=`ls -ld "$PRG"`
+    link=`expr "$ls" : '.*-> \(.*\)$'`
+    if expr "$link" : '/.*' > /dev/null; then
+        PRG="$link"
+    else
+        PRG=`dirname "$PRG"`"/$link"
+    fi
+done
+SAVED="`pwd`"
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
 APP_BASE_NAME=`basename "$0"`
 
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS=""
+
 # Use the maximum available, or set MAX_FD != -1 to use that value.
 MAX_FD="maximum"
 
@@ -30,6 +48,7 @@ die ( ) {
 cygwin=false
 msys=false
 darwin=false
+nonstop=false
 case "`uname`" in
   CYGWIN* )
     cygwin=true
@@ -40,31 +59,11 @@ case "`uname`" in
   MINGW* )
     msys=true
     ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
 esac
 
-# For Cygwin, ensure paths are in UNIX format before anything is touched.
-if $cygwin ; then
-    [ -n "$JAVA_HOME" ] && JAVA_HOME=`cygpath --unix "$JAVA_HOME"`
-fi
-
-# Attempt to set APP_HOME
-# Resolve links: $0 may be a link
-PRG="$0"
-# Need this for relative symlinks.
-while [ -h "$PRG" ] ; do
-    ls=`ls -ld "$PRG"`
-    link=`expr "$ls" : '.*-> \(.*\)$'`
-    if expr "$link" : '/.*' > /dev/null; then
-        PRG="$link"
-    else
-        PRG=`dirname "$PRG"`"/$link"
-    fi
-done
-SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
-APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
-
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
 # Determine the Java command to use to start the JVM.
@@ -90,7 +89,7 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if [ "$cygwin" = "false" -a "$darwin" = "false" ] ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
     MAX_FD_LIMIT=`ulimit -H -n`
     if [ $? -eq 0 ] ; then
         if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
@@ -114,6 +113,7 @@ fi
 if $cygwin ; then
     APP_HOME=`cygpath --path --mixed "$APP_HOME"`
     CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
     # We build the pattern for arguments to be converted via cygpath
     ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
@@ -154,11 +154,19 @@ if $cygwin ; then
     esac
 fi
 
-# Split up the JVM_OPTS And GRADLE_OPTS values into an array, following the shell quoting and substitution rules
+# Escape application args
-function splitJvmOpts() {
+save () {
-    JVM_OPTS=("$@")
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
 }
-eval splitJvmOpts $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS
+APP_ARGS=$(save "$@")
-JVM_OPTS[${#JVM_OPTS[*]}]="-Dorg.gradle.appname=$APP_BASE_NAME"
 
-exec "$JAVACMD" "${JVM_OPTS[@]}" -classpath "$CLASSPATH" org.gradle.wrapper.GradleWrapperMain "$@"
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -8,14 +8,14 @@
 @rem Set local scope for the variables with windows NT shell
 if "%OS%"=="Windows_NT" setlocal
 
-@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS=
-
 set DIRNAME=%~dp0
 if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS=
+
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
@@ -46,10 +46,9 @@ echo location of your Java installation.
 goto fail
 
 :init
-@rem Get command-line arguments, handling Windowz variants
+@rem Get command-line arguments, handling Windows variants
 
 if not "%OS%" == "Windows_NT" goto win9xME_args
-if "%@eval[2+2]" == "4" goto 4NT_args
 
 :win9xME_args
 @rem Slurp the command line arguments.
@@ -60,11 +59,6 @@ set _SKIP=2
 if "x%~1" == "x" goto execute
 
 set CMD_LINE_ARGS=%*
-goto execute
-
-:4NT_args
-@rem Get arguments from the 4NT Shell from JP Software
-set CMD_LINE_ARGS=%$
 
 :execute
 @rem Setup the command line

src/main/java/nl/requios/effortlessbuilding/Array.java

@@ -1,82 +0,0 @@
-package nl.requios.effortlessbuilding;
-
-import net.minecraft.util.EnumHand;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Vec3i;
-import net.minecraftforge.common.util.BlockSnapshot;
-import net.minecraftforge.event.world.BlockEvent;
-
-public class Array {
-    //TODO config file
-    public static final int MAX_COUNT = 100;
-
-    public static class ArraySettings{
-        public boolean enabled = false;
-        public BlockPos offset = BlockPos.ORIGIN;
-        public int count = 5;
-
-        public ArraySettings(){
-        }
-
-        public ArraySettings(boolean enabled, BlockPos offset, int count) {
-            this.enabled = enabled;
-            this.offset = offset;
-            this.count = count;
-        }
-    }
-
-    //Called from EventHandler
-    public static void onBlockPlaced(BlockEvent.PlaceEvent event) {
-        if (event.getWorld().isRemote) return;
-
-        //find arraysettings for the player that placed the block
-        ArraySettings a = BuildSettingsManager.getBuildSettings(event.getPlayer()).getArraySettings();
-        if (a == null || !a.enabled) return;
-
-        if (a.offset.getX() == 0 && a.offset.getY() == 0 && a.offset.getZ() == 0) return;
-
-        BlockPos pos = event.getPos();
-        Vec3i offset = new Vec3i(a.offset.getX(), a.offset.getY(), a.offset.getZ());
-        for (int i = 0; i < a.count; i++) {
-            pos = pos.add(offset);
-            if (event.getWorld().isBlockLoaded(pos, true)) {
-                event.getWorld().setBlockState(pos, event.getPlacedBlock());
-
-                //Mirror synergy
-                BlockSnapshot blockSnapshot = new BlockSnapshot(event.getWorld(), pos, event.getPlacedBlock());
-                BlockEvent.PlaceEvent placeEvent = new BlockEvent.PlaceEvent(blockSnapshot, event.getPlacedBlock(), event.getPlayer(), EnumHand.MAIN_HAND);
-                Mirror.onBlockPlaced(placeEvent);
-            }
-        }
-    }
-
-    //Called from EventHandler
-    public static void onBlockBroken(BlockEvent.BreakEvent event) {
-        if (event.getWorld().isRemote) return;
-
-        //find arraysettings for the player that placed the block
-        ArraySettings a = BuildSettingsManager.getBuildSettings(event.getPlayer()).getArraySettings();
-        if (a == null || !a.enabled) return;
-
-        if (a.offset.getX() == 0 && a.offset.getY() == 0 && a.offset.getZ() == 0) return;
-
-        BlockPos pos = event.getPos();
-        Vec3i offset = new Vec3i(a.offset.getX(), a.offset.getY(), a.offset.getZ());
-        for (int i = 0; i < a.count; i++) {
-            pos = pos.add(offset);
-            if (event.getWorld().isBlockLoaded(pos, false)) {
-                event.getWorld().setBlockToAir(pos);
-
-                //Mirror synergy
-                BlockEvent.BreakEvent breakEvent = new BlockEvent.BreakEvent(event.getWorld(), pos, event.getState(), event.getPlayer());
-                Mirror.onBlockBroken(breakEvent);
-            }
-        }
-    }
-
-//    @SubscribeEvent
-//    @SideOnly(Side.CLIENT)
-//    public static void onRender(RenderWorldLastEvent event) {
-//
-//    }
-}

src/main/java/nl/requios/effortlessbuilding/BuildConfig.java

@@ -0,0 +1,89 @@
+package nl.requios.effortlessbuilding;
+
+import net.minecraftforge.common.config.Config;
+
+import static net.minecraftforge.common.config.Config.*;
+
+@Config(modid = EffortlessBuilding.MODID, name = "EffortlessBuilding", type = Type.INSTANCE, category = "")
+public class BuildConfig {
+
+    public static Reach reach = new Reach();
+    public static SurvivalBalancers survivalBalancers = new SurvivalBalancers();
+    public static Visuals visuals = new Visuals();
+
+    public static class Reach {
+        @Comment({"Reach: how far away the player can place blocks using mirror/array etc.",
+                 "Enable the crafting of reach upgrades to increase reach.",
+                 "If disabled, reach is set to level 3 for survival players."})
+        public boolean enableReachUpgrades = true;
+
+        @Comment({"Maximum reach in creative",
+                 "Keep in mind that chunks need to be loaded to be able to place blocks inside."})
+        public int maxReachCreative = 200;
+
+        @Comment({"Maximum reach in survival without upgrades",
+                 "Reach upgrades are craftable consumables that permanently increase reach.",
+                 "Set to 0 to disable Effortless Building until the player has consumed a reach upgrade."})
+        public int maxReachLevel0 = 20;
+
+        @Comment("Maximum reach in survival with one upgrade")
+        public int maxReachLevel1 = 50;
+
+        @Comment("Maximum reach in survival with two upgrades")
+        public int maxReachLevel2 = 100;
+
+        @Comment("Maximum reach in survival with three upgrades")
+        public int maxReachLevel3 = 200;
+    }
+
+    public static class SurvivalBalancers {
+        @Comment({"Allows a survival player to break blocks that are far away, in addition to placing blocks.",
+                 "Note: this allows insta-breaking of blocks in survival."})
+        public boolean breakFar = false;
+
+        @Comment({"Increases the time to mine a block when breaking multiple at once.",
+                 "Mining time depends on how many blocks, what type of blocks, and the percentage below.",
+                 "Example: breaking 1 dirt + 1 obsidian takes the time of breaking 1 dirt + 1 obsidian."})
+        public boolean increasedMiningTime = true;
+
+        @Comment({"How much the mining time of each additional block counts towards an increased mining time.",
+                 "A percentage between 0% and 100%, where 0% is the same as disabling it,",
+                 "and 100% takes as much time as breaking each block individually.",
+                 "The block in front of you always counts as 100%."})
+        @RangeInt(min = 0, max = 200)
+        public int miningTimePercentage = 50;
+
+        @Comment({"Determines what blocks can be replaced in survival.",
+                 "-1: only blocks that can be harvested by hand (default)",
+                 "0: blocks that can be harvested with wooden or gold tools",
+                 "1: blocks that can be harvested with stone tools",
+                 "2: blocks that can be harvested with iron tools",
+                 "3: blocks that can be harvested with diamond tools",
+                 })
+        @RangeInt(min = -1, max = 3)
+        public int quickReplaceMiningLevel = -1;
+
+        @Comment({"How many placements are remembered for the undo functionality."})
+        @RequiresMcRestart
+        public int undoStackSize = 10;
+    }
+
+    public static class Visuals {
+        @Comment({"Show a block preview if you have a block in hand on build mode NORMAL"})
+        public boolean alwaysShowBlockPreview = false;
+
+        @Comment({"How long the dissolve effect takes when placing blocks.",
+                 "Default between 30 and 60 ticks, you can multiply that here.",
+                 "Recommended values:",
+                 "Snappy: 0.7",
+                 "Relaxing: 1.5"})
+        public double dissolveTimeMultiplier = 1.0;
+
+        @Comment({"Switch to using the simple performance shader when placing more than this many blocks."})
+        public int shaderTreshold = 1500;
+
+        @Comment({"Use fancy shaders while placing blocks"})
+        public boolean useShaders = true;
+
+    }
+}

src/main/java/nl/requios/effortlessbuilding/BuildSettingsManager.java

@@ -1,102 +0,0 @@
-package nl.requios.effortlessbuilding;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.common.gameevent.PlayerEvent;
-import nl.requios.effortlessbuilding.capability.BuildModifierCapability;
-import nl.requios.effortlessbuilding.network.BuildSettingsMessage;
-
-@Mod.EventBusSubscriber
-public class BuildSettingsManager {
-
-    public static BuildSettings getBuildSettings(EntityPlayer player){
-        if (player.hasCapability(BuildModifierCapability.buildModifier, null)) {
-            BuildModifierCapability.IBuildModifier capability = player.getCapability(BuildModifierCapability.buildModifier, null);
-            return capability.getBuildModifierData();
-        }
-        EffortlessBuilding.log("buildsettings is null");
-        return null;
-    }
-
-    public static void setBuildSettings(EntityPlayer player, BuildSettings buildSettings) {
-        if (player == null) {
-            EffortlessBuilding.log("cannot set buildsettings, player is null");
-            return;
-        }
-        if (player.hasCapability(BuildModifierCapability.buildModifier, null)) {
-            BuildModifierCapability.IBuildModifier capability = player.getCapability(BuildModifierCapability.buildModifier, null);
-            capability.setBuildModifierData(buildSettings);
-        } else {
-            EffortlessBuilding.log(player, "Saving buildsettings failed.");
-        }
-    }
-
-    public static class BuildSettings {
-        private Mirror.MirrorSettings mirrorSettings;
-        private Array.ArraySettings arraySettings;
-        private boolean quickReplace = false;
-
-        public BuildSettings() {
-            mirrorSettings = new Mirror.MirrorSettings();
-            arraySettings = new Array.ArraySettings();
-        }
-
-        public BuildSettings(Mirror.MirrorSettings mirrorSettings, Array.ArraySettings arraySettings, boolean quickReplace) {
-            this.mirrorSettings = mirrorSettings;
-            this.arraySettings = arraySettings;
-            this.quickReplace = quickReplace;
-        }
-
-        public Mirror.MirrorSettings getMirrorSettings() {
-            return mirrorSettings;
-        }
-
-        public void setMirrorSettings(Mirror.MirrorSettings mirrorSettings) {
-            this.mirrorSettings = mirrorSettings;
-        }
-
-        public Array.ArraySettings getArraySettings() {
-            return arraySettings;
-        }
-
-        public void setArraySettings(Array.ArraySettings arraySettings) {
-            this.arraySettings = arraySettings;
-        }
-
-        public boolean doQuickReplace() {
-            return quickReplace;
-        }
-
-        public void setQuickReplace(boolean quickReplace) {
-            this.quickReplace = quickReplace;
-        }
-    }
-
-    @SubscribeEvent
-    public static void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
-        EntityPlayer player = event.player;
-        handleNewPlayer(player);
-    }
-
-    @SubscribeEvent
-    public static void onPlayerRespawn(PlayerEvent.PlayerRespawnEvent event) {
-        EntityPlayer player = event.player;
-        handleNewPlayer(player);
-    }
-
-    private static void handleNewPlayer(EntityPlayer player){
-        if (getBuildSettings(player) == null) {
-            setBuildSettings(player, new BuildSettings());
-        }
-
-        //Only on server
-        if (!player.world.isRemote) {
-            //Send to client
-            BuildSettingsMessage msg = new BuildSettingsMessage(getBuildSettings(player));
-            EffortlessBuilding.packetHandler.sendTo(msg, (EntityPlayerMP) player);
-        }
-    }
-}
-

src/main/java/nl/requios/effortlessbuilding/EffortlessBuilding.java

@@ -3,8 +3,12 @@ package nl.requios.effortlessbuilding;
 import net.minecraft.block.Block;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.Item;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.SoundEvent;
 import net.minecraft.util.text.TextComponentString;
 import net.minecraftforge.common.capabilities.CapabilityManager;
+import net.minecraftforge.common.config.Config;
+import net.minecraftforge.common.config.ConfigManager;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.Mod.EventHandler;
 import net.minecraftforge.fml.common.SidedProxy;
@@ -15,11 +19,17 @@ import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
 import net.minecraftforge.fml.common.network.NetworkRegistry;
 import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper;
 import net.minecraftforge.fml.relauncher.Side;
-import nl.requios.effortlessbuilding.capability.*;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
-import nl.requios.effortlessbuilding.inventory.RandomizerGuiHandler;
+import nl.requios.effortlessbuilding.capability.ModeCapabilityManager;
+import nl.requios.effortlessbuilding.capability.ModifierCapabilityManager;
+import nl.requios.effortlessbuilding.command.CommandReach;
+import nl.requios.effortlessbuilding.compatibility.CompatHelper;
+import nl.requios.effortlessbuilding.gui.RandomizerBagGuiHandler;
 import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
-import nl.requios.effortlessbuilding.network.BuildSettingsMessage;
+import nl.requios.effortlessbuilding.item.ItemReachUpgrade1;
-import nl.requios.effortlessbuilding.network.QuickReplaceMessage;
+import nl.requios.effortlessbuilding.item.ItemReachUpgrade2;
+import nl.requios.effortlessbuilding.item.ItemReachUpgrade3;
+import nl.requios.effortlessbuilding.network.*;
 import nl.requios.effortlessbuilding.proxy.IProxy;
 import org.apache.logging.log4j.Logger;
 
@@ -29,7 +39,7 @@ public class EffortlessBuilding
 {
     public static final String MODID = "effortlessbuilding";
     public static final String NAME = "Effortless Building";
-    public static final String VERSION = "0.1.2";
+    public static final String VERSION = "1.12.2-2.16";
 
     @Mod.Instance(EffortlessBuilding.MODID)
     public static EffortlessBuilding instance;
@@ -44,11 +54,19 @@ public class EffortlessBuilding
 
     public static final SimpleNetworkWrapper packetHandler = NetworkRegistry.INSTANCE.newSimpleChannel(EffortlessBuilding.MODID);
 
+    public static final ItemRandomizerBag ITEM_RANDOMIZER_BAG = new ItemRandomizerBag();
+    public static final ItemReachUpgrade1 ITEM_REACH_UPGRADE_1 = new ItemReachUpgrade1();
+    public static final ItemReachUpgrade2 ITEM_REACH_UPGRADE_2 = new ItemReachUpgrade2();
+    public static final ItemReachUpgrade3 ITEM_REACH_UPGRADE_3 = new ItemReachUpgrade3();
+
     public static final Block[] BLOCKS = {
     };
 
     public static final Item[] ITEMS = {
-            new ItemRandomizerBag()
+            ITEM_RANDOMIZER_BAG,
+            ITEM_REACH_UPGRADE_1,
+            ITEM_REACH_UPGRADE_2,
+            ITEM_REACH_UPGRADE_3
     };
 
     public static final int RANDOMIZER_BAG_GUI = 0;
@@ -59,13 +77,35 @@ public class EffortlessBuilding
     {
         logger = event.getModLog();
 
-        CapabilityManager.INSTANCE.register(BuildModifierCapability.IBuildModifier.class, new BuildModifierCapability.Storage(), BuildModifierCapability.BuildModifier.class);
+        CapabilityManager.INSTANCE.register(ModifierCapabilityManager.IModifierCapability.class, new ModifierCapabilityManager.Storage(), ModifierCapabilityManager.ModifierCapability.class);
+        CapabilityManager.INSTANCE.register(ModeCapabilityManager.IModeCapability.class, new ModeCapabilityManager.Storage(), ModeCapabilityManager.ModeCapability.class);
 
-        EffortlessBuilding.packetHandler.registerMessage(BuildSettingsMessage.MessageHandler.class, BuildSettingsMessage.class, 0, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ModifierSettingsMessage.MessageHandler.class, ModifierSettingsMessage.class, 0, Side.SERVER);
-        EffortlessBuilding.packetHandler.registerMessage(BuildSettingsMessage.MessageHandler.class, BuildSettingsMessage.class, 0, Side.CLIENT);
+        EffortlessBuilding.packetHandler.registerMessage(ModifierSettingsMessage.MessageHandler.class, ModifierSettingsMessage.class, 0, Side.CLIENT);
 
-        EffortlessBuilding.packetHandler.registerMessage(QuickReplaceMessage.MessageHandler.class, QuickReplaceMessage.class, 1, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ModeSettingsMessage.MessageHandler.class, ModeSettingsMessage.class, 1, Side.SERVER);
-        EffortlessBuilding.packetHandler.registerMessage(QuickReplaceMessage.MessageHandler.class, QuickReplaceMessage.class, 1, Side.CLIENT);
+        EffortlessBuilding.packetHandler.registerMessage(ModeSettingsMessage.MessageHandler.class, ModeSettingsMessage.class, 1, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(ModeActionMessage.MessageHandler.class, ModeActionMessage.class, 2, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ModeActionMessage.MessageHandler.class, ModeActionMessage.class, 2, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 3, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 3, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(BlockBrokenMessage.MessageHandler.class, BlockBrokenMessage.class, 4, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(BlockBrokenMessage.MessageHandler.class, BlockBrokenMessage.class, 4, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(CancelModeMessage.MessageHandler.class, CancelModeMessage.class, 5, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(CancelModeMessage.MessageHandler.class, CancelModeMessage.class, 5, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(RequestLookAtMessage.MessageHandler.class, RequestLookAtMessage.class, 6, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(RequestLookAtMessage.MessageHandler.class, RequestLookAtMessage.class, 6, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(AddUndoMessage.MessageHandler.class, AddUndoMessage.class, 7, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(AddUndoMessage.MessageHandler.class, AddUndoMessage.class, 7, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(ClearUndoMessage.MessageHandler.class, ClearUndoMessage.class, 8, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ClearUndoMessage.MessageHandler.class, ClearUndoMessage.class, 8, Side.CLIENT);
 
         proxy.preInit(event);
     }
@@ -75,7 +115,9 @@ public class EffortlessBuilding
     // Register network handlers
     public void init(FMLInitializationEvent event)
     {
-        NetworkRegistry.INSTANCE.registerGuiHandler(EffortlessBuilding.instance, new RandomizerGuiHandler());
+        ConfigManager.sync(MODID, Config.Type.INSTANCE);
+        NetworkRegistry.INSTANCE.registerGuiHandler(EffortlessBuilding.instance, new RandomizerBagGuiHandler());
+
         proxy.init(event);
     }
 
@@ -84,11 +126,13 @@ public class EffortlessBuilding
     public void postInit(FMLPostInitializationEvent event)
     {
         proxy.postInit(event);
+        CompatHelper.postInit();
     }
 
     @EventHandler
     public void serverStarting(FMLServerStartingEvent event)
     {
+        event.registerServerCommand(new CommandReach());
         proxy.serverStarting(event);
     }
 

src/main/java/nl/requios/effortlessbuilding/EventHandler.java

@@ -1,21 +1,51 @@
 package nl.requios.effortlessbuilding;
 
 import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import net.minecraftforge.common.config.Config;
+import net.minecraftforge.common.config.ConfigManager;
 import net.minecraftforge.event.AttachCapabilitiesEvent;
 import net.minecraftforge.event.RegistryEvent;
+import net.minecraftforge.event.entity.player.PlayerEvent;
 import net.minecraftforge.event.world.BlockEvent;
+import net.minecraftforge.fml.client.event.ConfigChangedEvent;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import nl.requios.effortlessbuilding.capability.BuildModifierCapability;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.BlockSet;
+import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.UndoRedo;
+import nl.requios.effortlessbuilding.capability.ModeCapabilityManager;
+import nl.requios.effortlessbuilding.capability.ModifierCapabilityManager;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+import nl.requios.effortlessbuilding.helper.SurvivalHelper;
+import nl.requios.effortlessbuilding.network.AddUndoMessage;
+import nl.requios.effortlessbuilding.network.BlockBrokenMessage;
+import nl.requios.effortlessbuilding.network.ClearUndoMessage;
+import nl.requios.effortlessbuilding.network.RequestLookAtMessage;
+import scala.actors.threadpool.Arrays;
+
+import java.util.ArrayList;
+import java.util.List;
+
+import static net.minecraftforge.fml.common.gameevent.PlayerEvent.*;
 
 @Mod.EventBusSubscriber
 public class EventHandler
 {
+
     @SubscribeEvent
     public static void registerBlocks(RegistryEvent.Register<Block> event)
     {
@@ -36,24 +66,141 @@ public class EventHandler
     @SubscribeEvent
     public static void attachCapabilities(AttachCapabilitiesEvent<Entity> event) {
         if (event.getObject() instanceof EntityPlayer) {
-            event.addCapability(new ResourceLocation(EffortlessBuilding.MODID, "BuildModifier"), new BuildModifierCapability.Provider());
+            event.addCapability(new ResourceLocation(EffortlessBuilding.MODID, "BuildModifier"), new ModifierCapabilityManager.Provider());
+            event.addCapability(new ResourceLocation(EffortlessBuilding.MODID, "BuildMode"), new ModeCapabilityManager.Provider());
         }
     }
 
-
     @SubscribeEvent
-    public static void onBlockPlaced(BlockEvent.PlaceEvent event) {
+    public static void onConfigChangedEvent(ConfigChangedEvent.OnConfigChangedEvent event)
-        QuickReplace.onBlockPlaced(event);
+    {
-        if (event.isCanceled()) return;
+        if (event.getModID().equals(EffortlessBuilding.MODID))
-        Array.onBlockPlaced(event);
+        {
-        Mirror.onBlockPlaced(event);
+            ConfigManager.sync(EffortlessBuilding.MODID, Config.Type.INSTANCE);
+        }
     }
 
+//    @SubscribeEvent
+//    public static void onServerTick(TickEvent.ServerTickEvent event) {
+//
+//    }
+
+    @SubscribeEvent
+    //Only called serverside (except with lilypads...)
+    public static void onBlockPlaced(BlockEvent.PlaceEvent event) {
+        if (event.getWorld().isRemote) return;
+
+        //Cancel event if necessary
+        EntityPlayer player = event.getPlayer();
+        BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(player).getBuildMode();
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+
+        if (buildMode != BuildModes.BuildModeEnum.NORMAL) {
+            event.setCanceled(true);
+        } else if (modifierSettings.doQuickReplace()) {
+            //Cancel event and send message if QuickReplace
+            event.setCanceled(true);
+            EffortlessBuilding.packetHandler.sendTo(new RequestLookAtMessage(true), (EntityPlayerMP) player);
+            EffortlessBuilding.packetHandler.sendTo(new AddUndoMessage(event.getPos(), event.getBlockSnapshot().getReplacedBlock(), event.getState()), (EntityPlayerMP) player);
+        } else {
+            //NORMAL mode, let vanilla handle block placing
+            //But modifiers should still work
+
+            //Send message to client, which sends message back with raytrace info
+            EffortlessBuilding.packetHandler.sendTo(new RequestLookAtMessage(false), (EntityPlayerMP) player);
+            EffortlessBuilding.packetHandler.sendTo(new AddUndoMessage(event.getPos(), event.getBlockSnapshot().getReplacedBlock(), event.getState()), (EntityPlayerMP) player);
+        }
+    }
 
     @SubscribeEvent
     public static void onBlockBroken(BlockEvent.BreakEvent event) {
-        Array.onBlockBroken(event);
+        if (event.getWorld().isRemote) return;
-        Mirror.onBlockBroken(event);
+
+        //Cancel event if necessary
+        //If cant break far then dont cancel event ever
+        BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(event.getPlayer()).getBuildMode();
+        if (buildMode != BuildModes.BuildModeEnum.NORMAL && ReachHelper.canBreakFar(event.getPlayer())) {
+            event.setCanceled(true);
+        } else {
+            //NORMAL mode, let vanilla handle block breaking
+            //But modifiers should still work
+            //Dont break the original block yourself, otherwise Tinkers Hammer and Veinminer won't work
+            BuildModes.onBlockBroken(event.getPlayer(), event.getPos(), false);
+
+            //Add to undo stack in client
+            EffortlessBuilding.packetHandler.sendTo(new AddUndoMessage(event.getPos(), event.getState(), Blocks.AIR.getDefaultState()), (EntityPlayerMP) event.getPlayer());
+        }
     }
 
+    @SubscribeEvent
+    public static void breakSpeed(PlayerEvent.BreakSpeed event) {
+        //Disable if config says so
+        if (!BuildConfig.survivalBalancers.increasedMiningTime) return;
+
+        EntityPlayer player = event.getEntityPlayer();
+        World world = player.world;
+        BlockPos pos = event.getPos();
+
+        //EffortlessBuilding.log(player, String.valueOf(event.getNewSpeed()));
+
+        float originalBlockHardness = event.getState().getBlockHardness(world, pos);
+        if (originalBlockHardness < 0) return; //Dont break bedrock
+        float totalBlockHardness = 0;
+        //get coordinates
+        List<BlockPos> coordinates = BuildModifiers.findCoordinates(player, pos);
+        for (int i = 1; i < coordinates.size(); i++) {
+            BlockPos coordinate = coordinates.get(i);
+            //get existing blockstates at those coordinates
+            IBlockState blockState = world.getBlockState(coordinate);
+            //add hardness for each blockstate, if can break
+            if (SurvivalHelper.canBreak(world, player, coordinate))
+                totalBlockHardness += blockState.getBlockHardness(world, coordinate);
+        }
+
+        //Grabbing percentage from config
+        float percentage = (float) BuildConfig.survivalBalancers.miningTimePercentage / 100;
+        totalBlockHardness *= percentage;
+        totalBlockHardness += originalBlockHardness;
+
+        float newSpeed = event.getOriginalSpeed() / totalBlockHardness * originalBlockHardness;
+        if (Float.isNaN(newSpeed) || newSpeed == 0f) newSpeed = 1f;
+        event.setNewSpeed(newSpeed);
+
+        //EffortlessBuilding.log(player, String.valueOf(event.getNewSpeed()));
+    }
+
+    @SubscribeEvent
+    public static void onPlayerLoggedIn(PlayerLoggedInEvent event) {
+        EntityPlayer player = event.player;
+        ModifierSettingsManager.handleNewPlayer(player);
+        ModeSettingsManager.handleNewPlayer(player);
+    }
+
+    @SubscribeEvent
+    public static void onPlayerLoggedOut(PlayerLoggedOutEvent event) {
+        EntityPlayer player = event.player;
+        if (player.getEntityWorld().isRemote) return;
+
+        UndoRedo.clear(player);
+        EffortlessBuilding.packetHandler.sendTo(new ClearUndoMessage(), (EntityPlayerMP) player);
+    }
+
+    @SubscribeEvent
+    public static void onPlayerRespawn(PlayerRespawnEvent event) {
+        EntityPlayer player = event.player;
+        ModifierSettingsManager.handleNewPlayer(player);
+        ModeSettingsManager.handleNewPlayer(player);
+    }
+
+    @SubscribeEvent
+    public static void onPlayerChangedDimension(PlayerChangedDimensionEvent event) {
+        EntityPlayer player = event.player;
+        if (player.getEntityWorld().isRemote) return;
+
+        ModifierSettingsManager.handleNewPlayer(player);
+        ModeSettingsManager.handleNewPlayer(player);
+
+        UndoRedo.clear(player);
+        EffortlessBuilding.packetHandler.sendTo(new ClearUndoMessage(), (EntityPlayerMP) player);
+    }
 }

src/main/java/nl/requios/effortlessbuilding/Mirror.java

@@ -1,401 +0,0 @@
-package nl.requios.effortlessbuilding;
-
-import net.minecraft.block.BlockDirectional;
-import net.minecraft.block.BlockDispenser;
-import net.minecraft.block.BlockStairs;
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.entity.EntityPlayerSP;
-import net.minecraft.client.renderer.BufferBuilder;
-import net.minecraft.client.renderer.Tessellator;
-import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Vec3d;
-import net.minecraft.world.World;
-import net.minecraftforge.client.event.RenderWorldLastEvent;
-import net.minecraftforge.event.world.BlockEvent;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.fml.relauncher.SideOnly;
-import org.lwjgl.opengl.GL11;
-import org.lwjgl.util.Color;
-
-@Mod.EventBusSubscriber
-public class Mirror {
-
-    //TODO config file
-    public static final int MAX_RADIUS = 200;
-
-    private static final Color colorX = new Color(255, 72, 52);
-    private static final Color colorY = new Color(67, 204, 51);
-    private static final Color colorZ = new Color(52, 247, 255);
-    private static final int lineAlpha = 200;
-    private static final int planeAlpha = 75;
-    private static final Vec3d epsilon = new Vec3d(0.001, 0.001, 0.001); //prevents z-fighting
-
-
-    public static class MirrorSettings {
-        public boolean enabled = false;
-        public Vec3d position = new Vec3d(0.5, 64.5, 0.5);
-        public boolean mirrorX = true, mirrorY = false, mirrorZ = false;
-        public int radius = 20;
-        public boolean drawLines = true, drawPlanes = false;
-
-        public MirrorSettings() {
-        }
-
-        public MirrorSettings(boolean mirrorEnabled, Vec3d position, boolean mirrorX, boolean mirrorY, boolean mirrorZ, int radius, boolean drawLines, boolean drawPlanes) {
-            this.enabled = mirrorEnabled;
-            this.position = position;
-            this.mirrorX = mirrorX;
-            this.mirrorY = mirrorY;
-            this.mirrorZ = mirrorZ;
-            this.radius = radius;
-            this.drawLines = drawLines;
-            this.drawPlanes = drawPlanes;
-        }
-    }
-
-    //Called from EventHandler
-    public static void onBlockPlaced(BlockEvent.PlaceEvent event) {
-        if (event.getWorld().isRemote) return;
-
-        //find mirrorsettings for the player that placed the block
-        MirrorSettings m = BuildSettingsManager.getBuildSettings(event.getPlayer()).getMirrorSettings();
-        if (m == null) return;
-
-        if (!m.enabled || (!m.mirrorX && !m.mirrorY && !m.mirrorZ)) return;
-
-        //if within mirror distance, mirror
-        BlockPos oldBlockPos = event.getPos();
-
-        if (oldBlockPos.getX() + 0.5 < m.position.x - m.radius || oldBlockPos.getX() + 0.5 > m.position.x + m.radius ||
-                oldBlockPos.getY() + 0.5 < m.position.y - m.radius || oldBlockPos.getY() + 0.5 > m.position.y + m.radius ||
-                oldBlockPos.getZ() + 0.5 < m.position.z - m.radius || oldBlockPos.getZ() + 0.5 > m.position.z+ m.radius)
-            return;
-
-        if (m.mirrorX) {
-            placeMirrorX(event.getWorld(), m, oldBlockPos, event.getPlacedBlock());
-        }
-
-        if (m.mirrorY) {
-            placeMirrorY(event.getWorld(), m, oldBlockPos, event.getPlacedBlock());
-        }
-
-        if (m.mirrorZ) {
-            placeMirrorZ(event.getWorld(), m, oldBlockPos, event.getPlacedBlock());
-        }
-    }
-
-    private static void placeMirrorX(World world, MirrorSettings m, BlockPos oldBlockPos, IBlockState oldBlockState) {
-        //find mirror position
-        double x = m.position.x + (m.position.x - oldBlockPos.getX() - 0.5);
-        BlockPos newBlockPos = new BlockPos(x, oldBlockPos.getY(), oldBlockPos.getZ());
-        IBlockState newBlockState = oldBlockState;
-        //place block
-        if (world.isBlockLoaded(newBlockPos, true)) {
-            newBlockState = oldBlockState.withMirror(net.minecraft.util.Mirror.FRONT_BACK);
-
-            world.setBlockState(newBlockPos, newBlockState);
-        }
-        if (m.mirrorY) placeMirrorY(world, m, newBlockPos, newBlockState);
-        if (m.mirrorZ) placeMirrorZ(world, m, newBlockPos, newBlockState);
-    }
-
-    private static void placeMirrorY(World world, MirrorSettings m, BlockPos oldBlockPos, IBlockState oldBlockState) {
-        //find mirror position
-        double y = m.position.y + (m.position.y - oldBlockPos.getY() - 0.5);
-        BlockPos newBlockPos = new BlockPos(oldBlockPos.getX(), y, oldBlockPos.getZ());
-        IBlockState newBlockState = oldBlockState;
-        //place block
-        if (world.isBlockLoaded(newBlockPos, true)) {
-            newBlockState = getVerticalMirror(oldBlockState);
-
-            world.setBlockState(newBlockPos, newBlockState);
-        }
-        if (m.mirrorZ) placeMirrorZ(world, m, newBlockPos, newBlockState);
-    }
-
-    private static void placeMirrorZ(World world, MirrorSettings m, BlockPos oldBlockPos, IBlockState oldBlockState) {
-        //find mirror position
-        double z = m.position.z + (m.position.z - oldBlockPos.getZ() - 0.5);
-        BlockPos newBlockPos = new BlockPos(oldBlockPos.getX(), oldBlockPos.getY(), z);
-        IBlockState newBlockState = oldBlockState;
-        //place block
-        if (world.isBlockLoaded(newBlockPos, true)) {
-            newBlockState = oldBlockState.withMirror(net.minecraft.util.Mirror.LEFT_RIGHT);
-
-            world.setBlockState(newBlockPos, newBlockState);
-        }
-    }
-
-    private static IBlockState getVerticalMirror(IBlockState blockState) {
-        //Stairs
-        if (blockState.getBlock() instanceof BlockStairs) {
-            if (blockState.getValue(BlockStairs.HALF) == BlockStairs.EnumHalf.BOTTOM) {
-                return blockState.withProperty(BlockStairs.HALF, BlockStairs.EnumHalf.TOP);
-            } else {
-                return blockState.withProperty(BlockStairs.HALF, BlockStairs.EnumHalf.BOTTOM);
-            }
-        }
-
-        //Buttons, endrod, observer, piston
-        if (blockState.getBlock() instanceof BlockDirectional) {
-            if (blockState.getValue(BlockDirectional.FACING) == EnumFacing.DOWN) {
-                return blockState.withProperty(BlockDirectional.FACING, EnumFacing.UP);
-            } else if (blockState.getValue(BlockDirectional.FACING) == EnumFacing.UP) {
-                return blockState.withProperty(BlockDirectional.FACING, EnumFacing.DOWN);
-            }
-        }
-
-        //Dispenser, dropper
-        if (blockState.getBlock() instanceof BlockDispenser) {
-            if (blockState.getValue(BlockDispenser.FACING) == EnumFacing.DOWN) {
-                return blockState.withProperty(BlockDispenser.FACING, EnumFacing.UP);
-            } else if (blockState.getValue(BlockDispenser.FACING) == EnumFacing.UP) {
-                return blockState.withProperty(BlockDispenser.FACING, EnumFacing.DOWN);
-            }
-        }
-
-        return blockState;
-    }
-
-    //Called from EventHandler
-    public static void onBlockBroken(BlockEvent.BreakEvent event) {
-        if (event.getWorld().isRemote) return;
-
-        //find mirrorsettings for the player that broke the block
-        MirrorSettings m = BuildSettingsManager.getBuildSettings(event.getPlayer()).getMirrorSettings();
-        if (m == null) return;
-
-        if (!m.enabled || (!m.mirrorX && !m.mirrorY && !m.mirrorZ)) return;
-
-        //if within mirror distance, break mirror block
-        BlockPos oldBlockPos = event.getPos();
-
-        if (oldBlockPos.getX() + 0.5 < m.position.x - m.radius || oldBlockPos.getX() + 0.5 > m.position.x + m.radius ||
-                oldBlockPos.getY() + 0.5 < m.position.y - m.radius || oldBlockPos.getY() + 0.5 > m.position.y + m.radius ||
-                oldBlockPos.getZ() + 0.5 < m.position.z - m.radius || oldBlockPos.getZ() + 0.5 > m.position.z+ m.radius)
-            return;
-
-        if (m.mirrorX) {
-            breakMirrorX(event, m, oldBlockPos);
-        }
-
-        if (m.mirrorY) {
-            breakMirrorY(event, m, oldBlockPos);
-        }
-
-        if (m.mirrorZ) {
-            breakMirrorZ(event, m, oldBlockPos);
-        }
-    }
-
-    private static void breakMirrorX(BlockEvent.BreakEvent event, MirrorSettings m, BlockPos oldBlockPos) {
-        //find mirror position
-        double x = m.position.x + (m.position.x - oldBlockPos.getX() - 0.5);
-        BlockPos newBlockPos = new BlockPos(x, oldBlockPos.getY(), oldBlockPos.getZ());
-        //break block
-        if (event.getWorld().isBlockLoaded(newBlockPos, true)) {
-            event.getWorld().setBlockToAir(newBlockPos);
-        }
-        if (m.mirrorY) breakMirrorY(event, m, newBlockPos);
-        if (m.mirrorZ) breakMirrorZ(event, m, newBlockPos);
-    }
-
-    private static void breakMirrorY(BlockEvent.BreakEvent event, MirrorSettings m, BlockPos oldBlockPos) {
-        //find mirror position
-        double y = m.position.y + (m.position.y - oldBlockPos.getY() - 0.5);
-        BlockPos newBlockPos = new BlockPos(oldBlockPos.getX(), y, oldBlockPos.getZ());
-        //place block
-        if (event.getWorld().isBlockLoaded(newBlockPos, true)) {
-            event.getWorld().setBlockToAir(newBlockPos);
-        }
-        if (m.mirrorZ) breakMirrorZ(event, m, newBlockPos);
-    }
-
-    private static void breakMirrorZ(BlockEvent.BreakEvent event, MirrorSettings m, BlockPos oldBlockPos) {
-        //find mirror position
-        double z = m.position.z + (m.position.z - oldBlockPos.getZ() - 0.5);
-        BlockPos newBlockPos = new BlockPos(oldBlockPos.getX(), oldBlockPos.getY(), z);
-        //place block
-        if (event.getWorld().isBlockLoaded(newBlockPos, true)) {
-            event.getWorld().setBlockToAir(newBlockPos);
-        }
-    }
-
-    @SubscribeEvent
-    @SideOnly(Side.CLIENT)
-    public static void onRender(RenderWorldLastEvent event) {
-        EntityPlayerSP player = Minecraft.getMinecraft().player;
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(player);
-        if (buildSettings == null) return;
-        MirrorSettings m = buildSettings.getMirrorSettings();
-
-        if (m == null || !m.enabled || (!m.mirrorX && !m.mirrorY && !m.mirrorZ)) return;
-
-        Vec3d playerPos = new Vec3d(player.posX, player.posY, player.posZ);
-        Vec3d pos = m.position.add(epsilon);
-        int radius = m.radius;
-
-        if (m.mirrorX) {
-            Vec3d posA = new Vec3d(pos.x, pos.y - radius, pos.z - radius);
-            Vec3d posB = new Vec3d(pos.x, pos.y + radius, pos.z + radius);
-
-            drawMirrorPlane(playerPos, posA, posB, colorX, m.drawLines, m.drawPlanes);
-        }
-        if (m.mirrorY) {
-            Vec3d posA = new Vec3d(pos.x - radius, pos.y, pos.z - radius);
-            Vec3d posB = new Vec3d(pos.x + radius, pos.y, pos.z + radius);
-
-            drawMirrorPlaneY(playerPos, posA, posB, colorY, m.drawLines, m.drawPlanes);
-        }
-        if (m.mirrorZ) {
-            Vec3d posA = new Vec3d(pos.x - radius, pos.y - radius, pos.z);
-            Vec3d posB = new Vec3d(pos.x + radius, pos.y + radius, pos.z);
-
-            drawMirrorPlane(playerPos, posA, posB, colorZ, m.drawLines, m.drawPlanes);
-        }
-
-        //Draw axis coordinated colors if two or more axes are enabled
-        //(If only one is enabled the lines are that planes color)
-        if (m.drawLines && ((m.mirrorX && m.mirrorY) || (m.mirrorX && m.mirrorZ) || (m.mirrorY && m.mirrorZ))) {
-            drawMirrorLines(playerPos, m);
-        }
-    }
-
-    @SideOnly(Side.CLIENT)
-    public static void drawMirrorPlane(Vec3d playerPos, Vec3d posA, Vec3d posB, Color c, boolean drawLines, boolean drawPlanes) {
-
-        GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
-        GL11.glPushMatrix();
-        GL11.glDisable(GL11.GL_CULL_FACE);
-        GL11.glDisable(GL11.GL_LIGHTING);
-        GL11.glDisable(GL11.GL_TEXTURE_2D);
-
-        GL11.glEnable(GL11.GL_BLEND);
-        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        GL11.glTranslated(-playerPos.x, -playerPos.y, -playerPos.z);
-
-        GL11.glColor4d(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha);
-        GL11.glLineWidth(2);
-        GL11.glDepthMask(false);
-        Tessellator tessellator = Tessellator.getInstance();
-        BufferBuilder bufferBuilder = tessellator.getBuffer();
-
-        if (drawPlanes) {
-            bufferBuilder.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION_COLOR);
-
-            bufferBuilder.pos(posA.x, posA.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posA.x, posB.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posB.x, posA.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posB.x, posB.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-
-            tessellator.draw();
-        }
-
-        if (drawLines) {
-            Vec3d middle = posA.add(posB).scale(0.5);
-            bufferBuilder.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
-
-            bufferBuilder.pos(posA.x, middle.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-            bufferBuilder.pos(posB.x, middle.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-            bufferBuilder.pos(middle.x, posA.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-            bufferBuilder.pos(middle.x, posB.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-
-            tessellator.draw();
-        }
-
-        GL11.glDepthMask(true);
-        GL11.glPopMatrix();
-        GL11.glPopAttrib();
-    }
-
-    @SideOnly(Side.CLIENT)
-    public static void drawMirrorPlaneY(Vec3d playerPos, Vec3d posA, Vec3d posB, Color c, boolean drawLines, boolean drawPlanes) {
-
-        GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
-        GL11.glPushMatrix();
-        GL11.glDisable(GL11.GL_CULL_FACE);
-        GL11.glDisable(GL11.GL_LIGHTING);
-        GL11.glDisable(GL11.GL_TEXTURE_2D);
-
-        GL11.glEnable(GL11.GL_BLEND);
-        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        GL11.glTranslated(-playerPos.x, -playerPos.y, -playerPos.z);
-
-        GL11.glColor4d(c.getRed(), c.getGreen(), c.getBlue(), c.getAlpha());
-        GL11.glLineWidth(2);
-        GL11.glDepthMask(false);
-        Tessellator tessellator = Tessellator.getInstance();
-        BufferBuilder bufferBuilder = tessellator.getBuffer();
-
-        if (drawPlanes) {
-            bufferBuilder.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION_COLOR);
-
-            bufferBuilder.pos(posA.x, posA.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posA.x, posA.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posB.x, posA.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-            bufferBuilder.pos(posB.x, posA.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
-
-            tessellator.draw();
-        }
-
-        if (drawLines) {
-            Vec3d middle = posA.add(posB).scale(0.5);
-            bufferBuilder.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
-
-            bufferBuilder.pos(middle.x, middle.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-            bufferBuilder.pos(middle.x, middle.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-            bufferBuilder.pos(posA.x, middle.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-            bufferBuilder.pos(posB.x, middle.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
-
-            tessellator.draw();
-        }
-
-        GL11.glDepthMask(true);
-        GL11.glPopMatrix();
-        GL11.glPopAttrib();
-    }
-
-    @SideOnly(Side.CLIENT)
-    public static void drawMirrorLines(Vec3d playerPos, MirrorSettings m) {
-
-        Vec3d pos = m.position.add(epsilon);
-
-        GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
-        GL11.glPushMatrix();
-        GL11.glDisable(GL11.GL_CULL_FACE);
-        GL11.glDisable(GL11.GL_LIGHTING);
-        GL11.glDisable(GL11.GL_TEXTURE_2D);
-
-        GL11.glEnable(GL11.GL_BLEND);
-        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
-        GL11.glTranslated(-playerPos.x, -playerPos.y, -playerPos.z);
-
-        GL11.glColor4d(100, 100, 100, 255);
-        GL11.glLineWidth(2);
-        GL11.glDepthMask(false);
-        Tessellator tessellator = Tessellator.getInstance();
-        BufferBuilder bufferBuilder = tessellator.getBuffer();
-
-        bufferBuilder.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
-
-        bufferBuilder.pos(pos.x - m.radius, pos.y, pos.z).color(colorZ.getRed(), colorZ.getGreen(), colorZ.getBlue(), lineAlpha).endVertex();
-        bufferBuilder.pos(pos.x + m.radius, pos.y, pos.z).color(colorZ.getRed(), colorZ.getGreen(), colorZ.getBlue(), lineAlpha).endVertex();
-        bufferBuilder.pos(pos.x, pos.y - m.radius, pos.z).color(colorY.getRed(), colorY.getGreen(), colorY.getBlue(), lineAlpha).endVertex();
-        bufferBuilder.pos(pos.x, pos.y + m.radius, pos.z).color(colorY.getRed(), colorY.getGreen(), colorY.getBlue(), lineAlpha).endVertex();
-        bufferBuilder.pos(pos.x, pos.y, pos.z - m.radius).color(colorX.getRed(), colorX.getGreen(), colorX.getBlue(), lineAlpha).endVertex();
-        bufferBuilder.pos(pos.x, pos.y, pos.z + m.radius).color(colorX.getRed(), colorX.getGreen(), colorX.getBlue(), lineAlpha).endVertex();
-
-        tessellator.draw();
-
-        GL11.glDepthMask(true);
-        GL11.glPopMatrix();
-        GL11.glPopAttrib();
-    }
-
-
-}

src/main/java/nl/requios/effortlessbuilding/QuickReplace.java

@@ -1,61 +0,0 @@
-package nl.requios.effortlessbuilding;
-
-import net.minecraft.block.state.IBlockState;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.util.EnumHand;
-import net.minecraft.util.math.BlockPos;
-import net.minecraftforge.common.util.BlockSnapshot;
-import net.minecraftforge.event.world.BlockEvent;
-import nl.requios.effortlessbuilding.network.QuickReplaceMessage;
-
-import java.util.Dictionary;
-import java.util.Hashtable;
-import java.util.UUID;
-
-public class QuickReplace {
-    //Dilemma in getting blockstate from event to when message is received:
-    // 1) send via client. Then hacking makes it possible to place any block.
-    // 2) save serverside. Messages may not be received chronologically so data could get switched.
-    //Solution for now: save blockstate per player. Messages from 1 player will rarely come unchronologically
-    //and players will rarely switch between blocks that quickly.
-
-    private static Dictionary<UUID, IBlockState> blockStates = new Hashtable<>();
-
-    public static void onBlockPlaced(BlockEvent.PlaceEvent event) {
-        if (event.getWorld().isRemote) return;
-        //Only serverside
-
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(event.getPlayer());
-        if (!buildSettings.doQuickReplace()) return;
-
-        //TODO base on player facing instead, no more messages (or break block clientside)
-
-        blockStates.put(event.getPlayer().getUniqueID(), event.getPlacedBlock());
-
-        //RayTraceResult result = event.getWorld().rayTraceBlocks(event.getPlayer().getPositionEyes(1f), event.getPlayer().getLookVec());
-        EffortlessBuilding.packetHandler.sendTo(new QuickReplaceMessage(), (EntityPlayerMP) event.getPlayer());
-
-        event.setCanceled(true);
-    }
-
-    public static void onMessageReceived(EntityPlayer player, QuickReplaceMessage message) {
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(player);
-        if (!buildSettings.doQuickReplace()) return;
-
-        //TODO check for bedrock, end portal etc in survival
-
-        if (!message.isBlockHit() || message.getBlockPos() == null) return;
-
-        BlockPos placedAgainstBlockPos = message.getBlockPos();
-        //placedAgainstBlockPos = placedAgainstBlockPos.down();
-        IBlockState blockState = blockStates.get(player.getUniqueID());
-        player.world.setBlockState(placedAgainstBlockPos, blockState);
-
-        //Mirror and Array synergy
-        BlockSnapshot blockSnapshot = new BlockSnapshot(player.world, placedAgainstBlockPos, blockState);
-        BlockEvent.PlaceEvent placeEvent = new BlockEvent.PlaceEvent(blockSnapshot, blockState, player, EnumHand.MAIN_HAND);
-        Array.onBlockPlaced(placeEvent);
-        Mirror.onBlockPlaced(placeEvent);
-    }
-}

src/main/java/nl/requios/effortlessbuilding/buildmode/BaseBuildMode.java

@@ -0,0 +1,40 @@
+package nl.requios.effortlessbuilding.buildmode;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+
+import java.util.Dictionary;
+import java.util.Hashtable;
+import java.util.List;
+import java.util.UUID;
+
+public abstract class BaseBuildMode implements IBuildMode {
+    //In singleplayer client and server variables are shared
+    //Split everything that needs separate values and may not be called twice in one click
+    protected Dictionary<UUID, Integer> rightClickClientTable = new Hashtable<>();
+    protected Dictionary<UUID, Integer> rightClickServerTable = new Hashtable<>();
+    protected Dictionary<UUID, BlockPos> firstPosTable = new Hashtable<>();
+    protected Dictionary<UUID, EnumFacing> sideHitTable = new Hashtable<>();
+    protected Dictionary<UUID, Vec3d> hitVecTable = new Hashtable<>();
+
+    @Override
+    public void initialize(EntityPlayer player) {
+        rightClickClientTable.put(player.getUniqueID(), 0);
+        rightClickServerTable.put(player.getUniqueID(), 0);
+        firstPosTable.put(player.getUniqueID(), BlockPos.ORIGIN);
+        sideHitTable.put(player.getUniqueID(), EnumFacing.UP);
+        hitVecTable.put(player.getUniqueID(), Vec3d.ZERO);
+    }
+
+    @Override
+    public EnumFacing getSideHit(EntityPlayer player) {
+        return sideHitTable.get(player.getUniqueID());
+    }
+
+    @Override
+    public Vec3d getHitVec(EntityPlayer player) {
+        return hitVecTable.get(player.getUniqueID());
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/BuildModes.java

@@ -0,0 +1,245 @@
+package nl.requios.effortlessbuilding.buildmode;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.buildmodes.*;
+import nl.requios.effortlessbuilding.buildmode.buildmodes.Circle;
+import nl.requios.effortlessbuilding.buildmode.buildmodes.Cylinder;
+import nl.requios.effortlessbuilding.buildmode.buildmodes.Sphere;
+import nl.requios.effortlessbuilding.buildmodifier.*;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+import nl.requios.effortlessbuilding.helper.SurvivalHelper;
+import nl.requios.effortlessbuilding.network.BlockBrokenMessage;
+import nl.requios.effortlessbuilding.network.BlockPlacedMessage;
+
+import java.util.ArrayList;
+import java.util.Dictionary;
+import java.util.Hashtable;
+import java.util.List;
+
+import static nl.requios.effortlessbuilding.buildmode.ModeOptions.*;
+
+public class BuildModes {
+
+    //Static variables are shared between client and server in singleplayer
+    //We need them separate
+    public static Dictionary<EntityPlayer, Boolean> currentlyBreakingClient = new Hashtable<>();
+    public static Dictionary<EntityPlayer, Boolean> currentlyBreakingServer = new Hashtable<>();
+
+    public enum BuildModeEnum {
+        NORMAL("effortlessbuilding.mode.normal", new Normal()),
+        NORMAL_PLUS("effortlessbuilding.mode.normal_plus", new NormalPlus(), OptionEnum.BUILD_SPEED),
+        LINE("effortlessbuilding.mode.line", new Line() /*, OptionEnum.THICKNESS*/),
+        WALL("effortlessbuilding.mode.wall", new Wall(), OptionEnum.FILL),
+        FLOOR("effortlessbuilding.mode.floor", new Floor(), OptionEnum.FILL),
+        DIAGONAL_LINE("effortlessbuilding.mode.diagonal_line", new DiagonalLine() /*, OptionEnum.THICKNESS*/),
+        DIAGONAL_WALL("effortlessbuilding.mode.diagonal_wall", new DiagonalWall() /*, OptionEnum.FILL*/),
+        SLOPE_FLOOR("effortlessbuilding.mode.slope_floor", new SlopeFloor(), OptionEnum.RAISED_EDGE),
+        CIRCLE("effortlessbuilding.mode.circle", new Circle(), OptionEnum.CIRCLE_START, OptionEnum.FILL),
+        CYLINDER("effortlessbuilding.mode.cylinder", new Cylinder(), OptionEnum.CIRCLE_START, OptionEnum.FILL),
+        SPHERE("effortlessbuilding.mode.sphere", new Sphere(), OptionEnum.CIRCLE_START, OptionEnum.FILL),
+        CUBE("effortlessbuilding.mode.cube", new Cube(), OptionEnum.CUBE_FILL);
+
+        public String name;
+        public IBuildMode instance;
+        public OptionEnum[] options;
+
+        BuildModeEnum(String name, IBuildMode instance, OptionEnum... options) {
+            this.name = name;
+            this.instance = instance;
+            this.options = options;
+        }
+    }
+
+    //Uses a network message to get the previous raytraceresult from the player
+    //The server could keep track of all raytraceresults but this might lag with many players
+    //Raytraceresult is needed for sideHit and hitVec
+    public static void onBlockPlacedMessage(EntityPlayer player, BlockPlacedMessage message) {
+
+        //Check if not in the middle of breaking
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
+        if (currentlyBreaking.get(player) != null && currentlyBreaking.get(player)) {
+            //Cancel breaking
+            initializeMode(player);
+            return;
+        }
+
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+        BuildModeEnum buildMode = modeSettings.getBuildMode();
+
+        BlockPos startPos = null;
+
+        if (message.isBlockHit() && message.getBlockPos() != null) {
+            startPos = message.getBlockPos();
+
+            //Offset in direction of sidehit if not quickreplace and not replaceable
+            boolean replaceable = player.world.getBlockState(startPos).getBlock().isReplaceable(player.world, startPos);
+            boolean becomesDoubleSlab = SurvivalHelper.doesBecomeDoubleSlab(player, startPos, message.getSideHit());
+            if (!modifierSettings.doQuickReplace() && !replaceable && !becomesDoubleSlab) {
+                startPos = startPos.offset(message.getSideHit());
+            }
+
+            //Get under tall grass and other replaceable blocks
+            if (modifierSettings.doQuickReplace() && replaceable) {
+                startPos = startPos.down();
+            }
+
+            //Check if player reach does not exceed startpos
+            int maxReach = ReachHelper.getMaxReach(player);
+            if (buildMode != BuildModeEnum.NORMAL && player.getPosition().distanceSq(startPos) > maxReach * maxReach) {
+                EffortlessBuilding.log(player, "Placement exceeds your reach.");
+                return;
+            }
+        }
+
+        //Even when no starting block is found, call buildmode instance
+        //We might want to place things in the air
+        List<BlockPos> coordinates = buildMode.instance.onRightClick(player, startPos, message.getSideHit(), message.getHitVec(), modifierSettings.doQuickReplace());
+
+        if (coordinates.isEmpty()) {
+            currentlyBreaking.put(player, false);
+            return;
+        }
+
+        //Limit number of blocks you can place
+        int limit = ReachHelper.getMaxBlocksPlacedAtOnce(player);
+        if (coordinates.size() > limit) {
+            coordinates = coordinates.subList(0, limit);
+        }
+
+        EnumFacing sideHit = buildMode.instance.getSideHit(player);
+        if (sideHit == null) sideHit = message.getSideHit();
+
+        Vec3d hitVec = buildMode.instance.getHitVec(player);
+        if (hitVec == null) hitVec = message.getHitVec();
+
+        BuildModifiers.onBlockPlaced(player, coordinates, sideHit, hitVec, message.getPlaceStartPos());
+
+        //Only works when finishing a buildmode is equal to placing some blocks
+        //No intermediate blocks allowed
+        currentlyBreaking.remove(player);
+
+    }
+
+    //Use a network message to break blocks in the distance using clientside mouse input
+    public static void onBlockBrokenMessage(EntityPlayer player, BlockBrokenMessage message) {
+        BlockPos startPos = message.isBlockHit() ? message.getBlockPos() : null;
+        onBlockBroken(player, startPos, true);
+    }
+
+    public static void onBlockBroken(EntityPlayer player, BlockPos startPos, boolean breakStartPos) {
+
+        //Check if not in the middle of placing
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
+        if (currentlyBreaking.get(player) != null && !currentlyBreaking.get(player)) {
+            //Cancel placing
+            initializeMode(player);
+            return;
+        }
+
+        //If first click
+        if (currentlyBreaking.get(player) == null) {
+            //If startpos is null, dont do anything
+            if (startPos == null) return;
+        }
+
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+
+        //Get coordinates
+        BuildModeEnum buildMode = modeSettings.getBuildMode();
+        List<BlockPos> coordinates = buildMode.instance.onRightClick(player, startPos, EnumFacing.UP, Vec3d.ZERO, true);
+
+        if (coordinates.isEmpty()) {
+            currentlyBreaking.put(player, true);
+            return;
+        }
+
+        //Let buildmodifiers break blocks
+        BuildModifiers.onBlockBroken(player, coordinates, breakStartPos);
+
+        //Only works when finishing a buildmode is equal to breaking some blocks
+        //No intermediate blocks allowed
+        currentlyBreaking.remove(player);
+    }
+
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos, boolean skipRaytrace) {
+        List<BlockPos> coordinates = new ArrayList<>();
+
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+        coordinates.addAll(modeSettings.getBuildMode().instance.findCoordinates(player, startPos, skipRaytrace));
+
+        return coordinates;
+    }
+
+    public static void initializeMode(EntityPlayer player) {
+        //Resetting mode, so not placing or breaking
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
+        currentlyBreaking.remove(player);
+
+        ModeSettingsManager.getModeSettings(player).getBuildMode().instance.initialize(player);
+    }
+
+    public static boolean isCurrentlyPlacing(EntityPlayer player) {
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
+        return currentlyBreaking.get(player) != null && !currentlyBreaking.get(player);
+    }
+
+    public static boolean isCurrentlyBreaking(EntityPlayer player) {
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
+        return currentlyBreaking.get(player) != null && currentlyBreaking.get(player);
+    }
+
+    //Either placing or breaking
+    public static boolean isActive(EntityPlayer player) {
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
+        return currentlyBreaking.get(player) != null;
+    }
+
+
+    //Find coordinates on a line bound by a plane
+    public static Vec3d findXBound(double x, Vec3d start, Vec3d look) {
+        //then y and z are
+        double y = (x - start.x) / look.x * look.y + start.y;
+        double z = (x - start.x) / look.x * look.z + start.z;
+
+        return new Vec3d(x, y, z);
+    }
+
+    public static Vec3d findYBound(double y, Vec3d start, Vec3d look) {
+        //then x and z are
+        double x = (y - start.y) / look.y * look.x + start.x;
+        double z = (y - start.y) / look.y * look.z + start.z;
+
+        return new Vec3d(x, y, z);
+    }
+
+    public static Vec3d findZBound(double z, Vec3d start, Vec3d look) {
+        //then x and y are
+        double x = (z - start.z) / look.z * look.x + start.x;
+        double y = (z - start.z) / look.z * look.y + start.y;
+
+        return new Vec3d(x, y, z);
+    }
+
+    public static boolean isCriteriaValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace, Vec3d lineBound, Vec3d planeBound, double distToPlayerSq) {
+        boolean intersects = false;
+        if (!skipRaytrace) {
+            //collision within a 1 block radius to selected is fine
+            RayTraceResult rayTraceResult = player.world.rayTraceBlocks(start, lineBound, false, true, false);
+            intersects = rayTraceResult != null && rayTraceResult.typeOfHit == RayTraceResult.Type.BLOCK &&
+                         planeBound.subtract(rayTraceResult.hitVec).lengthSquared() > 4;
+        }
+
+        return planeBound.subtract(start).dotProduct(look) > 0 &&
+               distToPlayerSq > 2 && distToPlayerSq < reach * reach &&
+               !intersects;
+    }
+
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/IBuildMode.java

@@ -0,0 +1,25 @@
+package nl.requios.effortlessbuilding.buildmode;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+
+import java.util.List;
+
+public interface IBuildMode {
+
+    //Fired when a player selects a buildmode and when it needs to initializeMode
+    void initialize(EntityPlayer player);
+
+    //Fired when a block would be placed
+    //Return a list of coordinates where you want to place blocks
+    List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace);
+
+    //Fired continuously for visualization purposes
+    List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace);
+
+    EnumFacing getSideHit(EntityPlayer player);
+
+    Vec3d getHitVec(EntityPlayer player);
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/ModeOptions.java

@@ -0,0 +1,182 @@
+package nl.requios.effortlessbuilding.buildmode;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.text.TextFormatting;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.UndoRedo;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
+
+public class ModeOptions {
+
+    public enum ActionEnum {
+        UNDO("effortlessbuilding.action.undo"),
+        REDO("effortlessbuilding.action.redo"),
+        REPLACE("effortlessbuilding.action.replace"),
+        OPEN_MODIFIER_SETTINGS("effortlessbuilding.action.open_modifier_settings"),
+
+        NORMAL_SPEED("effortlessbuilding.action.normal_speed"),
+        FAST_SPEED("effortlessbuilding.action.fast_speed"),
+
+        FULL("effortlessbuilding.action.full"),
+        HOLLOW("effortlessbuilding.action.hollow"),
+
+        CUBE_FULL("effortlessbuilding.action.full"),
+        CUBE_HOLLOW("effortlessbuilding.action.hollow"),
+        CUBE_SKELETON("effortlessbuilding.action.skeleton"),
+
+        SHORT_EDGE("effortlessbuilding.action.short_edge"),
+        LONG_EDGE("effortlessbuilding.action.long_edge"),
+
+        THICKNESS_1("effortlessbuilding.action.thickness_1"),
+        THICKNESS_3("effortlessbuilding.action.thickness_3"),
+        THICKNESS_5("effortlessbuilding.action.thickness_5"),
+
+        CIRCLE_START_CORNER("effortlessbuilding.action.start_corner"),
+        CIRCLE_START_CENTER("effortlessbuilding.action.start_center");
+
+        public String name;
+
+        ActionEnum(String name) {
+            this.name = name;
+        }
+    }
+
+    public enum OptionEnum {
+        BUILD_SPEED("effortlessbuilding.action.build_speed", ActionEnum.NORMAL_SPEED, ActionEnum.FAST_SPEED),
+        FILL("effortlessbuilding.action.filling", ActionEnum.FULL, ActionEnum.HOLLOW),
+        CUBE_FILL("effortlessbuilding.action.filling", ActionEnum.CUBE_FULL, ActionEnum.CUBE_HOLLOW, ActionEnum.CUBE_SKELETON),
+        RAISED_EDGE("effortlessbuilding.action.raised_edge", ActionEnum.SHORT_EDGE, ActionEnum.LONG_EDGE),
+        LINE_THICKNESS("effortlessbuilding.action.thickness", ActionEnum.THICKNESS_1, ActionEnum.THICKNESS_3, ActionEnum.THICKNESS_5),
+        CIRCLE_START("effortlessbuilding.action.circle_start", ActionEnum.CIRCLE_START_CORNER, ActionEnum.CIRCLE_START_CENTER);
+
+        public String name;
+        public ActionEnum[] actions;
+
+        OptionEnum(String name, ActionEnum... actions){
+            this.name = name;
+            this.actions = actions;
+        }
+    }
+
+    private static ActionEnum buildSpeed = ActionEnum.NORMAL_SPEED;
+    private static ActionEnum fill = ActionEnum.FULL;
+    private static ActionEnum cubeFill = ActionEnum.CUBE_FULL;
+    private static ActionEnum raisedEdge = ActionEnum.SHORT_EDGE;
+    private static ActionEnum lineThickness = ActionEnum.THICKNESS_1;
+    private static ActionEnum circleStart = ActionEnum.CIRCLE_START_CORNER;
+
+    public static ActionEnum getOptionSetting(OptionEnum option) {
+        switch (option) {
+            case BUILD_SPEED:
+                return getBuildSpeed();
+            case FILL:
+                return getFill();
+            case CUBE_FILL:
+                return getCubeFill();
+            case RAISED_EDGE:
+                return getRaisedEdge();
+            case LINE_THICKNESS:
+                return getLineThickness();
+            case CIRCLE_START:
+                return getCircleStart();
+            default:
+                return null;
+        }
+    }
+
+    public static ActionEnum getBuildSpeed() {
+        return buildSpeed;
+    }
+
+    public static ActionEnum getFill() {
+        return fill;
+    }
+
+    public static ActionEnum getCubeFill() {
+        return cubeFill;
+    }
+
+    public static ActionEnum getRaisedEdge() {
+        return raisedEdge;
+    }
+
+    public static ActionEnum getLineThickness() {
+        return lineThickness;
+    }
+
+    public static ActionEnum getCircleStart() {
+        return circleStart;
+    }
+
+    //Called on both client and server
+    public static void performAction(EntityPlayer player, ActionEnum action) {
+        if (action == null) return;
+
+        switch (action) {
+            case UNDO:
+                UndoRedo.undo(player);
+                break;
+            case REDO:
+                UndoRedo.redo(player);
+                break;
+            case REPLACE:
+                ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+                modifierSettings.setQuickReplace(!modifierSettings.doQuickReplace());
+                EffortlessBuilding.log(player, "Set " + TextFormatting.GOLD + "Quick Replace " + TextFormatting.RESET + (
+                        modifierSettings.doQuickReplace() ? "on" : "off"), true);
+                break;
+            case OPEN_MODIFIER_SETTINGS:
+                if (player.world.isRemote)
+                    ClientProxy.openModifierSettings();
+                break;
+
+            case NORMAL_SPEED:
+                buildSpeed = ActionEnum.NORMAL_SPEED;
+                break;
+            case FAST_SPEED:
+                buildSpeed = ActionEnum.FAST_SPEED;
+                break;
+            case FULL:
+                fill = ActionEnum.FULL;
+                break;
+            case HOLLOW:
+                fill = ActionEnum.HOLLOW;
+                break;
+            case CUBE_FULL:
+                cubeFill = ActionEnum.CUBE_FULL;
+                break;
+            case CUBE_HOLLOW:
+                cubeFill = ActionEnum.CUBE_HOLLOW;
+                break;
+            case CUBE_SKELETON:
+                cubeFill = ActionEnum.CUBE_SKELETON;
+                break;
+            case SHORT_EDGE:
+                raisedEdge = ActionEnum.SHORT_EDGE;
+                break;
+            case LONG_EDGE:
+                raisedEdge = ActionEnum.LONG_EDGE;
+                break;
+            case THICKNESS_1:
+                lineThickness = ActionEnum.THICKNESS_1;
+                break;
+            case THICKNESS_3:
+                lineThickness = ActionEnum.THICKNESS_3;
+                break;
+            case THICKNESS_5:
+                lineThickness = ActionEnum.THICKNESS_5;
+                break;
+            case CIRCLE_START_CENTER:
+                circleStart = ActionEnum.CIRCLE_START_CENTER;
+                break;
+            case CIRCLE_START_CORNER:
+                circleStart = ActionEnum.CIRCLE_START_CORNER;
+                break;
+        }
+
+        if (player.world.isRemote && action != ActionEnum.REPLACE && action != ActionEnum.OPEN_MODIFIER_SETTINGS) {
+            ClientProxy.logTranslate(action.name);
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/ModeSettingsManager.java

@@ -0,0 +1,86 @@
+package nl.requios.effortlessbuilding.buildmode;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraftforge.fml.common.Mod;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.capability.ModeCapabilityManager;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+import nl.requios.effortlessbuilding.network.ModeSettingsMessage;
+
+@Mod.EventBusSubscriber
+public class ModeSettingsManager {
+
+    //Retrieves the buildsettings of a player through the modifierCapability capability
+    //Never returns null
+    public static ModeSettings getModeSettings(EntityPlayer player) {
+        if (player.hasCapability(ModeCapabilityManager.modeCapability, null)) {
+            ModeCapabilityManager.IModeCapability capability = player.getCapability(
+                    ModeCapabilityManager.modeCapability, null);
+            if (capability.getModeData() == null) {
+                capability.setModeData(new ModeSettings());
+            }
+            return capability.getModeData();
+        }
+        throw new IllegalArgumentException("Player does not have modeCapability capability");
+    }
+
+    public static void setModeSettings(EntityPlayer player, ModeSettings modeSettings) {
+        if (player == null) {
+            EffortlessBuilding.log("Cannot set buildsettings, player is null");
+            return;
+        }
+        if (player.hasCapability(ModeCapabilityManager.modeCapability, null)) {
+            ModeCapabilityManager.IModeCapability capability = player.getCapability(
+                    ModeCapabilityManager.modeCapability, null);
+
+            capability.setModeData(modeSettings);
+
+            //Initialize new mode
+            BuildModes.initializeMode(player);
+        } else {
+            EffortlessBuilding.log(player, "Saving buildsettings failed.");
+        }
+    }
+
+    public static String sanitize(ModeSettings modeSettings, EntityPlayer player) {
+        int maxReach = ReachHelper.getMaxReach(player);
+        String error = "";
+
+        //TODO sanitize
+
+        return error;
+    }
+
+    public static class ModeSettings {
+        private BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.NORMAL;
+
+        public ModeSettings() {
+        }
+
+        public ModeSettings(BuildModes.BuildModeEnum buildMode) {
+            this.buildMode = buildMode;
+        }
+
+        public BuildModes.BuildModeEnum getBuildMode() {
+            return this.buildMode;
+        }
+
+        public void setBuildMode(BuildModes.BuildModeEnum buildMode) {
+            this.buildMode = buildMode;
+        }
+    }
+
+    public static void handleNewPlayer(EntityPlayer player){
+        if (getModeSettings(player) == null) {
+            setModeSettings(player, new ModeSettings());
+        }
+
+        //Only on server
+        if (!player.world.isRemote) {
+            //Send to client
+            ModeSettingsMessage msg = new ModeSettingsMessage(getModeSettings(player));
+            EffortlessBuilding.packetHandler.sendTo(msg, (EntityPlayerMP) player);
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/ThreeClicksBuildMode.java

@@ -0,0 +1,215 @@
+package nl.requios.effortlessbuilding.buildmode;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.buildmode.buildmodes.DiagonalLine;
+import nl.requios.effortlessbuilding.buildmode.buildmodes.Floor;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.util.*;
+
+public abstract class ThreeClicksBuildMode extends BaseBuildMode {
+    protected Dictionary<UUID, BlockPos> secondPosTable = new Hashtable<>();
+
+    static class HeightCriteria {
+        Vec3d planeBound;
+        Vec3d lineBound;
+        double distToLineSq;
+        double distToPlayerSq;
+
+        HeightCriteria(Vec3d planeBound, BlockPos secondPos, Vec3d start) {
+            this.planeBound = planeBound;
+            this.lineBound = toLongestLine(this.planeBound, secondPos);
+            this.distToLineSq = this.lineBound.subtract(this.planeBound).lengthSquared();
+            this.distToPlayerSq = this.planeBound.subtract(start).lengthSquared();
+        }
+
+        //Make it from a plane into a line, on y axis only
+        private Vec3d toLongestLine(Vec3d boundVec, BlockPos secondPos) {
+            BlockPos bound = new BlockPos(boundVec);
+            return new Vec3d(secondPos.getX(), bound.getY(), secondPos.getZ());
+        }
+
+        //check if its not behind the player and its not too close and not too far
+        //also check if raytrace from player to block does not intersect blocks
+        public boolean isValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace) {
+
+            return BuildModes.isCriteriaValid(start, look, reach, player, skipRaytrace, lineBound, planeBound, distToPlayerSq);
+        }
+    }
+
+    @Override
+    public void initialize(EntityPlayer player) {
+        super.initialize(player);
+        secondPosTable.put(player.getUniqueID(), BlockPos.ORIGIN);
+    }
+
+    @Override
+    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace) {
+        List<BlockPos> list = new ArrayList<>();
+
+        Dictionary<UUID, Integer> rightClickTable = player.world.isRemote ? rightClickClientTable : rightClickServerTable;
+        int rightClickNr = rightClickTable.get(player.getUniqueID());
+        rightClickNr++;
+        rightClickTable.put(player.getUniqueID(), rightClickNr);
+
+        if (rightClickNr == 1) {
+            //If clicking in air, reset and try again
+            if (blockPos == null) {
+                rightClickTable.put(player.getUniqueID(), 0);
+                return list;
+            }
+
+            //First click, remember starting position
+            firstPosTable.put(player.getUniqueID(), blockPos);
+            sideHitTable.put(player.getUniqueID(), sideHit);
+            hitVecTable.put(player.getUniqueID(), hitVec);
+            //Keep list empty, dont place any blocks yet
+        } else if (rightClickNr == 2) {
+            //Second click, find other floor point
+            BlockPos firstPos = firstPosTable.get(player.getUniqueID());
+            BlockPos secondPos = findSecondPos(player, firstPos, true);
+
+            if (secondPos == null) {
+                rightClickTable.put(player.getUniqueID(), 1);
+                return list;
+            }
+
+            secondPosTable.put(player.getUniqueID(), secondPos);
+
+        } else {
+            //Third click, place diagonal wall with height
+            list = findCoordinates(player, blockPos, skipRaytrace);
+            rightClickTable.put(player.getUniqueID(), 0);
+        }
+
+        return list;
+    }
+
+    @Override
+    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace) {
+        List<BlockPos> list = new ArrayList<>();
+        Dictionary<UUID, Integer> rightClickTable = player.world.isRemote ? rightClickClientTable : rightClickServerTable;
+        int rightClickNr = rightClickTable.get(player.getUniqueID());
+
+        if (rightClickNr == 0) {
+            if (blockPos != null)
+                list.add(blockPos);
+        } else if (rightClickNr == 1) {
+            BlockPos firstPos = firstPosTable.get(player.getUniqueID());
+
+            BlockPos secondPos = findSecondPos(player, firstPos, true);
+            if (secondPos == null) return list;
+
+            //Limit amount of blocks you can place per row
+            int axisLimit = ReachHelper.getMaxBlocksPerAxis(player);
+
+            int x1 = firstPos.getX(), x2 = secondPos.getX();
+            int y1 = firstPos.getY(), y2 = secondPos.getY();
+            int z1 = firstPos.getZ(), z2 = secondPos.getZ();
+
+            //limit axis
+            if (x2 - x1 >= axisLimit) x2 = x1 + axisLimit - 1;
+            if (x1 - x2 >= axisLimit) x2 = x1 - axisLimit + 1;
+            if (y2 - y1 >= axisLimit) y2 = y1 + axisLimit - 1;
+            if (y1 - y2 >= axisLimit) y2 = y1 - axisLimit + 1;
+            if (z2 - z1 >= axisLimit) z2 = z1 + axisLimit - 1;
+            if (z1 - z2 >= axisLimit) z2 = z1 - axisLimit + 1;
+
+            //Add diagonal line from first to second
+            list.addAll(getIntermediateBlocks(player, x1, y1, z1, x2, y2, z2));
+
+        } else {
+            BlockPos firstPos = firstPosTable.get(player.getUniqueID());
+            BlockPos secondPos = secondPosTable.get(player.getUniqueID());
+
+            BlockPos thirdPos = findThirdPos(player, firstPos, secondPos, skipRaytrace);
+            if (thirdPos == null) return list;
+
+            //Limit amount of blocks you can place per row
+            int axisLimit = ReachHelper.getMaxBlocksPerAxis(player);
+
+            int x1 = firstPos.getX(), x2 = secondPos.getX(), x3 = thirdPos.getX();
+            int y1 = firstPos.getY(), y2 = secondPos.getY(), y3 = thirdPos.getY();
+            int z1 = firstPos.getZ(), z2 = secondPos.getZ(), z3 = thirdPos.getZ();
+
+            //limit axis
+            if (x2 - x1 >= axisLimit) x2 = x1 + axisLimit - 1;
+            if (x1 - x2 >= axisLimit) x2 = x1 - axisLimit + 1;
+            if (y2 - y1 >= axisLimit) y2 = y1 + axisLimit - 1;
+            if (y1 - y2 >= axisLimit) y2 = y1 - axisLimit + 1;
+            if (z2 - z1 >= axisLimit) z2 = z1 + axisLimit - 1;
+            if (z1 - z2 >= axisLimit) z2 = z1 - axisLimit + 1;
+
+            if (x3 - x1 >= axisLimit) x3 = x1 + axisLimit - 1;
+            if (x1 - x3 >= axisLimit) x3 = x1 - axisLimit + 1;
+            if (y3 - y1 >= axisLimit) y3 = y1 + axisLimit - 1;
+            if (y1 - y3 >= axisLimit) y3 = y1 - axisLimit + 1;
+            if (z3 - z1 >= axisLimit) z3 = z1 + axisLimit - 1;
+            if (z1 - z3 >= axisLimit) z3 = z1 - axisLimit + 1;
+
+            //Add diagonal line from first to third
+            list.addAll(getFinalBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3));
+        }
+
+        return list;
+    }
+
+    //Finds the place of the second block pos
+    protected abstract BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace);
+
+    //Finds the place of the third block pos
+    protected abstract BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace);
+
+    //After first and second pos are known, we want to visualize the blocks in a way (like floor for cube)
+    protected abstract List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2);
+
+    //After first, second and third pos are known, we want all the blocks
+    protected abstract List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3);
+
+    //Finds height after floor has been chosen in buildmodes with 3 clicks
+    public static BlockPos findHeight(EntityPlayer player, BlockPos secondPos, boolean skipRaytrace) {
+        Vec3d look = player.getLookVec();
+        Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
+
+        List<HeightCriteria> criteriaList = new ArrayList<>(3);
+
+        //X
+        Vec3d xBound = BuildModes.findXBound(secondPos.getX(), start, look);
+        criteriaList.add(new HeightCriteria(xBound, secondPos, start));
+
+        //Z
+        Vec3d zBound = BuildModes.findZBound(secondPos.getZ(), start, look);
+        criteriaList.add(new HeightCriteria(zBound, secondPos, start));
+
+        //Remove invalid criteria
+        int reach = ReachHelper.getPlacementReach(player) * 4; //4 times as much as normal placement reach
+        criteriaList.removeIf(criteria -> !criteria.isValid(start, look, reach, player, skipRaytrace));
+
+        //If none are valid, return empty list of blocks
+        if (criteriaList.isEmpty()) return null;
+
+        //If only 1 is valid, choose that one
+        HeightCriteria selected = criteriaList.get(0);
+
+        //If multiple are valid, choose based on criteria
+        if (criteriaList.size() > 1) {
+            //Select the one that is closest (from wall position to its line counterpart)
+            for (int i = 1; i < criteriaList.size(); i++) {
+                HeightCriteria criteria = criteriaList.get(i);
+                if (criteria.distToLineSq < 2.0 && selected.distToLineSq < 2.0) {
+                    //Both very close to line, choose closest to player
+                    if (criteria.distToPlayerSq < selected.distToPlayerSq)
+                        selected = criteria;
+                } else {
+                    //Pick closest to line
+                    if (criteria.distToLineSq < selected.distToLineSq)
+                        selected = criteria;
+                }
+            }
+        }
+        return new BlockPos(selected.lineBound);
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/TwoClicksBuildMode.java

@@ -0,0 +1,86 @@
+package nl.requios.effortlessbuilding.buildmode;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.util.ArrayList;
+import java.util.Dictionary;
+import java.util.List;
+import java.util.UUID;
+
+public abstract class TwoClicksBuildMode extends BaseBuildMode {
+
+    @Override
+    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace) {
+        List<BlockPos> list = new ArrayList<>();
+
+        Dictionary<UUID, Integer> rightClickTable = player.world.isRemote ? rightClickClientTable : rightClickServerTable;
+        int rightClickNr = rightClickTable.get(player.getUniqueID());
+        rightClickNr++;
+        rightClickTable.put(player.getUniqueID(), rightClickNr);
+
+        if (rightClickNr == 1) {
+            //If clicking in air, reset and try again
+            if (blockPos == null) {
+                rightClickTable.put(player.getUniqueID(), 0);
+                return list;
+            }
+
+            //First click, remember starting position
+            firstPosTable.put(player.getUniqueID(), blockPos);
+            sideHitTable.put(player.getUniqueID(), sideHit);
+            hitVecTable.put(player.getUniqueID(), hitVec);
+            //Keep list empty, dont place any blocks yet
+        } else {
+            //Second click, place blocks
+            list = findCoordinates(player, blockPos, skipRaytrace);
+            rightClickTable.put(player.getUniqueID(), 0);
+        }
+
+        return list;
+    }
+
+    @Override
+    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace) {
+        List<BlockPos> list = new ArrayList<>();
+        Dictionary<UUID, Integer> rightClickTable = player.world.isRemote ? rightClickClientTable : rightClickServerTable;
+        int rightClickNr = rightClickTable.get(player.getUniqueID());
+        BlockPos firstPos = firstPosTable.get(player.getUniqueID());
+
+        if (rightClickNr == 0) {
+            if (blockPos != null)
+                list.add(blockPos);
+        } else {
+            BlockPos secondPos = findSecondPos(player, firstPos, skipRaytrace);
+            if (secondPos == null) return list;
+
+            //Limit amount of blocks we can place per row
+            int axisLimit = ReachHelper.getMaxBlocksPerAxis(player);
+
+            int x1 = firstPos.getX(), x2 = secondPos.getX();
+            int y1 = firstPos.getY(), y2 = secondPos.getY();
+            int z1 = firstPos.getZ(), z2 = secondPos.getZ();
+
+            //limit axis
+            if (x2 - x1 >= axisLimit) x2 = x1 + axisLimit - 1;
+            if (x1 - x2 >= axisLimit) x2 = x1 - axisLimit + 1;
+            if (y2 - y1 >= axisLimit) y2 = y1 + axisLimit - 1;
+            if (y1 - y2 >= axisLimit) y2 = y1 - axisLimit + 1;
+            if (z2 - z1 >= axisLimit) z2 = z1 + axisLimit - 1;
+            if (z1 - z2 >= axisLimit) z2 = z1 - axisLimit + 1;
+
+            list.addAll(getAllBlocks(player, x1, y1, z1, x2, y2, z2));
+        }
+
+        return list;
+    }
+
+    //Finds the place of the second block pos based on criteria (floor must be on same height as first click, wall on same plane etc)
+    protected abstract BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace);
+
+    //After first and second pos are known, we want all the blocks
+    protected abstract List<BlockPos> getAllBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2);
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/Circle.java

@@ -0,0 +1,88 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
+import nl.requios.effortlessbuilding.buildmode.TwoClicksBuildMode;
+import nl.requios.effortlessbuilding.buildmode.ModeOptions;
+
+import java.util.*;
+
+public class Circle extends TwoClicksBuildMode {
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    protected List<BlockPos> getAllBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return getCircleBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    public static List<BlockPos> getCircleBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        List<BlockPos> list = new ArrayList<>();
+
+        float centerX = x1;
+        float centerZ = z1;
+
+        //Adjust for CIRCLE_START
+        if (ModeOptions.getCircleStart() == ModeOptions.ActionEnum.CIRCLE_START_CORNER) {
+            centerX = x1 + (x2 - x1) / 2f;
+            centerZ = z1 + (z2 - z1) / 2f;
+        } else {
+            x1 = (int) (centerX - (x2 - centerX));
+            z1 = (int) (centerZ - (z2 - centerZ));
+        }
+
+        float radiusX = MathHelper.abs(x2 - centerX);
+        float radiusZ = MathHelper.abs(z2 - centerZ);
+
+        if (ModeOptions.getFill() == ModeOptions.ActionEnum.FULL)
+            addCircleBlocks(list, x1, y1, z1, x2, y2, z2, centerX, centerZ, radiusX, radiusZ);
+        else
+            addHollowCircleBlocks(list, x1, y1, z1, x2, y2, z2, centerX, centerZ, radiusX, radiusZ);
+
+        return list;
+    }
+
+    public static void addCircleBlocks(List<BlockPos> list, int x1, int y1, int z1, int x2, int y2, int z2, float centerX, float centerZ, float radiusX, float radiusZ) {
+
+        for (int l = x1; x1 < x2 ? l <= x2 : l >= x2; l += x1 < x2 ? 1 : -1) {
+
+            for (int n = z1; z1 < z2 ? n <= z2 : n >= z2; n += z1 < z2 ? 1 : -1) {
+
+                float distance = distance(l, n, centerX, centerZ);
+                float radius = calculateEllipseRadius(centerX, centerZ, radiusX, radiusZ, l, n);
+                if (distance < radius + 0.4f)
+                    list.add(new BlockPos(l, y1, n));
+            }
+        }
+    }
+
+    public static void addHollowCircleBlocks(List<BlockPos> list, int x1, int y1, int z1, int x2, int y2, int z2, float centerX, float centerZ, float radiusX, float radiusZ) {
+
+        for (int l = x1; x1 < x2 ? l <= x2 : l >= x2; l += x1 < x2 ? 1 : -1) {
+
+            for (int n = z1; z1 < z2 ? n <= z2 : n >= z2; n += z1 < z2 ? 1 : -1) {
+
+                float distance = distance(l, n, centerX, centerZ);
+                float radius = calculateEllipseRadius(centerX, centerZ, radiusX, radiusZ, l, n);
+                if (distance < radius + 0.4f && distance > radius - 0.6f)
+                    list.add(new BlockPos(l, y1, n));
+            }
+        }
+    }
+
+    private static float distance(float x1, float z1, float x2, float z2) {
+        return MathHelper.sqrt((x2 - x1) * (x2 - x1) + (z2 - z1) * (z2 - z1));
+    }
+
+    public static float calculateEllipseRadius(float centerX, float centerZ, float radiusX, float radiusZ, int x, int z) {
+        //https://math.stackexchange.com/questions/432902/how-to-get-the-radius-of-an-ellipse-at-a-specific-angle-by-knowing-its-semi-majo
+        float theta = (float) MathHelper.atan2(z - centerZ, x - centerX);
+        float part1 = radiusX * radiusX * MathHelper.sin(theta) * MathHelper.sin(theta);
+        float part2 = radiusZ * radiusZ * MathHelper.cos(theta) * MathHelper.cos(theta);
+        return radiusX * radiusZ / MathHelper.sqrt(part1 + part2);
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/Cube.java

@@ -0,0 +1,104 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.buildmode.IBuildMode;
+import nl.requios.effortlessbuilding.buildmode.ModeOptions;
+import nl.requios.effortlessbuilding.buildmode.ThreeClicksBuildMode;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.util.*;
+
+public class Cube extends ThreeClicksBuildMode {
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    protected BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    protected List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return getFloorBlocksUsingCubeFill(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    @Override
+    protected List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        return getCubeBlocks(player, x1, y1, z1, x3, y3, z3);
+    }
+
+    public static List<BlockPos> getFloorBlocksUsingCubeFill(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        List<BlockPos> list = new ArrayList<>();
+
+        if (ModeOptions.getCubeFill() == ModeOptions.ActionEnum.CUBE_SKELETON)
+            Floor.addHollowFloorBlocks(list, x1, x2, y1, z1, z2);
+        else
+            Floor.addFloorBlocks(list, x1, x2, y1, z1, z2);
+
+        return list;
+    }
+
+    public static List<BlockPos> getCubeBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        List<BlockPos> list = new ArrayList<>();
+
+        switch (ModeOptions.getCubeFill()) {
+            case CUBE_FULL:
+                addCubeBlocks(list, x1, x2, y1, y2, z1, z2);
+                break;
+            case CUBE_HOLLOW:
+                addHollowCubeBlocks(list, x1, x2, y1, y2, z1, z2);
+                break;
+            case CUBE_SKELETON:
+                addSkeletonCubeBlocks(list, x1, x2, y1, y2, z1, z2);
+                break;
+        }
+
+        return list;
+    }
+
+    public static void addCubeBlocks(List<BlockPos> list, int x1, int x2, int y1, int y2, int z1, int z2) {
+        for (int l = x1; x1 < x2 ? l <= x2 : l >= x2; l += x1 < x2 ? 1 : -1) {
+
+            for (int n = z1; z1 < z2 ? n <= z2 : n >= z2; n += z1 < z2 ? 1 : -1) {
+
+                for (int m = y1; y1 < y2 ? m <= y2 : m >= y2; m += y1 < y2 ? 1 : -1) {
+                    list.add(new BlockPos(l, m, n));
+                }
+            }
+        }
+    }
+
+    public static void addHollowCubeBlocks(List<BlockPos> list, int x1, int x2, int y1, int y2, int z1, int z2) {
+        Wall.addXWallBlocks(list, x1, y1, y2, z1, z2);
+        Wall.addXWallBlocks(list, x2, y1, y2, z1, z2);
+
+        Wall.addZWallBlocks(list, x1, x2, y1, y2, z1);
+        Wall.addZWallBlocks(list, x1, x2, y1, y2, z2);
+
+        Floor.addFloorBlocks(list, x1, x2, y1, z1, z2);
+        Floor.addFloorBlocks(list, x1, x2, y2, z1, z2);
+    }
+
+    public static void addSkeletonCubeBlocks(List<BlockPos> list, int x1, int x2, int y1, int y2, int z1, int z2) {
+        Line.addXLineBlocks(list, x1, x2, y1, z1);
+        Line.addXLineBlocks(list, x1, x2, y1, z2);
+        Line.addXLineBlocks(list, x1, x2, y2, z1);
+        Line.addXLineBlocks(list, x1, x2, y2, z2);
+
+        Line.addYLineBlocks(list, y1, y2, x1, z1);
+        Line.addYLineBlocks(list, y1, y2, x1, z2);
+        Line.addYLineBlocks(list, y1, y2, x2, z1);
+        Line.addYLineBlocks(list, y1, y2, x2, z2);
+
+        Line.addZLineBlocks(list, z1, z2, x1, y1);
+        Line.addZLineBlocks(list, z1, z2, x1, y2);
+        Line.addZLineBlocks(list, z1, z2, x2, y1);
+        Line.addZLineBlocks(list, z1, z2, x2, y2);
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/Cylinder.java

@@ -0,0 +1,50 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import nl.requios.effortlessbuilding.buildmode.ThreeClicksBuildMode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Cylinder extends ThreeClicksBuildMode {
+
+    @Override
+    public BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    public BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    public List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return Circle.getCircleBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    @Override
+    public List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        return getCylinderBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
+    }
+
+    public static List<BlockPos> getCylinderBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        List<BlockPos> list = new ArrayList<>();
+
+        //Get circle blocks (using CIRCLE_START and FILL options built-in)
+        List<BlockPos> circleBlocks = Circle.getCircleBlocks(player, x1, y1, z1, x2, y2, z2);
+
+        int lowest = Math.min(y1, y3);
+        int highest = Math.max(y1, y3);
+
+        //Copy circle on y axis
+        for (int y = lowest; y <= highest; y++) {
+            for (BlockPos blockPos : circleBlocks) {
+                list.add(new BlockPos(blockPos.getX(), y, blockPos.getZ()));
+            }
+        }
+
+        return list;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/DiagonalLine.java

@@ -0,0 +1,54 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.buildmode.ThreeClicksBuildMode;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DiagonalLine extends ThreeClicksBuildMode {
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    protected BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    protected List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        //Add diagonal line from first to second
+        return getDiagonalLineBlocks(player, x1, y1, z1, x2, y2, z2, 10);
+    }
+
+    @Override
+    protected List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        //Add diagonal line from first to third
+        return getDiagonalLineBlocks(player, x1, y1, z1, x3, y3, z3, 10);
+    }
+
+    //Add diagonal line from first to second
+    public static List<BlockPos> getDiagonalLineBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, float sampleMultiplier) {
+        List<BlockPos> list = new ArrayList<>();
+
+        Vec3d first = new Vec3d(x1, y1, z1).add(0.5, 0.5, 0.5);
+        Vec3d second = new Vec3d(x2, y2, z2).add(0.5, 0.5, 0.5);
+
+        int iterations = (int) Math.ceil(first.distanceTo(second) * sampleMultiplier);
+        for (double t = 0; t <= 1.0; t += 1.0/iterations) {
+            Vec3d lerp = first.add(second.subtract(first).scale(t));
+            BlockPos candidate = new BlockPos(lerp);
+            //Only add if not equal to the last in the list
+            if (list.isEmpty() || !list.get(list.size() - 1).equals(candidate))
+                list.add(candidate);
+        }
+
+        return list;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/DiagonalWall.java

@@ -0,0 +1,52 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import nl.requios.effortlessbuilding.buildmode.ThreeClicksBuildMode;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class DiagonalWall extends ThreeClicksBuildMode {
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    protected BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    protected List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return DiagonalLine.getDiagonalLineBlocks(player, x1, y1, z1, x2, y2, z2, 1);
+    }
+
+    @Override
+    protected List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        return getDiagonalWallBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
+    }
+
+    //Add diagonal wall from first to second
+    public static List<BlockPos> getDiagonalWallBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        List<BlockPos> list = new ArrayList<>();
+
+        //Get diagonal line blocks
+        List<BlockPos> diagonalLineBlocks = DiagonalLine.getDiagonalLineBlocks(player, x1, y1, z1, x2, y2, z2, 1);
+
+        int lowest = Math.min(y1, y3);
+        int highest = Math.max(y1, y3);
+
+        //Copy diagonal line on y axis
+        for (int y = lowest; y <= highest; y++) {
+            for (BlockPos blockPos : diagonalLineBlocks) {
+                list.add(new BlockPos(blockPos.getX(), y, blockPos.getZ()));
+            }
+        }
+
+        return list;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/Floor.java

@@ -0,0 +1,93 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmode.TwoClicksBuildMode;
+import nl.requios.effortlessbuilding.buildmode.ModeOptions;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.util.*;
+
+public class Floor extends TwoClicksBuildMode {
+
+    static class Criteria {
+        Vec3d planeBound;
+        double distToPlayerSq;
+
+        Criteria(Vec3d planeBound, Vec3d start) {
+            this.planeBound = planeBound;
+            this.distToPlayerSq = this.planeBound.subtract(start).lengthSquared();
+        }
+
+        //check if its not behind the player and its not too close and not too far
+        //also check if raytrace from player to block does not intersect blocks
+        public boolean isValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace) {
+
+            return BuildModes.isCriteriaValid(start, look, reach, player, skipRaytrace, planeBound, planeBound, distToPlayerSq);
+        }
+    }
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return findFloor(player, firstPos, skipRaytrace);
+    }
+
+    public static BlockPos findFloor(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        Vec3d look = player.getLookVec();
+        Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
+
+        List<Criteria> criteriaList = new ArrayList<>(3);
+
+        //Y
+        Vec3d yBound = BuildModes.findYBound(firstPos.getY(), start, look);
+        criteriaList.add(new Criteria(yBound, start));
+
+        //Remove invalid criteria
+        int reach = ReachHelper.getPlacementReach(player) * 4; //4 times as much as normal placement reach
+        criteriaList.removeIf(criteria -> !criteria.isValid(start, look, reach, player, skipRaytrace));
+
+        //If none are valid, return empty list of blocks
+        if (criteriaList.isEmpty()) return null;
+
+        //Then only 1 can be valid, return that one
+        Criteria selected = criteriaList.get(0);
+
+        return new BlockPos(selected.planeBound);
+    }
+
+    @Override
+    protected List<BlockPos> getAllBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return getFloorBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    public static List<BlockPos> getFloorBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        List<BlockPos> list = new ArrayList<>();
+
+        if (ModeOptions.getFill() == ModeOptions.ActionEnum.FULL)
+            addFloorBlocks(list, x1, x2, y1, z1, z2);
+        else
+            addHollowFloorBlocks(list, x1, x2, y1, z1, z2);
+
+        return list;
+    }
+
+    public static void addFloorBlocks(List<BlockPos> list, int x1, int x2, int y, int z1, int z2) {
+
+        for (int l = x1; x1 < x2 ? l <= x2 : l >= x2; l += x1 < x2 ? 1 : -1) {
+
+            for (int n = z1; z1 < z2 ? n <= z2 : n >= z2; n += z1 < z2 ? 1 : -1) {
+
+                list.add(new BlockPos(l, y, n));
+            }
+        }
+    }
+
+    public static void addHollowFloorBlocks(List<BlockPos> list, int x1, int x2, int y, int z1, int z2) {
+        Line.addXLineBlocks(list, x1, x2, y, z1);
+        Line.addXLineBlocks(list, x1, x2, y, z2);
+        Line.addZLineBlocks(list, z1, z2, x1, y);
+        Line.addZLineBlocks(list, z1, z2, x2, y);
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/Line.java

@@ -0,0 +1,147 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmode.TwoClicksBuildMode;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Line extends TwoClicksBuildMode {
+
+    static class Criteria {
+        Vec3d planeBound;
+        Vec3d lineBound;
+        double distToLineSq;
+        double distToPlayerSq;
+
+        Criteria(Vec3d planeBound, BlockPos firstPos, Vec3d start) {
+            this.planeBound = planeBound;
+            this.lineBound = toLongestLine(this.planeBound, firstPos);
+            this.distToLineSq = this.lineBound.subtract(this.planeBound).lengthSquared();
+            this.distToPlayerSq = this.planeBound.subtract(start).lengthSquared();
+        }
+
+        //Make it from a plane into a line
+        //Select the axis that is longest
+        private Vec3d toLongestLine(Vec3d boundVec, BlockPos firstPos) {
+            BlockPos bound = new BlockPos(boundVec);
+
+            BlockPos firstToSecond = bound.subtract(firstPos);
+            firstToSecond = new BlockPos(Math.abs(firstToSecond.getX()), Math.abs(firstToSecond.getY()), Math.abs(firstToSecond.getZ()));
+            int longest = Math.max(firstToSecond.getX(), Math.max(firstToSecond.getY(), firstToSecond.getZ()));
+            if (longest == firstToSecond.getX()) {
+                return new Vec3d(bound.getX(), firstPos.getY(), firstPos.getZ());
+            }
+            if (longest == firstToSecond.getY()) {
+                return new Vec3d(firstPos.getX(), bound.getY(), firstPos.getZ());
+            }
+            if (longest == firstToSecond.getZ()) {
+                return new Vec3d(firstPos.getX(), firstPos.getY(), bound.getZ());
+            }
+            return null;
+        }
+
+        //check if its not behind the player and its not too close and not too far
+        //also check if raytrace from player to block does not intersect blocks
+        public boolean isValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace) {
+
+            return BuildModes.isCriteriaValid(start, look, reach, player, skipRaytrace, lineBound, planeBound, distToPlayerSq);
+        }
+
+    }
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return findLine(player, firstPos, skipRaytrace);
+    }
+
+    public static BlockPos findLine(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        Vec3d look = player.getLookVec();
+        Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
+
+        List<Criteria> criteriaList = new ArrayList<>(3);
+
+        //X
+        Vec3d xBound = BuildModes.findXBound(firstPos.getX(), start, look);
+        criteriaList.add(new Criteria(xBound, firstPos, start));
+
+        //Y
+        Vec3d yBound = BuildModes.findYBound(firstPos.getY(), start, look);
+        criteriaList.add(new Criteria(yBound, firstPos, start));
+
+        //Z
+        Vec3d zBound = BuildModes.findZBound(firstPos.getZ(), start, look);
+        criteriaList.add(new Criteria(zBound, firstPos, start));
+
+        //Remove invalid criteria
+        int reach = ReachHelper.getPlacementReach(player) * 4; //4 times as much as normal placement reach
+        criteriaList.removeIf(criteria -> !criteria.isValid(start, look, reach, player, skipRaytrace));
+
+        //If none are valid, return empty list of blocks
+        if (criteriaList.isEmpty()) return null;
+
+        //If only 1 is valid, choose that one
+        Criteria selected = criteriaList.get(0);
+
+        //If multiple are valid, choose based on criteria
+        if (criteriaList.size() > 1) {
+            //Select the one that is closest (from wall position to its line counterpart)
+            for (int i = 1; i < criteriaList.size(); i++) {
+                Criteria criteria = criteriaList.get(i);
+                if (criteria.distToLineSq < 2.0 && selected.distToLineSq < 2.0) {
+                    //Both very close to line, choose closest to player
+                    if (criteria.distToPlayerSq < selected.distToPlayerSq)
+                        selected = criteria;
+                } else {
+                    //Pick closest to line
+                    if (criteria.distToLineSq < selected.distToLineSq)
+                        selected = criteria;
+                }
+            }
+
+        }
+
+        return new BlockPos(selected.lineBound);
+    }
+
+    @Override
+    protected List<BlockPos> getAllBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return getLineBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    public static List<BlockPos> getLineBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        List<BlockPos> list = new ArrayList<>();
+
+        if (x1 != x2) {
+            addXLineBlocks(list, x1, x2, y1, z1);
+        } else if (y1 != y2) {
+            addYLineBlocks(list, y1, y2, x1, z1);
+        } else {
+            addZLineBlocks(list, z1, z2, x1, y1);
+        }
+
+        return list;
+    }
+
+    public static void addXLineBlocks(List<BlockPos> list, int x1, int x2, int y, int z) {
+        for (int x = x1; x1 < x2 ? x <= x2 : x >= x2; x += x1 < x2 ? 1 : -1) {
+            list.add(new BlockPos(x, y, z));
+        }
+    }
+
+    public static void addYLineBlocks(List<BlockPos> list, int y1, int y2, int x, int z) {
+        for (int y = y1; y1 < y2 ? y <= y2 : y >= y2; y += y1 < y2 ? 1 : -1) {
+            list.add(new BlockPos(x, y, z));
+        }
+    }
+
+    public static void addZLineBlocks(List<BlockPos> list, int z1, int z2, int x, int y) {
+        for (int z = z1; z1 < z2 ? z <= z2 : z >= z2; z += z1 < z2 ? 1 : -1) {
+            list.add(new BlockPos(x, y, z));
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/Normal.java

@@ -0,0 +1,41 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.buildmode.IBuildMode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Normal implements IBuildMode {
+    @Override
+    public void initialize(EntityPlayer player) {
+
+    }
+
+    @Override
+    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace) {
+        List<BlockPos> list = new ArrayList<>();
+        if (blockPos != null) list.add(blockPos);
+        return list;
+    }
+
+    @Override
+    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace) {
+        List<BlockPos> list = new ArrayList<>();
+        if (blockPos != null) list.add(blockPos);
+        return list;
+    }
+
+    @Override
+    public EnumFacing getSideHit(EntityPlayer player) {
+        return null;
+    }
+
+    @Override
+    public Vec3d getHitVec(EntityPlayer player) {
+        return null;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/NormalPlus.java

@@ -0,0 +1,41 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.buildmode.IBuildMode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class NormalPlus implements IBuildMode {
+    @Override
+    public void initialize(EntityPlayer player) {
+
+    }
+
+    @Override
+    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace) {
+        List<BlockPos> list = new ArrayList<>();
+        if (blockPos != null) list.add(blockPos);
+        return list;
+    }
+
+    @Override
+    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace) {
+        List<BlockPos> list = new ArrayList<>();
+        if (blockPos != null) list.add(blockPos);
+        return list;
+    }
+
+    @Override
+    public EnumFacing getSideHit(EntityPlayer player) {
+        return null;
+    }
+
+    @Override
+    public Vec3d getHitVec(EntityPlayer player) {
+        return null;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/SlopeFloor.java

@@ -0,0 +1,95 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import nl.requios.effortlessbuilding.buildmode.ModeOptions;
+import nl.requios.effortlessbuilding.buildmode.ThreeClicksBuildMode;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class SlopeFloor extends ThreeClicksBuildMode {
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    protected BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    protected List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return Floor.getFloorBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    @Override
+    protected List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        return getSlopeFloorBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
+    }
+
+    //Add slope floor from first to second
+    public static List<BlockPos> getSlopeFloorBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        List<BlockPos> list = new ArrayList<>();
+
+        int axisLimit = ReachHelper.getMaxBlocksPerAxis(player);
+
+        //Determine whether to use x or z axis to slope up
+        boolean onXAxis = true;
+
+        int xLength = Math.abs(x2 - x1);
+        int zLength = Math.abs(z2 - z1);
+
+        if (ModeOptions.getRaisedEdge() == ModeOptions.ActionEnum.SHORT_EDGE) {
+            //Slope along short edge
+            if (zLength > xLength) onXAxis = false;
+        } else {
+            //Slope along long edge
+            if (zLength <= xLength) onXAxis = false;
+        }
+
+        if (onXAxis) {
+            //Along X goes up
+
+            //Get diagonal line blocks
+            List<BlockPos> diagonalLineBlocks = DiagonalLine.getDiagonalLineBlocks(player, x1, y1, z1, x2, y3, z1, 1f);
+
+            //Limit amount of blocks we can place
+            int lowest = Math.min(z1, z2);
+            int highest = Math.max(z1, z2);
+
+            if (highest - lowest >= axisLimit) highest = lowest + axisLimit - 1;
+
+            //Copy diagonal line on x axis
+            for (int z = lowest; z <= highest; z++) {
+                for (BlockPos blockPos : diagonalLineBlocks) {
+                    list.add(new BlockPos(blockPos.getX(), blockPos.getY(), z));
+                }
+            }
+
+        } else {
+            //Along Z goes up
+
+            //Get diagonal line blocks
+            List<BlockPos> diagonalLineBlocks = DiagonalLine.getDiagonalLineBlocks(player, x1, y1, z1, x1, y3, z2, 1f);
+
+            //Limit amount of blocks we can place
+            int lowest = Math.min(x1, x2);
+            int highest = Math.max(x1, x2);
+
+            if (highest - lowest >= axisLimit) highest = lowest + axisLimit - 1;
+
+            //Copy diagonal line on x axis
+            for (int x = lowest; x <= highest; x++) {
+                for (BlockPos blockPos : diagonalLineBlocks) {
+                    list.add(new BlockPos(x, blockPos.getY(), blockPos.getZ()));
+                }
+            }
+        }
+
+        return list;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/Sphere.java

@@ -0,0 +1,110 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
+import nl.requios.effortlessbuilding.buildmode.ModeOptions;
+import nl.requios.effortlessbuilding.buildmode.ThreeClicksBuildMode;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Sphere extends ThreeClicksBuildMode {
+
+    @Override
+    public BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    public BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    public List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return Circle.getCircleBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    @Override
+    public List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        return getSphereBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
+    }
+
+    public static List<BlockPos> getSphereBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        List<BlockPos> list = new ArrayList<>();
+
+        float centerX = x1;
+        float centerY = y1;
+        float centerZ = z1;
+
+        //Adjust for CIRCLE_START
+        if (ModeOptions.getCircleStart() == ModeOptions.ActionEnum.CIRCLE_START_CORNER) {
+            centerX = x1 + (x2 - x1) / 2f;
+            centerY = y1 + (y3 - y1) / 2f;
+            centerZ = z1 + (z2 - z1) / 2f;
+        } else {
+            x1 = (int) (centerX - (x2 - centerX));
+            y1 = (int) (centerY - (y3 - centerY));
+            z1 = (int) (centerZ - (z2 - centerZ));
+        }
+
+        float radiusX = MathHelper.abs(x2 - centerX);
+        float radiusY = MathHelper.abs(y3 - centerY);
+        float radiusZ = MathHelper.abs(z2 - centerZ);
+
+        if (ModeOptions.getFill() == ModeOptions.ActionEnum.FULL)
+            addSphereBlocks(list, x1, y1, z1, x3, y3, z3, centerX, centerY, centerZ, radiusX, radiusY, radiusZ);
+        else
+            addHollowSphereBlocks(list, x1, y1, z1, x3, y3, z3, centerX, centerY, centerZ, radiusX, radiusY, radiusZ);
+
+        return list;
+    }
+
+    public static void addSphereBlocks(List<BlockPos> list, int x1, int y1, int z1, int x2, int y2, int z2,
+                                       float centerX, float centerY, float centerZ, float radiusX, float radiusY, float radiusZ) {
+        for (int l = x1; x1 < x2 ? l <= x2 : l >= x2; l += x1 < x2 ? 1 : -1) {
+
+            for (int n = z1; z1 < z2 ? n <= z2 : n >= z2; n += z1 < z2 ? 1 : -1) {
+
+                for (int m = y1; y1 < y2 ? m <= y2 : m >= y2; m += y1 < y2 ? 1 : -1) {
+
+                    float distance = distance(l, m, n, centerX, centerY, centerZ);
+                    float radius = calculateSpheroidRadius(centerX, centerY, centerZ, radiusX, radiusY, radiusZ, l, m, n);
+                    if (distance < radius + 0.4f)
+                        list.add(new BlockPos(l, m, n));
+                }
+            }
+        }
+    }
+
+    public static void addHollowSphereBlocks(List<BlockPos> list, int x1, int y1, int z1, int x2, int y2, int z2,
+                                             float centerX, float centerY, float centerZ, float radiusX, float radiusY, float radiusZ) {
+        for (int l = x1; x1 < x2 ? l <= x2 : l >= x2; l += x1 < x2 ? 1 : -1) {
+
+            for (int n = z1; z1 < z2 ? n <= z2 : n >= z2; n += z1 < z2 ? 1 : -1) {
+
+                for (int m = y1; y1 < y2 ? m <= y2 : m >= y2; m += y1 < y2 ? 1 : -1) {
+
+                    float distance = distance(l, m, n, centerX, centerY, centerZ);
+                    float radius = calculateSpheroidRadius(centerX, centerY, centerZ, radiusX, radiusY, radiusZ, l, m, n);
+                    if (distance < radius + 0.4f && distance > radius - 0.6f)
+                        list.add(new BlockPos(l, m, n));
+                }
+            }
+        }
+    }
+
+    private static float distance(float x1, float y1, float z1, float x2, float y2, float z2) {
+        return MathHelper.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) + (z2 - z1) * (z2 - z1));
+    }
+
+    public static float calculateSpheroidRadius(float centerX, float centerY, float centerZ, float radiusX, float radiusY, float radiusZ, int x, int y, int z) {
+        //Twice ellipse radius
+        float radiusXZ = Circle.calculateEllipseRadius(centerX, centerZ, radiusX, radiusZ, x, z);
+
+        //TODO project x to plane
+
+        return Circle.calculateEllipseRadius(centerX, centerY, radiusXZ, radiusY, x, y);
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/Wall.java

@@ -0,0 +1,134 @@
+package nl.requios.effortlessbuilding.buildmode.buildmodes;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmode.TwoClicksBuildMode;
+import nl.requios.effortlessbuilding.buildmode.ModeOptions;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.util.*;
+
+public class Wall extends TwoClicksBuildMode {
+
+    static class Criteria {
+        Vec3d planeBound;
+        double distToPlayerSq;
+        double angle;
+
+        Criteria(Vec3d planeBound, BlockPos firstPos, Vec3d start, Vec3d look) {
+            this.planeBound = planeBound;
+            this.distToPlayerSq = this.planeBound.subtract(start).lengthSquared();
+            Vec3d wall = this.planeBound.subtract(new Vec3d(firstPos));
+            this.angle = wall.x * look.x + wall.z * look.z; //dot product ignoring y (looking up/down should not affect this angle)
+        }
+
+        //check if its not behind the player and its not too close and not too far
+        //also check if raytrace from player to block does not intersect blocks
+        public boolean isValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace) {
+
+            return BuildModes.isCriteriaValid(start, look, reach, player, skipRaytrace, planeBound, planeBound, distToPlayerSq);
+        }
+    }
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return findWall(player, firstPos, skipRaytrace);
+    }
+
+    public static BlockPos findWall(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        Vec3d look = player.getLookVec();
+        Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
+
+        List<Criteria> criteriaList = new ArrayList<>(3);
+
+        //X
+        Vec3d xBound = BuildModes.findXBound(firstPos.getX(), start, look);
+        criteriaList.add(new Criteria(xBound, firstPos, start, look));
+
+        //Z
+        Vec3d zBound = BuildModes.findZBound(firstPos.getZ(), start, look);
+        criteriaList.add(new Criteria(zBound, firstPos, start, look));
+
+        //Remove invalid criteria
+        int reach = ReachHelper.getPlacementReach(player) * 4; //4 times as much as normal placement reach
+        criteriaList.removeIf(criteria -> !criteria.isValid(start, look, reach, player, skipRaytrace));
+
+        //If none are valid, return empty list of blocks
+        if (criteriaList.isEmpty()) return null;
+
+        //If only 1 is valid, choose that one
+        Criteria selected = criteriaList.get(0);
+
+        //If multiple are valid, choose based on criteria
+        if (criteriaList.size() > 1) {
+            //Select the one that is closest
+            //Limit the angle to not be too extreme
+            for (int i = 1; i < criteriaList.size(); i++) {
+                Criteria criteria = criteriaList.get(i);
+                if (criteria.distToPlayerSq < selected.distToPlayerSq && Math.abs(criteria.angle) - Math.abs(selected.angle) < 3)
+                    selected = criteria;
+            }
+        }
+
+        return new BlockPos(selected.planeBound);
+    }
+
+    @Override
+    protected List<BlockPos> getAllBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return getWallBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    public static List<BlockPos> getWallBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        List<BlockPos> list = new ArrayList<>();
+
+        if (x1 == x2) {
+            if (ModeOptions.getFill() == ModeOptions.ActionEnum.FULL)
+                addXWallBlocks(list, x1, y1, y2, z1, z2);
+            else
+                addXHollowWallBlocks(list, x1, y1, y2, z1, z2);
+        } else {
+            if (ModeOptions.getFill() == ModeOptions.ActionEnum.FULL)
+                addZWallBlocks(list, x1, x2, y1, y2, z1);
+            else
+                addZHollowWallBlocks(list, x1, x2, y1, y2, z1);
+        }
+
+        return list;
+    }
+
+    public static void addXWallBlocks(List<BlockPos> list, int x, int y1, int y2, int z1, int z2) {
+
+        for (int z = z1; z1 < z2 ? z <= z2 : z >= z2; z += z1 < z2 ? 1 : -1) {
+
+            for (int y = y1; y1 < y2 ? y <= y2 : y >= y2; y += y1 < y2 ? 1 : -1) {
+                list.add(new BlockPos(x, y, z));
+            }
+        }
+    }
+
+    public static void addZWallBlocks(List<BlockPos> list, int x1, int x2, int y1, int y2, int z) {
+
+        for (int x = x1; x1 < x2 ? x <= x2 : x >= x2; x += x1 < x2 ? 1 : -1) {
+
+            for (int y = y1; y1 < y2 ? y <= y2 : y >= y2; y += y1 < y2 ? 1 : -1) {
+                list.add(new BlockPos(x, y, z));
+            }
+        }
+    }
+
+    public static void addXHollowWallBlocks(List<BlockPos> list, int x, int y1, int y2, int z1, int z2) {
+        Line.addZLineBlocks(list, z1, z2, x, y1);
+        Line.addZLineBlocks(list, z1, z2, x, y2);
+        Line.addYLineBlocks(list, y1, y2, x, z1);
+        Line.addYLineBlocks(list, y1, y2, x, z2);
+    }
+
+    public static void addZHollowWallBlocks(List<BlockPos> list, int x1, int x2, int y1, int y2, int z) {
+        Line.addXLineBlocks(list, x1, x2, y1, z);
+        Line.addXLineBlocks(list, x1, x2, y2, z);
+        Line.addYLineBlocks(list, y1, y2, x1, z);
+        Line.addYLineBlocks(list, y1, y2, x2, z);
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmodifier/Array.java

@@ -0,0 +1,104 @@
+package nl.requios.effortlessbuilding.buildmodifier;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.Vec3i;
+import net.minecraftforge.items.IItemHandler;
+import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Array {
+
+    public static class ArraySettings{
+        public boolean enabled = false;
+        public BlockPos offset = BlockPos.ORIGIN;
+        public int count = 5;
+
+        public ArraySettings() {
+        }
+
+        public ArraySettings(boolean enabled, BlockPos offset, int count) {
+            this.enabled = enabled;
+            this.offset = offset;
+            this.count = count;
+        }
+
+        public int getReach() {
+            //find largest offset
+            int x = Math.abs(offset.getX());
+            int y = Math.abs(offset.getY());
+            int z = Math.abs(offset.getZ());
+            int largestOffset = Math.max(Math.max(x, y), z);
+
+            return largestOffset * count;
+        }
+    }
+
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos) {
+        List<BlockPos> coordinates = new ArrayList<>();
+
+        //find arraysettings for the player
+        ArraySettings a = ModifierSettingsManager.getModifierSettings(player).getArraySettings();
+        if (!isEnabled(a)) return coordinates;
+
+        BlockPos pos = startPos;
+        Vec3i offset = new Vec3i(a.offset.getX(), a.offset.getY(), a.offset.getZ());
+
+        for (int i = 0; i < a.count; i++) {
+            pos = pos.add(offset);
+            coordinates.add(pos);
+        }
+
+        return coordinates;
+    }
+
+    public static List<IBlockState> findBlockStates(EntityPlayer player, BlockPos startPos, IBlockState blockState, ItemStack itemStack, List<ItemStack> itemStacks) {
+        List<IBlockState> blockStates = new ArrayList<>();
+
+        //find arraysettings for the player that placed the block
+        ArraySettings a = ModifierSettingsManager.getModifierSettings(player).getArraySettings();
+        if (!isEnabled(a)) return blockStates;
+
+        BlockPos pos = startPos;
+        Vec3i offset = new Vec3i(a.offset.getX(), a.offset.getY(), a.offset.getZ());
+
+        //Randomizer bag synergy
+        IItemHandler bagInventory = null;
+        if (!itemStack.isEmpty() && itemStack.getItem() instanceof ItemRandomizerBag) {
+            bagInventory = ItemRandomizerBag.getBagInventory(itemStack);
+        }
+
+        for (int i = 0; i < a.count; i++) {
+            pos = pos.add(offset);
+
+            //Randomizer bag synergy
+            if (bagInventory != null) {
+                itemStack = ItemRandomizerBag.pickRandomStack(bagInventory);
+                blockState = BuildModifiers
+                        .getBlockStateFromItem(itemStack, player, startPos, EnumFacing.UP, new Vec3d(0, 0, 0), EnumHand.MAIN_HAND);
+            }
+
+            //blockState = blockState.getBlock().getStateForPlacement(player.world, pos, )
+            blockStates.add(blockState);
+            itemStacks.add(itemStack);
+        }
+
+        return blockStates;
+    }
+
+    public static boolean isEnabled(ArraySettings a) {
+        if (a == null || !a.enabled) return false;
+
+        if (a.offset.getX() == 0 && a.offset.getY() == 0 && a.offset.getZ() == 0) return false;
+
+        return true;
+    }
+
+}

src/main/java/nl/requios/effortlessbuilding/buildmodifier/BlockSet.java

@@ -0,0 +1,50 @@
+package nl.requios.effortlessbuilding.buildmodifier;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+
+import java.util.List;
+
+public class BlockSet {
+    private List<BlockPos> coordinates;
+    private List<IBlockState> previousBlockStates;
+    private List<IBlockState> newBlockStates;
+    private Vec3d hitVec;
+    private BlockPos firstPos;
+    private BlockPos secondPos;
+
+    public BlockSet(List<BlockPos> coordinates, List<IBlockState> previousBlockStates,  List<IBlockState> newBlockStates, Vec3d hitVec,
+                    BlockPos firstPos, BlockPos secondPos) {
+        this.coordinates = coordinates;
+        this.previousBlockStates = previousBlockStates;
+        this.newBlockStates = newBlockStates;
+        this.hitVec = hitVec;
+        this.firstPos = firstPos;
+        this.secondPos = secondPos;
+    }
+
+    public List<BlockPos> getCoordinates() {
+        return coordinates;
+    }
+
+    public List<IBlockState> getPreviousBlockStates() {
+        return previousBlockStates;
+    }
+
+    public List<IBlockState> getNewBlockStates() {
+        return newBlockStates;
+    }
+
+    public Vec3d getHitVec() {
+        return hitVec;
+    }
+
+    public BlockPos getFirstPos() {
+        return firstPos;
+    }
+
+    public BlockPos getSecondPos() {
+        return secondPos;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmodifier/BuildModifiers.java

@@ -0,0 +1,259 @@
+package nl.requios.effortlessbuilding.buildmodifier;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import nl.requios.effortlessbuilding.compatibility.CompatHelper;
+import nl.requios.effortlessbuilding.helper.InventoryHelper;
+import nl.requios.effortlessbuilding.helper.SurvivalHelper;
+import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
+import nl.requios.effortlessbuilding.render.BlockPreviewRenderer;
+
+import java.util.*;
+
+public class BuildModifiers {
+
+    //Called from BuildModes
+    public static void onBlockPlaced(EntityPlayer player, List<BlockPos> startCoordinates, EnumFacing sideHit, Vec3d hitVec, boolean placeStartPos) {
+        World world = player.world;
+        ItemRandomizerBag.renewRandomness();
+
+        //Format hitvec to 0.x
+        hitVec = new Vec3d(Math.abs(hitVec.x - ((int) hitVec.x)), Math.abs(hitVec.y - ((int) hitVec.y)), Math.abs(hitVec.z - ((int) hitVec.z)));
+
+        //find coordinates and blockstates
+        List<BlockPos> coordinates = findCoordinates(player, startCoordinates);
+        List<ItemStack> itemStacks = new ArrayList<>();
+        List<IBlockState> blockStates = findBlockStates(player, startCoordinates, hitVec, sideHit, itemStacks);
+
+        //check if valid blockstates
+        if (blockStates.size() == 0 || coordinates.size() != blockStates.size()) return;
+
+        //remember previous blockstates for undo
+        List<IBlockState> previousBlockStates = new ArrayList<>(coordinates.size());
+        List<IBlockState> newBlockStates = new ArrayList<>(coordinates.size());
+        for (BlockPos coordinate : coordinates) {
+            previousBlockStates.add(world.getBlockState(coordinate));
+        }
+
+        if (world.isRemote) {
+
+            BlockPreviewRenderer.onBlocksPlaced();
+
+            newBlockStates = blockStates;
+
+        } else {
+
+            //place blocks
+            for (int i = placeStartPos ? 0 : 1; i < coordinates.size(); i++) {
+                BlockPos blockPos = coordinates.get(i);
+                IBlockState blockState = blockStates.get(i);
+                ItemStack itemStack = itemStacks.get(i);
+
+                if (world.isBlockLoaded(blockPos, true)) {
+                    //check itemstack empty
+                    if (itemStack.isEmpty()) {
+                        //try to find new stack, otherwise continue
+                        itemStack = InventoryHelper.findItemStackInInventory(player, blockState.getBlock());
+                        if (itemStack.isEmpty()) continue;
+                    }
+                    SurvivalHelper.placeBlock(world, player, blockPos, blockState, itemStack, EnumFacing.UP, hitVec, false, false, false);
+                }
+            }
+
+            //find actual new blockstates for undo
+            for (BlockPos coordinate : coordinates) {
+                newBlockStates.add(world.getBlockState(coordinate));
+            }
+        }
+
+        //Set first previousBlockState to empty if in NORMAL mode, to make undo/redo work
+        //(Block is placed by the time it gets here, and unplaced after this)
+        if (!placeStartPos) previousBlockStates.set(0, Blocks.AIR.getDefaultState());
+
+        //If all new blockstates are air then no use in adding it, no block was actually placed
+        //Can happen when e.g. placing one block in yourself
+        if (Collections.frequency(newBlockStates, Blocks.AIR.getDefaultState()) != newBlockStates.size()) {
+            //add to undo stack
+            BlockPos firstPos = startCoordinates.get(0);
+            BlockPos secondPos = startCoordinates.get(startCoordinates.size() - 1);
+            UndoRedo.addUndo(player, new BlockSet(coordinates, previousBlockStates, newBlockStates, hitVec, firstPos, secondPos));
+        }
+
+    }
+
+    public static void onBlockBroken(EntityPlayer player, List<BlockPos> startCoordinates, boolean breakStartPos) {
+        World world = player.world;
+
+        List<BlockPos> coordinates = findCoordinates(player, startCoordinates);
+
+        if (coordinates.isEmpty()) return;
+
+        //remember previous blockstates for undo
+        List<IBlockState> previousBlockStates = new ArrayList<>(coordinates.size());
+        List<IBlockState> newBlockStates = new ArrayList<>(coordinates.size());
+        for (BlockPos coordinate : coordinates) {
+            previousBlockStates.add(world.getBlockState(coordinate));
+        }
+
+        if (world.isRemote) {
+            BlockPreviewRenderer.onBlocksBroken();
+
+            //list of air blockstates
+            for (BlockPos coordinate : coordinates) {
+                newBlockStates.add(Blocks.AIR.getDefaultState());
+            }
+
+        } else {
+
+            //If the player is going to instabreak grass or a plant, only break other instabreaking things
+            boolean onlyInstaBreaking = !player.isCreative() &&
+                                        world.getBlockState(startCoordinates.get(0)).getBlockHardness(world, startCoordinates.get(0)) == 0f;
+
+            //break all those blocks
+            for (int i = breakStartPos ? 0 : 1; i < coordinates.size(); i++) {
+                BlockPos coordinate = coordinates.get(i);
+                if (world.isBlockLoaded(coordinate, false)) {
+                    if (!onlyInstaBreaking || world.getBlockState(coordinate).getBlockHardness(world, coordinate) == 0f) {
+                        SurvivalHelper.breakBlock(world, player, coordinate, false);
+                    }
+                }
+            }
+
+            //find actual new blockstates for undo
+            for (BlockPos coordinate : coordinates) {
+                newBlockStates.add(world.getBlockState(coordinate));
+            }
+        }
+
+        //Set first newBlockState to empty if in NORMAL mode, to make undo/redo work
+        //(Block isn't broken yet by the time it gets here, and broken after this)
+        if (!breakStartPos) newBlockStates.set(0, Blocks.AIR.getDefaultState());
+
+        //add to undo stack
+        BlockPos firstPos = startCoordinates.get(0);
+        BlockPos secondPos = startCoordinates.get(startCoordinates.size() - 1);
+        Vec3d hitVec = new Vec3d(0.5, 0.5, 0.5);
+        UndoRedo.addUndo(player, new BlockSet(coordinates, previousBlockStates, newBlockStates, hitVec, firstPos, secondPos));
+
+    }
+
+    public static List<BlockPos> findCoordinates(EntityPlayer player, List<BlockPos> posList) {
+        List<BlockPos> coordinates = new ArrayList<>();
+        //Add current blocks being placed too
+        coordinates.addAll(posList);
+
+        //Find mirror/array/radial mirror coordinates for each blockpos
+        for (BlockPos blockPos : posList) {
+            List<BlockPos> arrayCoordinates = Array.findCoordinates(player, blockPos);
+            coordinates.addAll(arrayCoordinates);
+            coordinates.addAll(Mirror.findCoordinates(player, blockPos));
+            coordinates.addAll(RadialMirror.findCoordinates(player, blockPos));
+            //get mirror for each array coordinate
+            for (BlockPos coordinate : arrayCoordinates) {
+                coordinates.addAll(Mirror.findCoordinates(player, coordinate));
+                coordinates.addAll(RadialMirror.findCoordinates(player, coordinate));
+            }
+        }
+
+        return coordinates;
+    }
+
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos) {
+        return findCoordinates(player, new ArrayList<>(Arrays.asList(blockPos)));
+    }
+
+    public static List<IBlockState> findBlockStates(EntityPlayer player, List<BlockPos> posList, Vec3d hitVec, EnumFacing facing, List<ItemStack> itemStacks) {
+        List<IBlockState> blockStates = new ArrayList<>();
+        itemStacks.clear();
+
+        //Get itemstack
+        ItemStack itemStack = player.getHeldItem(EnumHand.MAIN_HAND);
+        if (itemStack.isEmpty() || !CompatHelper.isItemBlockProxy(itemStack)) {
+            itemStack = player.getHeldItem(EnumHand.OFF_HAND);
+        }
+        if (itemStack.isEmpty() || !CompatHelper.isItemBlockProxy(itemStack)) {
+            return blockStates;
+        }
+
+        //Get ItemBlock stack
+        ItemStack itemBlock = ItemStack.EMPTY;
+        if (itemStack.getItem() instanceof ItemBlock) itemBlock = itemStack;
+        else itemBlock = CompatHelper.getItemBlockFromStack(itemStack);
+        ItemRandomizerBag.resetRandomness();
+
+        //Add blocks in posList first
+        for (BlockPos blockPos : posList) {
+            if (!(itemStack.getItem() instanceof ItemBlock)) itemBlock = CompatHelper.getItemBlockFromStack(itemStack);
+            IBlockState blockState = getBlockStateFromItem(itemBlock, player, blockPos, facing, hitVec, EnumHand.MAIN_HAND);
+            blockStates.add(blockState);
+            itemStacks.add(itemBlock);
+        }
+
+        for (BlockPos blockPos : posList) {
+            IBlockState blockState = getBlockStateFromItem(itemBlock, player, blockPos, facing, hitVec, EnumHand.MAIN_HAND);
+
+            List<IBlockState> arrayBlockStates = Array.findBlockStates(player, blockPos, blockState, itemStack, itemStacks);
+            blockStates.addAll(arrayBlockStates);
+            blockStates.addAll(Mirror.findBlockStates(player, blockPos, blockState, itemStack, itemStacks));
+            blockStates.addAll(RadialMirror.findBlockStates(player, blockPos, blockState, itemStack, itemStacks));
+            //add mirror for each array coordinate
+            List<BlockPos> arrayCoordinates = Array.findCoordinates(player, blockPos);
+            for (int i = 0; i < arrayCoordinates.size(); i++) {
+                BlockPos coordinate = arrayCoordinates.get(i);
+                IBlockState blockState1 = arrayBlockStates.get(i);
+                blockStates.addAll(Mirror.findBlockStates(player, coordinate, blockState1, itemStack, itemStacks));
+                blockStates.addAll(RadialMirror.findBlockStates(player, coordinate, blockState1, itemStack, itemStacks));
+            }
+
+            //Adjust blockstates for torches and ladders etc to place on a valid side
+            //TODO optimize findCoordinates (done twice now)
+            //TODO fix mirror
+//            List<BlockPos> coordinates = findCoordinates(player, startPos);
+//            for (int i = 0; i < blockStates.size(); i++) {
+//                blockStates.set(i, blockStates.get(i).getBlock().getStateForPlacement(player.world, coordinates.get(i), facing,
+//                        (float) hitVec.x, (float) hitVec.y, (float) hitVec.z, itemStacks.get(i).getMetadata(), player, EnumHand.MAIN_HAND));
+//            }
+        }
+
+        return blockStates;
+    }
+
+    public static boolean isEnabled(ModifierSettingsManager.ModifierSettings modifierSettings, BlockPos startPos) {
+        return Mirror.isEnabled(modifierSettings.getMirrorSettings(), startPos) ||
+               Array.isEnabled(modifierSettings.getArraySettings()) ||
+               RadialMirror.isEnabled(modifierSettings.getRadialMirrorSettings(), startPos) ||
+               modifierSettings.doQuickReplace();
+    }
+
+    public static IBlockState getBlockStateFromItem(ItemStack itemStack, EntityPlayer player, BlockPos blockPos, EnumFacing facing, Vec3d hitVec, EnumHand hand) {
+        return Block.getBlockFromItem(itemStack.getItem()).getStateForPlacement(player.world, blockPos, facing,
+                ((float) hitVec.x), ((float) hitVec.y), ((float) hitVec.z), itemStack.getMetadata(), player, hand);
+    }
+
+    //Returns true if equal (or both null)
+    public static boolean compareCoordinates(List<BlockPos> coordinates1, List<BlockPos> coordinates2) {
+        if (coordinates1 == null && coordinates2 == null) return true;
+        if (coordinates1 == null || coordinates2 == null) return false;
+
+        //Check count, not actual values
+        if (coordinates1.size() == coordinates2.size()){
+            if (coordinates1.size() == 1){
+                return coordinates1.get(0).equals(coordinates2.get(0));
+            }
+            return true;
+        } else {
+            return false;
+        }
+
+//        return coordinates1.equals(coordinates2);
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmodifier/Mirror.java

@@ -0,0 +1,225 @@
+package nl.requios.effortlessbuilding.buildmodifier;
+
+import net.minecraft.block.BlockDirectional;
+import net.minecraft.block.BlockDispenser;
+import net.minecraft.block.BlockSlab;
+import net.minecraft.block.BlockStairs;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.items.IItemHandler;
+import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class Mirror {
+
+    public static class MirrorSettings {
+        public boolean enabled = false;
+        public Vec3d position = new Vec3d(0.5, 64.5, 0.5);
+        public boolean mirrorX = true, mirrorY = false, mirrorZ = false;
+        public int radius = 10;
+        public boolean drawLines = true, drawPlanes = true;
+
+        public MirrorSettings() {
+        }
+
+        public MirrorSettings(boolean mirrorEnabled, Vec3d position, boolean mirrorX, boolean mirrorY, boolean mirrorZ, int radius, boolean drawLines, boolean drawPlanes) {
+            this.enabled = mirrorEnabled;
+            this.position = position;
+            this.mirrorX = mirrorX;
+            this.mirrorY = mirrorY;
+            this.mirrorZ = mirrorZ;
+            this.radius = radius;
+            this.drawLines = drawLines;
+            this.drawPlanes = drawPlanes;
+        }
+
+        public int getReach() {
+            return radius * 2; //Change ModifierSettings#setReachUpgrade too
+        }
+    }
+    
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos) {
+        List<BlockPos> coordinates = new ArrayList<>();
+
+        //find mirrorsettings for the player
+        MirrorSettings m = ModifierSettingsManager.getModifierSettings(player).getMirrorSettings();
+        if (!isEnabled(m, startPos)) return coordinates;
+
+        if (m.mirrorX) coordinateMirrorX(m, startPos, coordinates);
+        if (m.mirrorY) coordinateMirrorY(m, startPos, coordinates);
+        if (m.mirrorZ) coordinateMirrorZ(m, startPos, coordinates);
+
+        return coordinates;
+    }
+
+    private static void coordinateMirrorX(MirrorSettings m, BlockPos oldBlockPos, List<BlockPos> coordinates) {
+        //find mirror position
+        double x = m.position.x + (m.position.x - oldBlockPos.getX() - 0.5);
+        BlockPos newBlockPos = new BlockPos(x, oldBlockPos.getY(), oldBlockPos.getZ());
+        coordinates.add(newBlockPos);
+
+        if (m.mirrorY) coordinateMirrorY(m, newBlockPos, coordinates);
+        if (m.mirrorZ) coordinateMirrorZ(m, newBlockPos, coordinates);
+    }
+
+    private static void coordinateMirrorY(MirrorSettings m, BlockPos oldBlockPos, List<BlockPos> coordinates) {
+        //find mirror position
+        double y = m.position.y + (m.position.y - oldBlockPos.getY() - 0.5);
+        BlockPos newBlockPos = new BlockPos(oldBlockPos.getX(), y, oldBlockPos.getZ());
+        coordinates.add(newBlockPos);
+
+        if (m.mirrorZ) coordinateMirrorZ(m, newBlockPos, coordinates);
+    }
+
+    private static void coordinateMirrorZ(MirrorSettings m, BlockPos oldBlockPos, List<BlockPos> coordinates) {
+        //find mirror position
+        double z = m.position.z + (m.position.z - oldBlockPos.getZ() - 0.5);
+        BlockPos newBlockPos = new BlockPos(oldBlockPos.getX(), oldBlockPos.getY(), z);
+        coordinates.add(newBlockPos);
+    }
+
+    public static List<IBlockState> findBlockStates(EntityPlayer player, BlockPos startPos, IBlockState blockState, ItemStack itemStack, List<ItemStack> itemStacks) {
+        List<IBlockState> blockStates = new ArrayList<>();
+
+        //find mirrorsettings for the player
+        MirrorSettings m = ModifierSettingsManager.getModifierSettings(player).getMirrorSettings();
+        if (!isEnabled(m, startPos)) return blockStates;
+
+        //Randomizer bag synergy
+        IItemHandler bagInventory = null;
+        if (!itemStack.isEmpty() && itemStack.getItem() instanceof ItemRandomizerBag) {
+            bagInventory = ItemRandomizerBag.getBagInventory(itemStack);
+        }
+
+        if (m.mirrorX) blockStateMirrorX(player, m, startPos, blockState, bagInventory, itemStack, EnumHand.MAIN_HAND, blockStates, itemStacks);
+        if (m.mirrorY) blockStateMirrorY(player, m, startPos, blockState, bagInventory, itemStack, EnumHand.MAIN_HAND, blockStates, itemStacks);
+        if (m.mirrorZ) blockStateMirrorZ(player, m, startPos, blockState, bagInventory, itemStack, EnumHand.MAIN_HAND, blockStates, itemStacks);
+
+        return blockStates;
+    }
+
+    private static void blockStateMirrorX(EntityPlayer player, MirrorSettings m, BlockPos oldBlockPos, IBlockState oldBlockState,
+                                          IItemHandler bagInventory, ItemStack itemStack, EnumHand hand, List<IBlockState> blockStates, List<ItemStack> itemStacks) {
+        //find mirror position
+        double x = m.position.x + (m.position.x - oldBlockPos.getX() - 0.5);
+        BlockPos newBlockPos = new BlockPos(x, oldBlockPos.getY(), oldBlockPos.getZ());
+
+        //Randomizer bag synergy
+        if (bagInventory != null) {
+            itemStack = ItemRandomizerBag.pickRandomStack(bagInventory);
+            oldBlockState = BuildModifiers.getBlockStateFromItem(itemStack, player, oldBlockPos, EnumFacing.UP, new Vec3d(0, 0, 0), hand);
+        }
+
+        //Find blockstate
+        IBlockState newBlockState = oldBlockState == null ? null : oldBlockState.withMirror(net.minecraft.util.Mirror.FRONT_BACK);
+
+        //Store blockstate and itemstack
+        blockStates.add(newBlockState);
+        itemStacks.add(itemStack);
+
+        if (m.mirrorY) blockStateMirrorY(player, m, newBlockPos, newBlockState, bagInventory, itemStack, hand, blockStates, itemStacks);
+        if (m.mirrorZ) blockStateMirrorZ(player, m, newBlockPos, newBlockState, bagInventory, itemStack, hand, blockStates, itemStacks);
+    }
+
+    private static void blockStateMirrorY(EntityPlayer player, MirrorSettings m, BlockPos oldBlockPos, IBlockState oldBlockState,
+                                          IItemHandler bagInventory, ItemStack itemStack, EnumHand hand, List<IBlockState> blockStates, List<ItemStack> itemStacks) {
+        //find mirror position
+        double y = m.position.y + (m.position.y - oldBlockPos.getY() - 0.5);
+        BlockPos newBlockPos = new BlockPos(oldBlockPos.getX(), y, oldBlockPos.getZ());
+
+        //Randomizer bag synergy
+        if (bagInventory != null) {
+            itemStack = ItemRandomizerBag.pickRandomStack(bagInventory);
+            oldBlockState = BuildModifiers.getBlockStateFromItem(itemStack, player, oldBlockPos, EnumFacing.UP, new Vec3d(0, 0, 0), hand);
+        }
+
+        //Find blockstate
+        IBlockState newBlockState = oldBlockState == null ? null : getVerticalMirror(oldBlockState);
+
+        //Store blockstate and itemstack
+        blockStates.add(newBlockState);
+        itemStacks.add(itemStack);
+
+        if (m.mirrorZ) blockStateMirrorZ(player, m, newBlockPos, newBlockState, bagInventory, itemStack, hand, blockStates, itemStacks);
+    }
+
+    private static void blockStateMirrorZ(EntityPlayer player, MirrorSettings m, BlockPos oldBlockPos, IBlockState oldBlockState,
+                                          IItemHandler bagInventory, ItemStack itemStack, EnumHand hand, List<IBlockState> blockStates, List<ItemStack> itemStacks) {
+        //find mirror position
+        double z = m.position.z + (m.position.z - oldBlockPos.getZ() - 0.5);
+        BlockPos newBlockPos = new BlockPos(oldBlockPos.getX(), oldBlockPos.getY(), z);
+
+        //Randomizer bag synergy
+        if (bagInventory != null) {
+            itemStack = ItemRandomizerBag.pickRandomStack(bagInventory);
+            oldBlockState = BuildModifiers.getBlockStateFromItem(itemStack, player, oldBlockPos, EnumFacing.UP, new Vec3d(0, 0, 0), hand);
+        }
+
+        //Find blockstate
+        IBlockState newBlockState = oldBlockState == null ? null : oldBlockState.withMirror(net.minecraft.util.Mirror.LEFT_RIGHT);
+
+        //Store blockstate and itemstack
+        blockStates.add(newBlockState);
+        itemStacks.add(itemStack);
+    }
+
+    public static boolean isEnabled(MirrorSettings m, BlockPos startPos) {
+        if (m == null || !m.enabled || (!m.mirrorX && !m.mirrorY && !m.mirrorZ)) return false;
+
+        //within mirror distance
+        if (startPos.getX() + 0.5 < m.position.x - m.radius || startPos.getX() + 0.5 > m.position.x + m.radius ||
+            startPos.getY() + 0.5 < m.position.y - m.radius || startPos.getY() + 0.5 > m.position.y + m.radius ||
+            startPos.getZ() + 0.5 < m.position.z - m.radius || startPos.getZ() + 0.5 > m.position.z + m.radius)
+            return false;
+
+        return true;
+    }
+
+    private static IBlockState getVerticalMirror(IBlockState blockState) {
+        //Stairs
+        if (blockState.getBlock() instanceof BlockStairs) {
+            if (blockState.getValue(BlockStairs.HALF) == BlockStairs.EnumHalf.BOTTOM) {
+                return blockState.withProperty(BlockStairs.HALF, BlockStairs.EnumHalf.TOP);
+            } else {
+                return blockState.withProperty(BlockStairs.HALF, BlockStairs.EnumHalf.BOTTOM);
+            }
+        }
+
+        //Slabs
+        if (blockState.getBlock() instanceof BlockSlab) {
+            if (((BlockSlab) blockState.getBlock()).isDouble()) return blockState;
+            if (blockState.getValue(BlockSlab.HALF) == BlockSlab.EnumBlockHalf.BOTTOM) {
+                return blockState.withProperty(BlockSlab.HALF, BlockSlab.EnumBlockHalf.TOP);
+            } else {
+                return blockState.withProperty(BlockSlab.HALF, BlockSlab.EnumBlockHalf.BOTTOM);
+            }
+        }
+
+        //Buttons, endrod, observer, piston
+        if (blockState.getBlock() instanceof BlockDirectional) {
+            if (blockState.getValue(BlockDirectional.FACING) == EnumFacing.DOWN) {
+                return blockState.withProperty(BlockDirectional.FACING, EnumFacing.UP);
+            } else if (blockState.getValue(BlockDirectional.FACING) == EnumFacing.UP) {
+                return blockState.withProperty(BlockDirectional.FACING, EnumFacing.DOWN);
+            }
+        }
+
+        //Dispenser, dropper
+        if (blockState.getBlock() instanceof BlockDispenser) {
+            if (blockState.getValue(BlockDispenser.FACING) == EnumFacing.DOWN) {
+                return blockState.withProperty(BlockDispenser.FACING, EnumFacing.UP);
+            } else if (blockState.getValue(BlockDispenser.FACING) == EnumFacing.UP) {
+                return blockState.withProperty(BlockDispenser.FACING, EnumFacing.DOWN);
+            }
+        }
+
+        return blockState;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/buildmodifier/ModifierSettingsManager.java

@@ -0,0 +1,196 @@
+package nl.requios.effortlessbuilding.buildmodifier;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraftforge.fml.common.Mod;
+import nl.requios.effortlessbuilding.BuildConfig;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.capability.ModifierCapabilityManager;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+import nl.requios.effortlessbuilding.network.ModifierSettingsMessage;
+
+@Mod.EventBusSubscriber
+public class ModifierSettingsManager {
+
+    //Retrieves the buildsettings of a player through the modifierCapability capability
+    //Never returns null
+    public static ModifierSettings getModifierSettings(EntityPlayer player){
+        if (player.hasCapability(ModifierCapabilityManager.modifierCapability, null)) {
+            ModifierCapabilityManager.IModifierCapability capability = player.getCapability(
+                    ModifierCapabilityManager.modifierCapability, null);
+            if (capability.getModifierData() == null) {
+                capability.setModifierData(new ModifierSettings());
+            }
+            return capability.getModifierData();
+        }
+        throw new IllegalArgumentException("Player does not have modifierCapability capability");
+    }
+
+    public static void setModifierSettings(EntityPlayer player, ModifierSettings modifierSettings) {
+        if (player == null) {
+            EffortlessBuilding.log("Cannot set buildsettings, player is null");
+            return;
+        }
+        if (player.hasCapability(ModifierCapabilityManager.modifierCapability, null)) {
+            ModifierCapabilityManager.IModifierCapability capability = player.getCapability(
+                    ModifierCapabilityManager.modifierCapability, null);
+            capability.setModifierData(modifierSettings);
+        } else {
+            EffortlessBuilding.log(player, "Saving buildsettings failed.");
+        }
+    }
+
+    public static String sanitize(ModifierSettings modifierSettings, EntityPlayer player) {
+        int maxReach = ReachHelper.getMaxReach(player);
+        String error = "";
+
+        //Mirror settings
+        Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
+        if (m.radius < 1) {
+            m.radius = 1;
+            error += "Mirror size has to be at least 1. This has been corrected. ";
+        }
+        if (m.getReach() > maxReach) {
+            m.radius = maxReach / 2;
+            error += "Mirror exceeds your maximum reach of " + (maxReach / 2) + ". Radius has been set to "+ (maxReach / 2) + ". ";
+        }
+
+        //Array settings
+        Array.ArraySettings a = modifierSettings.getArraySettings();
+        if (a.count < 0) {
+            a.count = 0;
+            error += "Array count may not be negative. It has been reset to 0.";
+        }
+
+        if (a.getReach() > maxReach) {
+            a.count = 0;
+            error += "Array exceeds your maximum reach of " + maxReach + ". Array count has been reset to 0. ";
+        }
+
+        //Radial mirror settings
+        RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
+        if (r.slices < 2) {
+            r.slices = 2;
+            error += "Radial mirror needs to have at least 2 slices. Slices has been set to 2.";
+        }
+
+        if (r.radius < 1) {
+            r.radius = 1;
+            error += "Radial mirror radius has to be at least 1. This has been corrected. ";
+        }
+        if (r.getReach() > maxReach) {
+            r.radius = maxReach / 2;
+            error += "Radial mirror exceeds your maximum reach of " + (maxReach / 2) + ". Radius has been set to "+ (maxReach / 2) + ". ";
+        }
+
+        //Other
+        if (modifierSettings.reachUpgrade < 0) {
+            modifierSettings.reachUpgrade = 0;
+        }
+        if (modifierSettings.reachUpgrade > 3) {
+            modifierSettings.reachUpgrade = 3;
+        }
+
+        return error;
+    }
+
+    public static class ModifierSettings {
+        private Mirror.MirrorSettings mirrorSettings;
+        private Array.ArraySettings arraySettings;
+        private RadialMirror.RadialMirrorSettings radialMirrorSettings;
+        private boolean quickReplace = false;
+        private int reachUpgrade = 0;
+
+        public ModifierSettings() {
+            mirrorSettings = new Mirror.MirrorSettings();
+            arraySettings = new Array.ArraySettings();
+            radialMirrorSettings = new RadialMirror.RadialMirrorSettings();
+        }
+
+        public ModifierSettings(Mirror.MirrorSettings mirrorSettings, Array.ArraySettings arraySettings,
+                                RadialMirror.RadialMirrorSettings radialMirrorSettings, boolean quickReplace, int reachUpgrade) {
+            this.mirrorSettings = mirrorSettings;
+            this.arraySettings = arraySettings;
+            this.radialMirrorSettings = radialMirrorSettings;
+            this.quickReplace = quickReplace;
+            this.reachUpgrade = reachUpgrade;
+        }
+
+        public Mirror.MirrorSettings getMirrorSettings() {
+            if (this.mirrorSettings == null) this.mirrorSettings = new Mirror.MirrorSettings();
+            return this.mirrorSettings;
+        }
+
+        public void setMirrorSettings(Mirror.MirrorSettings mirrorSettings) {
+            if (mirrorSettings == null) return;
+            this.mirrorSettings = mirrorSettings;
+        }
+
+        public Array.ArraySettings getArraySettings() {
+            if (this.arraySettings == null) this.arraySettings = new Array.ArraySettings();
+            return this.arraySettings;
+        }
+
+        public void setArraySettings(Array.ArraySettings arraySettings) {
+            if (arraySettings == null) return;
+            this.arraySettings = arraySettings;
+        }
+
+        public RadialMirror.RadialMirrorSettings getRadialMirrorSettings() {
+            if (this.radialMirrorSettings == null) this.radialMirrorSettings = new RadialMirror.RadialMirrorSettings();
+            return this.radialMirrorSettings;
+        }
+
+        public void setRadialMirrorSettings(RadialMirror.RadialMirrorSettings radialMirrorSettings) {
+            if (radialMirrorSettings == null) return;
+            this.radialMirrorSettings = radialMirrorSettings;
+        }
+
+        public boolean doQuickReplace() {
+            return quickReplace;
+        }
+
+        public void setQuickReplace(boolean quickReplace) {
+            this.quickReplace = quickReplace;
+        }
+
+        public int getReachUpgrade() {
+            return reachUpgrade;
+        }
+
+        public void setReachUpgrade(int reachUpgrade) {
+            this.reachUpgrade = reachUpgrade;
+            //Set mirror radius to max
+            int reach = 10;
+            switch (reachUpgrade) {
+                case 0: reach = BuildConfig.reach.maxReachLevel0; break;
+                case 1: reach =  BuildConfig.reach.maxReachLevel1; break;
+                case 2: reach =  BuildConfig.reach.maxReachLevel2; break;
+                case 3: reach =  BuildConfig.reach.maxReachLevel3; break;
+            }
+
+            EffortlessBuilding.log("before "+this.mirrorSettings.radius);
+
+            if (this.mirrorSettings != null)
+                this.mirrorSettings.radius = reach / 2;
+            if (this.radialMirrorSettings != null)
+                this.radialMirrorSettings.radius = reach / 2;
+
+            EffortlessBuilding.log("after "+this.mirrorSettings.radius);
+        }
+    }
+
+    public static void handleNewPlayer(EntityPlayer player){
+        if (getModifierSettings(player) == null) {
+            setModifierSettings(player, new ModifierSettings());
+        }
+
+        //Only on server
+        if (!player.world.isRemote) {
+            //Send to client
+            ModifierSettingsMessage msg = new ModifierSettingsMessage(getModifierSettings(player));
+            EffortlessBuilding.packetHandler.sendTo(msg, (EntityPlayerMP) player);
+        }
+    }
+}
+

src/main/java/nl/requios/effortlessbuilding/buildmodifier/RadialMirror.java

@@ -0,0 +1,195 @@
+package nl.requios.effortlessbuilding.buildmodifier;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.Mirror;
+import net.minecraft.util.Rotation;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.items.IItemHandler;
+import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
+
+import java.util.ArrayList;
+import java.util.List;
+
+public class RadialMirror {
+
+    public static class RadialMirrorSettings {
+        public boolean enabled = false;
+        public Vec3d position = new Vec3d(0.5, 64.5, 0.5);
+        public int slices = 4;
+        public boolean alternate = false;
+        public int radius = 20;
+        public boolean drawLines = true, drawPlanes = false;
+
+        public RadialMirrorSettings() {
+        }
+
+        public RadialMirrorSettings(boolean enabled, Vec3d position, int slices, boolean alternate, int radius, boolean drawLines, boolean drawPlanes) {
+            this.enabled = enabled;
+            this.position = position;
+            this.slices = slices;
+            this.alternate = alternate;
+            this.radius = radius;
+            this.drawLines = drawLines;
+            this.drawPlanes = drawPlanes;
+        }
+
+        public int getReach() {
+            return radius * 2;
+        }
+    }
+
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos) {
+        List<BlockPos> coordinates = new ArrayList<>();
+
+        //find radial mirror settings for the player
+        RadialMirrorSettings r = ModifierSettingsManager.getModifierSettings(player).getRadialMirrorSettings();
+        if (!isEnabled(r, startPos)) return coordinates;
+
+        //get angle between slices
+        double sliceAngle = 2 * Math.PI / r.slices;
+
+        Vec3d startVec = new Vec3d(startPos.getX() + 0.5f, startPos.getY() + 0.5f, startPos.getZ() + 0.5f);
+        Vec3d relStartVec = startVec.subtract(r.position);
+
+        double startAngleToCenter = MathHelper.atan2(relStartVec.x, relStartVec.z);
+        if (startAngleToCenter < 0) startAngleToCenter += Math.PI;
+        double startAngleInSlice = startAngleToCenter % sliceAngle;
+
+        for (int i = 1; i < r.slices; i++) {
+            double curAngle = sliceAngle * i;
+
+            //alternate mirroring of slices
+            if (r.alternate && i%2 == 1) {
+                curAngle = curAngle - startAngleInSlice + (sliceAngle - startAngleInSlice);
+            }
+
+            Vec3d relNewVec = relStartVec.rotateYaw((float) curAngle);
+            BlockPos newBlockPos = new BlockPos(r.position.add(relNewVec));
+            if (!coordinates.contains(newBlockPos) && !newBlockPos.equals(startPos)) coordinates.add(newBlockPos);
+        }
+
+        return coordinates;
+    }
+
+    public static List<IBlockState> findBlockStates(EntityPlayer player, BlockPos startPos, IBlockState blockState, ItemStack itemStack, List<ItemStack> itemStacks) {
+        List<IBlockState> blockStates = new ArrayList<>();
+        List<BlockPos> coordinates = new ArrayList<>(); //to keep track of duplicates
+
+        //find radial mirror settings for the player that placed the block
+        RadialMirrorSettings r = ModifierSettingsManager.getModifierSettings(player).getRadialMirrorSettings();
+        if (!isEnabled(r, startPos)) return blockStates;
+
+
+        //get angle between slices
+        double sliceAngle = 2 * Math.PI / r.slices;
+
+        Vec3d startVec = new Vec3d(startPos.getX() + 0.5f, startPos.getY() + 0.5f, startPos.getZ() + 0.5f);
+        Vec3d relStartVec = startVec.subtract(r.position);
+
+        double startAngleToCenter = MathHelper.atan2(relStartVec.x, relStartVec.z);
+        double startAngleToCenterMod = startAngleToCenter < 0 ? startAngleToCenter + Math.PI : startAngleToCenter;
+        double startAngleInSlice = startAngleToCenterMod % sliceAngle;
+
+        //Rotate the original blockstate
+        blockState = rotateOriginalBlockState(startAngleToCenter, blockState);
+
+        //Randomizer bag synergy
+        IItemHandler bagInventory = null;
+        if (!itemStack.isEmpty() && itemStack.getItem() instanceof ItemRandomizerBag) {
+            bagInventory = ItemRandomizerBag.getBagInventory(itemStack);
+        }
+
+        IBlockState newBlockState;
+        for (int i = 1; i < r.slices; i++) {
+            newBlockState = blockState;
+            double curAngle = sliceAngle * i;
+
+            //alternate mirroring of slices
+            if (r.alternate && i%2 == 1) {
+                curAngle = curAngle - startAngleInSlice + (sliceAngle - startAngleInSlice);
+            }
+
+            Vec3d relNewVec = relStartVec.rotateYaw((float) curAngle);
+            BlockPos newBlockPos = new BlockPos(r.position.add(relNewVec));
+            if (coordinates.contains(newBlockPos) || newBlockPos.equals(startPos)) continue; //filter out duplicates
+            coordinates.add(newBlockPos);
+
+            //Randomizer bag synergy
+            if (bagInventory != null) {
+                itemStack = ItemRandomizerBag.pickRandomStack(bagInventory);
+                newBlockState = BuildModifiers
+                        .getBlockStateFromItem(itemStack, player, startPos, EnumFacing.UP, new Vec3d(0, 0, 0), EnumHand.MAIN_HAND);
+
+                newBlockState = rotateOriginalBlockState(startAngleToCenter, newBlockState);
+            }
+
+            //rotate
+            newBlockState = rotateBlockState(relNewVec, newBlockState, r.alternate && i%2 == 1);
+
+            blockStates.add(newBlockState);
+            itemStacks.add(itemStack);
+        }
+
+        return blockStates;
+    }
+
+    private static IBlockState rotateOriginalBlockState(double startAngleToCenter, IBlockState blockState) {
+        IBlockState newBlockState = blockState;
+
+        if (startAngleToCenter < -0.751 * Math.PI || startAngleToCenter > 0.749 * Math.PI) {
+            newBlockState = blockState.withRotation(Rotation.CLOCKWISE_180);
+        } else if (startAngleToCenter < -0.251 * Math.PI) {
+            newBlockState = blockState.withRotation(Rotation.COUNTERCLOCKWISE_90);
+        } else if (startAngleToCenter > 0.249 * Math.PI) {
+            newBlockState = blockState.withRotation(Rotation.CLOCKWISE_90);
+        }
+
+        return newBlockState;
+    }
+
+    private static IBlockState rotateBlockState(Vec3d relVec, IBlockState blockState, boolean alternate) {
+        IBlockState newBlockState;
+        double angleToCenter = MathHelper.atan2(relVec.x, relVec.z); //between -PI and PI
+
+        if (angleToCenter < -0.751 * Math.PI || angleToCenter > 0.749 * Math.PI) {
+            newBlockState = blockState.withRotation(Rotation.CLOCKWISE_180);
+            if (alternate) {
+                newBlockState = newBlockState.withMirror(Mirror.FRONT_BACK);
+            }
+        } else if (angleToCenter < -0.251 * Math.PI) {
+            newBlockState = blockState.withRotation(Rotation.CLOCKWISE_90);
+            if (alternate) {
+                newBlockState = newBlockState.withMirror(Mirror.LEFT_RIGHT);
+            }
+        } else if (angleToCenter > 0.249 * Math.PI) {
+            newBlockState = blockState.withRotation(Rotation.COUNTERCLOCKWISE_90);
+            if (alternate) {
+                newBlockState = newBlockState.withMirror(Mirror.LEFT_RIGHT);
+            }
+        } else {
+            newBlockState = blockState;
+            if (alternate) {
+                newBlockState = newBlockState.withMirror(Mirror.FRONT_BACK);
+            }
+        }
+
+        return newBlockState;
+    }
+
+    public static boolean isEnabled(RadialMirrorSettings r, BlockPos startPos) {
+        if (r == null || !r.enabled) return false;
+
+        if (new Vec3d(startPos.getX() + 0.5, startPos.getY() + 0.5, startPos.getZ() + 0.5).subtract(r.position).lengthSquared() >
+            r.radius * r.radius)
+            return false;
+
+        return true;
+    }
+
+}

src/main/java/nl/requios/effortlessbuilding/buildmodifier/UndoRedo.java

@@ -0,0 +1,230 @@
+package nl.requios.effortlessbuilding.buildmodifier;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import nl.requios.effortlessbuilding.BuildConfig;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.helper.FixedStack;
+import nl.requios.effortlessbuilding.helper.InventoryHelper;
+import nl.requios.effortlessbuilding.helper.SurvivalHelper;
+import nl.requios.effortlessbuilding.render.BlockPreviewRenderer;
+
+import java.util.*;
+
+public class UndoRedo {
+
+    //Undo and redo stacks per player
+    //Gets added to twice in singleplayer (server and client) if not careful. So separate stacks.
+    private static Map<UUID, FixedStack<BlockSet>> undoStacksClient = new HashMap<>();
+    private static Map<UUID, FixedStack<BlockSet>> undoStacksServer = new HashMap<>();
+    private static Map<UUID, FixedStack<BlockSet>> redoStacksClient = new HashMap<>();
+    private static Map<UUID, FixedStack<BlockSet>> redoStacksServer = new HashMap<>();
+
+    //add to undo stack
+    public static void addUndo(EntityPlayer player, BlockSet blockSet) {
+        Map<UUID, FixedStack<BlockSet>> undoStacks = player.world.isRemote ? undoStacksClient : undoStacksServer;
+
+        //Assert coordinates is as long as previous and new blockstate lists
+        if (blockSet.getCoordinates().size() != blockSet.getPreviousBlockStates().size() ||
+            blockSet.getCoordinates().size() != blockSet.getNewBlockStates().size()) {
+            EffortlessBuilding.logger.error("Coordinates and blockstate lists are not equal length. Coordinates: {}. Previous blockstates: {}. New blockstates: {}.",
+                    blockSet.getCoordinates().size(), blockSet.getPreviousBlockStates().size(), blockSet.getNewBlockStates().size());
+        }
+
+        //Warn if previous and new blockstate are equal
+        //Can happen in a lot of valid cases
+//        for (int i = 0; i < blockSet.getCoordinates().size(); i++) {
+//            if (blockSet.getPreviousBlockStates().get(i).equals(blockSet.getNewBlockStates().get(i))) {
+//                EffortlessBuilding.logger.warn("Previous and new blockstates are equal at index {}. Blockstate: {}.",
+//                        i, blockSet.getPreviousBlockStates().get(i));
+//            }
+//        }
+
+        //If no stack exists, make one
+        if (!undoStacks.containsKey(player.getUniqueID())) {
+            undoStacks.put(player.getUniqueID(), new FixedStack<>(new BlockSet[BuildConfig.survivalBalancers.undoStackSize]));
+        }
+
+
+        undoStacks.get(player.getUniqueID()).push(blockSet);
+    }
+
+    private static void addRedo(EntityPlayer player, BlockSet blockSet) {
+        Map<UUID, FixedStack<BlockSet>> redoStacks = player.world.isRemote ? redoStacksClient : redoStacksServer;
+
+        //(No asserts necessary, it's private)
+
+        //If no stack exists, make one
+        if (!redoStacks.containsKey(player.getUniqueID())) {
+            redoStacks.put(player.getUniqueID(), new FixedStack<>(new BlockSet[BuildConfig.survivalBalancers.undoStackSize]));
+        }
+
+        redoStacks.get(player.getUniqueID()).push(blockSet);
+    }
+
+    public static boolean undo(EntityPlayer player) {
+        Map<UUID, FixedStack<BlockSet>> undoStacks = player.world.isRemote ? undoStacksClient : undoStacksServer;
+
+        if (!undoStacks.containsKey(player.getUniqueID())) return false;
+
+        FixedStack<BlockSet> undoStack = undoStacks.get(player.getUniqueID());
+
+        if (undoStack.isEmpty()) return false;
+
+        BlockSet blockSet = undoStack.pop();
+        List<BlockPos> coordinates = blockSet.getCoordinates();
+        List<IBlockState> previousBlockStates = blockSet.getPreviousBlockStates();
+        List<IBlockState> newBlockStates = blockSet.getNewBlockStates();
+        Vec3d hitVec = blockSet.getHitVec();
+
+        //Find up to date itemstacks in player inventory
+        List<ItemStack> itemStacks = findItemStacksInInventory(player, previousBlockStates);
+
+        if (player.world.isRemote) {
+            BlockPreviewRenderer.onBlocksBroken(coordinates, itemStacks, newBlockStates, blockSet.getSecondPos(), blockSet.getFirstPos());
+        } else {
+            //break all those blocks, reset to what they were
+            for (int i = 0; i < coordinates.size(); i++) {
+                BlockPos coordinate = coordinates.get(i);
+                ItemStack itemStack = itemStacks.get(i);
+
+                if (previousBlockStates.get(i).equals(newBlockStates.get(i))) continue;
+
+                //get blockstate from itemstack
+                IBlockState previousBlockState = Blocks.AIR.getDefaultState();
+                if (itemStack.getItem() instanceof ItemBlock) {
+                    previousBlockState = previousBlockStates.get(i);//((ItemBlock) itemStack.getItem()).getBlock().getDefaultState();
+                }
+
+                if (player.world.isBlockLoaded(coordinate, true)) {
+                    //check itemstack empty
+                    if (itemStack.isEmpty()) {
+                        itemStack = findItemStackInInventory(player, previousBlockStates.get(i));
+                        //get blockstate from new itemstack
+                        if (!itemStack.isEmpty() && itemStack.getItem() instanceof ItemBlock) {
+                            previousBlockState = previousBlockStates.get(i);//((ItemBlock) itemStack.getItem()).getBlock().getDefaultState();
+                        } else {
+                            previousBlockState = Blocks.AIR.getDefaultState();
+                        }
+                    }
+                    if (itemStack.isEmpty()) SurvivalHelper.breakBlock(player.world, player, coordinate, true);
+                    //if previousBlockState is air, placeBlock will set it to air
+                    SurvivalHelper.placeBlock(player.world, player, coordinate, previousBlockState, itemStack, EnumFacing.UP, hitVec, true, false, false);
+                }
+            }
+        }
+
+        //add to redo
+        addRedo(player, blockSet);
+
+        return true;
+    }
+
+    public static boolean redo(EntityPlayer player) {
+        Map<UUID, FixedStack<BlockSet>> redoStacks = player.world.isRemote ? redoStacksClient : redoStacksServer;
+
+        if (!redoStacks.containsKey(player.getUniqueID())) return false;
+
+        FixedStack<BlockSet> redoStack = redoStacks.get(player.getUniqueID());
+
+        if (redoStack.isEmpty()) return false;
+
+        BlockSet blockSet = redoStack.pop();
+        List<BlockPos> coordinates = blockSet.getCoordinates();
+        List<IBlockState> previousBlockStates = blockSet.getPreviousBlockStates();
+        List<IBlockState> newBlockStates = blockSet.getNewBlockStates();
+        Vec3d hitVec = blockSet.getHitVec();
+
+        //Find up to date itemstacks in player inventory
+        List<ItemStack> itemStacks = findItemStacksInInventory(player, newBlockStates);
+
+        if (player.world.isRemote) {
+            BlockPreviewRenderer.onBlocksPlaced(coordinates, itemStacks, newBlockStates, blockSet.getFirstPos(), blockSet.getSecondPos());
+        } else {
+            //place blocks
+            for (int i = 0; i < coordinates.size(); i++) {
+                BlockPos coordinate = coordinates.get(i);
+                ItemStack itemStack = itemStacks.get(i);
+
+                if (previousBlockStates.get(i).equals(newBlockStates.get(i))) continue;
+
+                //get blockstate from itemstack
+                IBlockState newBlockState = Blocks.AIR.getDefaultState();
+                if (itemStack.getItem() instanceof ItemBlock) {
+                    newBlockState = newBlockStates.get(i);//((ItemBlock) itemStack.getItem()).getBlock().getDefaultState();
+                }
+
+                if (player.world.isBlockLoaded(coordinate, true)) {
+                    //check itemstack empty
+                    if (itemStack.isEmpty()) {
+                        itemStack = findItemStackInInventory(player, newBlockStates.get(i));
+                        //get blockstate from new itemstack
+                        if (!itemStack.isEmpty() && itemStack.getItem() instanceof ItemBlock) {
+                            newBlockState = newBlockStates.get(i);//((ItemBlock) itemStack.getItem()).getBlock().getDefaultState();
+                        } else {
+                            newBlockState = Blocks.AIR.getDefaultState();
+                        }
+                    }
+                    if (itemStack.isEmpty()) SurvivalHelper.breakBlock(player.world, player, coordinate, true);
+                    SurvivalHelper.placeBlock(player.world, player, coordinate, newBlockState, itemStack, EnumFacing.UP, hitVec, true, false, false);
+                }
+            }
+        }
+
+        //add to undo
+        addUndo(player, blockSet);
+
+        return true;
+    }
+
+    public static void clear(EntityPlayer player) {
+        Map<UUID, FixedStack<BlockSet>> undoStacks = player.world.isRemote ? undoStacksClient : undoStacksServer;
+        Map<UUID, FixedStack<BlockSet>> redoStacks = player.world.isRemote ? redoStacksClient : redoStacksServer;
+        if (undoStacks.containsKey(player.getUniqueID())) {
+            undoStacks.get(player.getUniqueID()).clear();
+        }
+        if (redoStacks.containsKey(player.getUniqueID())) {
+            redoStacks.get(player.getUniqueID()).clear();
+        }
+    }
+
+    private static List<ItemStack> findItemStacksInInventory(EntityPlayer player, List<IBlockState> blockStates) {
+        List<ItemStack> itemStacks = new ArrayList<>(blockStates.size());
+        for (IBlockState blockState : blockStates) {
+            itemStacks.add(findItemStackInInventory(player, blockState));
+        }
+        return itemStacks;
+    }
+
+    private static ItemStack findItemStackInInventory(EntityPlayer player, IBlockState blockState) {
+        ItemStack itemStack = ItemStack.EMPTY;
+        if (blockState == null) return itemStack;
+
+        //First try previousBlockStates
+        //TODO try to find itemstack with right blockstate first
+        // then change line 103 back (get state from item)
+        itemStack = InventoryHelper.findItemStackInInventory(player, blockState.getBlock());
+
+        //then anything it drops
+        if (itemStack.isEmpty()) {
+            Item itemDropped = blockState.getBlock().getItemDropped(blockState, player.world.rand, 10);
+            if (itemDropped instanceof ItemBlock) {
+                Block block = ((ItemBlock) itemDropped).getBlock();
+                itemStack = InventoryHelper.findItemStackInInventory(player, block);
+            }
+        }
+
+        //then air
+        //(already empty)
+
+        return itemStack;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/capability/BuildModifierCapability.java

@@ -1,138 +0,0 @@
-package nl.requios.effortlessbuilding.capability;
-
-import net.minecraft.nbt.NBTBase;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.util.EnumFacing;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Vec3d;
-import net.minecraftforge.common.capabilities.Capability;
-import net.minecraftforge.common.capabilities.CapabilityInject;
-import net.minecraftforge.common.capabilities.ICapabilitySerializable;
-import net.minecraftforge.event.entity.player.PlayerEvent;
-import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import nl.requios.effortlessbuilding.Array;
-import nl.requios.effortlessbuilding.BuildSettingsManager.BuildSettings;
-import nl.requios.effortlessbuilding.Mirror;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-@Mod.EventBusSubscriber
-public class BuildModifierCapability {
-
-    @CapabilityInject(IBuildModifier.class)
-    public final static Capability<IBuildModifier> buildModifier = null;
-
-    public interface IBuildModifier {
-        BuildSettings getBuildModifierData();
-
-        void setBuildModifierData(BuildSettings buildSettings);
-    }
-
-    public static class BuildModifier implements IBuildModifier {
-        private BuildSettings buildSettings;
-
-        @Override
-        public BuildSettings getBuildModifierData() {
-            return buildSettings;
-        }
-
-        @Override
-        public void setBuildModifierData(BuildSettings buildSettings) {
-            this.buildSettings = buildSettings;
-        }
-    }
-
-    public static class Storage implements Capability.IStorage<IBuildModifier> {
-        @Override
-        public NBTBase writeNBT(Capability<IBuildModifier> capability, IBuildModifier instance, EnumFacing side) {
-            NBTTagCompound compound = new NBTTagCompound();
-            BuildSettings buildSettings = instance.getBuildModifierData();
-
-            //MIRROR
-            Mirror.MirrorSettings m = buildSettings.getMirrorSettings();
-            compound.setBoolean("mirrorEnabled", m.enabled);
-            compound.setDouble("mirrorPosX", m.position.x);
-            compound.setDouble("mirrorPosY", m.position.y);
-            compound.setDouble("mirrorPosZ", m.position.z);
-            compound.setBoolean("mirrorX", m.mirrorX);
-            compound.setBoolean("mirrorY", m.mirrorY);
-            compound.setBoolean("mirrorZ", m.mirrorZ);
-            compound.setInteger("mirrorRadius", m.radius);
-            compound.setBoolean("mirrorDrawLines", m.drawLines);
-            compound.setBoolean("mirrorDrawPlanes", m.drawPlanes);
-
-            //ARRAY
-            Array.ArraySettings a = buildSettings.getArraySettings();
-            compound.setBoolean("arrayEnabled", a.enabled);
-            compound.setInteger("arrayOffsetX", a.offset.getX());
-            compound.setInteger("arrayOffsetY", a.offset.getY());
-            compound.setInteger("arrayOffsetZ", a.offset.getZ());
-            compound.setInteger("arrayCount", a.count);
-
-            //compound.setBoolean("quickReplace", buildSettings.doQuickReplace()); dont save quickreplace
-            return compound;
-        }
-
-        @Override
-        public void readNBT(Capability<IBuildModifier> capability, IBuildModifier instance, EnumFacing side, NBTBase nbt) {
-            NBTTagCompound compound = (NBTTagCompound) nbt;
-
-            //MIRROR
-            boolean mirrorEnabled = compound.getBoolean("mirrorEnabled");
-            Vec3d mirrorPosition = new Vec3d(compound.getDouble("mirrorPosX"), compound.getDouble("mirrorPosY"), compound.getDouble("mirrorPosZ"));
-            boolean mirrorX = compound.getBoolean("mirrorX");
-            boolean mirrorY = compound.getBoolean("mirrorY");
-            boolean mirrorZ = compound.getBoolean("mirrorZ");
-            int mirrorRadius = compound.getInteger("mirrorRadius");
-            boolean mirrorDrawLines = compound.getBoolean("mirrorDrawLines");
-            boolean mirrorDrawPlanes = compound.getBoolean("mirrorDrawPlanes");
-            Mirror.MirrorSettings mirrorSettings = new Mirror.MirrorSettings(mirrorEnabled, mirrorPosition, mirrorX, mirrorY, mirrorZ, mirrorRadius, mirrorDrawLines, mirrorDrawPlanes);
-
-            //ARRAY
-            boolean arrayEnabled = compound.getBoolean("arrayEnabled");
-            BlockPos arrayOffset = new BlockPos(compound.getInteger("arrayOffsetX"), compound.getInteger("arrayOffsetY"), compound.getInteger("arrayOffsetZ"));
-            int arrayCount = compound.getInteger("arrayCount");
-            Array.ArraySettings arraySettings = new Array.ArraySettings(arrayEnabled, arrayOffset, arrayCount);
-
-            //boolean quickReplace = compound.getBoolean("quickReplace"); //dont load quickreplace
-
-            BuildSettings buildSettings = new BuildSettings(mirrorSettings, arraySettings, false);
-            instance.setBuildModifierData(buildSettings);
-        }
-    }
-
-    public static class Provider implements ICapabilitySerializable<NBTBase> {
-        IBuildModifier inst = buildModifier.getDefaultInstance();
-
-        @Override
-        public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
-            return capability == buildModifier;
-        }
-
-        @Override
-        public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
-            if (capability == buildModifier) return buildModifier.<T>cast(inst);
-            return null;
-        }
-
-        @Override
-        public NBTBase serializeNBT() {
-            return buildModifier.getStorage().writeNBT(buildModifier, inst, null);
-        }
-
-        @Override
-        public void deserializeNBT(NBTBase nbt) {
-            buildModifier.getStorage().readNBT(buildModifier, inst, null, nbt);
-        }
-    }
-
-    // Allows for the capability to persist after death.
-    @SubscribeEvent
-    public static void clonePlayer(PlayerEvent.Clone event) {
-        IBuildModifier original = event.getOriginal().getCapability(buildModifier, null);
-        IBuildModifier clone = event.getEntity().getCapability(buildModifier, null);
-        clone.setBuildModifierData(original.getBuildModifierData());
-    }
-}

src/main/java/nl/requios/effortlessbuilding/capability/ItemHandlerCapabilityProvider.java

@@ -0,0 +1,42 @@
+package nl.requios.effortlessbuilding.capability;
+
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.ICapabilitySerializable;
+import net.minecraftforge.items.CapabilityItemHandler;
+import net.minecraftforge.items.IItemHandler;
+import net.minecraftforge.items.ItemStackHandler;
+import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class ItemHandlerCapabilityProvider implements ICapabilitySerializable<NBTTagCompound> {
+    IItemHandler itemHandler = new ItemStackHandler(ItemRandomizerBag.INV_SIZE);
+
+    @Override
+    public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
+        if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
+            return true;
+        return false;
+    }
+
+    @Nullable
+    @Override
+    public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
+        if (capability == CapabilityItemHandler.ITEM_HANDLER_CAPABILITY)
+            return (T) itemHandler;
+        return null;
+    }
+
+    @Override
+    public NBTTagCompound serializeNBT() {
+        return ((ItemStackHandler) itemHandler).serializeNBT();
+    }
+
+    @Override
+    public void deserializeNBT(NBTTagCompound nbt) {
+        ((ItemStackHandler) itemHandler).deserializeNBT(nbt);
+    }
+}

src/main/java/nl/requios/effortlessbuilding/capability/ModeCapabilityManager.java

@@ -0,0 +1,104 @@
+package nl.requios.effortlessbuilding.capability;
+
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.CapabilityInject;
+import net.minecraftforge.common.capabilities.ICapabilitySerializable;
+import net.minecraftforge.event.entity.player.PlayerEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import static nl.requios.effortlessbuilding.buildmode.ModeSettingsManager.*;
+
+@Mod.EventBusSubscriber
+public class ModeCapabilityManager {
+
+    @CapabilityInject(IModeCapability.class)
+    public final static Capability<IModeCapability> modeCapability = null;
+
+    public interface IModeCapability {
+        ModeSettings getModeData();
+
+        void setModeData(ModeSettings modeSettings);
+    }
+
+    public static class ModeCapability implements IModeCapability {
+        private ModeSettings modeSettings;
+
+        @Override
+        public ModeSettings getModeData() {
+            return modeSettings;
+        }
+
+        @Override
+        public void setModeData(ModeSettings modeSettings) {
+            this.modeSettings = modeSettings;
+        }
+    }
+
+    public static class Storage implements Capability.IStorage<IModeCapability> {
+        @Override
+        public NBTBase writeNBT(Capability<IModeCapability> capability, IModeCapability instance, EnumFacing side) {
+            NBTTagCompound compound = new NBTTagCompound();
+            ModeSettings modeSettings = instance.getModeData();
+            if (modeSettings == null) modeSettings = new ModeSettings();
+
+            //compound.setInteger("buildMode", modeSettings.getBuildMode().ordinal());
+
+            //TODO add mode settings
+
+            return compound;
+        }
+
+        @Override
+        public void readNBT(Capability<IModeCapability> capability, IModeCapability instance, EnumFacing side, NBTBase nbt) {
+            NBTTagCompound compound = (NBTTagCompound) nbt;
+
+            //BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.values()[compound.getInteger("buildMode")];
+
+            //TODO add mode settings
+
+            ModeSettings modeSettings = new ModeSettings(BuildModes.BuildModeEnum.NORMAL);
+            instance.setModeData(modeSettings);
+        }
+    }
+
+    public static class Provider implements ICapabilitySerializable<NBTBase> {
+        IModeCapability inst = modeCapability.getDefaultInstance();
+
+        @Override
+        public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
+            return capability == modeCapability;
+        }
+
+        @Override
+        public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
+            if (capability == modeCapability) return modeCapability.<T>cast(inst);
+            return null;
+        }
+
+        @Override
+        public NBTBase serializeNBT() {
+            return modeCapability.getStorage().writeNBT(modeCapability, inst, null);
+        }
+
+        @Override
+        public void deserializeNBT(NBTBase nbt) {
+            modeCapability.getStorage().readNBT(modeCapability, inst, null, nbt);
+        }
+    }
+
+    // Allows for the capability to persist after death.
+    @SubscribeEvent
+    public static void clonePlayer(PlayerEvent.Clone event) {
+        IModeCapability original = event.getOriginal().getCapability(modeCapability, null);
+        IModeCapability clone = event.getEntity().getCapability(modeCapability, null);
+        clone.setModeData(original.getModeData());
+    }
+}

src/main/java/nl/requios/effortlessbuilding/capability/ModifierCapabilityManager.java

@@ -0,0 +1,181 @@
+package nl.requios.effortlessbuilding.capability;
+
+import net.minecraft.nbt.NBTBase;
+import net.minecraft.nbt.NBTTagCompound;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.common.capabilities.Capability;
+import net.minecraftforge.common.capabilities.CapabilityInject;
+import net.minecraftforge.common.capabilities.ICapabilitySerializable;
+import net.minecraftforge.event.entity.player.PlayerEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import nl.requios.effortlessbuilding.buildmodifier.Array;
+import nl.requios.effortlessbuilding.buildmodifier.Mirror;
+import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+import static nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager.*;
+
+@Mod.EventBusSubscriber
+public class ModifierCapabilityManager {
+
+    @CapabilityInject(IModifierCapability.class)
+    public final static Capability<IModifierCapability> modifierCapability = null;
+
+    public interface IModifierCapability {
+        ModifierSettings getModifierData();
+
+        void setModifierData(ModifierSettings modifierSettings);
+    }
+
+    public static class ModifierCapability implements IModifierCapability {
+        private ModifierSettings modifierSettings;
+
+        @Override
+        public ModifierSettings getModifierData() {
+            return modifierSettings;
+        }
+
+        @Override
+        public void setModifierData(ModifierSettings modifierSettings) {
+            this.modifierSettings = modifierSettings;
+        }
+    }
+
+    public static class Storage implements Capability.IStorage<IModifierCapability> {
+        @Override
+        public NBTBase writeNBT(Capability<IModifierCapability> capability, IModifierCapability instance, EnumFacing side) {
+            NBTTagCompound compound = new NBTTagCompound();
+            ModifierSettings modifierSettings = instance.getModifierData();
+            if (modifierSettings == null) modifierSettings = new ModifierSettings();
+
+            //MIRROR
+            Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
+            if (m == null) m = new Mirror.MirrorSettings();
+            compound.setBoolean("mirrorEnabled", m.enabled);
+            compound.setDouble("mirrorPosX", m.position.x);
+            compound.setDouble("mirrorPosY", m.position.y);
+            compound.setDouble("mirrorPosZ", m.position.z);
+            compound.setBoolean("mirrorX", m.mirrorX);
+            compound.setBoolean("mirrorY", m.mirrorY);
+            compound.setBoolean("mirrorZ", m.mirrorZ);
+            compound.setInteger("mirrorRadius", m.radius);
+            compound.setBoolean("mirrorDrawLines", m.drawLines);
+            compound.setBoolean("mirrorDrawPlanes", m.drawPlanes);
+
+            //ARRAY
+            Array.ArraySettings a = modifierSettings.getArraySettings();
+            if (a == null) a = new Array.ArraySettings();
+            compound.setBoolean("arrayEnabled", a.enabled);
+            compound.setInteger("arrayOffsetX", a.offset.getX());
+            compound.setInteger("arrayOffsetY", a.offset.getY());
+            compound.setInteger("arrayOffsetZ", a.offset.getZ());
+            compound.setInteger("arrayCount", a.count);
+
+            compound.setInteger("reachUpgrade", modifierSettings.getReachUpgrade());
+
+            //compound.setBoolean("quickReplace", buildSettings.doQuickReplace()); dont save quickreplace
+
+            //RADIAL MIRROR
+            RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
+            if (r == null) r = new RadialMirror.RadialMirrorSettings();
+            compound.setBoolean("radialMirrorEnabled", r.enabled);
+            compound.setDouble("radialMirrorPosX", r.position.x);
+            compound.setDouble("radialMirrorPosY", r.position.y);
+            compound.setDouble("radialMirrorPosZ", r.position.z);
+            compound.setInteger("radialMirrorSlices", r.slices);
+            compound.setBoolean("radialMirrorAlternate", r.alternate);
+            compound.setInteger("radialMirrorRadius", r.radius);
+            compound.setBoolean("radialMirrorDrawLines", r.drawLines);
+            compound.setBoolean("radialMirrorDrawPlanes", r.drawPlanes);
+
+            return compound;
+        }
+
+        @Override
+        public void readNBT(Capability<IModifierCapability> capability, IModifierCapability instance, EnumFacing side, NBTBase nbt) {
+            NBTTagCompound compound = (NBTTagCompound) nbt;
+
+            //MIRROR
+            boolean mirrorEnabled = compound.getBoolean("mirrorEnabled");
+            Vec3d mirrorPosition = new Vec3d(
+                    compound.getDouble("mirrorPosX"),
+                    compound.getDouble("mirrorPosY"),
+                    compound.getDouble("mirrorPosZ"));
+            boolean mirrorX = compound.getBoolean("mirrorX");
+            boolean mirrorY = compound.getBoolean("mirrorY");
+            boolean mirrorZ = compound.getBoolean("mirrorZ");
+            int mirrorRadius = compound.getInteger("mirrorRadius");
+            boolean mirrorDrawLines = compound.getBoolean("mirrorDrawLines");
+            boolean mirrorDrawPlanes = compound.getBoolean("mirrorDrawPlanes");
+            Mirror.MirrorSettings mirrorSettings = new Mirror.MirrorSettings(mirrorEnabled, mirrorPosition, mirrorX, mirrorY, mirrorZ, mirrorRadius, mirrorDrawLines, mirrorDrawPlanes);
+
+            //ARRAY
+            boolean arrayEnabled = compound.getBoolean("arrayEnabled");
+            BlockPos arrayOffset = new BlockPos(
+                    compound.getInteger("arrayOffsetX"),
+                    compound.getInteger("arrayOffsetY"),
+                    compound.getInteger("arrayOffsetZ"));
+            int arrayCount = compound.getInteger("arrayCount");
+            Array.ArraySettings arraySettings = new Array.ArraySettings(arrayEnabled, arrayOffset, arrayCount);
+
+            int reachUpgrade = compound.getInteger("reachUpgrade");
+
+            //boolean quickReplace = compound.getBoolean("quickReplace"); //dont load quickreplace
+
+            //RADIAL MIRROR
+            boolean radialMirrorEnabled = compound.getBoolean("radialMirrorEnabled");
+            Vec3d radialMirrorPosition = new Vec3d(
+                    compound.getDouble("radialMirrorPosX"),
+                    compound.getDouble("radialMirrorPosY"),
+                    compound.getDouble("radialMirrorPosZ"));
+            int radialMirrorSlices = compound.getInteger("radialMirrorSlices");
+            boolean radialMirrorAlternate = compound.getBoolean("radialMirrorAlternate");
+            int radialMirrorRadius = compound.getInteger("radialMirrorRadius");
+            boolean radialMirrorDrawLines = compound.getBoolean("radialMirrorDrawLines");
+            boolean radialMirrorDrawPlanes = compound.getBoolean("radialMirrorDrawPlanes");
+            RadialMirror.RadialMirrorSettings radialMirrorSettings = new RadialMirror.RadialMirrorSettings(radialMirrorEnabled, radialMirrorPosition,
+                    radialMirrorSlices, radialMirrorAlternate, radialMirrorRadius, radialMirrorDrawLines, radialMirrorDrawPlanes);
+
+            ModifierSettings modifierSettings = new ModifierSettings(mirrorSettings, arraySettings, radialMirrorSettings, false, reachUpgrade);
+            instance.setModifierData(modifierSettings);
+        }
+    }
+
+    public static class Provider implements ICapabilitySerializable<NBTBase> {
+        IModifierCapability inst = modifierCapability.getDefaultInstance();
+
+        @Override
+        public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
+            return capability == modifierCapability;
+        }
+
+        @Override
+        public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
+            if (capability == modifierCapability) return modifierCapability.<T>cast(inst);
+            return null;
+        }
+
+        @Override
+        public NBTBase serializeNBT() {
+            return modifierCapability.getStorage().writeNBT(modifierCapability, inst, null);
+        }
+
+        @Override
+        public void deserializeNBT(NBTBase nbt) {
+            modifierCapability.getStorage().readNBT(modifierCapability, inst, null, nbt);
+        }
+    }
+
+    // Allows for the capability to persist after death.
+    @SubscribeEvent
+    public static void clonePlayer(PlayerEvent.Clone event) {
+        IModifierCapability original = event.getOriginal().getCapability(modifierCapability, null);
+        IModifierCapability clone = event.getEntity().getCapability(modifierCapability, null);
+        clone.setModifierData(original.getModifierData());
+    }
+}

src/main/java/nl/requios/effortlessbuilding/command/CommandReach.java

@@ -0,0 +1,46 @@
+package nl.requios.effortlessbuilding.command;
+
+import net.minecraft.command.CommandBase;
+import net.minecraft.command.CommandException;
+import net.minecraft.command.ICommandSender;
+import net.minecraft.command.WrongUsageException;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.util.text.TextComponentString;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.network.ModifierSettingsMessage;
+
+public class CommandReach extends CommandBase {
+    @Override
+    public String getName() {
+        return "reach";
+    }
+
+    @Override
+    public String getUsage(ICommandSender sender) {
+        return "commands.reach.usage";
+    }
+
+    @Override
+    public void execute(MinecraftServer server, ICommandSender sender, String[] args) throws CommandException {
+        EntityPlayerMP player = (EntityPlayerMP) sender;
+        if (args.length != 1) {
+            int reachUpgrade = ModifierSettingsManager.getModifierSettings(player).getReachUpgrade();
+            EffortlessBuilding.log(player, "Current reach: level "+reachUpgrade);
+            throw new WrongUsageException("commands.reach.usage");
+        }
+
+        if (sender instanceof EntityPlayerMP) {
+            //Set reach level to args[0]
+            ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+            modifierSettings.setReachUpgrade(Integer.valueOf(args[0]));
+            ModifierSettingsManager.setModifierSettings(player, modifierSettings);
+            //Send to client
+            EffortlessBuilding.packetHandler.sendTo(new ModifierSettingsMessage(modifierSettings), player);
+
+            sender.sendMessage(new TextComponentString("Reach level of " + sender.getName() + " set to " + modifierSettings
+                    .getReachUpgrade()));
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/compatibility/ActiveChiselsAndBitsProxy.java

@@ -0,0 +1,13 @@
+package nl.requios.effortlessbuilding.compatibility;
+
+import mod.chiselsandbits.core.ClientSide;
+import mod.chiselsandbits.helpers.ChiselToolType;
+import net.minecraft.util.EnumHand;
+
+public class ActiveChiselsAndBitsProxy implements IChiselsAndBitsProxy {
+    @Override
+    public boolean isHoldingChiselTool(EnumHand hand) {
+        ChiselToolType toolType = ClientSide.instance.getHeldToolType(hand);
+        return toolType != null && toolType.hasMenu();
+    }
+}

src/main/java/nl/requios/effortlessbuilding/compatibility/CompatHelper.java

@@ -0,0 +1,117 @@
+package nl.requios.effortlessbuilding.compatibility;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumHand;
+import net.minecraftforge.fml.common.Loader;
+import net.minecraftforge.fml.common.registry.GameRegistry;
+import net.minecraftforge.items.CapabilityItemHandler;
+import net.minecraftforge.items.IItemHandler;
+import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
+
+public class CompatHelper {
+    // Get a handle to the dank null item instance. This will remain null if the mod doesn't load
+    // and all checks will fail, so it works.
+    @GameRegistry.ObjectHolder("danknull:dank_null")
+    public static final Item dankNullItem = null;
+
+    public static IChiselsAndBitsProxy chiselsAndBitsProxy;
+
+    public static void postInit() {
+        if (Loader.isModLoaded("chiselsandbits")) {
+            // reflection to avoid hard dependency
+            try {
+                chiselsAndBitsProxy = Class.forName("nl.requios.effortlessbuilding.compatibility.ActiveChiselsAndBitsProxy").asSubclass(ActiveChiselsAndBitsProxy.class).newInstance();
+            } catch (InstantiationException | IllegalAccessException | ClassNotFoundException e) {
+                e.printStackTrace();
+            }
+        } else {
+            chiselsAndBitsProxy = new DummyChiselsAndBitsProxy();
+        }
+    }
+
+    // Check if the item given is a proxy for blocks. For now, we check for the randomizer bag,
+    // /dank/null, or plain old blocks.
+    public static boolean isItemBlockProxy(ItemStack stack) {
+        Item item = stack.getItem();
+        if (item instanceof ItemBlock)
+            return true;
+        if ((item instanceof ItemRandomizerBag))
+            return true;
+        if (item == dankNullItem)
+            return true;
+        return false;
+    }
+
+    // Get the block to be placed by this proxy. For the /dank/null, it's the slot stack
+    // pointed to by nbt integer selectedIndex.
+    public static ItemStack getItemBlockFromStack(ItemStack proxy) {
+        Item proxyItem = proxy.getItem();
+
+        if (proxyItem instanceof ItemBlock)
+            return proxy;
+
+        //Randomizer Bag
+        if (proxyItem instanceof ItemRandomizerBag) {
+            ItemStack itemStack = proxy;
+            while (!(itemStack.getItem() instanceof ItemBlock || itemStack.isEmpty())) {
+                if (itemStack.getItem() instanceof ItemRandomizerBag)
+                    itemStack = ItemRandomizerBag.pickRandomStack(ItemRandomizerBag.getBagInventory(itemStack));
+            }
+            return itemStack;
+        }
+
+        //Dank Null
+        if (proxyItem == dankNullItem) {
+            int index = 0;
+            if (proxy.hasTagCompound() && proxy.getTagCompound().hasKey("selectedIndex"))
+                index = proxy.getTagCompound().getInteger("selectedIndex");
+            return proxy.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null).getStackInSlot(index);
+        }
+
+        return ItemStack.EMPTY;
+    }
+
+    public static ItemStack getItemBlockByState(ItemStack stack, IBlockState state) {
+        Item blockItem = Item.getItemFromBlock(state.getBlock());
+        if (stack.getItem() instanceof ItemBlock)
+            return stack;
+        else if (stack.getItem() instanceof ItemRandomizerBag) {
+            IItemHandler bagInventory = ItemRandomizerBag.getBagInventory(stack);
+            return ItemRandomizerBag.findStack(bagInventory, blockItem);
+        } else if (stack.getItem() == dankNullItem) {
+            int index = itemHandlerSlotForItem(stack, blockItem);
+            if (index >= 0)
+                return stack.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null).getStackInSlot(index);
+        }
+        return ItemStack.EMPTY;
+    }
+
+    // Handle IItemHandler slot stacks not being modifiable. We must call IItemHandler#extractItem,
+    // because the ItemStack returned by IItemHandler#getStackInSlot isn't modifiable.
+    public static void shrinkStack(ItemStack origStack, ItemStack curStack, EntityPlayer player) {
+        //Hacky way to get the origstack, because given origStack is itemblock stack and never a proxy
+        origStack = player.getHeldItem(EnumHand.MAIN_HAND);
+
+        if (origStack.getItem() == dankNullItem) {
+            int index = itemHandlerSlotForItem(origStack, curStack.getItem());
+            origStack.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null).extractItem(index, 1, false);
+        } else
+            curStack.shrink(1);
+    }
+
+    private static int itemHandlerSlotForItem(ItemStack stack, Item blockItem) {
+        IItemHandler handler = stack.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
+        for (int i = 0; i < handler.getSlots(); i++) {
+            ItemStack ref = handler.getStackInSlot(i);
+            if (ref.getItem() instanceof ItemBlock)
+                if (ref.getItem() == blockItem)
+                    return i;
+        }
+        return -1;
+    }
+
+}

src/main/java/nl/requios/effortlessbuilding/compatibility/DummyChiselsAndBitsProxy.java

@@ -0,0 +1,10 @@
+package nl.requios.effortlessbuilding.compatibility;
+
+import net.minecraft.util.EnumHand;
+
+public class DummyChiselsAndBitsProxy implements IChiselsAndBitsProxy {
+    @Override
+    public boolean isHoldingChiselTool(EnumHand hand) {
+        return false;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/compatibility/IChiselsAndBitsProxy.java

@@ -0,0 +1,7 @@
+package nl.requios.effortlessbuilding.compatibility;
+
+import net.minecraft.util.EnumHand;
+
+public interface IChiselsAndBitsProxy {
+    boolean isHoldingChiselTool(EnumHand hand);
+}

src/main/java/nl/requios/effortlessbuilding/gui/RandomizerBagContainer.java

@@ -0,0 +1,130 @@
+package nl.requios.effortlessbuilding.gui;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.inventory.ClickType;
+import net.minecraft.inventory.Container;
+import net.minecraft.inventory.Slot;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumHand;
+import net.minecraftforge.items.IItemHandler;
+import net.minecraftforge.items.SlotItemHandler;
+import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
+
+public class RandomizerBagContainer extends Container {
+
+    private final IItemHandler bagInventory;
+    private final int sizeInventory;
+
+    private static final int INV_START = ItemRandomizerBag.INV_SIZE, INV_END = INV_START + 26,
+            HOTBAR_START = INV_END + 1, HOTBAR_END = HOTBAR_START + 8;
+
+    public RandomizerBagContainer(InventoryPlayer parInventoryPlayer, IItemHandler parIInventory) {
+        bagInventory = parIInventory;
+        sizeInventory = bagInventory.getSlots();
+        for (int i = 0; i < sizeInventory; ++i) {
+            this.addSlotToContainer(new SlotItemHandler(bagInventory, i, 44 + (18 * i), 20));
+        }
+
+        // add player inventory slots
+        int i;
+        for (i = 0; i < 3; ++i) {
+            for (int j = 0; j < 9; ++j) {
+                addSlotToContainer(new Slot(parInventoryPlayer, j + i * 9 + 9, 8 + j * 18, 51 + i * 18));
+            }
+        }
+
+        // add hotbar slots
+        for (i = 0; i < 9; ++i) {
+            addSlotToContainer(new Slot(parInventoryPlayer, i, 8 + i * 18, 109));
+        }
+    }
+
+    @Override
+    public boolean canInteractWith(EntityPlayer playerIn) {
+        return true;
+    }
+
+    @Override
+    public Slot getSlot(int parSlotIndex)
+    {
+        if(parSlotIndex >= inventorySlots.size())
+            parSlotIndex = inventorySlots.size() - 1;
+        return super.getSlot(parSlotIndex);
+    }
+
+    @Override
+    public ItemStack transferStackInSlot(EntityPlayer playerIn, int slotIndex) {
+        ItemStack itemstack = ItemStack.EMPTY;
+        Slot slot = this.inventorySlots.get(slotIndex);
+
+        if (slot != null && slot.getHasStack()) {
+            ItemStack itemstack1 = slot.getStack();
+            itemstack = itemstack1.copy();
+
+            // If item is in our custom inventory
+            if (slotIndex < INV_START) {
+                // try to place in player inventory / action bar
+                if (!this.mergeItemStack(itemstack1, INV_START, HOTBAR_END + 1, true)) {
+                    return ItemStack.EMPTY;
+                }
+
+                slot.onSlotChange(itemstack1, itemstack);
+            }
+            // Item is in inventory / hotbar, try to place in custom inventory or armor slots
+            else {
+                /**
+                 * Implementation number 1: Shift-click into your custom inventory
+                 */
+                if (slotIndex >= INV_START) {
+                    // place in custom inventory
+                    if (!this.mergeItemStack(itemstack1, 0, INV_START, false)) {
+                        return ItemStack.EMPTY;
+                    }
+                }
+
+            }
+
+            if (itemstack1.getCount() == 0) {
+                slot.putStack(ItemStack.EMPTY);
+            } else {
+                slot.onSlotChanged();
+            }
+
+            if (itemstack1.getCount() == itemstack.getCount()) {
+                return ItemStack.EMPTY;
+            }
+
+            slot.onTake(playerIn, itemstack1);
+        }
+
+        return itemstack;
+    }
+
+    /**
+     * You should override this method to prevent the player from moving the stack that
+     * opened the inventory, otherwise if the player moves it, the inventory will not
+     * be able to save properly
+     */
+    @Override
+    public ItemStack slotClick(int slot, int dragType, ClickType clickTypeIn, EntityPlayer player) {
+        // this will prevent the player from interacting with the item that opened the inventory:
+        if (slot >= 0 && getSlot(slot) != null && getSlot(slot).getStack().equals(player.getHeldItem(EnumHand.MAIN_HAND))) {
+            return ItemStack.EMPTY;
+        }
+        return super.slotClick(slot, dragType, clickTypeIn, player);
+    }
+
+    /**
+     * Callback for when the crafting gui is closed.
+     */
+    @Override
+    public void onContainerClosed(EntityPlayer player)
+    {
+        super.onContainerClosed(player);
+        if(!player.world.isRemote)
+        {
+            detectAndSendChanges();
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/gui/RandomizerBagGuiContainer.java

@@ -0,0 +1,49 @@
+package nl.requios.effortlessbuilding.gui;
+
+import net.minecraft.client.gui.inventory.GuiContainer;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.entity.player.InventoryPlayer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import net.minecraftforge.items.IItemHandler;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+
+@SideOnly(Side.CLIENT)
+public class RandomizerBagGuiContainer extends GuiContainer {
+    private static final ResourceLocation guiTextures =
+            new ResourceLocation(EffortlessBuilding.MODID, "textures/gui/container/randomizerbag.png");
+    private final InventoryPlayer inventoryPlayer;
+    private final IItemHandler inventoryBag;
+
+    public RandomizerBagGuiContainer(InventoryPlayer inventoryPlayer, IItemHandler inventoryBag) {
+        super(new RandomizerBagContainer(inventoryPlayer, inventoryBag));
+        this.inventoryPlayer = inventoryPlayer;
+        this.inventoryBag = inventoryBag;
+
+        ySize = 134;
+    }
+
+    @Override
+    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
+        drawDefaultBackground();
+        super.drawScreen(mouseX, mouseY, partialTicks);
+        this.renderHoveredToolTip(mouseX, mouseY);
+    }
+
+    @Override
+    protected void drawGuiContainerForegroundLayer(int mouseX, int mouseY) {
+        String s = "Randomizer Bag";
+        fontRenderer.drawString(s, 8, 6, 0x404040);
+        fontRenderer.drawString(inventoryPlayer.getDisplayName().getUnformattedText(), 8, ySize - 96 + 2, 0x404040);
+    }
+
+    @Override
+    protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY) {
+        GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
+        mc.getTextureManager().bindTexture(guiTextures);
+        int marginHorizontal = (width - xSize) / 2;
+        int marginVertical = (height - ySize) / 2;
+        drawTexturedModalRect(marginHorizontal, marginVertical, 0, 0, xSize, ySize);
+    }
+}

src/main/java/nl/requios/effortlessbuilding/gui/RandomizerBagGuiHandler.java

@@ -0,0 +1,41 @@
+package nl.requios.effortlessbuilding.gui;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.world.World;
+import net.minecraftforge.fml.common.network.IGuiHandler;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import net.minecraftforge.items.CapabilityItemHandler;
+import net.minecraftforge.items.IItemHandler;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+
+import javax.annotation.Nullable;
+
+public class RandomizerBagGuiHandler implements IGuiHandler {
+    @Nullable
+    @Override
+    public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
+        if (ID == EffortlessBuilding.RANDOMIZER_BAG_GUI) {
+            // Use the player's held item to create the container
+            IItemHandler capability = player.getHeldItemMainhand().hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null) ?
+                    player.getHeldItemMainhand().getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null) :
+                    player.getHeldItemOffhand().getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
+            return new RandomizerBagContainer(player.inventory, capability);
+        }
+        return null;
+    }
+
+    @Nullable
+    @Override
+    @SideOnly(Side.CLIENT)
+    public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
+        if (ID == EffortlessBuilding.RANDOMIZER_BAG_GUI) {
+            // Use the player's held item to create the client-side gui container
+            IItemHandler capability = player.getHeldItemMainhand().hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null) ?
+                    player.getHeldItemMainhand().getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null) :
+                    player.getHeldItemOffhand().getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
+            return new RandomizerBagGuiContainer(player.inventory, capability);
+        }
+        return null;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/gui/SettingsGui.java

@@ -1,314 +0,0 @@
-package nl.requios.effortlessbuilding.gui;
-
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.gui.GuiTextField;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Vec3d;
-import net.minecraftforge.fml.client.config.GuiCheckBox;
-import nl.requios.effortlessbuilding.Array;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.Mirror;
-import nl.requios.effortlessbuilding.network.BuildSettingsMessage;
-import nl.requios.effortlessbuilding.proxy.ClientProxy;
-import org.lwjgl.input.Keyboard;
-
-import java.io.IOException;
-import java.util.ArrayList;
-import java.util.List;
-
-public class SettingsGui extends GuiScreen {
-
-    protected List<GuiTextField> textFieldList = new ArrayList<>();
-
-    protected List<GuiButton> mirrorButtonList = new ArrayList<>();
-    protected List<GuiTextField> mirrorTextFieldList = new ArrayList<>();
-    protected List<GuiTextField> arrayTextFieldList = new ArrayList<>();
-
-    private GuiTextField textMirrorPosX, textMirrorPosY, textMirrorPosZ, textMirrorRadius;
-    private GuiCheckBox buttonMirrorEnabled, buttonMirrorX, buttonMirrorY, buttonMirrorZ;
-    private GuiButton buttonDrawPlanes, buttonDrawLines;
-    private boolean drawPlanes, drawLines;
-    private GuiButton buttonCurrentPosition, buttonClose;
-
-    private GuiCheckBox buttonArrayEnabled;
-    private GuiTextField textArrayOffsetX, textArrayOffsetY, textArrayOffsetZ, textArrayCount;
-
-    private int left, right, top, bottom;
-
-    @Override
-    //Create buttons and labels and add them to buttonList/labelList
-    public void initGui() {
-        int id = 0;
-        left = width / 2 - 140;
-        right = width / 2 + 140;
-        top = height / 2 - 100;
-        bottom = height / 2 + 100;
-
-        //MIRROR
-        int y = top - 2;
-        buttonMirrorEnabled = new GuiCheckBox(id++, left - 15 + 8, y, "", false);
-        buttonList.add(buttonMirrorEnabled);
-
-        y = top + 18;
-        textMirrorPosX = new GuiTextField(id++, fontRenderer, left + 70, y, 50, 18);
-        textMirrorPosX.setText("0.5");
-        mirrorTextFieldList.add(textMirrorPosX);
-
-        textMirrorPosY = new GuiTextField(id++, fontRenderer, left + 140, y, 50, 18);
-        textMirrorPosY.setText("64.5");
-        mirrorTextFieldList.add(textMirrorPosY);
-
-        textMirrorPosZ = new GuiTextField(id++, fontRenderer, left + 210, y, 50, 18);
-        textMirrorPosZ.setText("0.5");
-        mirrorTextFieldList.add(textMirrorPosZ);
-
-        y = top + 50;
-        buttonMirrorX = new GuiCheckBox(id++, left + 60, y, " X", true);
-        mirrorButtonList.add(buttonMirrorX);
-
-        buttonMirrorY = new GuiCheckBox(id++, left + 100, y, " Y", false);
-        mirrorButtonList.add(buttonMirrorY);
-
-        buttonMirrorZ = new GuiCheckBox(id++, left + 140, y, " Z", false);
-        mirrorButtonList.add(buttonMirrorZ);
-
-        y = top + 47;
-        textMirrorRadius = new GuiTextField(id++, fontRenderer, left + 220, y, 60, 18);
-        textMirrorRadius.setText("50");
-        mirrorTextFieldList.add(textMirrorRadius);
-
-        y = top + 72;
-        buttonCurrentPosition = new GuiButton(id++, left + 5, y, 110, 20, "Set to current pos");
-        mirrorButtonList.add(buttonCurrentPosition);
-
-        buttonDrawLines = new GuiButton(id++, left + 127, y, 70, 20, "Show lines");
-        mirrorButtonList.add(buttonDrawLines);
-
-        buttonDrawPlanes = new GuiButton(id++, left + 209, y, 75, 20, "Show area");
-        mirrorButtonList.add(buttonDrawPlanes);
-
-        //ARRAY
-        y = top + 100;
-        buttonArrayEnabled = new GuiCheckBox(id++, left - 15 + 8, y, "", false);
-        buttonList.add(buttonArrayEnabled);
-
-        y = top + 120;
-        textArrayOffsetX = new GuiTextField(id++, fontRenderer, left + 70, y, 50, 18);
-        textArrayOffsetX.setText("0");
-        arrayTextFieldList.add(textArrayOffsetX);
-
-        textArrayOffsetY = new GuiTextField(id++, fontRenderer, left + 140, y, 50, 18);
-        textArrayOffsetY.setText("0");
-        arrayTextFieldList.add(textArrayOffsetY);
-
-        textArrayOffsetZ = new GuiTextField(id++, fontRenderer, left + 210, y, 50, 18);
-        textArrayOffsetZ.setText("0");
-        arrayTextFieldList.add(textArrayOffsetZ);
-
-        y = top + 150;
-        textArrayCount = new GuiTextField(id++, fontRenderer, left + 55, y, 50, 18);
-        textArrayCount.setText("5");
-        arrayTextFieldList.add(textArrayCount);
-
-        //CLOSE
-        y = height - 40;
-        buttonClose = new GuiButton(id++, width / 2 - 100, y, "Close");
-        buttonList.add(buttonClose);
-
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(mc.player);
-        if (buildSettings != null) {
-            //MIRROR
-            Mirror.MirrorSettings m = buildSettings.getMirrorSettings();
-            buttonMirrorEnabled.setIsChecked(m.enabled);
-            textMirrorPosX.setText(String.valueOf(m.position.x));
-            textMirrorPosY.setText(String.valueOf(m.position.y));
-            textMirrorPosZ.setText(String.valueOf(m.position.z));
-            buttonMirrorX.setIsChecked(m.mirrorX);
-            buttonMirrorY.setIsChecked(m.mirrorY);
-            buttonMirrorZ.setIsChecked(m.mirrorZ);
-            textMirrorRadius.setText(String.valueOf(m.radius));
-            drawLines = m.drawLines;
-            drawPlanes = m.drawPlanes;
-            buttonDrawLines.displayString = drawLines ? "Hide lines" : "Show lines";
-            buttonDrawPlanes.displayString = drawPlanes ? "Hide area" : "Show area";
-
-            //ARRAY
-            Array.ArraySettings a = buildSettings.getArraySettings();
-            buttonArrayEnabled.setIsChecked(a.enabled);
-            textArrayOffsetX.setText(String.valueOf(a.offset.getX()));
-            textArrayOffsetY.setText(String.valueOf(a.offset.getY()));
-            textArrayOffsetZ.setText(String.valueOf(a.offset.getZ()));
-            textArrayCount.setText(String.valueOf(a.count));
-        }
-
-        buttonList.addAll(mirrorButtonList);
-        textFieldList.addAll(mirrorTextFieldList);
-        textFieldList.addAll(arrayTextFieldList);
-    }
-
-    @Override
-    //Process general logic, i.e. hide buttons
-    public void updateScreen() {
-        textFieldList.forEach(GuiTextField::updateCursorCounter);
-    }
-
-    @Override
-    //Set colors using GL11, use the fontRendererObj field to display text
-    //Use drawTexturedModalRect() to transfers areas of a texture resource to the screen
-    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
-        this.drawDefaultBackground();
-
-        int y = top;
-        int offset = 8;
-
-        buttonMirrorEnabled.drawButton(this.mc, mouseX, mouseY, partialTicks);
-        if (buttonMirrorEnabled.isChecked()) {
-            fontRenderer.drawString("Mirror enabled", left + offset, y, 0xFFFFFF, true);
-
-            y = top + 18 + 5;
-            fontRenderer.drawString("Position", left + offset, y, 0xFFFFFF, true);
-            fontRenderer.drawString("X", left + 50 + offset, y, 0xFFFFFF, true);
-            fontRenderer.drawString("Y", left + 120 + offset, y, 0xFFFFFF, true);
-            fontRenderer.drawString("Z", left + 190 + offset, y, 0xFFFFFF, true);
-
-            y = top + 52;
-            fontRenderer.drawString("Direction", left + offset, y, 0xFFFFFF, true);
-            fontRenderer.drawString("Size", left + 190, y, 0xFFFFFF, true);
-
-            mirrorButtonList.forEach(button -> button.drawButton(this.mc, mouseX, mouseY, partialTicks));
-            mirrorTextFieldList.forEach(textField -> textField.drawTextBox());
-        } else {
-            fontRenderer.drawString("Mirror disabled", left + offset, y, 0x999999, true);
-        }
-
-        y = top + 100 + 2;
-        buttonArrayEnabled.drawButton(this.mc, mouseX, mouseY, partialTicks);
-        if (buttonArrayEnabled.isChecked()) {
-            fontRenderer.drawString("Array enabled", left + offset, y, 0xFFFFFF, true);
-
-            y = top + 120 + 5;
-            fontRenderer.drawString("Offset", left + offset, y, 0xFFFFFF, true);
-            fontRenderer.drawString("X", left + 50 + offset, y, 0xFFFFFF, true);
-            fontRenderer.drawString("Y", left + 120 + offset, y, 0xFFFFFF, true);
-            fontRenderer.drawString("Z", left + 190 + offset, y, 0xFFFFFF, true);
-
-            y = top + 150 + 5;
-            fontRenderer.drawString("Count", left + offset, y, 0xFFFFFF, true);
-
-            arrayTextFieldList.forEach(textField -> textField.drawTextBox());
-        } else {
-            fontRenderer.drawString("Array disabled", left + offset, y, 0x999999, true);
-        }
-
-        buttonClose.drawButton(this.mc, mouseX, mouseY, partialTicks);
-    }
-
-    @Override
-    protected void keyTyped(char typedChar, int keyCode) throws IOException {
-        super.keyTyped(typedChar, keyCode);
-        if (Character.isDigit(typedChar) || typedChar == '.' || typedChar == '-' || keyCode == Keyboard.KEY_BACK || keyCode == Keyboard.KEY_DELETE) {
-            for (GuiTextField textField : textFieldList) {
-                if (textField.isFocused()) {
-                    textField.textboxKeyTyped(typedChar, keyCode);
-                }
-            }
-        }
-        if (keyCode == ClientProxy.keyBindings[0].getKeyCode()) {
-            Minecraft.getMinecraft().player.closeScreen();
-        }
-    }
-
-    @Override
-    protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException {
-        super.mouseClicked(mouseX, mouseY, mouseButton);
-        textFieldList.forEach(textField -> textField.mouseClicked(mouseX, mouseY, mouseButton));
-    }
-
-    @Override
-    protected void actionPerformed(GuiButton button) throws IOException {
-        //check what button and action type (left/right click)
-        if (button == buttonClose) {
-            mc.player.closeScreen();
-        }
-        if (button == buttonCurrentPosition) {
-            Vec3d pos = new Vec3d(Math.floor(mc.player.posX) + 0.5, Math.floor(mc.player.posY) + 0.5, Math.floor(mc.player.posZ) + 0.5);
-            textMirrorPosX.setText(String.valueOf(pos.x));
-            textMirrorPosY.setText(String.valueOf(pos.y));
-            textMirrorPosZ.setText(String.valueOf(pos.z));
-        }
-        if (button == buttonDrawLines) {
-            drawLines = !drawLines;
-            buttonDrawLines.displayString = drawLines ? "Hide lines" : "Show lines";
-        }
-        if (button == buttonDrawPlanes) {
-            drawPlanes = !drawPlanes;
-            buttonDrawPlanes.displayString = drawPlanes ? "Hide area" : "Show area";
-        }
-    }
-
-    @Override
-    public void onGuiClosed() {
-        //save everything
-
-        //MIRROR
-        boolean mirrorEnabled = buttonMirrorEnabled.isChecked();
-
-        Vec3d mirrorPos = new Vec3d(0.5, 64.5, 0.5);
-        try {
-            mirrorPos = new Vec3d(Double.parseDouble(textMirrorPosX.getText()), Double.parseDouble(textMirrorPosY.getText()), Double.parseDouble(textMirrorPosZ.getText()));
-        } catch (NumberFormatException | NullPointerException ex) {
-            EffortlessBuilding.log(Minecraft.getMinecraft().player, "Mirror position not valid.", true);
-            EffortlessBuilding.log("Mirror position not valid. Resetting to default.");
-        }
-
-        boolean mirrorX = buttonMirrorX.isChecked();
-        boolean mirrorY = buttonMirrorY.isChecked();
-        boolean mirrorZ = buttonMirrorZ.isChecked();
-
-        int mirrorRadius = 50;
-        try {
-            mirrorRadius = Math.min(Integer.parseInt(textMirrorRadius.getText()), Mirror.MAX_RADIUS);
-        } catch (NumberFormatException | NullPointerException ex) {
-            EffortlessBuilding.log(Minecraft.getMinecraft().player, "Mirror radius not valid.", true);
-            EffortlessBuilding.log("Mirror radius not valid. Resetting to default.");
-        }
-        mirrorRadius = Math.max(1, mirrorRadius);
-        mirrorRadius = Math.min(Mirror.MAX_RADIUS, mirrorRadius);
-
-        Mirror.MirrorSettings m = new Mirror.MirrorSettings(mirrorEnabled, mirrorPos, mirrorX, mirrorY, mirrorZ, mirrorRadius, drawLines, drawPlanes);
-
-        //ARRAY
-        boolean arrayEnabled = buttonArrayEnabled.isChecked();
-        BlockPos arrayOffset = new BlockPos(0, 0, 0);
-        try {
-            arrayOffset = new BlockPos(Integer.parseInt(textArrayOffsetX.getText()), Integer.parseInt(textArrayOffsetY.getText()), Integer.parseInt(textArrayOffsetZ.getText()));
-        } catch (NumberFormatException | NullPointerException ex) {
-            EffortlessBuilding.log(Minecraft.getMinecraft().player, "Array offset not valid.", true);
-            EffortlessBuilding.log("Array offset not valid. Resetting to default.");
-        }
-
-        int arrayCount = 5;
-        try {
-            arrayCount = Integer.parseInt(textArrayCount.getText());
-        } catch (NumberFormatException | NullPointerException ex) {
-            EffortlessBuilding.log(Minecraft.getMinecraft().player, "Array count not valid.", true);
-            EffortlessBuilding.log("Array count not valid. Resetting to default.");
-        }
-        arrayCount = Math.max(1, arrayCount);
-        arrayCount = Math.min(Array.MAX_COUNT, arrayCount);
-
-        Array.ArraySettings a = new Array.ArraySettings(arrayEnabled, arrayOffset, arrayCount);
-
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(mc.player);
-        if (buildSettings == null) buildSettings = new BuildSettingsManager.BuildSettings();
-        buildSettings.setMirrorSettings(m);
-        buildSettings.setArraySettings(a);
-        BuildSettingsManager.setBuildSettings(mc.player, buildSettings);
-
-        //Send to server
-        EffortlessBuilding.packetHandler.sendToServer(new BuildSettingsMessage(buildSettings));
-    }
-}

src/main/java/nl/requios/effortlessbuilding/gui/buildmode/RadialMenu.java

@@ -0,0 +1,476 @@
+package nl.requios.effortlessbuilding.gui.buildmode;
+
+import java.util.ArrayList;
+import java.util.concurrent.TimeUnit;
+
+import net.minecraft.client.resources.I18n;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.util.text.TextFormatting;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.ModeOptions;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
+import org.apache.commons.lang3.text.WordUtils;
+import org.lwjgl.opengl.GL11;
+
+import com.google.common.base.Stopwatch;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.client.model.ModelLoader;
+
+import static nl.requios.effortlessbuilding.buildmode.BuildModes.*;
+import static nl.requios.effortlessbuilding.buildmode.ModeOptions.*;
+
+/**
+ * From Chisels and Bits by AlgorithmX2
+ * https://github.com/AlgorithmX2/Chisels-and-Bits/blob/1.12/src/main/java/mod/chiselsandbits/client/gui/ChiselsAndBitsMenu.java
+ */
+public class RadialMenu extends GuiScreen {
+
+    private final float TIME_SCALE = 0.01f;
+    public static final RadialMenu instance = new RadialMenu();
+
+    private float visibility = 0.0f;
+    private Stopwatch lastChange = Stopwatch.createStarted();
+    public BuildModeEnum switchTo = null;
+    public ActionEnum doAction = null;
+    public boolean actionUsed = false;
+
+    private float clampVis(final float f) {
+        return Math.max( 0.0f, Math.min( 1.0f, f ) );
+    }
+
+    public void raiseVisibility() {
+        visibility = clampVis( visibility + lastChange.elapsed( TimeUnit.MILLISECONDS ) * TIME_SCALE );
+        lastChange = Stopwatch.createStarted();
+    }
+
+    public void decreaseVisibility() {
+        visibility = clampVis( visibility - lastChange.elapsed( TimeUnit.MILLISECONDS ) * TIME_SCALE );
+        lastChange = Stopwatch.createStarted();
+    }
+
+    public void setVisibility(float visibility) {
+        this.visibility = visibility;
+    }
+
+    public boolean isVisible() {
+        return visibility > 0.001;
+    }
+
+    public void configure(final int scaledWidth, final int scaledHeight ) {
+        mc = Minecraft.getMinecraft();
+        fontRenderer = mc.fontRenderer;
+        width = scaledWidth;
+        height = scaledHeight;
+    }
+
+    private static class MenuButton {
+
+        public double x1, x2;
+        public double y1, y2;
+        public boolean highlighted;
+
+        public final ActionEnum action;
+        public String name;
+        public EnumFacing textSide;
+
+        public MenuButton(final String name, final ActionEnum action, final double x, final double y,
+                final EnumFacing textSide) {
+            this.name = I18n.format(name);
+            this.action = action;
+            x1 = x - 10;
+            x2 = x + 10;
+            y1 = y - 10;
+            y2 = y + 10;
+            this.textSide = textSide;
+        }
+
+    }
+
+    static class MenuRegion {
+
+        public final BuildModeEnum mode;
+        public double x1, x2;
+        public double y1, y2;
+        public boolean highlighted;
+
+        public MenuRegion(final BuildModeEnum mode) {
+            this.mode = mode;
+        }
+
+    }
+
+    @Override
+    public void drawScreen(final int mouseX, final int mouseY, final float partialTicks) {
+        if (!isVisible()) return;
+
+        BuildModeEnum currentBuildMode = ModeSettingsManager.getModeSettings(Minecraft.getMinecraft().player).getBuildMode();
+
+        GlStateManager.pushMatrix();
+        GlStateManager.translate( 0.0F, 0.0F, 200.0F );
+
+        final int startColor = (int) ( visibility * 98 ) << 24;
+        final int endColor = (int) ( visibility * 128 ) << 24;
+
+        drawGradientRect(0, 0, width, height, startColor, endColor);
+
+        GlStateManager.disableTexture2D();
+        GlStateManager.enableBlend();
+        GlStateManager.disableAlpha();
+        GlStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, 1, 0);
+        GlStateManager.shadeModel(GL11.GL_SMOOTH);
+        final Tessellator tessellator = Tessellator.getInstance();
+        final BufferBuilder buffer = tessellator.getBuffer();
+
+        buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_COLOR);
+
+        final double middleX = width / 2.0;
+        final double middleY = height / 2.0;
+
+        final double mouseXCenter = mouseX - middleX;
+        final double mouseYCenter = mouseY - middleY;
+        double mouseRadians = Math.atan2(mouseYCenter, mouseXCenter);
+
+        final double ringInnerEdge = 30;
+        final double ringOuterEdge = 65;
+        final double textDistance = 75;
+        final double buttonDistance = 105;
+        final double quarterCircle = Math.PI / 2.0;
+
+        if ( mouseRadians < -quarterCircle ) {
+            mouseRadians = mouseRadians + Math.PI * 2;
+        }
+
+        final ArrayList<MenuRegion> modes = new ArrayList<MenuRegion>();
+        final ArrayList<MenuButton> buttons = new ArrayList<MenuButton>();
+
+        //Add build modes
+        for (final BuildModeEnum mode : BuildModeEnum.values()) {
+            modes.add(new MenuRegion(mode));
+        }
+
+        //Add actions
+        buttons.add(new MenuButton(ActionEnum.UNDO.name, ActionEnum.UNDO, -buttonDistance - 26, -13, EnumFacing.UP));
+        buttons.add(new MenuButton(ActionEnum.REDO.name, ActionEnum.REDO, -buttonDistance, -13, EnumFacing.UP));
+        buttons.add(new MenuButton(ActionEnum.OPEN_MODIFIER_SETTINGS.name, ActionEnum.OPEN_MODIFIER_SETTINGS, -buttonDistance - 26, 13, EnumFacing.DOWN));
+        buttons.add(new MenuButton(ActionEnum.REPLACE.name, ActionEnum.REPLACE, -buttonDistance, 13, EnumFacing.DOWN));
+
+        //Add buildmode dependent options
+        OptionEnum[] options = currentBuildMode.options;
+        for (int i = 0; i < options.length; i++) {
+            for (int j = 0; j < options[i].actions.length; j++) {
+                ActionEnum action = options[i].actions[j];
+                buttons.add(new MenuButton(action.name, action, buttonDistance + j * 26, -13 + i * 39, EnumFacing.DOWN));
+            }
+        }
+
+        switchTo = null;
+        doAction = null;
+
+        //Draw buildmode backgrounds
+        if (!modes.isEmpty()) {
+            final int totalModes = Math.max( 3, modes.size() );
+            int currentMode = 0;
+            final double fragment = Math.PI * 0.005;
+            final double fragment2 = Math.PI * 0.0025;
+            final double perObject = 2.0 * Math.PI / totalModes;
+
+            for (int i = 0; i < modes.size(); i++) {
+                MenuRegion menuRegion = modes.get(i);
+                final double beginRadians = currentMode * perObject - quarterCircle;
+                final double endRadians = (currentMode + 1) * perObject - quarterCircle;
+
+                menuRegion.x1 = Math.cos(beginRadians);
+                menuRegion.x2 = Math.cos(endRadians);
+                menuRegion.y1 = Math.sin(beginRadians);
+                menuRegion.y2 = Math.sin(endRadians);
+
+                final double x1m1 = Math.cos(beginRadians + fragment) * ringInnerEdge;
+                final double x2m1 = Math.cos(endRadians - fragment) * ringInnerEdge;
+                final double y1m1 = Math.sin(beginRadians + fragment) * ringInnerEdge;
+                final double y2m1 = Math.sin(endRadians - fragment) * ringInnerEdge;
+
+                final double x1m2 = Math.cos(beginRadians + fragment2) * ringOuterEdge;
+                final double x2m2 = Math.cos(endRadians - fragment2) * ringOuterEdge;
+                final double y1m2 = Math.sin(beginRadians + fragment2) * ringOuterEdge;
+                final double y2m2 = Math.sin(endRadians - fragment2) * ringOuterEdge;
+
+                float r = 0.0f;
+                float g = 0.0f;
+                float b = 0.0f;
+                float a = 0.5f;
+
+                //check if current mode
+                int buildMode = currentBuildMode.ordinal();
+                if (buildMode == i) {
+                    r = 0f;
+                    g = 0.5f;
+                    b = 1f;
+                    a = 0.5f;
+                    //menuRegion.highlighted = true; //draw text
+                }
+
+                //check if mouse is over this region
+                final boolean isMouseInQuad = inTriangle(x1m1, y1m1, x2m2, y2m2, x2m1, y2m1, mouseXCenter, mouseYCenter)
+                                              || inTriangle(x1m1, y1m1, x1m2, y1m2, x2m2, y2m2, mouseXCenter, mouseYCenter);
+
+                if (beginRadians <= mouseRadians && mouseRadians <= endRadians && isMouseInQuad) {
+                    r = 0.6f;
+                    g = 0.8f;
+                    b = 1f;
+                    a = 0.6f;
+                    menuRegion.highlighted = true;
+                    switchTo = menuRegion.mode;
+                }
+
+                buffer.pos(middleX + x1m1, middleY + y1m1, zLevel).color(r, g, b, a).endVertex();
+                buffer.pos(middleX + x2m1, middleY + y2m1, zLevel).color(r, g, b, a).endVertex();
+                buffer.pos(middleX + x2m2, middleY + y2m2, zLevel).color(r, g, b, a).endVertex();
+                buffer.pos(middleX + x1m2, middleY + y1m2, zLevel).color(r, g, b, a).endVertex();
+
+                currentMode++;
+            }
+        }
+
+        //Draw action backgrounds
+        for (final MenuButton btn : buttons) {
+            float r = 0.5f;
+            float g = 0.5f;
+            float b = 0.5f;
+            float a = 0.5f;
+
+            //highlight when active option
+            if (btn.action == getBuildSpeed() ||
+                btn.action == getFill() ||
+                btn.action == getCubeFill() ||
+                btn.action == getRaisedEdge() ||
+                btn.action == getLineThickness() ||
+                btn.action == getCircleStart()) {
+                r = 0.0f;
+                g = 0.5f;
+                b = 1f;
+                a = 0.6f;
+            }
+
+            //highlight when mouse over
+            if (btn.x1 <= mouseXCenter && btn.x2 >= mouseXCenter && btn.y1 <= mouseYCenter && btn.y2 >= mouseYCenter) {
+                r = 0.6f;
+                g = 0.8f;
+                b = 1f;
+                a = 0.6f;
+                btn.highlighted = true;
+                doAction = btn.action;
+            }
+
+            buffer.pos(middleX + btn.x1, middleY + btn.y1, zLevel).color(r, g, b, a).endVertex();
+            buffer.pos(middleX + btn.x1, middleY + btn.y2, zLevel).color(r, g, b, a).endVertex();
+            buffer.pos(middleX + btn.x2, middleY + btn.y2, zLevel).color(r, g, b, a).endVertex();
+            buffer.pos(middleX + btn.x2, middleY + btn.y1, zLevel).color(r, g, b, a).endVertex();
+        }
+
+        tessellator.draw();
+
+        GlStateManager.shadeModel(GL11.GL_FLAT);
+
+        GlStateManager.translate(0f, 0f, 5f);
+        GlStateManager.enableTexture2D();
+        GlStateManager.color(1f, 1f, 1f, 1f);
+        GlStateManager.disableBlend();
+        GlStateManager.enableAlpha();
+        GlStateManager.bindTexture(Minecraft.getMinecraft().getTextureMapBlocks().getGlTextureId());
+
+        buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX_COLOR);
+
+        //Draw buildmode icons
+        for (final MenuRegion menuRegion : modes) {
+
+            final double x = (menuRegion.x1 + menuRegion.x2) * 0.5 * (ringOuterEdge * 0.6 + 0.4 * ringInnerEdge);
+            final double y = (menuRegion.y1 + menuRegion.y2) * 0.5 * (ringOuterEdge * 0.6 + 0.4 * ringInnerEdge);
+
+            final TextureAtlasSprite sprite = ClientProxy.getBuildModeIcon(menuRegion.mode);
+
+            final double x1 = x - 8;
+            final double x2 = x + 8;
+            final double y1 = y - 8;
+            final double y2 = y + 8;
+
+            final float f = 1f;
+            final float a = 1f;
+
+            final double u1 = 0;
+            final double u2 = 16;
+            final double v1 = 0;
+            final double v2 = 16;
+
+            buffer.pos(middleX + x1, middleY + y1, zLevel).tex(sprite.getInterpolatedU(u1), sprite.getInterpolatedV(v1)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + x1, middleY + y2, zLevel).tex(sprite.getInterpolatedU(u1), sprite.getInterpolatedV(v2)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + x2, middleY + y2, zLevel).tex(sprite.getInterpolatedU(u2), sprite.getInterpolatedV(v2)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + x2, middleY + y1, zLevel).tex(sprite.getInterpolatedU(u2), sprite.getInterpolatedV(v1)).color(f, f, f, a).endVertex();
+        }
+
+        //Draw action icons
+        for (final MenuButton button : buttons) {
+
+            final float f = 1f;
+            final float a = 1f;
+
+            final double u1 = 0;
+            final double u2 = 16;
+            final double v1 = 0;
+            final double v2 = 16;
+
+            final TextureAtlasSprite sprite = ClientProxy.getModeOptionIcon(button.action);
+
+            final double btnmiddleX = (button.x1 + button.x2) / 2 + 0.01;
+            final double btnmiddleY = (button.y1 + button.y2) / 2 + 0.01;
+            final double btnx1 = btnmiddleX - 8;
+            final double btnx2 = btnmiddleX + 8;
+            final double btny1 = btnmiddleY - 8;
+            final double btny2 = btnmiddleY + 8;
+
+            buffer.pos(middleX + btnx1, middleY + btny1, zLevel).tex(sprite.getInterpolatedU(u1), sprite.getInterpolatedV(v1)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + btnx1, middleY + btny2, zLevel).tex(sprite.getInterpolatedU(u1), sprite.getInterpolatedV(v2)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + btnx2, middleY + btny2, zLevel).tex(sprite.getInterpolatedU(u2), sprite.getInterpolatedV(v2)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + btnx2, middleY + btny1, zLevel).tex(sprite.getInterpolatedU(u2), sprite.getInterpolatedV(v1)).color(f, f, f, a).endVertex();
+        }
+
+        tessellator.draw();
+
+        //Draw strings
+        //fontRenderer.drawStringWithShadow("Actions", (int) (middleX - buttonDistance - 13) - fontRenderer.getStringWidth("Actions") * 0.5f, (int) middleY - 38, 0xffffffff);
+
+        //Draw option strings
+        for (int i = 0; i < currentBuildMode.options.length; i++) {
+            OptionEnum option = options[i];
+            fontRenderer.drawStringWithShadow(I18n.format(option.name), (int) (middleX + buttonDistance - 9), (int) middleY - 37 + i * 39, 0xeeeeeeff);
+        }
+
+        String credits = "Effortless Building";
+        fontRenderer.drawStringWithShadow(credits, width - fontRenderer.getStringWidth(credits) - 4, height - 10, 0x88888888);
+
+        //Draw buildmode text
+        for (final MenuRegion menuRegion : modes) {
+
+            if (menuRegion.highlighted) {
+                final double x = (menuRegion.x1 + menuRegion.x2) * 0.5;
+                final double y = (menuRegion.y1 + menuRegion.y2) * 0.5;
+
+                int fixed_x = (int) (x * textDistance);
+                final int fixed_y = (int) (y * textDistance) - fontRenderer.FONT_HEIGHT / 2;
+                final String text = I18n.format(menuRegion.mode.name);
+
+                if ( x <= -0.2 ) {
+                    fixed_x -= fontRenderer.getStringWidth(text);
+                } else if ( -0.2 <= x && x <= 0.2 ) {
+                    fixed_x -= fontRenderer.getStringWidth(text) / 2;
+                }
+
+                fontRenderer.drawStringWithShadow(text, (int) middleX + fixed_x, (int) middleY + fixed_y, 0xffffffff);
+            }
+        }
+
+        //Draw action text
+        for (final MenuButton button : buttons) {
+            if (button.highlighted) {
+                String text = TextFormatting.AQUA + button.name;
+                int wrap = 120;
+                String keybind = "";
+                String keybindFormatted = "";
+
+                //Add keybind in brackets
+                if (button.action == ActionEnum.UNDO) {
+                    keybind = ClientProxy.keyBindings[4].getDisplayName();
+                }
+                if (button.action == ActionEnum.REDO) {
+                    keybind = ClientProxy.keyBindings[5].getDisplayName();
+                }
+                if (button.action == ActionEnum.REPLACE) {
+                    keybind = ClientProxy.keyBindings[1].getDisplayName();
+                }
+                if (button.action == ActionEnum.OPEN_MODIFIER_SETTINGS) {
+                    keybind = ClientProxy.keyBindings[0].getDisplayName();
+                }
+                if (currentBuildMode.options.length > 0) {
+                    //Add (ctrl) to first two actions of first option
+                    if (button.action == currentBuildMode.options[0].actions[0]
+                        || button.action == currentBuildMode.options[0].actions[1]) {
+                        keybind = ClientProxy.keyBindings[6].getDisplayName();
+                        if (keybind.equals("LCONTROL")) keybind = "Ctrl";
+                    }
+                }
+                if (!keybind.isEmpty()) keybindFormatted = TextFormatting.GRAY + "(" + WordUtils.capitalizeFully(keybind) + ")";
+
+                if (button.textSide == EnumFacing.WEST) {
+
+                    fontRenderer.drawSplitString( text, (int) (middleX + button.x1 - 8 ) - fontRenderer.getStringWidth(text),
+                            (int) (middleY + button.y1 + 6), wrap, 0xffffffff);
+
+                } else if (button.textSide == EnumFacing.EAST) {
+
+                    fontRenderer.drawSplitString(text, (int) (middleX + button.x2 + 8),
+                            (int) (middleY + button.y1 + 6 ), wrap, 0xffffffff);
+
+                } else if (button.textSide == EnumFacing.UP || button.textSide == EnumFacing.NORTH) {
+
+                    fontRenderer.drawSplitString( keybindFormatted, (int) (middleX + (button.x1 + button.x2) * 0.5 - fontRenderer.getStringWidth(keybindFormatted) * 0.5),
+                            (int) (middleY + button.y1 - 26), wrap,0xffffffff);
+
+                    fontRenderer.drawSplitString( text, (int) (middleX + (button.x1 + button.x2) * 0.5 - fontRenderer.getStringWidth(text) * 0.5),
+                            (int) (middleY + button.y1 - 14), wrap,0xffffffff);
+
+                } else if (button.textSide == EnumFacing.DOWN || button.textSide == EnumFacing.SOUTH) {
+
+                    fontRenderer.drawSplitString(text, (int) (middleX + (button.x1 + button.x2) * 0.5 - fontRenderer.getStringWidth(text) * 0.5),
+                            (int) (middleY + button.y1 + 26), wrap, 0xffffffff);
+
+                    fontRenderer.drawSplitString(keybindFormatted, (int) (middleX + (button.x1 + button.x2) * 0.5 - fontRenderer.getStringWidth(keybindFormatted) * 0.5),
+                            (int) (middleY + button.y1 + 38), wrap, 0xffffffff);
+
+                }
+
+            }
+        }
+
+        GlStateManager.popMatrix();
+    }
+
+    private boolean inTriangle(final double x1, final double y1, final double x2, final double y2,
+                               final double x3, final double y3, final double x, final double y ) {
+        final double ab = (x1 - x) * (y2 - y) - (x2 - x) * (y1 - y);
+        final double bc = (x2 - x) * (y3 - y) - (x3 - x) * (y2 - y);
+        final double ca = (x3 - x) * (y1 - y) - (x1 - x) * (y3 - y);
+        return sign(ab) == sign(bc) && sign(bc) == sign(ca);
+    }
+
+    private int sign(final double n) {
+        return n > 0 ? 1 : -1;
+    }
+
+    /**
+     * Called when the mouse is clicked. Args : mouseX, mouseY, clickedButton
+     */
+    @Override
+    protected void mouseClicked(int mouseX, int mouseY, int mouseButton ) {
+        EffortlessBuilding.log("mouse clicked");
+
+//        KeyBinding.updateKeyBindState();
+//        KeyBinding.setKeyBindState(ClientProxy.keyBindings[3].getKeyCode(), true);
+
+//        if (mouseButton == 0) {
+//            this.mc.displayGuiScreen(null);
+//
+//            if (this.mc.currentScreen == null) {
+//                this.mc.setIngameFocus();
+//            }
+//        }
+    }
+}
+

src/main/java/nl/requios/effortlessbuilding/gui/buildmodifier/ArraySettingsGui.java

@@ -0,0 +1,214 @@
+package nl.requios.effortlessbuilding.gui.buildmodifier;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.fml.client.config.GuiCheckBox;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.Array;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.gui.elements.GuiCollapsibleScrollEntry;
+import nl.requios.effortlessbuilding.gui.elements.GuiNumberField;
+import nl.requios.effortlessbuilding.gui.elements.GuiScrollPane;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+public class ArraySettingsGui extends GuiCollapsibleScrollEntry {
+
+    protected List<GuiNumberField> arrayNumberFieldList = new ArrayList<>();
+
+    private GuiCheckBox buttonArrayEnabled;
+    private GuiNumberField textArrayOffsetX, textArrayOffsetY, textArrayOffsetZ, textArrayCount;
+
+    public ArraySettingsGui(GuiScrollPane scrollPane) {
+        super(scrollPane);
+    }
+
+    @Override
+    public int initGui(int id, List<GuiButton> buttonList) {
+        id = super.initGui(id, buttonList);
+
+        int y = top;
+        buttonArrayEnabled = new GuiCheckBox(id++, left - 15 + 8, y, "", false);
+        buttonList.add(buttonArrayEnabled);
+
+        y = top + 20;
+        textArrayOffsetX = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 70, y, 50, 18);
+        textArrayOffsetX.setNumber(0);
+        textArrayOffsetX.setTooltip("How much each copy is shifted.");
+        arrayNumberFieldList.add(textArrayOffsetX);
+
+        textArrayOffsetY = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 140, y, 50, 18);
+        textArrayOffsetY.setNumber(0);
+        textArrayOffsetY.setTooltip("How much each copy is shifted.");
+        arrayNumberFieldList.add(textArrayOffsetY);
+
+        textArrayOffsetZ = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 210, y, 50, 18);
+        textArrayOffsetZ.setNumber(0);
+        textArrayOffsetZ.setTooltip("How much each copy is shifted.");
+        arrayNumberFieldList.add(textArrayOffsetZ);
+
+        y = top + 50;
+        textArrayCount = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 55, y, 50, 18);
+        textArrayCount.setNumber(5);
+        textArrayCount.setTooltip("How many copies should be made.");
+        arrayNumberFieldList.add(textArrayCount);
+
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
+        if (modifierSettings != null) {
+            Array.ArraySettings a = modifierSettings.getArraySettings();
+            buttonArrayEnabled.setIsChecked(a.enabled);
+            textArrayOffsetX.setNumber(a.offset.getX());
+            textArrayOffsetY.setNumber(a.offset.getY());
+            textArrayOffsetZ.setNumber(a.offset.getZ());
+            textArrayCount.setNumber(a.count);
+        }
+
+        setCollapsed(!buttonArrayEnabled.isChecked());
+
+        return id;
+    }
+
+    @Override
+    public void updateScreen() {
+        super.updateScreen();
+        arrayNumberFieldList.forEach(GuiNumberField::update);
+    }
+
+    @Override
+    public void drawEntry(int slotIndex, int x, int y, int listWidth, int slotHeight, int mouseX, int mouseY,
+                          boolean isSelected, float partialTicks) {
+        super.drawEntry(slotIndex, x, y, listWidth, slotHeight, mouseX, mouseY, isSelected, partialTicks);
+
+        int yy = y;
+        int offset = 8;
+
+        buttonArrayEnabled.drawButton(this.mc, mouseX, mouseY, partialTicks);
+        if (buttonArrayEnabled.isChecked()) {
+            buttonArrayEnabled.y = yy;
+            fontRenderer.drawString("Array enabled", left + offset, yy + 2, 0xFFFFFF, true);
+
+            yy = y + 20;
+            fontRenderer.drawString("Offset", left + offset, yy + 5, 0xFFFFFF, true);
+            fontRenderer.drawString("X", left + 50 + offset, yy + 5, 0xFFFFFF, true);
+            textArrayOffsetX.y = yy;
+            fontRenderer.drawString("Y", left + 120 + offset, yy + 5, 0xFFFFFF, true);
+            textArrayOffsetY.y = yy;
+            fontRenderer.drawString("Z", left + 190 + offset, yy + 5, 0xFFFFFF, true);
+            textArrayOffsetZ.y = yy;
+
+            yy = y + 50;
+            fontRenderer.drawString("Count", left + offset, yy + 5, 0xFFFFFF, true);
+            textArrayCount.y = yy;
+
+            int currentReach = Math.max(-1, getArrayReach());
+            int maxReach = ReachHelper.getMaxReach(mc.player);
+            TextFormatting reachColor = isCurrentReachValid(currentReach, maxReach) ? TextFormatting.GRAY : TextFormatting.RED;
+            String reachText = "Reach: " + reachColor + currentReach + TextFormatting.GRAY + "/" + TextFormatting.GRAY + maxReach;
+            fontRenderer.drawString(reachText, left + 176 + offset, yy + 5, 0xFFFFFF, true);
+
+            arrayNumberFieldList.forEach(numberField -> numberField.drawNumberField(this.mc, mouseX, mouseY, partialTicks));
+        } else {
+            buttonArrayEnabled.y = yy;
+            fontRenderer.drawString("Array disabled", left + offset, yy + 2, 0x999999, true);
+        }
+
+    }
+
+    public void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY) {
+        //Draw tooltips last
+        if (buttonArrayEnabled.isChecked())
+        {
+            arrayNumberFieldList.forEach(numberField -> numberField.drawTooltip(scrollPane.parent, mouseX, mouseY));
+        }
+    }
+
+    @Override
+    public void updatePosition(int slotIndex, int x, int y, float partialTicks) {
+        super.updatePosition(slotIndex, x, y, partialTicks);
+    }
+
+    @Override
+    public void keyTyped(char typedChar, int keyCode) throws IOException {
+        super.keyTyped(typedChar, keyCode);
+        for (GuiNumberField numberField : arrayNumberFieldList) {
+            numberField.keyTyped(typedChar, keyCode);
+        }
+    }
+
+    @Override
+    public boolean mousePressed(int slotIndex, int mouseX, int mouseY, int mouseEvent, int relativeX, int relativeY) {
+        super.mousePressed(slotIndex, mouseX, mouseY, mouseEvent, relativeX, relativeY);
+        arrayNumberFieldList.forEach(numberField -> numberField.mouseClicked(mouseX, mouseY, mouseEvent));
+
+        boolean insideArrayEnabledLabel = mouseX >= left && mouseX < right && relativeY >= -2 && relativeY < 12;
+
+        if (insideArrayEnabledLabel) {
+            buttonArrayEnabled.setIsChecked(!buttonArrayEnabled.isChecked());
+            buttonArrayEnabled.playPressSound(this.mc.getSoundHandler());
+            actionPerformed(buttonArrayEnabled);
+        }
+
+        return true;
+    }
+
+    @Override
+    public void actionPerformed(GuiButton button) {
+        super.actionPerformed(button);
+        if (button == buttonArrayEnabled) {
+            setCollapsed(!buttonArrayEnabled.isChecked());
+        }
+        arrayNumberFieldList.forEach(numberField -> numberField.actionPerformed(button));
+    }
+
+    public Array.ArraySettings getArraySettings() {
+        boolean arrayEnabled = buttonArrayEnabled.isChecked();
+        BlockPos arrayOffset = new BlockPos(0, 0, 0);
+        try {
+            arrayOffset = new BlockPos(textArrayOffsetX.getNumber(), textArrayOffsetY.getNumber(), textArrayOffsetZ.getNumber());
+        } catch (NumberFormatException | NullPointerException ex) {
+            EffortlessBuilding.log(mc.player, "Array offset not a valid number.");
+        }
+
+        int arrayCount = 5;
+        try {
+            arrayCount = (int) textArrayCount.getNumber();
+        } catch (NumberFormatException | NullPointerException ex) {
+            EffortlessBuilding.log(mc.player, "Array count not a valid number.");
+        }
+
+        return new Array.ArraySettings(arrayEnabled, arrayOffset, arrayCount);
+    }
+
+    @Override
+    protected String getName() {
+        return "Array";
+    }
+
+    @Override
+    protected int getExpandedHeight() {
+        return 80;
+    }
+
+    private int getArrayReach() {
+        try
+        {
+            //find largest offset
+            double x = Math.abs(textArrayOffsetX.getNumber());
+            double y = Math.abs(textArrayOffsetY.getNumber());
+            double z = Math.abs(textArrayOffsetZ.getNumber());
+            double largestOffset = Math.max(Math.max(x, y), z);
+            return (int) (largestOffset * textArrayCount.getNumber());
+        } catch (NumberFormatException | NullPointerException ex) {
+            return -1;
+        }
+    }
+
+    private boolean isCurrentReachValid(int currentReach, int maxReach) {
+        return currentReach <= maxReach && currentReach > -1;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/gui/buildmodifier/MirrorSettingsGui.java

@@ -0,0 +1,299 @@
+package nl.requios.effortlessbuilding.gui.buildmodifier;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.fml.client.config.GuiCheckBox;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.Mirror;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.gui.elements.GuiCollapsibleScrollEntry;
+import nl.requios.effortlessbuilding.gui.elements.GuiIconButton;
+import nl.requios.effortlessbuilding.gui.elements.GuiNumberField;
+import nl.requios.effortlessbuilding.gui.elements.GuiScrollPane;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class MirrorSettingsGui extends GuiCollapsibleScrollEntry {
+
+    protected static final ResourceLocation BUILDING_ICONS = new ResourceLocation(EffortlessBuilding.MODID, "textures/gui/building_icons.png");
+
+    protected List<GuiButton> mirrorButtonList = new ArrayList<>();
+    protected List<GuiIconButton> mirrorIconButtonList = new ArrayList<>();
+    protected List<GuiNumberField> mirrorNumberFieldList = new ArrayList<>();
+
+    private GuiNumberField textMirrorPosX, textMirrorPosY, textMirrorPosZ, textMirrorRadius;
+    private GuiCheckBox buttonMirrorEnabled, buttonMirrorX, buttonMirrorY, buttonMirrorZ;
+    private GuiIconButton buttonCurrentPosition, buttonToggleOdd, buttonDrawPlanes, buttonDrawLines;
+    private boolean drawPlanes, drawLines, toggleOdd;
+
+    public MirrorSettingsGui(GuiScrollPane scrollPane) {
+        super(scrollPane);
+    }
+
+    @Override
+    public int initGui(int id, List<GuiButton> buttonList) {
+        id = super.initGui(id, buttonList);
+
+        int y = top - 2;
+        buttonMirrorEnabled = new GuiCheckBox(id++, left - 15 + 8, y, "", false);
+        buttonList.add(buttonMirrorEnabled);
+
+        y = top + 18;
+        textMirrorPosX = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 58, y, 62, 18);
+        textMirrorPosX.setNumber(0);
+        textMirrorPosX.setTooltip(
+                Arrays.asList("The position of the mirror.", TextFormatting.GRAY + "For odd numbered builds add 0.5."));
+        mirrorNumberFieldList.add(textMirrorPosX);
+
+        textMirrorPosY = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 138, y, 62, 18);
+        textMirrorPosY.setNumber(64);
+        textMirrorPosY.setTooltip(Arrays.asList("The position of the mirror.", TextFormatting.GRAY + "For odd numbered builds add 0.5."));
+        mirrorNumberFieldList.add(textMirrorPosY);
+
+        textMirrorPosZ = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 218, y, 62, 18);
+        textMirrorPosZ.setNumber(0);
+        textMirrorPosZ.setTooltip(Arrays.asList("The position of the mirror.", TextFormatting.GRAY + "For odd numbered builds add 0.5."));
+        mirrorNumberFieldList.add(textMirrorPosZ);
+
+        y = top + 50;
+        buttonMirrorX = new GuiCheckBox(id++, left + 60, y, " X", true);
+        mirrorButtonList.add(buttonMirrorX);
+
+        buttonMirrorY = new GuiCheckBox(id++, left + 100, y, " Y", false);
+        mirrorButtonList.add(buttonMirrorY);
+
+        buttonMirrorZ = new GuiCheckBox(id++, left + 140, y, " Z", false);
+        mirrorButtonList.add(buttonMirrorZ);
+
+        y = top + 47;
+        textMirrorRadius = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 218, y, 62, 18);
+        textMirrorRadius.setNumber(50);
+        //TODO change to diameter (remove /2)
+        textMirrorRadius.setTooltip(Arrays.asList("How far the mirror reaches in any direction.",
+                TextFormatting.GRAY + "Max: " + TextFormatting.GOLD + ReachHelper.getMaxReach(mc.player) / 2,
+                TextFormatting.GRAY + "Upgradeable in survival with reach upgrades."));
+        mirrorNumberFieldList.add(textMirrorRadius);
+
+        y = top + 72;
+        buttonCurrentPosition = new GuiIconButton(id++, left + 5, y, 0, 0, BUILDING_ICONS);
+        buttonCurrentPosition.setTooltip("Set mirror position to current player position");
+        mirrorIconButtonList.add(buttonCurrentPosition);
+
+        buttonToggleOdd = new GuiIconButton(id++, left + 35, y, 0, 20, BUILDING_ICONS);
+        buttonToggleOdd.setTooltip(Arrays.asList("Set mirror position to middle of block", "for odd numbered builds"));
+        mirrorIconButtonList.add(buttonToggleOdd);
+
+        buttonDrawLines = new GuiIconButton(id++, left + 65, y, 0, 40, BUILDING_ICONS);
+        buttonDrawLines.setTooltip("Show lines");
+        mirrorIconButtonList.add(buttonDrawLines);
+
+        buttonDrawPlanes = new GuiIconButton(id++, left + 95, y, 0, 60, BUILDING_ICONS);
+        buttonDrawPlanes.setTooltip("Show area");
+        mirrorIconButtonList.add(buttonDrawPlanes);
+
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
+        if (modifierSettings != null) {
+            Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
+            buttonMirrorEnabled.setIsChecked(m.enabled);
+            textMirrorPosX.setNumber(m.position.x);
+            textMirrorPosY.setNumber(m.position.y);
+            textMirrorPosZ.setNumber(m.position.z);
+            buttonMirrorX.setIsChecked(m.mirrorX);
+            buttonMirrorY.setIsChecked(m.mirrorY);
+            buttonMirrorZ.setIsChecked(m.mirrorZ);
+            textMirrorRadius.setNumber(m.radius);
+            drawLines = m.drawLines;
+            drawPlanes = m.drawPlanes;
+            buttonDrawLines.setUseAlternateIcon(drawLines);
+            buttonDrawPlanes.setUseAlternateIcon(drawPlanes);
+            buttonDrawLines.setTooltip(drawLines ? "Hide lines" : "Show lines");
+            buttonDrawPlanes.setTooltip(drawPlanes ? "Hide area" : "Show area");
+            if (textMirrorPosX.getNumber() == Math.floor(textMirrorPosX.getNumber())) {
+                toggleOdd = false;
+                buttonToggleOdd.setTooltip(Arrays.asList("Set mirror position to middle of block", "for odd numbered builds"));
+            } else {
+                toggleOdd = true;
+                buttonToggleOdd.setTooltip(Arrays.asList("Set mirror position to corner of block", "for even numbered builds"));
+            }
+            buttonToggleOdd.setUseAlternateIcon(toggleOdd);
+        }
+
+        buttonList.addAll(mirrorButtonList);
+        buttonList.addAll(mirrorIconButtonList);
+
+        setCollapsed(!buttonMirrorEnabled.isChecked());
+
+        return id;
+    }
+
+    @Override
+    public void updateScreen() {
+        super.updateScreen();
+        mirrorNumberFieldList.forEach(GuiNumberField::update);
+    }
+
+    @Override
+    public void drawEntry(int slotIndex, int x, int y, int listWidth, int slotHeight, int mouseX, int mouseY,
+                          boolean isSelected, float partialTicks) {
+        super.drawEntry(slotIndex, x, y, listWidth, slotHeight, mouseX, mouseY, isSelected, partialTicks);
+
+        int yy = y;
+        int offset = 8;
+
+        buttonMirrorEnabled.drawButton(this.mc, mouseX, mouseY, partialTicks);
+        if (buttonMirrorEnabled.isChecked()) {
+            buttonMirrorEnabled.y = yy;
+            fontRenderer.drawString("Mirror enabled", left + offset, yy + 2, 0xFFFFFF, true);
+
+            yy = y + 18;
+            fontRenderer.drawString("Position", left + offset, yy + 5, 0xFFFFFF, true);
+            fontRenderer.drawString("X", left + 40 + offset, yy + 5, 0xFFFFFF, true);
+            textMirrorPosX.y = yy;
+            fontRenderer.drawString("Y", left + 120 + offset, yy + 5, 0xFFFFFF, true);
+            textMirrorPosY.y = yy;
+            fontRenderer.drawString("Z", left + 200 + offset, yy + 5, 0xFFFFFF, true);
+            textMirrorPosZ.y = yy;
+
+            yy = y + 50;
+            fontRenderer.drawString("Direction", left + offset, yy + 2, 0xFFFFFF, true);
+            buttonMirrorX.y = yy;
+            buttonMirrorY.y = yy;
+            buttonMirrorZ.y = yy;
+            fontRenderer.drawString("Radius", left + 176 + offset, yy + 2, 0xFFFFFF, true);
+            textMirrorRadius.y = yy - 3;
+
+            yy = y + 72;
+            buttonCurrentPosition.y = yy;
+            buttonToggleOdd.y = yy;
+            buttonDrawLines.y = yy;
+            buttonDrawPlanes.y = yy;
+
+            mirrorButtonList.forEach(button -> button.drawButton(this.mc, mouseX, mouseY, partialTicks));
+            mirrorIconButtonList.forEach(button -> button.drawButton(this.mc, mouseX, mouseY, partialTicks));
+            mirrorNumberFieldList.forEach(numberField -> numberField.drawNumberField(this.mc, mouseX, mouseY, partialTicks));
+        } else {
+            buttonMirrorEnabled.y = yy;
+            fontRenderer.drawString("Mirror disabled", left + offset, yy + 2, 0x999999, true);
+        }
+
+    }
+
+    public void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY) {
+        //Draw tooltips last
+        if (buttonMirrorEnabled.isChecked())
+        {
+            mirrorIconButtonList.forEach(iconButton -> iconButton.drawTooltip(scrollPane.parent, mouseX, mouseY));
+            mirrorNumberFieldList.forEach(numberField -> numberField.drawTooltip(scrollPane.parent, mouseX, mouseY));
+        }
+    }
+
+    @Override
+    public void updatePosition(int slotIndex, int x, int y, float partialTicks) {
+        super.updatePosition(slotIndex, x, y, partialTicks);
+    }
+
+    @Override
+    public void keyTyped(char typedChar, int keyCode) throws IOException {
+        super.keyTyped(typedChar, keyCode);
+        for (GuiNumberField numberField : mirrorNumberFieldList) {
+            numberField.keyTyped(typedChar, keyCode);
+        }
+    }
+
+    @Override
+    public boolean mousePressed(int slotIndex, int mouseX, int mouseY, int mouseEvent, int relativeX, int relativeY) {
+        super.mousePressed(slotIndex, mouseX, mouseY, mouseEvent, relativeX, relativeY);
+        mirrorNumberFieldList.forEach(numberField -> numberField.mouseClicked(mouseX, mouseY, mouseEvent));
+
+        boolean insideMirrorEnabledLabel = mouseX >= left && mouseX < right && relativeY >= -2 && relativeY < 12;
+
+        if (insideMirrorEnabledLabel) {
+            buttonMirrorEnabled.setIsChecked(!buttonMirrorEnabled.isChecked());
+            buttonMirrorEnabled.playPressSound(this.mc.getSoundHandler());
+            actionPerformed(buttonMirrorEnabled);
+        }
+
+        return true;
+    }
+
+    @Override
+    public void actionPerformed(GuiButton button) {
+        super.actionPerformed(button);
+        if (button == buttonMirrorEnabled) {
+            setCollapsed(!buttonMirrorEnabled.isChecked());
+        }
+        if (button == buttonCurrentPosition) {
+            Vec3d pos = new Vec3d(Math.floor(mc.player.posX) + 0.5, Math.floor(mc.player.posY) + 0.5, Math.floor(mc.player.posZ) + 0.5);
+            textMirrorPosX.setNumber(pos.x);
+            textMirrorPosY.setNumber(pos.y);
+            textMirrorPosZ.setNumber(pos.z);
+        }
+        if (button == buttonToggleOdd) {
+            toggleOdd = !toggleOdd;
+            buttonToggleOdd.setUseAlternateIcon(toggleOdd);
+            if (toggleOdd) {
+                buttonToggleOdd.setTooltip(Arrays.asList("Set mirror position to corner of block", "for even numbered builds"));
+                textMirrorPosX.setNumber(textMirrorPosX.getNumber() + 0.5);
+                textMirrorPosY.setNumber(textMirrorPosY.getNumber() + 0.5);
+                textMirrorPosZ.setNumber(textMirrorPosZ.getNumber() + 0.5);
+            } else {
+                buttonToggleOdd.setTooltip(Arrays.asList("Set mirror position to middle of block", "for odd numbered builds"));
+                textMirrorPosX.setNumber(Math.floor(textMirrorPosX.getNumber()));
+                textMirrorPosY.setNumber(Math.floor(textMirrorPosY.getNumber()));
+                textMirrorPosZ.setNumber(Math.floor(textMirrorPosZ.getNumber()));
+            }
+        }
+        if (button == buttonDrawLines) {
+            drawLines = !drawLines;
+            buttonDrawLines.setUseAlternateIcon(drawLines);
+            buttonDrawLines.setTooltip(drawLines ? "Hide lines" : "Show lines");
+        }
+        if (button == buttonDrawPlanes) {
+            drawPlanes = !drawPlanes;
+            buttonDrawPlanes.setUseAlternateIcon(drawPlanes);
+            buttonDrawPlanes.setTooltip(drawPlanes ? "Hide area" : "Show area");
+        }
+        mirrorNumberFieldList.forEach(numberField -> numberField.actionPerformed(button));
+    }
+
+    public Mirror.MirrorSettings getMirrorSettings() {
+        boolean mirrorEnabled = buttonMirrorEnabled.isChecked();
+
+        Vec3d mirrorPos = new Vec3d(0, 64, 0);
+        try {
+            mirrorPos = new Vec3d(textMirrorPosX.getNumber(), textMirrorPosY.getNumber(), textMirrorPosZ.getNumber());
+        } catch (NumberFormatException | NullPointerException ex) {
+            EffortlessBuilding.log(mc.player, "Mirror position not a valid number.");
+        }
+
+        boolean mirrorX = buttonMirrorX.isChecked();
+        boolean mirrorY = buttonMirrorY.isChecked();
+        boolean mirrorZ = buttonMirrorZ.isChecked();
+
+        int mirrorRadius = 50;
+        try {
+            mirrorRadius = (int) textMirrorRadius.getNumber();
+        } catch (NumberFormatException | NullPointerException ex) {
+            EffortlessBuilding.log(mc.player, "Mirror radius not a valid number.");
+        }
+
+        return new Mirror.MirrorSettings(mirrorEnabled, mirrorPos, mirrorX, mirrorY, mirrorZ, mirrorRadius, drawLines, drawPlanes);
+    }
+
+    @Override
+    protected String getName() {
+        return "Mirror";
+    }
+
+    @Override
+    protected int getExpandedHeight() {
+        return 100;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/gui/buildmodifier/ModifierSettingsGui.java

@@ -0,0 +1,137 @@
+package nl.requios.effortlessbuilding.gui.buildmodifier;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.Array;
+import nl.requios.effortlessbuilding.buildmodifier.Mirror;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
+import nl.requios.effortlessbuilding.gui.elements.GuiScrollPane;
+import nl.requios.effortlessbuilding.network.ModifierSettingsMessage;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
+
+import java.io.IOException;
+
+public class ModifierSettingsGui extends GuiScreen {
+
+    private GuiScrollPane scrollPane;
+    private GuiButton buttonClose;
+
+    private MirrorSettingsGui mirrorSettingsGui;
+    private ArraySettingsGui arraySettingsGui;
+    private RadialMirrorSettingsGui radialMirrorSettingsGui;
+
+    @Override
+    //Create buttons and labels and add them to buttonList/labelList
+    public void initGui() {
+        int id = 0;
+
+        scrollPane = new GuiScrollPane(this, fontRenderer, 8, height - 30);
+
+        mirrorSettingsGui = new MirrorSettingsGui(scrollPane);
+        scrollPane.listEntries.add(mirrorSettingsGui);
+
+        arraySettingsGui = new ArraySettingsGui(scrollPane);
+        scrollPane.listEntries.add(arraySettingsGui);
+
+        radialMirrorSettingsGui = new RadialMirrorSettingsGui(scrollPane);
+        scrollPane.listEntries.add(radialMirrorSettingsGui);
+
+        id = scrollPane.initGui(id, buttonList);
+
+        //Close button
+        int y = height - 26;
+        buttonClose = new GuiButton(id++, width / 2 - 100, y, "Close");
+        buttonList.add(buttonClose);
+
+    }
+
+    @Override
+    //Process general logic, i.e. hide buttons
+    public void updateScreen() {
+        scrollPane.updateScreen();
+    }
+
+    @Override
+    //Set colors using GL11, use the fontRendererObj field to display text
+    //Use drawTexturedModalRect() to transfers areas of a texture resource to the screen
+    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
+        this.drawDefaultBackground();
+
+        scrollPane.drawScreen(mouseX, mouseY, partialTicks);
+
+        buttonClose.drawButton(this.mc, mouseX, mouseY, partialTicks);
+
+        scrollPane.drawTooltip(this, mouseX, mouseY);
+    }
+
+    @Override
+    protected void keyTyped(char typedChar, int keyCode) throws IOException {
+        super.keyTyped(typedChar, keyCode);
+        scrollPane.keyTyped(typedChar, keyCode);
+        if (keyCode == ClientProxy.keyBindings[0].getKeyCode()) {
+            mc.player.closeScreen();
+        }
+    }
+
+    @Override
+    protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException {
+        super.mouseClicked(mouseX, mouseY, mouseButton);
+        scrollPane.mouseClicked(mouseX, mouseY, mouseButton);
+    }
+
+    @Override
+    protected void mouseReleased(int mouseX, int mouseY, int state) {
+        if (state != 0 || !scrollPane.mouseReleased(mouseX, mouseY, state))
+        {
+            super.mouseReleased(mouseX, mouseY, state);
+        }
+    }
+
+    @Override
+    public void handleMouseInput() throws IOException {
+        super.handleMouseInput();
+        scrollPane.handleMouseInput();
+
+        //Scrolling numbers
+//        int mouseX = Mouse.getEventX() * this.width / this.mc.displayWidth;
+//        int mouseY = this.height - Mouse.getEventY() * this.height / this.mc.displayHeight - 1;
+//        numberFieldList.forEach(numberField -> numberField.handleMouseInput(mouseX, mouseY));
+    }
+
+    @Override
+    protected void actionPerformed(GuiButton button) {
+        //check what button and action type (left/right click)
+        if (button == buttonClose) {
+            mc.player.closeScreen();
+        }
+        scrollPane.actionPerformed(button);
+    }
+
+    @Override
+    public void onGuiClosed() {
+        scrollPane.onGuiClosed();
+
+        //save everything
+        Mirror.MirrorSettings m = mirrorSettingsGui.getMirrorSettings();
+        Array.ArraySettings a = arraySettingsGui.getArraySettings();
+        RadialMirror.RadialMirrorSettings r = radialMirrorSettingsGui.getRadialMirrorSettings();
+
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
+        if (modifierSettings == null) modifierSettings = new ModifierSettingsManager.ModifierSettings();
+        modifierSettings.setMirrorSettings(m);
+        modifierSettings.setArraySettings(a);
+        modifierSettings.setRadialMirrorSettings(r);
+
+        //Sanitize
+        String error = ModifierSettingsManager.sanitize(modifierSettings, mc.player);
+        if (!error.isEmpty()) EffortlessBuilding.log(mc.player, error);
+
+        ModifierSettingsManager.setModifierSettings(mc.player, modifierSettings);
+
+        //Send to server
+        EffortlessBuilding.packetHandler.sendToServer(new ModifierSettingsMessage(modifierSettings));
+    }
+
+}

src/main/java/nl/requios/effortlessbuilding/gui/buildmodifier/RadialMirrorSettingsGui.java

@@ -0,0 +1,306 @@
+package nl.requios.effortlessbuilding.gui.buildmodifier;
+
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.fml.client.config.GuiCheckBox;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
+import nl.requios.effortlessbuilding.gui.elements.GuiCollapsibleScrollEntry;
+import nl.requios.effortlessbuilding.gui.elements.GuiIconButton;
+import nl.requios.effortlessbuilding.gui.elements.GuiNumberField;
+import nl.requios.effortlessbuilding.gui.elements.GuiScrollPane;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class RadialMirrorSettingsGui extends GuiCollapsibleScrollEntry {
+
+    protected static final ResourceLocation BUILDING_ICONS = new ResourceLocation(EffortlessBuilding.MODID, "textures/gui/building_icons.png");
+
+    protected List<GuiButton> radialMirrorButtonList = new ArrayList<>();
+    protected List<GuiIconButton> radialMirrorIconButtonList = new ArrayList<>();
+    protected List<GuiNumberField> radialMirrorNumberFieldList = new ArrayList<>();
+
+    private GuiNumberField textRadialMirrorPosX, textRadialMirrorPosY, textRadialMirrorPosZ, textRadialMirrorSlices, textRadialMirrorRadius;
+    private GuiCheckBox buttonRadialMirrorEnabled, buttonRadialMirrorAlternate;
+    private GuiIconButton buttonCurrentPosition, buttonToggleOdd, buttonDrawPlanes, buttonDrawLines;
+    private boolean drawPlanes, drawLines, toggleOdd;
+
+    public RadialMirrorSettingsGui(GuiScrollPane scrollPane) {
+        super(scrollPane);
+    }
+
+    @Override
+    public int initGui(int id, List<GuiButton> buttonList) {
+        id = super.initGui(id, buttonList);
+
+        int y = top - 2;
+        buttonRadialMirrorEnabled = new GuiCheckBox(id++, left - 15 + 8, y, "", false);
+        buttonList.add(buttonRadialMirrorEnabled);
+
+        y = top + 18;
+        textRadialMirrorPosX = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 58, y, 62, 18);
+        textRadialMirrorPosX.setNumber(0);
+        textRadialMirrorPosX.setTooltip(
+                Arrays.asList("The position of the radial mirror.", TextFormatting.GRAY + "For odd numbered builds add 0.5."));
+        radialMirrorNumberFieldList.add(textRadialMirrorPosX);
+
+        textRadialMirrorPosY = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 138, y, 62, 18);
+        textRadialMirrorPosY.setNumber(64);
+        textRadialMirrorPosY.setTooltip(Arrays.asList("The position of the radial mirror.", TextFormatting.GRAY + "For odd numbered builds add 0.5."));
+        radialMirrorNumberFieldList.add(textRadialMirrorPosY);
+
+        textRadialMirrorPosZ = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 218, y, 62, 18);
+        textRadialMirrorPosZ.setNumber(0);
+        textRadialMirrorPosZ.setTooltip(Arrays.asList("The position of the radial mirror.", TextFormatting.GRAY + "For odd numbered builds add 0.5."));
+        radialMirrorNumberFieldList.add(textRadialMirrorPosZ);
+
+        y = top + 47;
+        textRadialMirrorSlices = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 55, y, 50, 18);
+        textRadialMirrorSlices.setNumber(4);
+        textRadialMirrorSlices.setTooltip(Arrays.asList("The number of repeating slices.", TextFormatting.GRAY + "Minimally 2."));
+        radialMirrorNumberFieldList.add(textRadialMirrorSlices);
+
+        textRadialMirrorRadius = new GuiNumberField(id++, id++, id++, fontRenderer, buttonList, left + 218, y, 62, 18);
+        textRadialMirrorRadius.setNumber(50);
+        //TODO change to diameter (remove /2)
+        textRadialMirrorRadius.setTooltip(Arrays.asList("How far the radial mirror reaches from its center position.",
+                TextFormatting.GRAY + "Max: " + TextFormatting.GOLD + ReachHelper.getMaxReach(mc.player) / 2,
+                TextFormatting.GRAY + "Upgradeable in survival with reach upgrades."));
+        radialMirrorNumberFieldList.add(textRadialMirrorRadius);
+
+
+        y = top + 72;
+        buttonCurrentPosition = new GuiIconButton(id++, left + 5, y, 0, 0, BUILDING_ICONS);
+        buttonCurrentPosition.setTooltip("Set radial mirror position to current player position");
+        radialMirrorIconButtonList.add(buttonCurrentPosition);
+
+        buttonToggleOdd = new GuiIconButton(id++, left + 35, y, 0, 20, BUILDING_ICONS);
+        buttonToggleOdd.setTooltip(Arrays.asList("Set radial mirror position to middle of block", "for odd numbered builds"));
+        radialMirrorIconButtonList.add(buttonToggleOdd);
+
+        buttonDrawLines = new GuiIconButton(id++, left + 65, y, 0, 40, BUILDING_ICONS);
+        buttonDrawLines.setTooltip("Show lines");
+        radialMirrorIconButtonList.add(buttonDrawLines);
+
+        buttonDrawPlanes = new GuiIconButton(id++, left + 95, y, 0, 60, BUILDING_ICONS);
+        buttonDrawPlanes.setTooltip("Show area");
+        radialMirrorIconButtonList.add(buttonDrawPlanes);
+
+        y = top + 76;
+        buttonRadialMirrorAlternate = new GuiCheckBox(id++, left + 140, y, " Alternate", false);
+        radialMirrorButtonList.add(buttonRadialMirrorAlternate);
+
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
+        if (modifierSettings != null) {
+            RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
+            buttonRadialMirrorEnabled.setIsChecked(r.enabled);
+            textRadialMirrorPosX.setNumber(r.position.x);
+            textRadialMirrorPosY.setNumber(r.position.y);
+            textRadialMirrorPosZ.setNumber(r.position.z);
+            textRadialMirrorSlices.setNumber(r.slices);
+            buttonRadialMirrorAlternate.setIsChecked(r.alternate);
+            textRadialMirrorRadius.setNumber(r.radius);
+            drawLines = r.drawLines;
+            drawPlanes = r.drawPlanes;
+            buttonDrawLines.setUseAlternateIcon(drawLines);
+            buttonDrawPlanes.setUseAlternateIcon(drawPlanes);
+            buttonDrawLines.setTooltip(drawLines ? "Hide lines" : "Show lines");
+            buttonDrawPlanes.setTooltip(drawPlanes ? "Hide area" : "Show area");
+            if (textRadialMirrorPosX.getNumber() == Math.floor(textRadialMirrorPosX.getNumber())) {
+                toggleOdd = false;
+                buttonToggleOdd.setTooltip(Arrays.asList("Set radial mirror position to middle of block", "for odd numbered builds"));
+            } else {
+                toggleOdd = true;
+                buttonToggleOdd.setTooltip(Arrays.asList("Set radial mirror position to corner of block", "for even numbered builds"));
+            }
+            buttonToggleOdd.setUseAlternateIcon(toggleOdd);
+        }
+
+        buttonList.addAll(radialMirrorButtonList);
+        buttonList.addAll(radialMirrorIconButtonList);
+
+        setCollapsed(!buttonRadialMirrorEnabled.isChecked());
+
+        return id;
+    }
+
+    @Override
+    public void updateScreen() {
+        super.updateScreen();
+        radialMirrorNumberFieldList.forEach(GuiNumberField::update);
+    }
+
+    @Override
+    public void drawEntry(int slotIndex, int x, int y, int listWidth, int slotHeight, int mouseX, int mouseY,
+                          boolean isSelected, float partialTicks) {
+        super.drawEntry(slotIndex, x, y, listWidth, slotHeight, mouseX, mouseY, isSelected, partialTicks);
+
+        int yy = y;
+        int offset = 8;
+
+        buttonRadialMirrorEnabled.drawButton(this.mc, mouseX, mouseY, partialTicks);
+        if (buttonRadialMirrorEnabled.isChecked()) {
+            buttonRadialMirrorEnabled.y = yy;
+            fontRenderer.drawString("Radial mirror enabled", left + offset, yy + 2, 0xFFFFFF, true);
+
+            yy = y + 18;
+            fontRenderer.drawString("Position", left + offset, yy + 5, 0xFFFFFF, true);
+            fontRenderer.drawString("X", left + 40 + offset, yy + 5, 0xFFFFFF, true);
+            textRadialMirrorPosX.y = yy;
+            fontRenderer.drawString("Y", left + 120 + offset, yy + 5, 0xFFFFFF, true);
+            textRadialMirrorPosY.y = yy;
+            fontRenderer.drawString("Z", left + 200 + offset, yy + 5, 0xFFFFFF, true);
+            textRadialMirrorPosZ.y = yy;
+
+            yy = y + 50;
+            fontRenderer.drawString("Slices", left + offset, yy + 2, 0xFFFFFF, true);
+            textRadialMirrorSlices.y = yy - 3;
+            fontRenderer.drawString("Radius", left + 176 + offset, yy + 2, 0xFFFFFF, true);
+            textRadialMirrorRadius.y = yy - 3;
+
+            yy = y + 72;
+            buttonCurrentPosition.y = yy;
+            buttonToggleOdd.y = yy;
+            buttonDrawLines.y = yy;
+            buttonDrawPlanes.y = yy;
+
+            yy = y + 76;
+            buttonRadialMirrorAlternate.y = yy;
+
+            radialMirrorButtonList.forEach(button -> button.drawButton(this.mc, mouseX, mouseY, partialTicks));
+            radialMirrorIconButtonList.forEach(button -> button.drawButton(this.mc, mouseX, mouseY, partialTicks));
+            radialMirrorNumberFieldList
+                    .forEach(numberField -> numberField.drawNumberField(this.mc, mouseX, mouseY, partialTicks));
+        } else {
+            buttonRadialMirrorEnabled.y = yy;
+            fontRenderer.drawString("Radial mirror disabled", left + offset, yy + 2, 0x999999, true);
+        }
+
+    }
+
+    public void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY) {
+        //Draw tooltips last
+        if (buttonRadialMirrorEnabled.isChecked())
+        {
+            radialMirrorIconButtonList.forEach(iconButton -> iconButton.drawTooltip(scrollPane.parent, mouseX, mouseY));
+            radialMirrorNumberFieldList.forEach(numberField -> numberField.drawTooltip(scrollPane.parent, mouseX, mouseY));
+        }
+    }
+
+    @Override
+    public void updatePosition(int slotIndex, int x, int y, float partialTicks) {
+        super.updatePosition(slotIndex, x, y, partialTicks);
+    }
+
+    @Override
+    public void keyTyped(char typedChar, int keyCode) throws IOException {
+        super.keyTyped(typedChar, keyCode);
+        for (GuiNumberField numberField : radialMirrorNumberFieldList) {
+            numberField.keyTyped(typedChar, keyCode);
+        }
+    }
+
+    @Override
+    public boolean mousePressed(int slotIndex, int mouseX, int mouseY, int mouseEvent, int relativeX, int relativeY) {
+        super.mousePressed(slotIndex, mouseX, mouseY, mouseEvent, relativeX, relativeY);
+        radialMirrorNumberFieldList.forEach(numberField -> numberField.mouseClicked(mouseX, mouseY, mouseEvent));
+
+        boolean insideRadialMirrorEnabledLabel = mouseX >= left && mouseX < right && relativeY >= -2 && relativeY < 12;
+
+        if (insideRadialMirrorEnabledLabel) {
+            buttonRadialMirrorEnabled.setIsChecked(!buttonRadialMirrorEnabled.isChecked());
+            buttonRadialMirrorEnabled.playPressSound(this.mc.getSoundHandler());
+            actionPerformed(buttonRadialMirrorEnabled);
+        }
+
+        return true;
+    }
+
+    @Override
+    public void actionPerformed(GuiButton button) {
+        super.actionPerformed(button);
+        if (button == buttonRadialMirrorEnabled) {
+            setCollapsed(!buttonRadialMirrorEnabled.isChecked());
+        }
+        if (button == buttonCurrentPosition) {
+            Vec3d pos = new Vec3d(Math.floor(mc.player.posX) + 0.5, Math.floor(mc.player.posY) + 0.5, Math.floor(mc.player.posZ) + 0.5);
+            textRadialMirrorPosX.setNumber(pos.x);
+            textRadialMirrorPosY.setNumber(pos.y);
+            textRadialMirrorPosZ.setNumber(pos.z);
+        }
+        if (button == buttonToggleOdd) {
+            toggleOdd = !toggleOdd;
+            buttonToggleOdd.setUseAlternateIcon(toggleOdd);
+            if (toggleOdd) {
+                buttonToggleOdd.setTooltip(Arrays.asList("Set mirror position to corner of block", "for even numbered builds"));
+                textRadialMirrorPosX.setNumber(textRadialMirrorPosX.getNumber() + 0.5);
+                textRadialMirrorPosY.setNumber(textRadialMirrorPosY.getNumber() + 0.5);
+                textRadialMirrorPosZ.setNumber(textRadialMirrorPosZ.getNumber() + 0.5);
+            } else {
+                buttonToggleOdd.setTooltip(Arrays.asList("Set mirror position to middle of block", "for odd numbered builds"));
+                textRadialMirrorPosX.setNumber(Math.floor(textRadialMirrorPosX.getNumber()));
+                textRadialMirrorPosY.setNumber(Math.floor(textRadialMirrorPosY.getNumber()));
+                textRadialMirrorPosZ.setNumber(Math.floor(textRadialMirrorPosZ.getNumber()));
+            }
+        }
+        if (button == buttonDrawLines) {
+            drawLines = !drawLines;
+            buttonDrawLines.setUseAlternateIcon(drawLines);
+            buttonDrawLines.setTooltip(drawLines ? "Hide lines" : "Show lines");
+        }
+        if (button == buttonDrawPlanes) {
+            drawPlanes = !drawPlanes;
+            buttonDrawPlanes.setUseAlternateIcon(drawPlanes);
+            buttonDrawPlanes.setTooltip(drawPlanes ? "Hide area" : "Show area");
+        }
+        radialMirrorNumberFieldList.forEach(numberField -> numberField.actionPerformed(button));
+    }
+
+    public RadialMirror.RadialMirrorSettings getRadialMirrorSettings() {
+        boolean radialMirrorEnabled = buttonRadialMirrorEnabled.isChecked();
+
+        Vec3d radialMirrorPos = new Vec3d(0, 64, 0);
+        try {
+            radialMirrorPos = new Vec3d(textRadialMirrorPosX.getNumber(), textRadialMirrorPosY.getNumber(), textRadialMirrorPosZ
+                    .getNumber());
+        } catch (NumberFormatException | NullPointerException ex) {
+            EffortlessBuilding.log(mc.player, "Radial mirror position not a valid number.");
+        }
+
+        int radialMirrorSlices = 4;
+        try {
+            radialMirrorSlices = (int) textRadialMirrorSlices.getNumber();
+        } catch (NumberFormatException | NullPointerException ex) {
+            EffortlessBuilding.log(mc.player, "Radial mirror slices not a valid number.");
+        }
+
+        boolean radialMirrorAlternate = buttonRadialMirrorAlternate.isChecked();
+
+        int radialMirrorRadius = 50;
+        try {
+            radialMirrorRadius = (int) textRadialMirrorRadius.getNumber();
+        } catch (NumberFormatException | NullPointerException ex) {
+            EffortlessBuilding.log(mc.player, "Mirror radius not a valid number.");
+        }
+
+        return new RadialMirror.RadialMirrorSettings(radialMirrorEnabled, radialMirrorPos, radialMirrorSlices, radialMirrorAlternate, radialMirrorRadius, drawLines, drawPlanes);
+    }
+
+    @Override
+    protected String getName() {
+        return "Radial mirror";
+    }
+
+    @Override
+    protected int getExpandedHeight() {
+        return 100;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/gui/elements/GuiCollapsibleScrollEntry.java

@@ -0,0 +1,103 @@
+package nl.requios.effortlessbuilding.gui.elements;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+
+import java.io.IOException;
+import java.util.List;
+
+public abstract class GuiCollapsibleScrollEntry implements GuiScrollPane.IScrollEntry {
+
+    public GuiScrollPane scrollPane;
+    protected FontRenderer fontRenderer;
+    protected Minecraft mc;
+
+    protected boolean isCollapsed = true;
+    protected int left, right, top, bottom;
+
+    public GuiCollapsibleScrollEntry(GuiScrollPane scrollPane) {
+        this.scrollPane = scrollPane;
+        this.fontRenderer = scrollPane.fontRenderer;
+        this.mc = scrollPane.parent.mc;
+    }
+
+    @Override
+    public int initGui(int id, List<GuiButton> buttonList) {
+
+        left = scrollPane.width / 2 - 140;
+        right = scrollPane.width / 2 + 140;
+        top = scrollPane.height / 2 - 100;
+        bottom = scrollPane.height / 2 + 100;
+
+        return id;
+    }
+
+    @Override
+    public void updateScreen() {
+
+    }
+
+    @Override
+    public void drawEntry(int slotIndex, int x, int y, int listWidth, int slotHeight, int mouseX, int mouseY,
+                          boolean isSelected, float partialTicks) {
+
+    }
+
+    @Override
+    public void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY) {
+
+    }
+
+    @Override
+    public void updatePosition(int slotIndex, int x, int y, float partialTicks) {
+
+    }
+
+    @Override
+    public void keyTyped(char eventChar, int eventKey) throws IOException {
+
+    }
+
+    @Override
+    public boolean mousePressed(int slotIndex, int mouseX, int mouseY, int mouseEvent, int relativeX, int relativeY) {
+        return false;
+    }
+
+    @Override
+    public void mouseReleased(int slotIndex, int x, int y, int mouseEvent, int relativeX, int relativeY) {
+
+    }
+
+    @Override
+    public void actionPerformed(GuiButton button) {
+
+    }
+
+    @Override
+    public void onGuiClosed() {
+
+    }
+
+    @Override
+    public int getHeight() {
+        return isCollapsed ? getCollapsedHeight() : getExpandedHeight();
+    }
+
+    public void setCollapsed(boolean collapsed) {
+        this.isCollapsed = collapsed;
+    }
+
+    protected String getName() {
+        return "Collapsible scroll entry";
+    }
+
+    protected int getCollapsedHeight() {
+        return 24;
+    }
+
+    protected int getExpandedHeight() {
+        return 100;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/gui/elements/GuiIconButton.java

@@ -0,0 +1,75 @@
+package nl.requios.effortlessbuilding.gui.elements;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.util.ResourceLocation;
+
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class GuiIconButton extends GuiButton {
+
+    private final ResourceLocation resourceLocation;
+    private final int iconX, iconY, iconWidth, iconHeight, iconAltX, iconAltY;
+    List<String> tooltip = new ArrayList<>();
+    private boolean useAltIcon = false;
+
+    public GuiIconButton(int buttonId, int x, int y, int iconX, int iconY, ResourceLocation resourceLocation) {
+        this(buttonId, x, y, 20, 20, iconX, iconY, 20, 20, 20, 0, resourceLocation);
+    }
+
+    public GuiIconButton(int buttonId, int x, int y, int width, int height, int iconX, int iconY, int iconWidth, int iconHeight, int iconAltX, int iconAltY, ResourceLocation resourceLocation) {
+        super(buttonId, x, y, width, height, "");
+        this.iconX = iconX;
+        this.iconY = iconY;
+        this.iconWidth = iconWidth;
+        this.iconHeight = iconHeight;
+        this.iconAltX = iconAltX;
+        this.iconAltY = iconAltY;
+        this.resourceLocation = resourceLocation;
+    }
+
+    public void setTooltip(String tooltip) {
+        setTooltip(Arrays.asList(tooltip));
+    }
+
+    public void setTooltip(List<String> tooltip) {
+        this.tooltip = tooltip;
+    }
+
+    public void setUseAlternateIcon(boolean useAlternateIcon) {
+        this.useAltIcon = useAlternateIcon;
+    }
+
+    @Override
+    public void drawButton(Minecraft mc, int mouseX, int mouseY, float partialTicks) {
+        super.drawButton(mc, mouseX, mouseY, partialTicks);
+        if (this.visible)
+        {
+            this.hovered = mouseX >= this.x && mouseY >= this.y && mouseX < this.x + this.width && mouseY < this.y + this.height;
+            mc.getTextureManager().bindTexture(this.resourceLocation);
+            int currentIconX = this.iconX;
+            int currentIconY = this.iconY;
+
+            if (useAltIcon)
+            {
+                currentIconX += iconAltX;
+                currentIconY += iconAltY;
+            }
+
+            this.drawTexturedModalRect(this.x, this.y, currentIconX, currentIconY, this.iconWidth, this.iconHeight);
+        }
+    }
+
+    public void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY) {
+        boolean flag = mouseX >= x && mouseX < x + width && mouseY >= y && mouseY < y + height;
+
+        if (flag) {
+            List<String> textLines = new ArrayList<>();
+            textLines.addAll(tooltip);
+            guiScreen.drawHoveringText(textLines, mouseX - 10, mouseY + 25);
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/gui/elements/GuiNumberField.java

@@ -0,0 +1,151 @@
+package nl.requios.effortlessbuilding.gui.elements;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.*;
+import net.minecraft.util.text.TextFormatting;
+
+import java.io.IOException;
+import java.text.DecimalFormat;
+import java.util.ArrayList;
+import java.util.Arrays;
+import java.util.List;
+
+public class GuiNumberField extends Gui {
+
+    public int x, y, width, height;
+    public int buttonWidth = 10;
+
+    protected GuiTextField textField;
+    protected GuiButton minusButton, plusButton;
+
+    List<String> tooltip = new ArrayList<>();
+
+    public GuiNumberField(int id1, int id2, int id3, FontRenderer fontRenderer,
+                          List<GuiButton> buttonList, int x, int y, int width, int height) {
+        this.x = x;
+        this.y = y;
+        this.width = width;
+        this.height = height;
+
+        textField = new GuiTextField(id1, fontRenderer, x + buttonWidth + 1, y + 1, width - 2 * buttonWidth - 2, height - 2);
+        minusButton = new GuiButton(id2, x, y - 1, buttonWidth, height + 2, "-");
+        plusButton  = new GuiButton(id3, x + width - buttonWidth, y - 1, buttonWidth, height + 2, "+");
+
+        buttonList.add(minusButton);
+        buttonList.add(plusButton);
+    }
+
+    public void setNumber(double number) {
+        DecimalFormat format = new DecimalFormat("0.#");
+        textField.setText(format.format(number));
+    }
+
+    public double getNumber() {
+        if (textField.getText().isEmpty()) return 0;
+        return Double.parseDouble(textField.getText());
+    }
+
+    public void setTooltip(String tooltip) {
+        setTooltip(Arrays.asList(tooltip));
+    }
+
+    public void setTooltip(List<String> tooltip) {
+        this.tooltip = tooltip;
+    }
+
+    public boolean mouseClicked(int mouseX, int mouseY, int mouseButton) {
+        boolean result = textField.mouseClicked(mouseX, mouseY, mouseButton);
+
+        //Check if clicked inside textfield
+        boolean flag = mouseX >= x + buttonWidth && mouseX < x + width - buttonWidth && mouseY >= y && mouseY < y + height;
+
+        //Rightclicked inside textfield
+        if (flag && mouseButton == 1) {
+            textField.setText("");
+            textField.setFocused(true);
+            result = true;
+        }
+
+        return result;
+    }
+
+    public void drawNumberField(Minecraft mc, int mouseX, int mouseY, float partialTicks) {
+        textField.y = y + 1;
+        minusButton.y = y - 1;
+        plusButton.y = y - 1;
+
+        textField.drawTextBox();
+        minusButton.drawButton(mc, mouseX, mouseY, partialTicks);
+        plusButton.drawButton(mc, mouseX, mouseY, partialTicks);
+    }
+
+    public void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY) {
+        boolean insideTextField = mouseX >= x + buttonWidth && mouseX < x + width - buttonWidth && mouseY >= y && mouseY < y + height;
+        boolean insideMinusButton = mouseX >= x && mouseX < x + buttonWidth && mouseY >= y && mouseY < y + height;
+        boolean insidePlusButton = mouseX >= x + width - buttonWidth && mouseX < x + width && mouseY >= y && mouseY < y + height;
+
+        List<String> textLines = new ArrayList<>();
+
+        if (insideTextField) {
+            if (!tooltip.isEmpty())
+                textLines.addAll(tooltip);
+//            textLines.add(TextFormatting.GRAY + "Tip: try scrolling.");
+        }
+
+        if (insideMinusButton) {
+            textLines.add("Hold " + TextFormatting.AQUA + "shift " + TextFormatting.RESET + "for " + TextFormatting.RED + "10");
+            textLines.add("Hold " + TextFormatting.AQUA + "ctrl " + TextFormatting.RESET + "for " + TextFormatting.RED + "5");
+        }
+
+        if (insidePlusButton) {
+            textLines.add("Hold " + TextFormatting.AQUA + "shift " + TextFormatting.RESET + "for " + TextFormatting.DARK_GREEN + "10");
+            textLines.add("Hold " + TextFormatting.AQUA + "ctrl " + TextFormatting.RESET + "for " + TextFormatting.DARK_GREEN + "5");
+        }
+
+        guiScreen.drawHoveringText(textLines, mouseX - 10, mouseY + 25);
+
+    }
+
+    public void actionPerformed(GuiButton button) {
+        float valueChanged = 1f;
+        if (GuiScreen.isCtrlKeyDown()) valueChanged = 5f;
+        if (GuiScreen.isShiftKeyDown()) valueChanged = 10f;
+
+        if (button == minusButton) {
+            setNumber(getNumber() - valueChanged);
+        }
+        if (button == plusButton) {
+            setNumber(getNumber() + valueChanged);
+        }
+    }
+
+    public void update() {
+        textField.updateCursorCounter();
+    }
+
+    public void keyTyped(char typedChar, int keyCode) throws IOException {
+        if (!textField.isFocused()) return;
+//        if (Character.isDigit(typedChar) || typedChar == '.' || typedChar == '-' || keyCode == Keyboard.KEY_BACK
+//            || keyCode == Keyboard.KEY_DELETE || keyCode == Keyboard.KEY_LEFT || keyCode == Keyboard.KEY_RIGHT
+//            || keyCode == Keyboard.KEY_UP || keyCode == Keyboard.KEY_DOWN) {
+            textField.textboxKeyTyped(typedChar, keyCode);
+//        }
+    }
+
+    //Scroll inside textfield to change number
+//    public void handleMouseInput(int mouseX, int mouseY) {
+//        boolean insideTextField = mouseX >= x + buttonWidth && mouseX < x + width - buttonWidth && mouseY >= y && mouseY < y + height;
+//
+//        if (insideTextField)
+//        {
+//            int valueChanged = 0;
+//            if (Mouse.getEventDWheel() > 0)
+//                valueChanged = 1;
+//            if (Mouse.getEventDWheel() < 0)
+//                valueChanged = -1;
+//
+//            if (valueChanged != 0)
+//                setNumber(getNumber() + valueChanged);
+//        }
+//    }
+}

src/main/java/nl/requios/effortlessbuilding/gui/elements/GuiScrollPane.java

@@ -0,0 +1,466 @@
+package nl.requios.effortlessbuilding.gui.elements;
+
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.FontRenderer;
+import net.minecraft.client.gui.GuiButton;
+import net.minecraft.client.gui.GuiListExtended;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.util.math.MathHelper;
+import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import org.lwjgl.input.Mouse;
+
+import java.io.IOException;
+import java.util.ArrayList;
+import java.util.List;
+
+@SideOnly(Side.CLIENT)
+public class GuiScrollPane extends GuiListExtended {
+
+    public GuiScreen parent;
+    public FontRenderer fontRenderer;
+    public List<IScrollEntry> listEntries;
+
+    public GuiScrollPane(GuiScreen parent, FontRenderer fontRenderer, int top, int bottom) {
+        super(parent.mc, parent.width, parent.height, top, bottom, 100);
+        this.parent = parent;
+        this.fontRenderer = fontRenderer;
+        this.setShowSelectionBox(false);
+        listEntries = new ArrayList<>();
+    }
+
+    @Override
+    public IGuiListEntry getListEntry(int index) {
+        return listEntries.get(index);
+    }
+
+    @Override
+    protected int getSize() {
+        return listEntries.size();
+    }
+
+    @Override
+    protected int getScrollBarX() {
+        //return width / 2 + 140 + 10;
+        return width - 15;
+    }
+
+    @Override
+    public int getListWidth() {
+        return 280;
+    }
+
+    //Removed background
+    @Override
+    public void drawScreen(int mouseXIn, int mouseYIn, float partialTicks)
+    {
+        if (this.visible)
+        {
+            this.mouseX = mouseXIn;
+            this.mouseY = mouseYIn;
+            int scrollBarLeft = this.getScrollBarX();
+            int scrollBarRight = scrollBarLeft + 6;
+            this.bindAmountScrolled();
+            GlStateManager.disableLighting();
+            GlStateManager.disableFog();
+
+            Tessellator tessellator = Tessellator.getInstance();
+            BufferBuilder bufferbuilder = tessellator.getBuffer();
+            int insideLeft = this.left + this.width / 2 - this.getListWidth() / 2 + 2;
+            int insideTop = this.top + 4 - (int)this.amountScrolled;
+
+            if (this.hasListHeader) {
+                this.drawListHeader(insideLeft, insideTop, tessellator);
+            }
+
+            //All entries
+            this.drawSelectionBox(insideLeft, insideTop, mouseXIn, mouseYIn, partialTicks);
+            GlStateManager.disableDepth();
+
+            //Dirt overlays on top and bottom
+//            this.overlayBackground(0, this.top, 255, 255);
+//            this.overlayBackground(this.bottom, this.height, 255, 255);
+
+            GlStateManager.enableBlend();
+            GlStateManager.tryBlendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ZERO, GlStateManager.DestFactor.ONE);
+            GlStateManager.disableAlpha();
+            GlStateManager.shadeModel(7425);
+            GlStateManager.disableTexture2D();
+
+//            //top fade
+//            bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
+//            bufferbuilder.pos((double)this.left, (double)(this.top + 5), 0.0D).tex(0.0D, 1.0D).color(100, 100, 100, 0).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)(this.top + 5), 0.0D).tex(1.0D, 1.0D).color(100, 100, 100, 0).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)this.top, 0.0D).tex(1.0D, 0.0D).color(100, 100, 100, 100).endVertex();
+//            bufferbuilder.pos((double)this.left, (double)this.top, 0.0D).tex(0.0D, 0.0D).color(100, 100, 100, 100).endVertex();
+//            tessellator.draw();
+
+//            //top line
+//            bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
+//            bufferbuilder.pos((double)this.left, (double)this.top, 0.0D).tex(0.0D, 1.0D).color(20, 20, 20, 255).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)this.top, 0.0D).tex(1.0D, 1.0D).color(20, 20, 20, 255).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)(this.top - 1), 0.0D).tex(1.0D, 0.0D).color(20, 20, 20, 255).endVertex();
+//            bufferbuilder.pos((double)this.left, (double)(this.top - 1), 0.0D).tex(0.0D, 0.0D).color(20, 20, 20, 255).endVertex();
+//            tessellator.draw();
+
+//            //bottom fade
+//            bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
+//            bufferbuilder.pos((double)this.left, (double)this.bottom, 0.0D).tex(0.0D, 1.0D).color(10, 10, 10, 100).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)this.bottom, 0.0D).tex(1.0D, 1.0D).color(10, 10, 10, 100).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)(this.bottom - 5), 0.0D).tex(1.0D, 0.0D).color(10, 10, 10, 0).endVertex();
+//            bufferbuilder.pos((double)this.left, (double)(this.bottom - 5), 0.0D).tex(0.0D, 0.0D).color(10, 10, 10, 0).endVertex();
+//            tessellator.draw();
+
+//            //bottom line
+//            bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
+//            bufferbuilder.pos((double)this.left, (double)(this.bottom + 1), 0.0D).tex(0.0D, 1.0D).color(20, 20, 20, 255).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)(this.bottom + 1), 0.0D).tex(1.0D, 1.0D).color(20, 20, 20, 255).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)this.bottom, 0.0D).tex(1.0D, 0.0D).color(20, 20, 20, 255).endVertex();
+//            bufferbuilder.pos((double)this.left, (double)this.bottom, 0.0D).tex(0.0D, 0.0D).color(20, 20, 20, 255).endVertex();
+//            tessellator.draw();
+
+            //Draw scrollbar
+            int maxScroll = this.getMaxScroll();
+            if (maxScroll > 0)
+            {
+                int k1 = (this.bottom - this.top) * (this.bottom - this.top) / this.getContentHeight();
+                k1 = MathHelper.clamp(k1, 32, this.bottom - this.top - 8);
+                int l1 = (int)this.amountScrolled * (this.bottom - this.top - k1) / maxScroll + this.top;
+
+                if (l1 < this.top)
+                {
+                    l1 = this.top;
+                }
+
+                bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
+                bufferbuilder.pos((double)scrollBarLeft, (double)this.bottom, 0.0D).tex(0.0D, 1.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarRight, (double)this.bottom, 0.0D).tex(1.0D, 1.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarRight, (double)this.top, 0.0D).tex(1.0D, 0.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarLeft, (double)this.top, 0.0D).tex(0.0D, 0.0D).color(0, 0, 0, 255).endVertex();
+                tessellator.draw();
+
+                bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
+                bufferbuilder.pos((double)scrollBarLeft, (double)(l1 + k1), 0.0D).tex(0.0D, 1.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarRight, (double)(l1 + k1), 0.0D).tex(1.0D, 1.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarRight, (double)l1, 0.0D).tex(1.0D, 0.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarLeft, (double)l1, 0.0D).tex(0.0D, 0.0D).color(128, 128, 128, 255).endVertex();
+                tessellator.draw();
+
+                bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
+                bufferbuilder.pos((double)scrollBarLeft, (double)(l1 + k1 - 1), 0.0D).tex(0.0D, 1.0D).color(192, 192, 192, 255).endVertex();
+                bufferbuilder.pos((double)(scrollBarRight - 1), (double)(l1 + k1 - 1), 0.0D).tex(1.0D, 1.0D).color(192, 192, 192, 255).endVertex();
+                bufferbuilder.pos((double)(scrollBarRight - 1), (double)l1, 0.0D).tex(1.0D, 0.0D).color(192, 192, 192, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarLeft, (double)l1, 0.0D).tex(0.0D, 0.0D).color(192, 192, 192, 255).endVertex();
+                tessellator.draw();
+            }
+
+            GlStateManager.enableTexture2D();
+            GlStateManager.shadeModel(7424);
+            GlStateManager.enableAlpha();
+            GlStateManager.disableBlend();
+        }
+    }
+
+    //SLOTHEIGHT MODIFICATIONS
+    //SlotHeight is still relied on for determining how much to scroll
+    @Override
+    protected int getContentHeight() {
+        //Add every entry height
+        int height = this.headerPadding;
+        for (IScrollEntry entry : listEntries) {
+            height += entry.getHeight();
+        }
+        return height;
+    }
+
+    public int getContentHeight(int count) {
+        //Add all count entry heights
+        int height = this.headerPadding;
+        for (int i = 0; i < count; i++) {
+            IScrollEntry entry = listEntries.get(i);
+            height += entry.getHeight();
+        }
+        return height;
+    }
+
+    @Override
+    public int getSlotIndexFromScreenCoords(int posX, int posY) {
+        int left = this.left + (this.width - this.getListWidth()) / 2;
+        int right = this.left + (this.width + this.getListWidth()) / 2;
+        int relativeMouseY = getRelativeMouseY(mouseY, 0);
+
+        //Iterate over every entry until relativeMouseY falls within its height
+        for (int i = 0; i < listEntries.size(); i++) {
+            IScrollEntry entry = listEntries.get(i);
+            if (relativeMouseY <= entry.getHeight())
+                return posX < this.getScrollBarX() && posX >= left && posX <= right && i >= 0 &&
+                       relativeMouseY >= 0 && i < this.getSize() ? i : -1;
+            relativeMouseY -= entry.getHeight();
+        }
+        return -1;
+    }
+
+    @Override
+    public boolean mouseClicked(int mouseX, int mouseY, int mouseEvent)
+    {
+        int selectedSlot = this.getSlotIndexFromScreenCoords(mouseX, mouseY);
+        int relativeX = getRelativeMouseX(mouseX);
+
+        //Always pass through mouseclicked, to be able to unfocus textfields
+        for (int i = 0; i < this.listEntries.size(); i++) {
+            int relativeY = getRelativeMouseY(mouseY, i);
+            this.getListEntry(i).mousePressed(selectedSlot, mouseX, mouseY, mouseEvent, relativeX, relativeY);
+        }
+
+
+//        if (this.isMouseYWithinSlotBounds(mouseY))
+//        {
+//            int i = this.getSlotIndexFromScreenCoords(mouseX, mouseY);
+//
+//            if (i >= 0)
+//            {
+//                int relativeX = getRelativeMouseX(mouseX);
+//                int relativeY = getRelativeMouseY(mouseY, i);
+//
+//                if (this.getListEntry(i).mousePressed(i, mouseX, mouseY, mouseEvent, relativeX, relativeY))
+//                {
+//                    this.setEnabled(false);
+//                    return true;
+//                }
+//            }
+//        }
+
+        return false;
+    }
+
+    @Override
+    public boolean mouseReleased(int x, int y, int mouseEvent)
+    {
+        for (int i = 0; i < this.getSize(); ++i)
+        {
+            int relativeX = getRelativeMouseX(mouseX);
+            int relativeY = getRelativeMouseY(mouseY, i);
+            this.getListEntry(i).mouseReleased(i, x, y, mouseEvent, relativeX, relativeY);
+        }
+
+        this.setEnabled(true);
+        return false;
+    }
+
+    @Override
+    public void handleMouseInput() {
+        if (this.isMouseYWithinSlotBounds(this.mouseY)) {
+            if (Mouse.getEventButton() == 0 && Mouse.getEventButtonState() && this.mouseY >= this.top &&
+                this.mouseY <= this.bottom) {
+                int i = this.left + (this.width - this.getListWidth()) / 2;
+                int j = this.left + (this.width + this.getListWidth()) / 2;
+                int slotIndex = getSlotIndexFromScreenCoords(this.mouseX, this.mouseY);
+                int relativeMouseY = getRelativeMouseY(mouseY, slotIndex);
+
+                if (slotIndex > -1) {
+                    this.elementClicked(slotIndex, false, this.mouseX, this.mouseY);
+                    this.selectedElement = slotIndex;
+                } else if (this.mouseX >= i && this.mouseX <= j && relativeMouseY < 0) {
+                    this.clickedHeader(this.mouseX - i, this.mouseY - this.top + (int) this.amountScrolled - 4);
+                }
+            }
+
+            if (Mouse.isButtonDown(0) && this.getEnabled()) {
+                if (this.initialClickY == -1) {
+                    boolean flag1 = true;
+
+                    if (this.mouseY >= this.top && this.mouseY <= this.bottom) {
+                        int i2 = this.left + (this.width - this.getListWidth()) / 2;
+                        int j2 = this.left + (this.width + this.getListWidth()) / 2;
+                        int slotIndex = getSlotIndexFromScreenCoords(this.mouseX, this.mouseY);
+                        int relativeMouseY = getRelativeMouseY(mouseY, slotIndex);
+
+                        if (slotIndex > -1) {
+                            boolean flag = slotIndex == this.selectedElement &&
+                                           Minecraft.getSystemTime() - this.lastClicked < 250L;
+                            this.elementClicked(slotIndex, flag, this.mouseX, this.mouseY);
+                            this.selectedElement = slotIndex;
+                            this.lastClicked = Minecraft.getSystemTime();
+                        } else if (this.mouseX >= i2 && this.mouseX <= j2 && relativeMouseY < 0) {
+                            this.clickedHeader(this.mouseX - i2,
+                                    this.mouseY - this.top + (int) this.amountScrolled - 4);
+                            flag1 = false;
+                        }
+
+                        int i3 = this.getScrollBarX();
+                        int j1 = i3 + 6;
+
+                        if (this.mouseX >= i3 && this.mouseX <= j1) {
+                            this.scrollMultiplier = -1.0F;
+                            int maxScroll = this.getMaxScroll();
+
+                            if (maxScroll < 1) {
+                                maxScroll = 1;
+                            }
+
+                            int l1 = (int) ((float) ((this.bottom - this.top) * (this.bottom - this.top)) /
+                                            (float) this.getContentHeight());
+                            l1 = MathHelper.clamp(l1, 32, this.bottom - this.top - 8);
+                            this.scrollMultiplier /= (float) (this.bottom - this.top - l1) / (float) maxScroll;
+                        } else {
+                            this.scrollMultiplier = 1.0F;
+                        }
+
+                        if (flag1) {
+                            this.initialClickY = this.mouseY;
+                        } else {
+                            this.initialClickY = -2;
+                        }
+                    } else {
+                        this.initialClickY = -2;
+                    }
+                } else if (this.initialClickY >= 0) {
+                    this.amountScrolled -= (float) (this.mouseY - this.initialClickY) * this.scrollMultiplier;
+                    this.initialClickY = this.mouseY;
+                }
+            } else {
+                this.initialClickY = -1;
+            }
+
+            int i2 = Mouse.getEventDWheel();
+
+            if (i2 != 0) {
+                if (i2 > 0) {
+                    i2 = -1;
+                } else if (i2 < 0) {
+                    i2 = 1;
+                }
+
+                this.amountScrolled += (float) (i2 * this.slotHeight / 2);
+            }
+        }
+    }
+
+    //Draw in center if it fits
+    @Override
+    protected void drawSelectionBox(int insideLeft, int insideTop, int mouseXIn, int mouseYIn, float partialTicks)
+    {
+        int size = this.getSize();
+        Tessellator tessellator = Tessellator.getInstance();
+        BufferBuilder bufferbuilder = tessellator.getBuffer();
+
+        //Find y to start with
+        int y = this.headerPadding + insideTop;
+        int contentHeight = getContentHeight();
+        int insideHeight = this.bottom - this.top - 4;
+
+        if (contentHeight < insideHeight) {
+            //it fits, so we can center it vertically
+            y += (insideHeight - contentHeight) / 2;
+        }
+
+        //Draw all entries
+        for (int i = 0; i < size; ++i)
+        {
+            int entryHeight = listEntries.get(i).getHeight();
+            int entryHeight2 = entryHeight - 4;
+
+            if (y > this.bottom || y + entryHeight2 < this.top)
+            {
+                this.updateItemPos(i, insideLeft, y, partialTicks);
+            }
+
+            if (this.showSelectionBox && this.isSelected(i))
+            {
+                int i1 = this.left + this.width / 2 - this.getListWidth() / 2;
+                int j1 = this.left + this.width / 2 + this.getListWidth() / 2;
+                GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
+                GlStateManager.disableTexture2D();
+                bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
+                bufferbuilder.pos((double)i1, (double)(y + entryHeight2 + 2), 0.0D).tex(0.0D, 1.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)j1, (double)(y + entryHeight2 + 2), 0.0D).tex(1.0D, 1.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)j1, (double)(y - 2), 0.0D).tex(1.0D, 0.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)i1, (double)(y - 2), 0.0D).tex(0.0D, 0.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)(i1 + 1), (double)(y + entryHeight2 + 1), 0.0D).tex(0.0D, 1.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)(j1 - 1), (double)(y + entryHeight2 + 1), 0.0D).tex(1.0D, 1.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)(j1 - 1), (double)(y - 1), 0.0D).tex(1.0D, 0.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)(i1 + 1), (double)(y - 1), 0.0D).tex(0.0D, 0.0D).color(0, 0, 0, 255).endVertex();
+                tessellator.draw();
+                GlStateManager.enableTexture2D();
+            }
+
+            this.drawSlot(i, insideLeft, y, entryHeight2, mouseXIn, mouseYIn, partialTicks);
+            y += entryHeight;
+        }
+    }
+
+    private int getRelativeMouseX(int mouseX) {
+        int j = this.left + this.width / 2 - this.getListWidth() / 2 + 2;
+        return mouseX - j;
+    }
+
+    private int getRelativeMouseY(int mouseY, int contentIndex) {
+        int k = this.top + 4 - this.getAmountScrolled() + getContentHeight(contentIndex) + this.headerPadding;
+        int relativeMouseY = mouseY - k;
+
+        //Content might be centered, adjust relative mouse y accordingly
+        int contentHeight = getContentHeight();
+        int insideHeight = this.bottom - this.top - 4;
+
+        if (contentHeight < insideHeight) {
+            //it fits, so we can center it vertically
+            relativeMouseY -= (insideHeight - contentHeight) / 2;
+        }
+        return relativeMouseY;
+    }
+
+    //PASSTHROUGHS
+    public int initGui(int id, List<GuiButton> buttonList) {
+        for (IScrollEntry entry : this.listEntries) {
+            id = entry.initGui(id, buttonList);
+        }
+        registerScrollButtons(id++, id++);
+        return id;
+    }
+
+    public void updateScreen() {
+        for (IScrollEntry entry : this.listEntries)
+            entry.updateScreen();
+    }
+
+    public void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY) {
+        for (IScrollEntry entry : this.listEntries)
+            entry.drawTooltip(guiScreen, mouseX, mouseY);
+    }
+
+    public void keyTyped(char eventChar, int eventKey) throws IOException {
+        for (IScrollEntry entry : this.listEntries)
+            entry.keyTyped(eventChar, eventKey);
+    }
+
+    public void actionPerformed(GuiButton button) {
+        for (IScrollEntry entry : this.listEntries)
+            entry.actionPerformed(button);
+    }
+
+    public void onGuiClosed() {
+        for (IScrollEntry entry : this.listEntries)
+            entry.onGuiClosed();
+    }
+
+    public interface IScrollEntry extends GuiListExtended.IGuiListEntry {
+        int initGui(int id, List<GuiButton> buttonList);
+
+        void updateScreen();
+
+        void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY);
+
+        void keyTyped(char eventChar, int eventKey) throws IOException;
+
+        void actionPerformed(GuiButton button);
+
+        void onGuiClosed();
+
+        int getHeight();
+    }
+}

src/main/java/nl/requios/effortlessbuilding/helper/FixedStack.java

@@ -0,0 +1,54 @@
+package nl.requios.effortlessbuilding.helper;
+
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+
+//Stack with fixed size. Removes (overwrites) oldest element on push.
+public class FixedStack<T> {
+    private T[] stack;
+    private int size;
+    private int top;
+    private int filled = 0; //how many valid items are in the stack
+
+    public FixedStack(T[] stack) {
+        this.stack = stack;
+        this.top = 0;
+        this.size = stack.length;
+    }
+
+    public void push(T object) {
+        if (top == stack.length)
+            top = 0;
+
+        stack[top] = object;
+        top++;
+
+        if (filled < size)
+            filled++;
+    }
+
+    public T pop() {
+        if (filled <= 0) return null;
+
+        if (top - 1 < 0)
+            top = size;
+
+        top--;
+        T object = stack[top];
+        filled--;
+
+        return object;
+    }
+
+    public void clear() {
+        top = 0;
+        filled = 0;
+    }
+
+    public int size() {
+        return size;
+    }
+
+    public boolean isEmpty() {
+        return filled <= 0;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/helper/InventoryHelper.java

@@ -0,0 +1,31 @@
+package nl.requios.effortlessbuilding.helper;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+
+public class InventoryHelper {
+
+    public static ItemStack findItemStackInInventory(EntityPlayer player, Block block) {
+        for (ItemStack invStack : player.inventory.mainInventory) {
+            if (!invStack.isEmpty() && invStack.getItem() instanceof ItemBlock &&
+                ((ItemBlock) invStack.getItem()).getBlock().equals(block)) {
+                return invStack;
+            }
+        }
+        return ItemStack.EMPTY;
+    }
+
+    public static int findTotalBlocksInInventory(EntityPlayer player, Block block) {
+        int total = 0;
+        for (ItemStack invStack : player.inventory.mainInventory) {
+            if (!invStack.isEmpty() && invStack.getItem() instanceof ItemBlock &&
+                ((ItemBlock) invStack.getItem()).getBlock().equals(block)) {
+                total += invStack.getCount();
+            }
+        }
+        return total;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/helper/ReachConditionFactory.java

@@ -0,0 +1,15 @@
+package nl.requios.effortlessbuilding.helper;
+
+import com.google.gson.JsonObject;
+import net.minecraftforge.common.crafting.IConditionFactory;
+import net.minecraftforge.common.crafting.JsonContext;
+import nl.requios.effortlessbuilding.BuildConfig;
+
+import java.util.function.BooleanSupplier;
+
+public class ReachConditionFactory implements IConditionFactory {
+    @Override
+    public BooleanSupplier parse(JsonContext context, JsonObject json) {
+        return () -> BuildConfig.reach.enableReachUpgrades;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/helper/ReachHelper.java

@@ -0,0 +1,50 @@
+package nl.requios.effortlessbuilding.helper;
+
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.MathHelper;
+import nl.requios.effortlessbuilding.BuildConfig;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+
+public class ReachHelper {
+    public static int getMaxReach(EntityPlayer player) {
+        if (player.isCreative()) return BuildConfig.reach.maxReachCreative;
+
+        if (!BuildConfig.reach.enableReachUpgrades) return BuildConfig.reach.maxReachLevel3;
+
+        //Check buildsettings for reachUpgrade
+        int reachUpgrade = ModifierSettingsManager.getModifierSettings(player).getReachUpgrade();
+        switch (reachUpgrade) {
+            case 0: return BuildConfig.reach.maxReachLevel0;
+            case 1: return BuildConfig.reach.maxReachLevel1;
+            case 2: return BuildConfig.reach.maxReachLevel2;
+            case 3: return BuildConfig.reach.maxReachLevel3;
+        }
+        return BuildConfig.reach.maxReachLevel0;
+    }
+
+    public static int getPlacementReach(EntityPlayer player) {
+        return getMaxReach(player) / 4;
+    }
+
+    public static int getMaxBlocksPlacedAtOnce(EntityPlayer player) {
+        if (player.isCreative()) return 1000000;
+        return MathHelper.ceil(Math.pow(getMaxReach(player), 1.6));
+        //Level 0: 121
+        //Level 1: 523
+        //Level 2: 1585
+        //Level 3: 4805
+    }
+
+    public static int getMaxBlocksPerAxis(EntityPlayer player) {
+        if (player.isCreative()) return 2000;
+        return MathHelper.ceil(getMaxReach(player) * 0.3);
+        //Level 0: 6
+        //Level 1: 15
+        //Level 2: 30
+        //Level 3: 60
+    }
+
+    public static boolean canBreakFar(EntityPlayer player) {
+        return player.isCreative() || BuildConfig.survivalBalancers.breakFar;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/helper/SurvivalHelper.java

@@ -0,0 +1,335 @@
+package nl.requios.effortlessbuilding.helper;
+
+import net.minecraft.block.Block;
+import net.minecraft.block.BlockLiquid;
+import net.minecraft.block.BlockSlab;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.material.Material;
+import net.minecraft.block.properties.IProperty;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.Blocks;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemSlab;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.IBlockAccess;
+import net.minecraft.world.World;
+import nl.requios.effortlessbuilding.BuildConfig;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.compatibility.CompatHelper;
+
+import javax.annotation.Nonnull;
+import javax.annotation.Nullable;
+
+public class SurvivalHelper {
+
+    //Used for all placing of blocks in this mod.
+    //Checks if area is loaded, if player has the right permissions, if existing block can be replaced (drops it if so) and consumes an item from the stack.
+    //Based on ItemBlock#onItemUse
+    public static boolean placeBlock(World world, EntityPlayer player, BlockPos pos, IBlockState blockState,
+                                     ItemStack origstack, EnumFacing facing, Vec3d hitVec, boolean skipPlaceCheck,
+                                     boolean skipCollisionCheck, boolean playSound) {
+        if (!world.isBlockLoaded(pos, true)) return false;
+        ItemStack itemstack = origstack;
+
+        if (blockState.getBlock().isAir(blockState, world, pos) || itemstack.isEmpty()) {
+            dropBlock(world, player, pos);
+            world.setBlockToAir(pos);
+            return true;
+        }
+
+        //Randomizer bag, other proxy item synergy
+        //Preliminary compatibility code for other items that hold blocks
+        if (CompatHelper.isItemBlockProxy(itemstack))
+            itemstack = CompatHelper.getItemBlockByState(itemstack, blockState);
+
+        if (!(itemstack.getItem() instanceof ItemBlock))
+            return false;
+        Block block = ((ItemBlock) itemstack.getItem()).getBlock();
+
+
+        //More manual with ItemBlock#placeBlockAt
+        if (skipPlaceCheck || canPlace(world, player, pos, blockState, itemstack, skipCollisionCheck, facing.getOpposite())) {
+            //Drop existing block
+            dropBlock(world, player, pos);
+
+            boolean placed = ((ItemBlock) itemstack.getItem()).placeBlockAt(itemstack, player, world, pos, facing, (float) hitVec.x, (float) hitVec.y, (float) hitVec.z, blockState);
+            if (!placed) return false;
+
+            IBlockState afterState = world.getBlockState(pos);
+
+            if (playSound) {
+                SoundType soundtype = afterState.getBlock().getSoundType(afterState, world, pos, player);
+                world.playSound(null, pos, soundtype.getPlaceSound(), SoundCategory.BLOCKS, (soundtype.getVolume() + 1.0F) / 2.0F, soundtype.getPitch() * 0.8F);
+            }
+
+            if (!player.isCreative() && Block.getBlockFromItem(itemstack.getItem()) == block) {
+                CompatHelper.shrinkStack(origstack, itemstack, player);
+            }
+
+            return true;
+        }
+        return false;
+
+        //Using ItemBlock#onItemUse
+//        EnumActionResult result;
+//        PlayerInteractEvent.RightClickBlock event = ForgeHooks.onRightClickBlock(player, EnumHand.MAIN_HAND, pos, facing, net.minecraftforge.common.ForgeHooks.rayTraceEyeHitVec(player, ReachHelper.getPlacementReach(player)));
+//        if (player.isCreative())
+//        {
+//            int i = itemstack.getMetadata();
+//            int j = itemstack.getCount();
+//            if (event.getUseItem() != net.minecraftforge.fml.common.eventhandler.Event.Result.DENY) {
+//                EnumActionResult enumactionresult = itemstack.getItem().onItemUse(player, world, pos, EnumHand.MAIN_HAND, facing, (float) hitVec.x, (float) hitVec.y, (float) hitVec.z);
+//                itemstack.setItemDamage(i);
+//                itemstack.setCount(j);
+//                return enumactionresult == EnumActionResult.SUCCESS;
+//            } else return false;
+//        }
+//        else
+//        {
+//            ItemStack copyForUse = itemstack.copy();
+//            if (event.getUseItem() != net.minecraftforge.fml.common.eventhandler.Event.Result.DENY)
+//                result = itemstack.getItem().onItemUse(player, world, pos, EnumHand.MAIN_HAND, facing, (float) hitVec.x, (float) hitVec.y, (float) hitVec.z);
+//            if (itemstack.isEmpty()) net.minecraftforge.event.ForgeEventFactory.onPlayerDestroyItem(player, copyForUse, EnumHand.MAIN_HAND);
+//            return false;
+//        }
+
+    }
+
+    //Used for all breaking of blocks in this mod.
+    //Checks if area is loaded, if appropriate tool is used in survival mode, and drops the block directly into the players inventory
+    public static boolean breakBlock(World world, EntityPlayer player, BlockPos pos, boolean skipChecks) {
+        if (!world.isBlockLoaded(pos, false)) return false;
+
+        //Check if can break
+        if (skipChecks || canBreak(world, player, pos)) {
+//            player.addStat(StatList.getBlockStats(world.getNewBlockState(pos).getBlock()));
+//            player.addExhaustion(0.005F);
+
+            //Drop existing block
+            dropBlock(world, player, pos);
+
+            //Damage tool
+            player.getHeldItemMainhand().onBlockDestroyed(world, world.getBlockState(pos), pos, player);
+
+            world.setBlockToAir(pos);
+            return true;
+        }
+        return false;
+    }
+
+    //Gives items directly to player
+    public static void dropBlock(World world, EntityPlayer player, BlockPos pos){
+        if (player.isCreative()) return;
+
+        IBlockState blockState = world.getBlockState(pos);
+        Block block = blockState.getBlock();
+
+        block.harvestBlock(world, player, pos, blockState, world.getTileEntity(pos), player.getHeldItemMainhand());
+
+        //TODO drop items in inventory instead of world
+
+//        List<ItemStack> drops = new ArrayList<>();
+//
+//        //From Block#harvestBlock
+//        int silktouch = EnchantmentHelper.getEnchantmentLevel(Enchantments.SILK_TOUCH, player.getHeldItemMainhand());
+//        if (block.canSilkHarvest(world, pos, blockState, player) && silktouch > 0) {
+//
+//            //From Block#getSilkTouchDrop (protected)
+//            Item item = Item.getItemFromBlock(block);
+//            int i = 0;
+//
+//            if (item.getHasSubtypes())
+//            {
+//                i = block.getMetaFromState(blockState);
+//            }
+//
+//            drops.add(new ItemStack(item, 1, i));
+//
+//            net.minecraftforge.event.ForgeEventFactory.fireBlockHarvesting(drops, world, pos, blockState, 0, 1.0f, true, player);
+//        }
+//
+//        int fortune = EnchantmentHelper.getEnchantmentLevel(Enchantments.FORTUNE, player.getHeldItemMainhand());
+//        drops.addAll(block.getDrops(world, pos, blockState, fortune));
+//        for (ItemStack drop : drops)
+//        {
+//            ItemHandlerHelper.giveItemToPlayer(player, drop);
+//        }
+    }
+
+    /**
+     * Check if player can place a block.
+     * Turn randomizer bag into itemstack inside before.
+     * @param world
+     * @param player
+     * @param pos
+     * @param newBlockState the blockstate that is going to be placed
+     * @param itemStack the itemstack used for placing
+     * @param skipCollisionCheck skips collision check with entities
+     * @param sidePlacedOn
+     * @return Whether the player may place the block at pos with itemstack
+     */
+    public static boolean canPlace(World world, EntityPlayer player, BlockPos pos, IBlockState newBlockState, ItemStack itemStack, boolean skipCollisionCheck, EnumFacing sidePlacedOn) {
+
+        //Check if itemstack is correct
+        if (!(itemStack.getItem() instanceof ItemBlock) || Block.getBlockFromItem(itemStack.getItem()) != newBlockState.getBlock()) {
+//            EffortlessBuilding.log(player, "Cannot (re)place block", true);
+//            EffortlessBuilding.log("SurvivalHelper#canPlace: itemstack " + itemStack.toString() + " does not match blockstate " + newBlockState.toString());
+            //Happens when breaking blocks, no need to notify in that case
+            return false;
+        }
+
+        Block block = ((ItemBlock) itemStack.getItem()).getBlock();
+
+        return !itemStack.isEmpty() && canPlayerEdit(player, world, pos, itemStack) &&
+               mayPlace(world, block, newBlockState, pos, skipCollisionCheck, sidePlacedOn, player) &&
+               canReplace(world, player, pos);
+    }
+
+    //Can be harvested with hand? (or in creative)
+    private static boolean canReplace(World world, EntityPlayer player, BlockPos pos){
+        if (player.isCreative()) return true;
+
+        IBlockState state = world.getBlockState(pos);
+        state = state.getBlock().getActualState(state, world, pos);
+
+        switch (BuildConfig.survivalBalancers.quickReplaceMiningLevel) {
+            case -1: return state.getMaterial().isToolNotRequired();
+            case 0: return state.getBlock().getHarvestLevel(state) <= 0;
+            case 1: return state.getBlock().getHarvestLevel(state) <= 1;
+            case 2: return state.getBlock().getHarvestLevel(state) <= 2;
+            case 3: return state.getBlock().getHarvestLevel(state) <= 3;
+        }
+
+        return false;
+    }
+
+    //From EntityPlayer#canPlayerEdit
+    private static boolean canPlayerEdit(EntityPlayer player, World world, BlockPos pos, ItemStack stack)
+    {
+        if (player.capabilities.allowEdit)
+        {
+            //True in creative and survival mode
+            return true;
+        }
+        else
+        {
+            //Adventure mode
+            Block block = world.getBlockState(pos).getBlock();
+            return stack.canPlaceOn(block) || stack.canEditBlocks();
+        }
+    }
+
+    //From World#mayPlace
+    private static boolean mayPlace(World world, Block blockIn, IBlockState newBlockState, BlockPos pos, boolean skipCollisionCheck, EnumFacing sidePlacedOn, @Nullable Entity placer)
+    {
+        IBlockState iblockstate1 = world.getBlockState(pos);
+        AxisAlignedBB axisalignedbb = skipCollisionCheck ? Block.NULL_AABB : blockIn.getDefaultState().getCollisionBoundingBox(world, pos);
+
+        if (axisalignedbb != Block.NULL_AABB && !world.checkNoEntityCollision(axisalignedbb.offset(pos)))
+        {
+            return false;
+        }
+
+        //Check if double slab
+        if (placer != null && doesBecomeDoubleSlab(((EntityPlayer) placer), pos, sidePlacedOn)) {
+            return true;
+        }
+
+        //Check if same block
+        //Necessary otherwise extra items will be dropped
+        if (iblockstate1 == newBlockState) {
+            return false;
+        }
+
+        if (iblockstate1.getMaterial() == Material.CIRCUITS && blockIn == Blocks.ANVIL)
+        {
+            return true;
+        }
+
+        //Check quickreplace
+        if (placer instanceof EntityPlayer && ModifierSettingsManager.getModifierSettings(((EntityPlayer) placer)).doQuickReplace()) {
+            return true;
+        }
+
+        return iblockstate1.getBlock().isReplaceable(world, pos) && blockIn.canPlaceBlockOnSide(world, pos, sidePlacedOn);
+    }
+
+
+
+    //Can break using held tool? (or in creative)
+    public static boolean canBreak(World world, EntityPlayer player, BlockPos pos) {
+        IBlockState blockState = world.getBlockState(pos);
+        if (blockState.getBlock() instanceof BlockLiquid) return false;
+
+        if (player.isCreative()) return true;
+
+        return canHarvestBlock(blockState.getBlock(), player, world, pos);
+    }
+
+    //From ForgeHooks#canHarvestBlock
+    public static boolean canHarvestBlock(@Nonnull Block block, @Nonnull EntityPlayer player, @Nonnull IBlockAccess world, @Nonnull BlockPos pos)
+    {
+        IBlockState state = world.getBlockState(pos);
+        state = state.getBlock().getActualState(state, world, pos);
+
+        //Dont break bedrock
+        if (state.getBlockHardness((World) world, pos) < 0) {
+            return false;
+        }
+
+        if (state.getMaterial().isToolNotRequired())
+        {
+            return true;
+        }
+
+        ItemStack stack = player.getHeldItemMainhand();
+        String tool = block.getHarvestTool(state);
+        if (stack.isEmpty() || tool == null)
+        {
+            return player.canHarvestBlock(state);
+        }
+
+        if (stack.getItemDamage() >= stack.getMaxDamage()) return false;
+
+        int toolLevel = stack.getItem().getHarvestLevel(stack, tool, player, state);
+        if (toolLevel < 0)
+        {
+            return player.canHarvestBlock(state);
+        }
+
+        return toolLevel >= block.getHarvestLevel(state);
+    }
+
+    public static boolean doesBecomeDoubleSlab(EntityPlayer player, BlockPos pos, EnumFacing facing) {
+        IBlockState placedBlockState = player.world.getBlockState(pos);
+
+        ItemStack itemstack = player.getHeldItem(EnumHand.MAIN_HAND);
+        if (CompatHelper.isItemBlockProxy(itemstack))
+            itemstack = CompatHelper.getItemBlockFromStack(itemstack);
+
+        if (itemstack.isEmpty() || !(itemstack.getItem() instanceof ItemSlab)) return false;
+        BlockSlab heldSlab = (BlockSlab) ((ItemSlab) itemstack.getItem()).getBlock();
+
+        if (placedBlockState.getBlock() == heldSlab) {
+            IProperty<?> variantProperty = heldSlab.getVariantProperty();
+            Comparable<?> placedVariant = placedBlockState.getValue(variantProperty);
+            BlockSlab.EnumBlockHalf placedHalf = placedBlockState.getValue(BlockSlab.HALF);
+
+            Comparable<?> heldVariant = heldSlab.getTypeForItem(itemstack);
+
+            if ((facing == EnumFacing.UP && placedHalf == BlockSlab.EnumBlockHalf.BOTTOM || facing == EnumFacing.DOWN && placedHalf == BlockSlab.EnumBlockHalf.TOP) && placedVariant == heldVariant)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
+}

src/main/java/nl/requios/effortlessbuilding/inventory/RandomizerBagContainer.java

@@ -1,11 +0,0 @@
-package nl.requios.effortlessbuilding.inventory;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.inventory.Container;
-
-public class RandomizerBagContainer extends Container {
-    @Override
-    public boolean canInteractWith(EntityPlayer playerIn) {
-        return false;
-    }
-}

src/main/java/nl/requios/effortlessbuilding/inventory/RandomizerBagGuiContainer.java

@@ -1,15 +0,0 @@
-package nl.requios.effortlessbuilding.inventory;
-
-import net.minecraft.client.gui.inventory.GuiContainer;
-import net.minecraft.inventory.Container;
-
-public class RandomizerBagGuiContainer extends GuiContainer {
-    public RandomizerBagGuiContainer(Container inventorySlotsIn) {
-        super(inventorySlotsIn);
-    }
-
-    @Override
-    protected void drawGuiContainerBackgroundLayer(float partialTicks, int mouseX, int mouseY) {
-
-    }
-}

src/main/java/nl/requios/effortlessbuilding/inventory/RandomizerBagInventory.java

@@ -1,144 +0,0 @@
-package nl.requios.effortlessbuilding.inventory;
-
-import net.minecraft.item.ItemStack;
-import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.nbt.NBTTagList;
-import net.minecraftforge.items.IItemHandler;
-
-import javax.annotation.Nonnull;
-
-public class RandomizerBagInventory implements IItemHandler {
-
-    //Reference to NBT data
-    private final ItemStack invItem;
-
-    public static final int INV_SIZE = 5;
-
-    private ItemStack[] inventory = new ItemStack[INV_SIZE];
-
-    public RandomizerBagInventory(ItemStack invItem) {
-        this.invItem = invItem;
-
-        if (!invItem.hasTagCompound()) {
-            invItem.setTagCompound(new NBTTagCompound());
-        }
-
-        readFromNBT(invItem.getTagCompound());
-    }
-
-    @Override
-    public int getSlots() {
-        return INV_SIZE;
-    }
-
-    @Nonnull
-    @Override
-    public ItemStack getStackInSlot(int slot) {
-        return inventory[slot];
-    }
-
-    @Nonnull
-    @Override
-    public ItemStack insertItem(int slot, @Nonnull ItemStack stack, boolean simulate) {
-        ItemStack slotStack = getStackInSlot(slot);
-        if (slotStack.getCount() == 0) {
-            setInventorySlotContents(slot, stack);
-            return null;
-        }
-        if (getSlotLimit(slot) - slotStack.getCount() < stack.getCount()) {
-            //Not enough place remaining, split stack
-            slotStack.setCount(getSlotLimit(slot));
-            onInventoryChanged();
-            stack.copy().shrink(getSlotLimit(slot) - slotStack.getCount());
-            //TODO make proper
-            return stack;
-        } else {
-            slotStack.grow(stack.getCount());
-            onInventoryChanged();
-            return null;
-        }
-    }
-
-    @Nonnull
-    @Override
-    public ItemStack extractItem(int slot, int amount, boolean simulate) {
-        ItemStack stack = getStackInSlot(slot);
-        if (stack == null) return stack;
-
-        if (stack.getCount() > amount) {
-            stack = stack.splitStack(amount);
-            onInventoryChanged();
-        } else {
-            setInventorySlotContents(slot, null);
-        }
-        return stack;
-    }
-
-    @Override
-    public int getSlotLimit(int slot) {
-        return 64;
-    }
-
-    public void onInventoryChanged() {
-        for (int i = 0; i < getSlotLimit(0); ++i) {
-            if (getStackInSlot(i) != null && getStackInSlot(i).getCount() == 0) {
-                inventory[i] = null;
-            }
-        }
-
-        writeToNBT(invItem.getTagCompound());
-    }
-
-    public void setInventorySlotContents(int slot, ItemStack stack) {
-        inventory[slot] = stack;
-
-        if (stack != null && stack.getCount() > getSlotLimit(slot)) {
-            stack.setCount(getSlotLimit(slot));
-        }
-
-        // Don't forget this line or your inventory will not be saved!
-        onInventoryChanged();
-    }
-
-    public void readFromNBT(NBTTagCompound compound) {
-        // Gets the custom taglist we wrote to this compound, if any
-        // 1.7.2+ change to compound.getTagList("ItemInventory", Constants.NBT.TAG_COMPOUND);
-        NBTTagList items = compound.getTagList("ItemInventory", 0);
-
-        for (int i = 0; i < items.tagCount(); ++i) {
-            // 1.7.2+ change to items.getCompoundTagAt(i)
-            NBTTagCompound item = items.getCompoundTagAt(i);
-            int slot = item.getInteger("Slot");
-
-            // Just double-checking that the saved slot index is within our inventory array bounds
-            if (slot >= 0 && slot < getSlots()) {
-                inventory[slot] = new ItemStack(item);
-            }
-        }
-    }
-
-    /**
-     * A custom method to write our inventory to an ItemStack's NBT compound
-     */
-    public void writeToNBT(NBTTagCompound tagcompound) {
-        // Create a new NBT Tag List to store itemstacks as NBT Tags
-        NBTTagList items = new NBTTagList();
-
-        for (int i = 0; i < getSlots(); ++i) {
-            // Only write stacks that contain items
-            if (getStackInSlot(i) != null) {
-                // Make a new NBT Tag Compound to write the itemstack and slot index to
-                NBTTagCompound item = new NBTTagCompound();
-                item.setInteger("Slot", i);
-                // Writes the itemstack in slot(i) to the Tag Compound we just made
-                getStackInSlot(i).writeToNBT(item);
-
-                // add the tag compound to our tag list
-                items.appendTag(item);
-            }
-        }
-        // Add the TagList to the ItemStack's Tag Compound with the name "ItemInventory"
-        tagcompound.setTag("ItemInventory", items);
-    }
-
-}

src/main/java/nl/requios/effortlessbuilding/inventory/RandomizerGuiHandler.java

@@ -1,32 +0,0 @@
-package nl.requios.effortlessbuilding.inventory;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.world.World;
-import net.minecraftforge.fml.common.network.IGuiHandler;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.inventory.RandomizerBagContainer;
-
-import javax.annotation.Nullable;
-
-public class RandomizerGuiHandler implements IGuiHandler {
-    @Nullable
-    @Override
-    public Object getServerGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
-        if (ID == EffortlessBuilding.RANDOMIZER_BAG_GUI) {
-            // Use the player's held item to create the inventory
-            return new RandomizerBagContainer();
-        }
-        return null;
-    }
-
-    @Nullable
-    @Override
-    public Object getClientGuiElement(int ID, EntityPlayer player, World world, int x, int y, int z) {
-        if (ID == EffortlessBuilding.RANDOMIZER_BAG_GUI) {
-            // We have to cast the new container as our custom class
-            // and pass in currently held item for the inventory
-            return new RandomizerBagGuiContainer(new RandomizerBagContainer());
-        }
-        return null;
-    }
-}

src/main/java/nl/requios/effortlessbuilding/item/ItemRandomizerBag.java

@@ -1,56 +1,208 @@
 package nl.requios.effortlessbuilding.item;
 
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.util.ITooltipFlag;
 import net.minecraft.creativetab.CreativeTabs;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemStack;
+import net.minecraft.nbt.NBTTagCompound;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.EnumActionResult;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.text.TextFormatting;
 import net.minecraft.world.World;
+import net.minecraftforge.common.capabilities.ICapabilityProvider;
+import net.minecraftforge.items.CapabilityItemHandler;
+import net.minecraftforge.items.IItemHandler;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.capability.ItemHandlerCapabilityProvider;
+import nl.requios.effortlessbuilding.helper.SurvivalHelper;
+
+import javax.annotation.Nullable;
+import java.util.ArrayList;
+import java.util.Calendar;
+import java.util.List;
+import java.util.Random;
 
 public class ItemRandomizerBag extends Item {
+    public static final int INV_SIZE = 5;
+
+    private static long currentSeed = 1337;
+    private static Random rand = new Random(currentSeed);
 
     public ItemRandomizerBag() {
         this.setRegistryName(EffortlessBuilding.MODID, "randomizer_bag");
-        this.setUnlocalizedName(this.getRegistryName().toString());
+        this.setTranslationKey(this.getRegistryName().toString());
 
         this.maxStackSize = 1;
-        this.setCreativeTab(CreativeTabs.DECORATIONS);
+        this.setCreativeTab(CreativeTabs.TOOLS);
     }
 
     @Override
-    public EnumActionResult onItemUse(EntityPlayer player, World worldIn, BlockPos pos, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
+    public EnumActionResult onItemUse(EntityPlayer player, World world, BlockPos pos, EnumHand hand, EnumFacing facing, float hitX, float hitY, float hitZ) {
-
-        if (worldIn.isRemote) return EnumActionResult.PASS;
-        EffortlessBuilding.log(player, "onItemUse");
 
         if (player.isSneaking()) {
+            if (world.isRemote) return EnumActionResult.SUCCESS;
             //Open inventory
-            player.openGui(EffortlessBuilding.instance, EffortlessBuilding.RANDOMIZER_BAG_GUI, worldIn, 0, 0, 0);
+            player.openGui(EffortlessBuilding.instance, EffortlessBuilding.RANDOMIZER_BAG_GUI, world, 0, 0, 0);
         } else {
-            //Place block
+            if (world.isRemote) return EnumActionResult.SUCCESS;
 
+            //Only place manually if in normal vanilla mode
+            BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(player).getBuildMode();
+            ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+            if (buildMode != BuildModes.BuildModeEnum.NORMAL || modifierSettings.doQuickReplace()) {
+                return EnumActionResult.FAIL;
             }
-        return EnumActionResult.PASS;
+
+            //Use item
+            //Get bag inventory
+            ItemStack bag = player.getHeldItem(hand);
+            IItemHandler bagInventory = getBagInventory(bag);
+            if (bagInventory == null)
+                return EnumActionResult.FAIL;
+
+            ItemStack toPlace = pickRandomStack(bagInventory);
+            if (toPlace.isEmpty()) return EnumActionResult.FAIL;
+
+            //Previously: use onItemUse to place block (no synergy)
+            //bag.setItemDamage(toPlace.getMetadata());
+            //toPlace.onItemUse(player, world, pos, hand, facing, hitX, hitY, hitZ);
+
+            if (!world.getBlockState(pos).getBlock().isReplaceable(world, pos)) {
+                pos = pos.offset(facing);
+            }
+
+            IBlockState blockState = Block.getBlockFromItem(toPlace.getItem()).getStateForPlacement(world, pos, facing,
+                    hitX, hitY, hitZ, toPlace.getMetadata(), player, hand);
+
+            SurvivalHelper.placeBlock(world, player, pos, blockState, toPlace, facing, new Vec3d(hitX, hitY, hitZ), false, false, true);
+
+            //Synergy
+            //Works without calling
+//            BlockSnapshot blockSnapshot = new BlockSnapshot(player.world, pos, blockState);
+//            BlockEvent.PlaceEvent placeEvent = new BlockEvent.PlaceEvent(blockSnapshot, blockState, player, hand);
+//            Mirror.onBlockPlaced(placeEvent);
+//            Array.onBlockPlaced(placeEvent);
+        }
+        return EnumActionResult.SUCCESS;
     }
 
     @Override
-    public ActionResult<ItemStack> onItemRightClick(World worldIn, EntityPlayer playerIn, EnumHand handIn) {
+    public ActionResult<ItemStack> onItemRightClick(World world, EntityPlayer player, EnumHand hand) {
-        if (worldIn.isRemote) return new ActionResult<>(EnumActionResult.PASS, playerIn.getHeldItem(handIn));
+        ItemStack bag = player.getHeldItem(hand);
-        EffortlessBuilding.log(playerIn, "onItemRightClick");
 
+        if (player.isSneaking()) {
+            if (world.isRemote) return new ActionResult<>(EnumActionResult.SUCCESS, bag);
             //Open inventory
-        playerIn.openGui(EffortlessBuilding.instance, EffortlessBuilding.RANDOMIZER_BAG_GUI, worldIn, 0, 0, 0);
+            player.openGui(EffortlessBuilding.instance, EffortlessBuilding.RANDOMIZER_BAG_GUI, world, 0, 0, 0);
+        } else {
+            //Use item
+            //Get bag inventory
+            IItemHandler bagInventory = getBagInventory(bag);
+            if (bagInventory == null)
+                return new ActionResult<>(EnumActionResult.FAIL, bag);
 
-        return new ActionResult<>(EnumActionResult.PASS, playerIn.getHeldItem(handIn));
+            ItemStack toUse = pickRandomStack(bagInventory);
+            if (toUse.isEmpty()) return new ActionResult<>(EnumActionResult.FAIL, bag);
+
+            return toUse.useItemRightClick(world, player, hand);
+        }
+        return new ActionResult<>(EnumActionResult.PASS, bag);
+    }
+
+    /**
+     * Get the inventory of a randomizer bag by checking the capability.
+     *
+     * @param bag
+     * @return
+     */
+    public static IItemHandler getBagInventory(ItemStack bag) {
+        if (!bag.hasCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null)) return null;
+        return bag.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null);
+    }
+
+    /**
+     * Pick a random slot from the bag. Empty slots will never get chosen.
+     *
+     * @param bagInventory
+     * @return
+     */
+    public static ItemStack pickRandomStack(IItemHandler bagInventory) {
+        //Find how many stacks are non-empty, and save them in a list
+        int nonempty = 0;
+        List<ItemStack> nonEmptyStacks = new ArrayList<>(INV_SIZE);
+        List<Integer> originalSlots = new ArrayList<>(INV_SIZE);
+        for (int i = 0; i < bagInventory.getSlots(); i++) {
+            ItemStack stack = bagInventory.getStackInSlot(i);
+            if (!stack.isEmpty()) {
+                nonempty++;
+                nonEmptyStacks.add(stack);
+                originalSlots.add(i);
+            }
+        }
+
+        if (nonEmptyStacks.size() != originalSlots.size())
+            throw new Error("NonEmptyStacks and OriginalSlots not same size");
+
+        if (nonempty == 0) return ItemStack.EMPTY;
+
+        //Pick random slot
+        int randomSlot = rand.nextInt(nonempty);
+        if (randomSlot < 0 || randomSlot > bagInventory.getSlots()) return ItemStack.EMPTY;
+
+        int originalSlot = originalSlots.get(randomSlot);
+        if (originalSlot < 0 || originalSlot > bagInventory.getSlots()) return ItemStack.EMPTY;
+
+        return bagInventory.getStackInSlot(originalSlot);
+    }
+
+    public static ItemStack findStack(IItemHandler bagInventory, Item item) {
+        for (int i = 0; i < bagInventory.getSlots(); i++) {
+            ItemStack stack = bagInventory.getStackInSlot(i);
+            if (!stack.isEmpty() && stack.getItem() == item) {
+                return stack;
+            }
+        }
+        return ItemStack.EMPTY;
     }
 
     @Override
     public int getMaxItemUseDuration(ItemStack stack) {
         return 1;
     }
+
+    @Nullable
+    @Override
+    public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable NBTTagCompound nbt) {
+        return new ItemHandlerCapabilityProvider();
+    }
+
+    @Override
+    public void addInformation(ItemStack stack, @Nullable World world, List<String> tooltip, ITooltipFlag flag) {
+        tooltip.add(TextFormatting.BLUE + "Rightclick" + TextFormatting.GRAY + " to place a random block");
+        tooltip.add(TextFormatting.BLUE + "Sneak + rightclick" + TextFormatting.GRAY + " to open inventory");
+    }
+
+    @Override
+    public String getTranslationKey() {
+        return super.getTranslationKey();
+    }
+
+    public static void resetRandomness() {
+        rand.setSeed(currentSeed);
+    }
+
+    public static void renewRandomness() {
+        currentSeed = Calendar.getInstance().getTimeInMillis();
+        rand.setSeed(currentSeed);
+    }
 }

src/main/java/nl/requios/effortlessbuilding/item/ItemReachUpgrade1.java

@@ -0,0 +1,67 @@
+package nl.requios.effortlessbuilding.item;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.EntityLivingBase;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.*;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import nl.requios.effortlessbuilding.BuildConfig;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+public class ItemReachUpgrade1 extends Item {
+
+    public ItemReachUpgrade1() {
+        this.setRegistryName(EffortlessBuilding.MODID, "reach_upgrade1");
+        this.setTranslationKey(this.getRegistryName().toString());
+
+        this.maxStackSize = 1;
+        this.setCreativeTab(CreativeTabs.TOOLS);
+    }
+
+    @Override
+    public ActionResult<ItemStack> onItemRightClick(World world, EntityPlayer player, EnumHand hand) {
+        if (player.isCreative()) {
+            if (world.isRemote) EffortlessBuilding.log(player, "Reach upgrades are not necessary in creative.");
+            if (world.isRemote) EffortlessBuilding.log(player, "Still want increased reach? Use the config.");
+            return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
+        }
+
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        int currentLevel = modifierSettings.getReachUpgrade();
+        if (currentLevel == 0) {
+            modifierSettings.setReachUpgrade(1);
+
+            if (world.isRemote) EffortlessBuilding.log(player, "Upgraded reach to " + ReachHelper.getMaxReach(player));
+            player.setHeldItem(hand, ItemStack.EMPTY);
+
+            SoundEvent soundEvent = new SoundEvent(new ResourceLocation("entity.player.levelup"));
+            player.playSound(soundEvent, 1f, 1f);
+        } else if (currentLevel > 0) {
+            if (world.isRemote) EffortlessBuilding.log(player, "Already used this upgrade! Current reach is " + ReachHelper
+                    .getMaxReach(player) + ".");
+
+            SoundEvent soundEvent = new SoundEvent(new ResourceLocation("item.armor.equip_leather"));
+            player.playSound(soundEvent, 1f, 1f);
+        }
+        return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
+    }
+
+    @Override
+    public void addInformation(ItemStack stack, @Nullable World world, List<String> tooltip, ITooltipFlag flag) {
+        tooltip.add(TextFormatting.GRAY + "Consume to increase reach to " + TextFormatting.BLUE + BuildConfig.reach.maxReachLevel1);
+    }
+
+    @Override
+    public String getTranslationKey() {
+        return super.getTranslationKey();
+    }
+}

src/main/java/nl/requios/effortlessbuilding/item/ItemReachUpgrade2.java

@@ -0,0 +1,71 @@
+package nl.requios.effortlessbuilding.item;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.*;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import nl.requios.effortlessbuilding.BuildConfig;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+public class ItemReachUpgrade2 extends Item {
+
+    public ItemReachUpgrade2() {
+        this.setRegistryName(EffortlessBuilding.MODID, "reach_upgrade2");
+        this.setTranslationKey(this.getRegistryName().toString());
+
+        this.maxStackSize = 1;
+        this.setCreativeTab(CreativeTabs.TOOLS);
+    }
+
+    @Override
+    public ActionResult<ItemStack> onItemRightClick(World world, EntityPlayer player, EnumHand hand) {
+        if (player.isCreative()) {
+            if (world.isRemote) EffortlessBuilding.log(player, "Reach upgrades are not necessary in creative.");
+            if (world.isRemote) EffortlessBuilding.log(player, "Still want increased reach? Use the config.");
+            return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
+        }
+
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        int currentLevel = modifierSettings.getReachUpgrade();
+        if (currentLevel == 1) {
+            modifierSettings.setReachUpgrade(2);
+            if (world.isRemote) EffortlessBuilding.log(player, "Upgraded reach to " + ReachHelper.getMaxReach(player));
+            player.setHeldItem(hand, ItemStack.EMPTY);
+
+            SoundEvent soundEvent = new SoundEvent(new ResourceLocation("entity.player.levelup"));
+            player.playSound(soundEvent, 1f, 1f);
+        } else if (currentLevel < 1) {
+            if (world.isRemote) EffortlessBuilding.log(player, "Use Reach Upgrade 1 first.");
+
+            SoundEvent soundEvent = new SoundEvent(new ResourceLocation("item.armor.equip_leather"));
+            player.playSound(soundEvent, 1f, 1f);
+        } else if (currentLevel > 1) {
+            if (world.isRemote) EffortlessBuilding.log(player, "Already used this upgrade! Current reach is " + ReachHelper
+                    .getMaxReach(player) + ".");
+
+            SoundEvent soundEvent = new SoundEvent(new ResourceLocation("item.armor.equip_leather"));
+            player.playSound(soundEvent, 1f, 1f);
+        }
+        return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
+    }
+
+    @Override
+    public void addInformation(ItemStack stack, @Nullable World world, List<String> tooltip, ITooltipFlag flag) {
+        tooltip.add(TextFormatting.GRAY + "Consume to increase reach to " + TextFormatting.BLUE + BuildConfig.reach.maxReachLevel2);
+        tooltip.add(TextFormatting.GRAY + "Previous upgrades need to be consumed first");
+    }
+
+    @Override
+    public String getTranslationKey() {
+        return super.getTranslationKey();
+    }
+}

src/main/java/nl/requios/effortlessbuilding/item/ItemReachUpgrade3.java

@@ -0,0 +1,74 @@
+package nl.requios.effortlessbuilding.item;
+
+import net.minecraft.client.util.ITooltipFlag;
+import net.minecraft.creativetab.CreativeTabs;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.Item;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.*;
+import net.minecraft.util.text.TextFormatting;
+import net.minecraft.world.World;
+import nl.requios.effortlessbuilding.BuildConfig;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+public class ItemReachUpgrade3 extends Item {
+
+    public ItemReachUpgrade3() {
+        this.setRegistryName(EffortlessBuilding.MODID, "reach_upgrade3");
+        this.setTranslationKey(this.getRegistryName().toString());
+
+        this.maxStackSize = 1;
+        this.setCreativeTab(CreativeTabs.TOOLS);
+    }
+
+    @Override
+    public ActionResult<ItemStack> onItemRightClick(World world, EntityPlayer player, EnumHand hand) {
+        if (player.isCreative()) {
+            if (world.isRemote) EffortlessBuilding.log(player, "Reach upgrades are not necessary in creative.");
+            if (world.isRemote) EffortlessBuilding.log(player, "Still want increased reach? Use the config.");
+            return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
+        }
+
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        int currentLevel = modifierSettings.getReachUpgrade();
+        if (currentLevel == 2) {
+            modifierSettings.setReachUpgrade(3);
+            if (world.isRemote) EffortlessBuilding.log(player, "Upgraded reach to " + ReachHelper.getMaxReach(player));
+            player.setHeldItem(hand, ItemStack.EMPTY);
+
+            SoundEvent soundEvent = new SoundEvent(new ResourceLocation("entity.player.levelup"));
+            player.playSound(soundEvent, 1f, 1f);
+        } else if (currentLevel < 2) {
+            if (currentLevel == 0)
+                if (world.isRemote) EffortlessBuilding.log(player, "Use Reach Upgrade 1 and 2 first.");
+            if (currentLevel == 1)
+                if (world.isRemote) EffortlessBuilding.log(player, "Use Reach Upgrade 2 first.");
+
+            SoundEvent soundEvent = new SoundEvent(new ResourceLocation("item.armor.equip_leather"));
+            player.playSound(soundEvent, 1f, 1f);
+        } else if (currentLevel > 2) {
+            if (world.isRemote) EffortlessBuilding.log(player, "Already used this upgrade! Current reach is " + ReachHelper
+                    .getMaxReach(player) + ".");
+
+            SoundEvent soundEvent = new SoundEvent(new ResourceLocation("item.armor.equip_leather"));
+            player.playSound(soundEvent, 1f, 1f);
+        }
+        return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
+    }
+
+    @Override
+    public void addInformation(ItemStack stack, @Nullable World world, List<String> tooltip, ITooltipFlag flag) {
+        tooltip.add(TextFormatting.GRAY + "Consume to increase reach to " + TextFormatting.BLUE + BuildConfig.reach.maxReachLevel3);
+        tooltip.add(TextFormatting.GRAY + "Previous upgrades need to be consumed first");
+    }
+
+    @Override
+    public String getTranslationKey() {
+        return super.getTranslationKey();
+    }
+}

src/main/java/nl/requios/effortlessbuilding/network/AddUndoMessage.java

@@ -0,0 +1,94 @@
+package nl.requios.effortlessbuilding.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import net.minecraftforge.fml.relauncher.Side;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.BlockSet;
+import nl.requios.effortlessbuilding.buildmodifier.UndoRedo;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
+
+import java.util.ArrayList;
+
+/***
+ * Sends a message to the client asking to add a block to the undo stack.
+ */
+public class AddUndoMessage implements IMessage {
+    private BlockPos coordinate;
+    private IBlockState previousBlockState;
+    private IBlockState newBlockState;
+
+    public AddUndoMessage() {
+        coordinate = BlockPos.ORIGIN;
+        previousBlockState = null;
+        newBlockState = null;
+    }
+
+    public AddUndoMessage(BlockPos coordinate, IBlockState previousBlockState, IBlockState newBlockState) {
+        this.coordinate = coordinate;
+        this.previousBlockState = previousBlockState;
+        this.newBlockState = newBlockState;
+    }
+
+    public BlockPos getCoordinate() {
+        return coordinate;
+    }
+
+    public IBlockState getPreviousBlockState() {
+        return previousBlockState;
+    }
+
+    public IBlockState getNewBlockState() {
+        return newBlockState;
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(this.coordinate.getX());
+        buf.writeInt(this.coordinate.getY());
+        buf.writeInt(this.coordinate.getZ());
+        buf.writeInt(Block.getStateId(this.previousBlockState));
+        buf.writeInt(Block.getStateId(this.newBlockState));
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        coordinate = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
+        previousBlockState = Block.getStateById(buf.readInt());
+        newBlockState = Block.getStateById(buf.readInt());
+    }
+
+    // The params of the IMessageHandler are <REQ, REPLY>
+    public static class MessageHandler implements IMessageHandler<AddUndoMessage, IMessage> {
+        // Do note that the default constructor is required, but implicitly defined in this case
+
+        @Override
+        public IMessage onMessage(AddUndoMessage message, MessageContext ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
+
+            if (ctx.side == Side.CLIENT){
+                //Received clientside
+
+                EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
+                    EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
+
+                    //Add to undo stack clientside
+                    UndoRedo.addUndo(player, new BlockSet(
+                            new ArrayList<BlockPos>() {{add(message.getCoordinate());}},
+                            new ArrayList<IBlockState>() {{add(message.getPreviousBlockState());}},
+                            new ArrayList<IBlockState>() {{add(message.getNewBlockState());}},
+                            new Vec3d(0,0,0),
+                            message.getCoordinate(), message.getCoordinate()));
+                });
+            }
+            return null;
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/network/BlockBrokenMessage.java

@@ -4,29 +4,37 @@ import io.netty.buffer.ByteBuf;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.math.Vec3d;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 import net.minecraftforge.fml.relauncher.Side;
-import nl.requios.effortlessbuilding.QuickReplace;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.proxy.ClientProxy;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
 
-public class QuickReplaceMessage implements IMessage {
+/***
+ * Sends a message to the server indicating that a player wants to break a block
+ */
+public class BlockBrokenMessage implements IMessage {
 
     private boolean blockHit;
     private BlockPos blockPos;
     private EnumFacing sideHit;
+    private Vec3d hitVec;
 
-    public QuickReplaceMessage() {
+    public BlockBrokenMessage() {
         this.blockHit = false;
         this.blockPos = BlockPos.ORIGIN;
         this.sideHit = EnumFacing.UP;
+        this.hitVec = new Vec3d(0, 0, 0);
     }
 
-    public QuickReplaceMessage(RayTraceResult result) {
+    public BlockBrokenMessage(RayTraceResult result) {
         this.blockHit = result.typeOfHit == RayTraceResult.Type.BLOCK;
         this.blockPos = result.getBlockPos();
         this.sideHit = result.sideHit;
+        this.hitVec = result.hitVec;
     }
 
     public boolean isBlockHit() {
@@ -41,6 +49,10 @@ public class QuickReplaceMessage implements IMessage {
         return sideHit;
     }
 
+    public Vec3d getHitVec() {
+        return hitVec;
+    }
+
     @Override
     public void toBytes(ByteBuf buf) {
         buf.writeBoolean(blockHit);
@@ -48,41 +60,36 @@ public class QuickReplaceMessage implements IMessage {
         buf.writeInt(blockPos.getY());
         buf.writeInt(blockPos.getZ());
         buf.writeInt(sideHit.getIndex());
+        buf.writeDouble(hitVec.x);
+        buf.writeDouble(hitVec.y);
+        buf.writeDouble(hitVec.z);
     }
 
     @Override
     public void fromBytes(ByteBuf buf) {
         blockHit = buf.readBoolean();
         blockPos = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
-        sideHit = EnumFacing.getFront(buf.readInt());
+        sideHit = EnumFacing.byIndex(buf.readInt());
+        hitVec = new Vec3d(buf.readDouble(), buf.readDouble(), buf.readDouble());
     }
 
     // The params of the IMessageHandler are <REQ, REPLY>
-    public static class MessageHandler implements IMessageHandler<QuickReplaceMessage, IMessage> {
+    public static class MessageHandler implements IMessageHandler<BlockBrokenMessage, IMessage> {
         // Do note that the default constructor is required, but implicitly defined in this case
 
         @Override
-        public IMessage onMessage(QuickReplaceMessage message, MessageContext ctx) {
+        public IMessage onMessage(BlockBrokenMessage message, MessageContext ctx) {
             //EffortlessBuilding.log("message received on " + ctx.side + " side");
 
-            if (ctx.side == Side.CLIENT){
+            if (ctx.side == Side.SERVER) {
-                //Received clientside
-                //Send back your info
-                return new QuickReplaceMessage(ClientProxy.previousLookAt);
-
-                //TODO break block then return
-//                Minecraft.getMinecraft().addScheduledTask(() -> {
-//                    EffortlessBuilding.packetHandler.sendToServer(new QuickReplaceMessage(Minecraft.getMinecraft().objectMouseOver));
-//                });
-
-            } else {
                 //Received serverside
-                ctx.getServerHandler().player.getServerWorld().addScheduledTask(() -> {
+                EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
-                    QuickReplace.onMessageReceived(ctx.getServerHandler().player, message);
+                    BuildModes.onBlockBrokenMessage(ctx.getServerHandler().player, message);
                 });
             }
             // No response packet
             return null;
         }
     }
+
 }

src/main/java/nl/requios/effortlessbuilding/network/BlockPlacedMessage.java

@@ -0,0 +1,113 @@
+package nl.requios.effortlessbuilding.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import net.minecraftforge.fml.relauncher.Side;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
+import nl.requios.effortlessbuilding.render.BlockPreviewRenderer;
+
+/***
+ * Sends a message to the server indicating that a player wants to place a block.
+ * Received clientside: server has placed blocks and its letting the client know.
+ */
+public class BlockPlacedMessage implements IMessage {
+
+    private boolean blockHit;
+    private BlockPos blockPos;
+    private EnumFacing sideHit;
+    private Vec3d hitVec;
+    private boolean placeStartPos; //prevent double placing in normal mode
+
+    public BlockPlacedMessage() {
+        this.blockHit = false;
+        this.blockPos = BlockPos.ORIGIN;
+        this.sideHit = EnumFacing.UP;
+        this.hitVec = new Vec3d(0, 0, 0);
+        this.placeStartPos = true;
+    }
+
+    public BlockPlacedMessage(RayTraceResult result, boolean placeStartPos) {
+        this.blockHit = result.typeOfHit == RayTraceResult.Type.BLOCK;
+        this.blockPos = result.getBlockPos();
+        this.sideHit = result.sideHit;
+        this.hitVec = result.hitVec;
+        this.placeStartPos = placeStartPos;
+    }
+
+    public boolean isBlockHit() {
+        return blockHit;
+    }
+
+    public BlockPos getBlockPos() {
+        return blockPos;
+    }
+
+    public EnumFacing getSideHit() {
+        return sideHit;
+    }
+
+    public Vec3d getHitVec() {
+        return hitVec;
+    }
+
+    public boolean getPlaceStartPos() {
+        return placeStartPos;
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeBoolean(blockHit);
+        buf.writeInt(blockPos.getX());
+        buf.writeInt(blockPos.getY());
+        buf.writeInt(blockPos.getZ());
+        buf.writeInt(sideHit.getIndex());
+        buf.writeDouble(hitVec.x);
+        buf.writeDouble(hitVec.y);
+        buf.writeDouble(hitVec.z);
+        buf.writeBoolean(placeStartPos);
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        blockHit = buf.readBoolean();
+        blockPos = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
+        sideHit = EnumFacing.byIndex(buf.readInt());
+        hitVec = new Vec3d(buf.readDouble(), buf.readDouble(), buf.readDouble());
+        placeStartPos = buf.readBoolean();
+    }
+
+    // The params of the IMessageHandler are <REQ, REPLY>
+    public static class MessageHandler implements IMessageHandler<BlockPlacedMessage, IMessage> {
+        // Do note that the default constructor is required, but implicitly defined in this case
+
+        @Override
+        public IMessage onMessage(BlockPlacedMessage message, MessageContext ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
+
+            if (ctx.side == Side.CLIENT){
+                //Received clientside
+                EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
+                    //Nod RenderHandler to do the dissolve shader effect
+                    BlockPreviewRenderer.onBlocksPlaced();
+                });
+                return null;
+            } else {
+                //Received serverside
+                EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
+                    BuildModes.onBlockPlacedMessage(ctx.getServerHandler().player, message);
+                });
+                // No response packet
+                return null;
+            }
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/network/BuildSettingsMessage.java

@@ -1,110 +0,0 @@
-package nl.requios.effortlessbuilding.network;
-
-import io.netty.buffer.ByteBuf;
-import net.minecraft.client.Minecraft;
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.util.IThreadListener;
-import net.minecraft.util.math.BlockPos;
-import net.minecraft.util.math.Vec3d;
-import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
-import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
-import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
-import nl.requios.effortlessbuilding.Array;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
-import nl.requios.effortlessbuilding.BuildSettingsManager.BuildSettings;
-import nl.requios.effortlessbuilding.Mirror;
-
-public class BuildSettingsMessage implements IMessage {
-
-    private BuildSettings buildSettings;
-
-    public BuildSettingsMessage() {
-    }
-
-    public BuildSettingsMessage(BuildSettings buildSettings) {
-        this.buildSettings = buildSettings;
-    }
-
-    @Override
-    public void toBytes(ByteBuf buf) {
-        //MIRROR
-        Mirror.MirrorSettings m = buildSettings.getMirrorSettings();
-        buf.writeBoolean(m.enabled);
-        buf.writeDouble(m.position.x);
-        buf.writeDouble(m.position.y);
-        buf.writeDouble(m.position.z);
-        buf.writeBoolean(m.mirrorX);
-        buf.writeBoolean(m.mirrorY);
-        buf.writeBoolean(m.mirrorZ);
-        buf.writeInt(m.radius);
-        buf.writeBoolean(m.drawLines);
-        buf.writeBoolean(m.drawPlanes);
-
-        //ARRAY
-        Array.ArraySettings a = buildSettings.getArraySettings();
-        buf.writeBoolean(a.enabled);
-        buf.writeInt(a.offset.getX());
-        buf.writeInt(a.offset.getY());
-        buf.writeInt(a.offset.getZ());
-        buf.writeInt(a.count);
-
-        buf.writeBoolean(buildSettings.doQuickReplace());
-    }
-
-    @Override
-    public void fromBytes(ByteBuf buf) {
-        //MIRROR
-        boolean mirrorEnabled = buf.readBoolean();
-        Vec3d mirrorPosition = new Vec3d(buf.readDouble(), buf.readDouble(), buf.readDouble());
-        boolean mirrorX = buf.readBoolean();
-        boolean mirrorY = buf.readBoolean();
-        boolean mirrorZ = buf.readBoolean();
-        int mirrorRadius = buf.readInt();
-        boolean mirrorDrawLines = buf.readBoolean();
-        boolean mirrorDrawPlanes = buf.readBoolean();
-        Mirror.MirrorSettings m = new Mirror.MirrorSettings(mirrorEnabled, mirrorPosition, mirrorX, mirrorY, mirrorZ, mirrorRadius, mirrorDrawLines, mirrorDrawPlanes);
-
-        //ARRAY
-        boolean arrayEnabled = buf.readBoolean();
-        BlockPos arrayOffset = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
-        int arrayCount = buf.readInt();
-        Array.ArraySettings a = new Array.ArraySettings(arrayEnabled, arrayOffset, arrayCount);
-
-        boolean quickReplace = buf.readBoolean();
-        buildSettings = new BuildSettings(m, a, quickReplace);
-    }
-
-    // The params of the IMessageHandler are <REQ, REPLY>
-    public static class MessageHandler implements IMessageHandler<BuildSettingsMessage, IMessage> {
-        // Do note that the default constructor is required, but implicitly defined in this case
-
-        @Override
-        public IMessage onMessage(BuildSettingsMessage message, MessageContext ctx) {
-            //EffortlessBuilding.log("message received on " + ctx.side + " side");
-
-            // This is the player the packet was sent to the server from
-            EntityPlayer player = (ctx.side.isClient() ? Minecraft.getMinecraft().player : ctx.getServerHandler().player);
-            // The value that was sent
-            BuildSettings buildSettings = message.buildSettings;
-            Mirror.MirrorSettings m = buildSettings.getMirrorSettings();
-            Array.ArraySettings a = buildSettings.getArraySettings();
-
-            // Sanitize
-            m.radius = Math.min(m.radius, Mirror.MAX_RADIUS);
-            m.radius = Math.max(1, m.radius);
-
-            a.count = Math.min(a.count, Array.MAX_COUNT);
-            a.count = Math.max(0, a.count);
-
-            // Execute the action on the main server thread by adding it as a scheduled task
-            IThreadListener threadListener = (ctx.side.isClient() ? Minecraft.getMinecraft() : ((EntityPlayerMP) player).getServerWorld());
-            threadListener.addScheduledTask(() -> {
-                EntityPlayer p = (ctx.side.isClient() ? Minecraft.getMinecraft().player : ctx.getServerHandler().player);
-                BuildSettingsManager.setBuildSettings(p, buildSettings);
-            });
-            // No response packet
-            return null;
-        }
-    }
-}

src/main/java/nl/requios/effortlessbuilding/network/CancelModeMessage.java

@@ -0,0 +1,45 @@
+package nl.requios.effortlessbuilding.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.IThreadListener;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+
+/**
+ * Sends a message to the server indicating that a buildmode needs to be canceled for a player
+ */
+public class CancelModeMessage implements IMessage {
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+
+    }
+
+    // The params of the IMessageHandler are <REQ, REPLY>
+    public static class MessageHandler implements IMessageHandler<CancelModeMessage, IMessage> {
+        // Do note that the default constructor is required, but implicitly defined in this case
+
+        @Override
+        public IMessage onMessage(CancelModeMessage message, MessageContext ctx) {
+
+            // Execute the action on the main server thread by adding it as a scheduled task
+            IThreadListener threadListener = EffortlessBuilding.proxy.getThreadListenerFromContext(ctx);
+            threadListener.addScheduledTask(() -> {
+                EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
+
+                BuildModes.initializeMode(player);
+            });
+            // No response packet
+            return null;
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/network/ClearUndoMessage.java

@@ -0,0 +1,57 @@
+package nl.requios.effortlessbuilding.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import net.minecraftforge.fml.relauncher.Side;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.BlockSet;
+import nl.requios.effortlessbuilding.buildmodifier.UndoRedo;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
+
+import java.util.ArrayList;
+
+/***
+ * Sends a message to the client asking to clear the undo and redo stacks.
+ */
+public class ClearUndoMessage implements IMessage {
+
+    public ClearUndoMessage() {
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+    }
+
+    // The params of the IMessageHandler are <REQ, REPLY>
+    public static class MessageHandler implements IMessageHandler<ClearUndoMessage, IMessage> {
+        // Do note that the default constructor is required, but implicitly defined in this case
+
+        @Override
+        public IMessage onMessage(ClearUndoMessage message, MessageContext ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
+
+            if (ctx.side == Side.CLIENT){
+                //Received clientside
+
+                EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
+                    EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
+
+                    //Add to undo stack clientside
+                    UndoRedo.clear(player);
+                });
+            }
+            return null;
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/network/ModeActionMessage.java

@@ -0,0 +1,62 @@
+package nl.requios.effortlessbuilding.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.IThreadListener;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmode.ModeOptions;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
+
+import static nl.requios.effortlessbuilding.buildmode.ModeSettingsManager.*;
+
+/**
+ * Shares mode settings (see ModeSettingsManager) between server and client
+ */
+public class ModeActionMessage implements IMessage {
+
+    private ModeOptions.ActionEnum action;
+
+    public ModeActionMessage() {
+    }
+
+    public ModeActionMessage(ModeOptions.ActionEnum action) {
+        this.action = action;
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(action.ordinal());
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        action = ModeOptions.ActionEnum.values()[buf.readInt()];
+    }
+
+    // The params of the IMessageHandler are <REQ, REPLY>
+    public static class MessageHandler implements IMessageHandler<ModeActionMessage, IMessage> {
+        // Do note that the default constructor is required, but implicitly defined in this case
+
+        @Override
+        public IMessage onMessage(ModeActionMessage message, MessageContext ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
+
+            // The value that was sent
+            ModeOptions.ActionEnum action = message.action;
+
+            // Execute the action on the main server thread by adding it as a scheduled task
+            IThreadListener threadListener = EffortlessBuilding.proxy.getThreadListenerFromContext(ctx);
+            threadListener.addScheduledTask(() -> {
+                EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
+
+                ModeOptions.performAction(player, action);
+            });
+            // No response packet
+            return null;
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/network/ModeSettingsMessage.java

@@ -0,0 +1,66 @@
+package nl.requios.effortlessbuilding.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.IThreadListener;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
+
+import static nl.requios.effortlessbuilding.buildmode.ModeSettingsManager.*;
+
+/**
+ * Shares mode settings (see ModeSettingsManager) between server and client
+ */
+public class ModeSettingsMessage implements IMessage {
+
+    private ModeSettings modeSettings;
+
+    public ModeSettingsMessage() {
+    }
+
+    public ModeSettingsMessage(ModeSettings modeSettings) {
+        this.modeSettings = modeSettings;
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeInt(modeSettings.getBuildMode().ordinal());
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.values()[buf.readInt()];
+
+        modeSettings = new ModeSettings(buildMode);
+    }
+
+    // The params of the IMessageHandler are <REQ, REPLY>
+    public static class MessageHandler implements IMessageHandler<ModeSettingsMessage, IMessage> {
+        // Do note that the default constructor is required, but implicitly defined in this case
+
+        @Override
+        public IMessage onMessage(ModeSettingsMessage message, MessageContext ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
+
+            // The value that was sent
+            ModeSettings modeSettings = message.modeSettings;
+
+            // Execute the action on the main server thread by adding it as a scheduled task
+            IThreadListener threadListener = EffortlessBuilding.proxy.getThreadListenerFromContext(ctx);
+            threadListener.addScheduledTask(() -> {
+                EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
+
+                // Sanitize
+                ModeSettingsManager.sanitize(modeSettings, player);
+
+                ModeSettingsManager.setModeSettings(player, modeSettings);
+            });
+            // No response packet
+            return null;
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/network/ModifierSettingsMessage.java

@@ -0,0 +1,154 @@
+package nl.requios.effortlessbuilding.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.IThreadListener;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.Array;
+import nl.requios.effortlessbuilding.buildmodifier.Mirror;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
+
+import static nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager.*;
+
+/**
+ * Shares modifier settings (see ModifierSettingsManager) between server and client
+ */
+public class ModifierSettingsMessage implements IMessage {
+
+    private ModifierSettings modifierSettings;
+
+    public ModifierSettingsMessage() {
+    }
+
+    public ModifierSettingsMessage(ModifierSettings modifierSettings) {
+        this.modifierSettings = modifierSettings;
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        //MIRROR
+        Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
+        buf.writeBoolean(m != null);
+        if (m != null) {
+            buf.writeBoolean(m.enabled);
+            buf.writeDouble(m.position.x);
+            buf.writeDouble(m.position.y);
+            buf.writeDouble(m.position.z);
+            buf.writeBoolean(m.mirrorX);
+            buf.writeBoolean(m.mirrorY);
+            buf.writeBoolean(m.mirrorZ);
+            buf.writeInt(m.radius);
+            buf.writeBoolean(m.drawLines);
+            buf.writeBoolean(m.drawPlanes);
+        }
+
+        //ARRAY
+        Array.ArraySettings a = modifierSettings.getArraySettings();
+        buf.writeBoolean(a != null);
+        if (a != null) {
+            buf.writeBoolean(a.enabled);
+            buf.writeInt(a.offset.getX());
+            buf.writeInt(a.offset.getY());
+            buf.writeInt(a.offset.getZ());
+            buf.writeInt(a.count);
+        }
+
+        buf.writeBoolean(modifierSettings.doQuickReplace());
+
+        buf.writeInt(modifierSettings.getReachUpgrade());
+
+        //RADIAL MIRROR
+        RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
+        buf.writeBoolean(r != null);
+        if (r != null) {
+            buf.writeBoolean(r.enabled);
+            buf.writeDouble(r.position.x);
+            buf.writeDouble(r.position.y);
+            buf.writeDouble(r.position.z);
+            buf.writeInt(r.slices);
+            buf.writeBoolean(r.alternate);
+            buf.writeInt(r.radius);
+            buf.writeBoolean(r.drawLines);
+            buf.writeBoolean(r.drawPlanes);
+        }
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        //MIRROR
+        Mirror.MirrorSettings m = new Mirror.MirrorSettings();
+        if (buf.readBoolean()) {
+            boolean mirrorEnabled = buf.readBoolean();
+            Vec3d mirrorPosition = new Vec3d(buf.readDouble(), buf.readDouble(), buf.readDouble());
+            boolean mirrorX = buf.readBoolean();
+            boolean mirrorY = buf.readBoolean();
+            boolean mirrorZ = buf.readBoolean();
+            int mirrorRadius = buf.readInt();
+            boolean mirrorDrawLines = buf.readBoolean();
+            boolean mirrorDrawPlanes = buf.readBoolean();
+            m = new Mirror.MirrorSettings(mirrorEnabled, mirrorPosition, mirrorX, mirrorY, mirrorZ, mirrorRadius,
+                            mirrorDrawLines, mirrorDrawPlanes);
+        }
+
+        //ARRAY
+        Array.ArraySettings a = new Array.ArraySettings();
+        if (buf.readBoolean()) {
+            boolean arrayEnabled = buf.readBoolean();
+            BlockPos arrayOffset = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
+            int arrayCount = buf.readInt();
+            a = new Array.ArraySettings(arrayEnabled, arrayOffset, arrayCount);
+        }
+
+        boolean quickReplace = buf.readBoolean();
+
+        int reachUpgrade = buf.readInt();
+
+        //RADIAL MIRROR
+        RadialMirror.RadialMirrorSettings r = new RadialMirror.RadialMirrorSettings();
+        if (buf.readBoolean()) {
+            boolean radialMirrorEnabled = buf.readBoolean();
+            Vec3d radialMirrorPosition = new Vec3d(buf.readDouble(), buf.readDouble(), buf.readDouble());
+            int radialMirrorSlices = buf.readInt();
+            boolean radialMirrorAlternate = buf.readBoolean();
+            int radialMirrorRadius = buf.readInt();
+            boolean radialMirrorDrawLines = buf.readBoolean();
+            boolean radialMirrorDrawPlanes = buf.readBoolean();
+            r = new RadialMirror.RadialMirrorSettings(radialMirrorEnabled, radialMirrorPosition, radialMirrorSlices,
+                            radialMirrorAlternate, radialMirrorRadius, radialMirrorDrawLines, radialMirrorDrawPlanes);
+        }
+
+        modifierSettings = new ModifierSettings(m, a, r, quickReplace, reachUpgrade);
+    }
+
+    // The params of the IMessageHandler are <REQ, REPLY>
+    public static class MessageHandler implements IMessageHandler<ModifierSettingsMessage, IMessage> {
+        // Do note that the default constructor is required, but implicitly defined in this case
+
+        @Override
+        public IMessage onMessage(ModifierSettingsMessage message, MessageContext ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
+
+            // The value that was sent
+            ModifierSettings modifierSettings = message.modifierSettings;
+
+            // Execute the action on the main server thread by adding it as a scheduled task
+            IThreadListener threadListener = EffortlessBuilding.proxy.getThreadListenerFromContext(ctx);
+            threadListener.addScheduledTask(() -> {
+                EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
+
+                // Sanitize
+                ModifierSettingsManager.sanitize(modifierSettings, player);
+
+                ModifierSettingsManager.setModifierSettings(player, modifierSettings);
+            });
+            // No response packet
+            return null;
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/network/RequestLookAtMessage.java

@@ -0,0 +1,73 @@
+package nl.requios.effortlessbuilding.network;
+
+import io.netty.buffer.ByteBuf;
+import net.minecraft.block.Block;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import net.minecraftforge.fml.relauncher.Side;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.BlockSet;
+import nl.requios.effortlessbuilding.buildmodifier.UndoRedo;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
+
+import java.util.ArrayList;
+
+/***
+ * Sends a message to the client asking for its lookat (objectmouseover) data.
+ * This is then sent back with a BlockPlacedMessage.
+ */
+public class RequestLookAtMessage implements IMessage {
+    private boolean placeStartPos;
+
+    public RequestLookAtMessage() {
+        placeStartPos = false;
+    }
+
+    public RequestLookAtMessage(boolean placeStartPos) {
+        this.placeStartPos = placeStartPos;
+    }
+
+    public boolean getPlaceStartPos() {
+        return placeStartPos;
+    }
+
+    @Override
+    public void toBytes(ByteBuf buf) {
+        buf.writeBoolean(this.placeStartPos);
+    }
+
+    @Override
+    public void fromBytes(ByteBuf buf) {
+        placeStartPos = buf.readBoolean();
+    }
+
+    // The params of the IMessageHandler are <REQ, REPLY>
+    public static class MessageHandler implements IMessageHandler<RequestLookAtMessage, IMessage> {
+        // Do note that the default constructor is required, but implicitly defined in this case
+
+        @Override
+        public IMessage onMessage(RequestLookAtMessage message, MessageContext ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
+
+            if (ctx.side == Side.CLIENT){
+                //Received clientside
+                //Send back your info
+
+//                EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
+//                    EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
+//
+//                });
+
+                //Prevent double placing in normal mode with placeStartPos false.
+                //Unless QuickReplace is on, then we do need to place start pos.
+                return new BlockPlacedMessage(ClientProxy.previousLookAt, message.getPlaceStartPos());
+            }
+            return null;
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/proxy/ClientProxy.java

@@ -1,49 +1,104 @@
 package nl.requios.effortlessbuilding.proxy;
 
 import net.minecraft.block.Block;
+import net.minecraft.block.SoundType;
+import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
 import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.client.renderer.block.model.ModelResourceLocation;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.client.resources.I18n;
 import net.minecraft.client.settings.KeyBinding;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.Item;
+import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.IThreadListener;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.RayTraceResult;
 import net.minecraft.util.text.TextFormatting;
+import net.minecraftforge.client.event.GuiOpenEvent;
 import net.minecraftforge.client.event.ModelRegistryEvent;
+import net.minecraftforge.client.event.TextureStitchEvent;
 import net.minecraftforge.client.model.ModelLoader;
+import net.minecraftforge.client.settings.IKeyConflictContext;
+import net.minecraftforge.client.settings.KeyConflictContext;
+import net.minecraftforge.client.settings.KeyModifier;
+import net.minecraftforge.event.entity.EntityJoinWorldEvent;
 import net.minecraftforge.fml.client.registry.ClientRegistry;
 import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.common.event.*;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
+import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
 import net.minecraftforge.fml.common.eventhandler.EventPriority;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.InputEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 import net.minecraftforge.fml.relauncher.Side;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.gui.SettingsGui;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
-import nl.requios.effortlessbuilding.network.BuildSettingsMessage;
+import nl.requios.effortlessbuilding.buildmode.ModeOptions;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.gui.buildmode.RadialMenu;
+import nl.requios.effortlessbuilding.gui.buildmodifier.ModifierSettingsGui;
+import nl.requios.effortlessbuilding.compatibility.CompatHelper;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+import nl.requios.effortlessbuilding.render.RenderHandler;
+import nl.requios.effortlessbuilding.render.ShaderHandler;
+import nl.requios.effortlessbuilding.network.*;
 import org.lwjgl.input.Keyboard;
 
+import javax.annotation.Nullable;
+import java.util.HashMap;
+
 @Mod.EventBusSubscriber(Side.CLIENT)
 public class ClientProxy implements IProxy {
     public static KeyBinding[] keyBindings;
     public static RayTraceResult previousLookAt;
     public static RayTraceResult currentLookAt;
+    private static int placeCooldown = 0;
+    private static int breakCooldown = 0;
+
+    public static int ticksInGame = 0;
+
+    private static final HashMap<BuildModes.BuildModeEnum, TextureAtlasSprite> buildModeIcons = new HashMap<>();
+    private static final HashMap<ModeOptions.ActionEnum, TextureAtlasSprite> modeOptionIcons = new HashMap<>();
 
     @Override
     public void preInit(FMLPreInitializationEvent event) {
+        ShaderHandler.init();
     }
 
     @Override
     public void init(FMLInitializationEvent event) {
         // register key bindings
-        keyBindings = new KeyBinding[2];
+        keyBindings = new KeyBinding[7];
 
         // instantiate the key bindings
-        keyBindings[0] = new KeyBinding("key.hud.desc", Keyboard.KEY_NUMPAD0, "key.effortlessbuilding.category");
+        keyBindings[0] = new KeyBinding("key.effortlessbuilding.hud.desc", KeyConflictContext.UNIVERSAL, Keyboard.KEY_ADD, "key.effortlessbuilding.category");
-        keyBindings[1] = new KeyBinding("key.replace.desc", Keyboard.KEY_NUMPAD1, "key.effortlessbuilding.category");
+        keyBindings[1] = new KeyBinding("key.effortlessbuilding.replace.desc", KeyConflictContext.IN_GAME, Keyboard.KEY_SUBTRACT, "key.effortlessbuilding.category");
+        keyBindings[2] = new KeyBinding("key.effortlessbuilding.creative.desc", KeyConflictContext.IN_GAME, Keyboard.KEY_NONE, "key.effortlessbuilding.category");
+        keyBindings[3] = new KeyBinding("key.effortlessbuilding.mode.desc", KeyConflictContext.IN_GAME, Keyboard.KEY_LMENU, "key.effortlessbuilding.category") {
+            @Override
+            public boolean conflicts(KeyBinding other) {
+                //Does not conflict with Chisels and Bits radial menu
+                if (other.getKeyCode() == getKeyCode() && other.getKeyDescription().equals("mod.chiselsandbits.other.mode")) return false;
+                return super.conflicts(other);
+            }
+        };
+        keyBindings[4] = new KeyBinding("key.effortlessbuilding.undo.desc", KeyConflictContext.IN_GAME, KeyModifier.CONTROL, Keyboard.KEY_Z, "key.effortlessbuilding.category");
+        keyBindings[5] = new KeyBinding("key.effortlessbuilding.redo.desc", KeyConflictContext.IN_GAME, KeyModifier.CONTROL, Keyboard.KEY_Y, "key.effortlessbuilding.category");
+        keyBindings[6] = new KeyBinding("key.effortlessbuilding.altplacement.desc", KeyConflictContext.IN_GAME, Keyboard.KEY_LCONTROL, "key.effortlessbuilding.category");
+//        keyBindings[7] = new KeyBinding("Reload shaders", Keyboard.KEY_TAB, "key.effortlessbuilding.category");
 
         // register all the key bindings
         for (int i = 0; i < keyBindings.length; ++i) {
@@ -58,12 +113,17 @@ public class ClientProxy implements IProxy {
 
     @Override
     public EntityPlayer getPlayerEntityFromContext(MessageContext ctx) {
-        return (ctx.side.isClient() ? Minecraft.getMinecraft().player : EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx));
+        return (ctx.side.isClient() ? Minecraft.getMinecraft().player : ctx.getServerHandler().player);
+    }
+
+    @Override
+    public IThreadListener getThreadListenerFromContext(MessageContext ctx) {
+        return (ctx.side.isClient() ? Minecraft.getMinecraft() : ((EntityPlayerMP) getPlayerEntityFromContext(ctx)).getServerWorld());
     }
 
     @Override
     public void serverStarting(FMLServerStartingEvent event) {
-        // This will never get called on client side
+        //This will get called clientside
     }
 
     @SubscribeEvent
@@ -77,34 +137,48 @@ public class ClientProxy implements IProxy {
         }
     }
 
-    @SubscribeEvent(priority = EventPriority.NORMAL, receiveCanceled = true)
+    @SubscribeEvent
-    public static void onKeyPress(InputEvent.KeyInputEvent event) {
+    public static void onEntityJoinWorld(EntityJoinWorldEvent event) {
-        // check each enumerated key binding type for pressed and take appropriate action
+        if (event.getEntity() == Minecraft.getMinecraft().player) {
-        EntityPlayerSP player = Minecraft.getMinecraft().player;
+            event.getWorld().addEventListener(new RenderHandler());
-        if (keyBindings[0].isPressed()) {
-            // do stuff for this key binding here
-            // remember you may need to send packet to server
-            if (Minecraft.getMinecraft().currentScreen == null) {
-                Minecraft.getMinecraft().displayGuiScreen(new SettingsGui());
-            } else {
-                player.closeScreen();
-            }
-        }
-        if (keyBindings[1].isPressed()) {
-            // do stuff for this key binding here
-            // remember you may need to send packet to server
-            BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(player);
-            buildSettings.setQuickReplace(!buildSettings.doQuickReplace());
-            EffortlessBuilding.log(player, "Set "+ TextFormatting.GOLD + "Quick Replace " + TextFormatting.RESET + (buildSettings.doQuickReplace() ? "on" : "off"));
-            EffortlessBuilding.packetHandler.sendToServer(new BuildSettingsMessage(buildSettings));
         }
     }
 
     @SubscribeEvent
-    public static void onClientTick(TickEvent.ClientTickEvent event) {
+    public static void onTextureStitch(final TextureStitchEvent.Pre event) {
-        if (event.phase != TickEvent.Phase.START) return;
+        //register icon textures
+        final TextureMap map = event.getMap();
 
+        for ( final BuildModes.BuildModeEnum mode : BuildModes.BuildModeEnum.values() )
+        {
+            final ResourceLocation sprite = new ResourceLocation("effortlessbuilding", "icons/" + mode.name().toLowerCase());
+            buildModeIcons.put( mode, map.registerSprite(sprite));
+        }
+
+        for ( final ModeOptions.ActionEnum action : ModeOptions.ActionEnum.values() )
+        {
+            final ResourceLocation sprite = new ResourceLocation("effortlessbuilding", "icons/" + action.name().toLowerCase());
+            modeOptionIcons.put( action, map.registerSprite(sprite));
+        }
+    }
+
+    public static TextureAtlasSprite getBuildModeIcon(BuildModes.BuildModeEnum mode) {
+        return buildModeIcons.get(mode);
+    }
+
+    public static TextureAtlasSprite getModeOptionIcon(ModeOptions.ActionEnum action) {
+        return modeOptionIcons.get(action);
+    }
+
+    @SubscribeEvent
+    public static void onClientTick(TickEvent.ClientTickEvent event) {
+
+        if (event.phase == TickEvent.Phase.START) {
+            onMouseInput();
+
+            //Update previousLookAt
             RayTraceResult objectMouseOver = Minecraft.getMinecraft().objectMouseOver;
+            //Checking for null is necessary! Even in vanilla when looking down ladders it is occasionally null (instead of Type MISS)
             if (objectMouseOver == null) return;
 
             if (currentLookAt == null) {
@@ -124,7 +198,220 @@ public class ClientProxy implements IProxy {
                     }
                 }
             }
-
+        } else if (event.phase == TickEvent.Phase.END){
-
+            GuiScreen gui = Minecraft.getMinecraft().currentScreen;
+            if(gui == null || !gui.doesGuiPauseGame()) {
+                ticksInGame++;
+            }
+        }
+
+    }
+
+    private static void onMouseInput() {
+        Minecraft mc = Minecraft.getMinecraft();
+        EntityPlayerSP player = mc.player;
+        if (player == null) return;
+        BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(player).getBuildMode();
+
+        if (Minecraft.getMinecraft().currentScreen != null ||
+            buildMode == BuildModes.BuildModeEnum.NORMAL ||
+            RadialMenu.instance.isVisible()) {
+            return;
+        }
+
+        if (mc.gameSettings.keyBindUseItem.isKeyDown()) {
+            //KeyBinding.setKeyBindState(mc.gameSettings.keyBindUseItem.getKeyCode(), false);
+
+            if (placeCooldown <= 0) {
+                placeCooldown = 4;
+
+                ItemStack currentItemStack = player.getHeldItem(EnumHand.MAIN_HAND);
+                if (currentItemStack.getItem() instanceof ItemBlock ||
+                    (CompatHelper.isItemBlockProxy(currentItemStack) && !player.isSneaking())) {
+
+                    ItemStack itemStack = CompatHelper.getItemBlockFromStack(currentItemStack);
+
+                    //find position in distance
+                    RayTraceResult lookingAt = getLookingAt(player);
+                    BuildModes.onBlockPlacedMessage(player, lookingAt == null ? new BlockPlacedMessage() : new BlockPlacedMessage(lookingAt, true));
+                    EffortlessBuilding.packetHandler.sendToServer(lookingAt == null ? new BlockPlacedMessage() : new BlockPlacedMessage(lookingAt, true));
+
+                    //play sound if further than normal
+                    if (lookingAt != null && lookingAt.typeOfHit == RayTraceResult.Type.BLOCK &&
+                        (lookingAt.hitVec.subtract(player.getPositionEyes(1f))).lengthSquared() > 25f &&
+                        itemStack.getItem() instanceof ItemBlock) {
+
+                        IBlockState state = ((ItemBlock) itemStack.getItem()).getBlock().getDefaultState();
+                        BlockPos blockPos = lookingAt.getBlockPos();
+                        SoundType soundType = state.getBlock().getSoundType(state, player.world, blockPos, player);
+                        player.world.playSound(player, player.getPosition(), soundType.getPlaceSound(), SoundCategory.BLOCKS,
+                                0.4f, soundType.getPitch() * 1f);
+                        player.swingArm(EnumHand.MAIN_HAND);
+                    }
+                }
+            } else if (buildMode == BuildModes.BuildModeEnum.NORMAL_PLUS) {
+                placeCooldown--;
+                if (ModeOptions.getBuildSpeed() == ModeOptions.ActionEnum.FAST_SPEED) placeCooldown = 0;
+            }
+        } else {
+            placeCooldown = 0;
+        }
+
+        if (mc.gameSettings.keyBindAttack.isKeyDown()) {
+
+            //Break block in distance in creative (or survival if enabled in config)
+            if (breakCooldown <= 0) {
+                breakCooldown = 4;
+
+                //Early out if cant break far, coming from own mouse event (not block broken event)
+                //To make breaking blocks in survival possible like array
+                //TODO this causes not being able to cancel placement in survival
+                //  moving it to after buildmodes fixes that, but introduces this bug
+                if (!ReachHelper.canBreakFar(player)) return;
+
+                RayTraceResult lookingAt = getLookingAt(player);
+                BuildModes.onBlockBrokenMessage(player, lookingAt == null ? new BlockBrokenMessage() : new BlockBrokenMessage(lookingAt));
+                EffortlessBuilding.packetHandler.sendToServer(lookingAt == null ? new BlockBrokenMessage() : new BlockBrokenMessage(lookingAt));
+
+                //play sound if further than normal
+                if (lookingAt != null && lookingAt.typeOfHit == RayTraceResult.Type.BLOCK &&
+                    (lookingAt.hitVec.subtract(player.getPositionEyes(1f))).lengthSquared() > 25f) {
+
+                    BlockPos blockPos = lookingAt.getBlockPos();
+                    IBlockState state = player.world.getBlockState(blockPos);
+                    SoundType soundtype = state.getBlock().getSoundType(state, player.world, blockPos, player);
+                    player.world.playSound(player, player.getPosition(), soundtype.getBreakSound(), SoundCategory.BLOCKS,
+                            0.4f, soundtype.getPitch() * 1f);
+                    player.swingArm(EnumHand.MAIN_HAND);
+                }
+            } else if (buildMode == BuildModes.BuildModeEnum.NORMAL_PLUS) {
+                breakCooldown--;
+                if (ModeOptions.getBuildSpeed() == ModeOptions.ActionEnum.FAST_SPEED) breakCooldown = 0;
+            }
+
+            //EffortlessBuilding.packetHandler.sendToServer(new CancelModeMessage());
+
+        } else {
+            breakCooldown = 0;
+        }
+
+        if (mc.gameSettings.keyBindAttack.isPressed()) {
+            if (RadialMenu.instance.isVisible()) {
+                EffortlessBuilding.log(player, "mouse click");
+            }
+        }
+
+    }
+
+    @SubscribeEvent(priority = EventPriority.NORMAL, receiveCanceled = true)
+    public static void onKeyPress(InputEvent.KeyInputEvent event) {
+        EntityPlayerSP player = Minecraft.getMinecraft().player;
+
+        //Remember to send packet to server if necessary
+        //Show Modifier Settings GUI
+        if (keyBindings[0].isPressed()) {
+            openModifierSettings();
+        }
+
+        //QuickReplace toggle
+        if (keyBindings[1].isPressed()) {
+            ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+            modifierSettings.setQuickReplace(!modifierSettings.doQuickReplace());
+            EffortlessBuilding.log(player, "Set "+ TextFormatting.GOLD + "Quick Replace " + TextFormatting.RESET + (
+                    modifierSettings.doQuickReplace() ? "on" : "off"));
+            EffortlessBuilding.packetHandler.sendToServer(new ModifierSettingsMessage(modifierSettings));
+        }
+
+        //Creative/survival mode toggle
+        if (keyBindings[2].isPressed()) {
+            if (player.isCreative()) {
+                player.sendChatMessage("/gamemode 0");
+            } else {
+                player.sendChatMessage("/gamemode 1");
+            }
+        }
+
+        //Undo (Ctrl+Z)
+        if (keyBindings[4].isPressed()) {
+            ModeOptions.ActionEnum action = ModeOptions.ActionEnum.UNDO;
+            ModeOptions.performAction(player, action);
+            EffortlessBuilding.packetHandler.sendToServer(new ModeActionMessage(action));
+        }
+
+        //Redo (Ctrl+Y)
+        if (keyBindings[5].isPressed()) {
+            ModeOptions.ActionEnum action = ModeOptions.ActionEnum.REDO;
+            ModeOptions.performAction(player, action);
+            EffortlessBuilding.packetHandler.sendToServer(new ModeActionMessage(action));
+        }
+
+        //Change placement mode
+        if (keyBindings[6].isPressed()) {
+            //Toggle between first two actions of the first option of the current build mode
+            BuildModes.BuildModeEnum currentBuildMode = ModeSettingsManager.getModeSettings(player).getBuildMode();
+            if (currentBuildMode.options.length > 0) {
+                ModeOptions.OptionEnum option = currentBuildMode.options[0];
+                if (option.actions.length >= 2) {
+                    if (ModeOptions.getOptionSetting(option) == option.actions[0]) {
+                        ModeOptions.performAction(player, option.actions[1]);
+                        EffortlessBuilding.packetHandler.sendToServer(new ModeActionMessage(option.actions[1]));
+                    } else {
+                        ModeOptions.performAction(player, option.actions[0]);
+                        EffortlessBuilding.packetHandler.sendToServer(new ModeActionMessage(option.actions[0]));
+                    }
+                }
+            }
+        }
+
+        //For shader development
+        if (keyBindings.length >= 8 && keyBindings[7].isPressed()) {
+            ShaderHandler.init();
+            EffortlessBuilding.log(player, "Reloaded shaders");
+        }
+
+    }
+
+    public static void openModifierSettings() {
+        Minecraft mc = Minecraft.getMinecraft();
+        EntityPlayerSP player = mc.player;
+
+        RadialMenu.instance.setVisibility(0f);
+
+        //Disabled if max reach is 0, might be set in the config that way.
+        if (ReachHelper.getMaxReach(player) == 0) {
+            EffortlessBuilding.log(player, "Build modifiers are disabled until your reach has increased. Increase your reach with craftable reach upgrades.");
+        } else {
+            if (mc.currentScreen == null) {
+                mc.displayGuiScreen(new ModifierSettingsGui());
+            } else {
+                player.closeScreen();
+            }
+        }
+    }
+
+    @SubscribeEvent
+    public static void onGuiOpen(GuiOpenEvent event) {
+        EntityPlayer player = Minecraft.getMinecraft().player;
+        if (player != null) {
+            BuildModes.initializeMode(player);
+        }
+    }
+
+    @Nullable
+    public static RayTraceResult getLookingAt(EntityPlayer player) {
+//        World world = player.world;
+
+        //base distance off of player ability (config)
+        float raytraceRange = ReachHelper.getPlacementReach(player);
+
+//        Vec3d look = player.getLookVec();
+//        Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
+//        Vec3d end = new Vec3d(player.posX + look.x * raytraceRange, player.posY + player.getEyeHeight() + look.y * raytraceRange, player.posZ + look.z * raytraceRange);
+        return player.rayTrace(raytraceRange, 1f);
+//        return world.rayTraceBlocks(start, end, false, false, false);
+    }
+
+    public static void logTranslate(String key) {
+        EffortlessBuilding.log(Minecraft.getMinecraft().player, I18n.format(key), true);
     }
 }

src/main/java/nl/requios/effortlessbuilding/proxy/IProxy.java

@@ -1,6 +1,7 @@
 package nl.requios.effortlessbuilding.proxy;
 
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.util.IThreadListener;
 import net.minecraftforge.fml.common.event.FMLInitializationEvent;
 import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
 import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
@@ -33,8 +34,10 @@ public interface IProxy
     /**
      * Returns a side-appropriate EntityPlayer for use during message handling.
      *
-     * @param parContext the context
+     * @param ctx the context
      * @return the player entity from context
      */
-    EntityPlayer getPlayerEntityFromContext(MessageContext parContext);
+    EntityPlayer getPlayerEntityFromContext(MessageContext ctx);
+
+    IThreadListener getThreadListenerFromContext(MessageContext ctx);
 }

src/main/java/nl/requios/effortlessbuilding/proxy/ServerProxy.java

@@ -1,6 +1,8 @@
 package nl.requios.effortlessbuilding.proxy;
 
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
+import net.minecraft.util.IThreadListener;
 import net.minecraftforge.fml.common.event.FMLInitializationEvent;
 import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
 import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
@@ -9,6 +11,7 @@ import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 
 public class ServerProxy implements IProxy
 {
+    //Only physical server! Singleplayer server is seen as clientproxy
     @Override
     public void preInit(FMLPreInitializationEvent event)
     {
@@ -27,7 +30,6 @@ public class ServerProxy implements IProxy
     @Override
     public void serverStarting(FMLServerStartingEvent event)
     {
-        //event.registerServerCommand(new CommandStructureCapture());
     }
 
     @Override
@@ -35,4 +37,9 @@ public class ServerProxy implements IProxy
     {
         return ctx.getServerHandler().player;
     }
+
+    @Override
+    public IThreadListener getThreadListenerFromContext(MessageContext ctx) {
+        return ((EntityPlayerMP) getPlayerEntityFromContext(ctx)).getServerWorld();
+    }
 }

src/main/java/nl/requios/effortlessbuilding/render/BlockPreviewRenderer.java

@@ -0,0 +1,436 @@
+package nl.requios.effortlessbuilding.render;
+
+import net.minecraft.block.SoundType;
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.renderer.BlockRendererDispatcher;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.item.ItemStack;
+import net.minecraft.util.EnumFacing;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.math.*;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import nl.requios.effortlessbuilding.BuildConfig;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmode.IBuildMode;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager.ModeSettings;
+import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager.ModifierSettings;
+import nl.requios.effortlessbuilding.compatibility.CompatHelper;
+import nl.requios.effortlessbuilding.helper.InventoryHelper;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+import nl.requios.effortlessbuilding.helper.SurvivalHelper;
+import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
+import org.lwjgl.opengl.ARBMultitexture;
+import org.lwjgl.opengl.ARBShaderObjects;
+import org.lwjgl.opengl.GL11;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+import java.util.function.Consumer;
+
+@SideOnly(Side.CLIENT)
+public class BlockPreviewRenderer {
+    private static List<BlockPos> previousCoordinates;
+    private static List<IBlockState> previousBlockStates;
+    private static List<ItemStack> previousItemStacks;
+    private static BlockPos previousFirstPos;
+    private static BlockPos previousSecondPos;
+    private static int soundTime = 0;
+
+    static class PlacedData {
+        float time;
+        List<BlockPos> coordinates;
+        List<IBlockState> blockStates;
+        List<ItemStack> itemStacks;
+        BlockPos firstPos;
+        BlockPos secondPos;
+        boolean breaking;
+
+        public PlacedData(float time, List<BlockPos> coordinates, List<IBlockState> blockStates,
+                          List<ItemStack> itemStacks, BlockPos firstPos, BlockPos secondPos, boolean breaking) {
+            this.time = time;
+            this.coordinates = coordinates;
+            this.blockStates = blockStates;
+            this.itemStacks = itemStacks;
+            this.firstPos = firstPos;
+            this.secondPos = secondPos;
+            this.breaking = breaking;
+        }
+    }
+
+    private static List<PlacedData> placedDataList = new ArrayList<>();
+
+    private static final int primaryTextureUnit = 0;
+    private static final int secondaryTextureUnit = 2;
+
+    public static void render(EntityPlayer player, ModifierSettings modifierSettings, ModeSettings modeSettings) {
+
+        //Render placed blocks with dissolve effect
+        //Use fancy shader if config allows, otherwise no dissolve
+        if (BuildConfig.visuals.useShaders) {
+            RenderHandler.beginBlockPreviews();
+            for (int i = 0; i < placedDataList.size(); i++) {
+                PlacedData placed = placedDataList.get(i);
+                if (placed.coordinates != null && !placed.coordinates.isEmpty()) {
+
+                    double totalTime = MathHelper.clampedLerp(30, 60, placed.firstPos.distanceSq(placed.secondPos) / 100.0) * BuildConfig.visuals.dissolveTimeMultiplier;
+                    float dissolve = (ClientProxy.ticksInGame - placed.time) / (float) totalTime;
+                    renderBlockPreviews(placed.coordinates, placed.blockStates, placed.itemStacks, dissolve, placed.firstPos, placed.secondPos, false, placed.breaking);
+                }
+            }
+            RenderHandler.endBlockPreviews();
+        }
+        //Expire
+        placedDataList.removeIf(placed -> {
+            double totalTime = MathHelper.clampedLerp(30, 60, placed.firstPos.distanceSq(placed.secondPos) / 100.0) * BuildConfig.visuals.dissolveTimeMultiplier;
+            return placed.time + totalTime < ClientProxy.ticksInGame;
+        });
+
+        //Render block previews
+        RayTraceResult lookingAt = ClientProxy.getLookingAt(player);
+        if (modeSettings.getBuildMode() == BuildModes.BuildModeEnum.NORMAL) lookingAt = Minecraft.getMinecraft().objectMouseOver;
+
+        ItemStack mainhand = player.getHeldItemMainhand();
+        boolean toolInHand = !(!mainhand.isEmpty() && CompatHelper.isItemBlockProxy(mainhand));
+
+        BlockPos startPos = null;
+        EnumFacing sideHit = null;
+        Vec3d hitVec = null;
+
+        //Checking for null is necessary! Even in vanilla when looking down ladders it is occasionally null (instead of Type MISS)
+        if (lookingAt != null && lookingAt.typeOfHit == RayTraceResult.Type.BLOCK) {
+            startPos = lookingAt.getBlockPos();
+
+            //Check if tool (or none) in hand
+            boolean replaceable = player.world.getBlockState(startPos).getBlock().isReplaceable(player.world, startPos);
+            boolean becomesDoubleSlab = SurvivalHelper.doesBecomeDoubleSlab(player, startPos, lookingAt.sideHit);
+            if (!modifierSettings.doQuickReplace() && !toolInHand && !replaceable && !becomesDoubleSlab) {
+                startPos = startPos.offset(lookingAt.sideHit);
+            }
+
+            //Get under tall grass and other replaceable blocks
+            if (modifierSettings.doQuickReplace() && !toolInHand && replaceable) {
+                startPos = startPos.down();
+            }
+
+            sideHit = lookingAt.sideHit;
+            hitVec = lookingAt.hitVec;
+        }
+
+        //Dont render if in normal mode and modifiers are disabled
+        //Unless alwaysShowBlockPreview is true in config
+        if (doRenderBlockPreviews(modifierSettings, modeSettings, startPos)) {
+
+            //Keep blockstate the same for every block in the buildmode
+            //So dont rotate blocks when in the middle of placing wall etc.
+            if (BuildModes.isActive(player)) {
+                IBuildMode buildModeInstance = modeSettings.getBuildMode().instance;
+                if (buildModeInstance.getSideHit(player) != null) sideHit = buildModeInstance.getSideHit(player);
+                if (buildModeInstance.getHitVec(player) != null) hitVec = buildModeInstance.getHitVec(player);
+            }
+
+            if (sideHit != null) {
+
+                //Should be red?
+                boolean breaking = BuildModes.currentlyBreakingClient.get(player) != null && BuildModes.currentlyBreakingClient.get(player);
+
+                //get coordinates
+                List<BlockPos> startCoordinates = BuildModes.findCoordinates(player, startPos, breaking || modifierSettings.doQuickReplace());
+
+                BlockPos firstPos = BlockPos.ORIGIN, secondPos = BlockPos.ORIGIN;
+                //Remember first and last pos for the shader
+                if (!startCoordinates.isEmpty()) {
+                    firstPos = startCoordinates.get(0);
+                    secondPos = startCoordinates.get(startCoordinates.size() - 1);
+                }
+
+                //Limit number of blocks you can place
+                int limit = ReachHelper.getMaxBlocksPlacedAtOnce(player);
+                if (startCoordinates.size() > limit) {
+                    startCoordinates = startCoordinates.subList(0, limit);
+                }
+
+                List<BlockPos> newCoordinates = BuildModifiers.findCoordinates(player, startCoordinates);
+
+                sortOnDistanceToPlayer(newCoordinates, player);
+
+                hitVec = new Vec3d(Math.abs(hitVec.x - ((int) hitVec.x)), Math.abs(hitVec.y - ((int) hitVec.y)),
+                        Math.abs(hitVec.z - ((int) hitVec.z)));
+
+                //Get blockstates
+                List<ItemStack> itemStacks = new ArrayList<>();
+                List<IBlockState> blockStates = new ArrayList<>();
+                if (breaking) {
+                    //Find blockstate of world
+                    for (BlockPos coordinate : newCoordinates) {
+                        blockStates.add(player.world.getBlockState(coordinate));
+                    }
+                } else {
+                    blockStates = BuildModifiers.findBlockStates(player, startCoordinates, hitVec, sideHit, itemStacks);
+                }
+
+
+                //Check if they are different from previous
+                //TODO fix triggering when moving player
+                if (!BuildModifiers.compareCoordinates(previousCoordinates, newCoordinates)) {
+                    previousCoordinates = newCoordinates;
+                    //remember the rest for placed blocks
+                    previousBlockStates = blockStates;
+                    previousItemStacks = itemStacks;
+                    previousFirstPos = firstPos;
+                    previousSecondPos = secondPos;
+
+                    //if so, renew randomness of randomizer bag
+                    ItemRandomizerBag.renewRandomness();
+                    //and play sound (max once every tick)
+                    if (newCoordinates.size() > 1 && blockStates.size() > 1 && soundTime < ClientProxy.ticksInGame - 0) {
+                        soundTime = ClientProxy.ticksInGame;
+
+                        if (blockStates.get(0) != null) {
+                            SoundType soundType = blockStates.get(0).getBlock().getSoundType(blockStates.get(0), player.world,
+                                    newCoordinates.get(0), player);
+                            player.world.playSound(player, player.getPosition(), breaking ? soundType.getBreakSound() : soundType.getPlaceSound(),
+                                    SoundCategory.BLOCKS, 0.3f, 0.8f);
+                        }
+                    }
+                }
+
+                //Render block previews
+                if (blockStates.size() != 0 && newCoordinates.size() == blockStates.size()) {
+                    int blockCount;
+
+                    //Use fancy shader if config allows, otherwise outlines
+                    if (BuildConfig.visuals.useShaders && newCoordinates.size() < BuildConfig.visuals.shaderTreshold) {
+
+                        RenderHandler.beginBlockPreviews();
+
+                        blockCount = renderBlockPreviews(newCoordinates, blockStates, itemStacks, 0f, firstPos, secondPos, !breaking, breaking);
+
+                        RenderHandler.endBlockPreviews();
+                    } else {
+
+                        RenderHandler.beginLines();
+
+                        Vec3d color = new Vec3d(1f, 1f, 1f);
+                        if (breaking) color = new Vec3d(1f, 0f, 0f);
+
+                        for (int i = newCoordinates.size() - 1; i >= 0; i--) {
+                            AxisAlignedBB boundingBox = blockStates.get(i).getBoundingBox(player.world, newCoordinates.get(i));
+                            RenderHandler.renderBlockOutline(newCoordinates.get(i), boundingBox, color);
+                        }
+
+                        RenderHandler.endLines();
+
+                        blockCount = newCoordinates.size();
+                    }
+
+                    //Display block count and dimensions in actionbar
+                    if (BuildModes.isActive(player)) {
+
+                        //Find min and max values (not simply firstPos and secondPos because that doesn't work with circles)
+                        int minX = Integer.MAX_VALUE, maxX = Integer.MIN_VALUE;
+                        int minY = Integer.MAX_VALUE, maxY = Integer.MIN_VALUE;
+                        int minZ = Integer.MAX_VALUE, maxZ = Integer.MIN_VALUE;
+                        for (BlockPos pos : startCoordinates) {
+                            if (pos.getX() < minX) minX = pos.getX();
+                            if (pos.getX() > maxX) maxX = pos.getX();
+                            if (pos.getY() < minY) minY = pos.getY();
+                            if (pos.getY() > maxY) maxY = pos.getY();
+                            if (pos.getZ() < minZ) minZ = pos.getZ();
+                            if (pos.getZ() > maxZ) maxZ = pos.getZ();
+                        }
+                        BlockPos dim = new BlockPos(maxX - minX + 1, maxY - minY + 1, maxZ - minZ + 1);
+
+                        String dimensions = "(";
+                        if (dim.getX() > 1) dimensions += dim.getX() + "x";
+                        if (dim.getZ() > 1) dimensions += dim.getZ() + "x";
+                        if (dim.getY() > 1) dimensions += dim.getY() + "x";
+                        dimensions = dimensions.substring(0, dimensions.length() - 1);
+                        if (dimensions.length() > 1) dimensions += ")";
+
+                        EffortlessBuilding.log(player, blockCount + " blocks " + dimensions, true);
+                    }
+                }
+
+
+            }
+
+            RenderHandler.beginLines();
+            //Draw outlines if tool in hand
+            //Find proper raytrace: either normal range or increased range depending on canBreakFar
+            RayTraceResult objectMouseOver = Minecraft.getMinecraft().objectMouseOver;
+            RayTraceResult breakingRaytrace = ReachHelper.canBreakFar(player) ? lookingAt : objectMouseOver;
+            if (toolInHand && breakingRaytrace != null && breakingRaytrace.typeOfHit == RayTraceResult.Type.BLOCK) {
+                List<BlockPos> breakCoordinates = BuildModifiers.findCoordinates(player, breakingRaytrace.getBlockPos());
+
+                //Only render first outline if further than normal reach
+                boolean excludeFirst = objectMouseOver != null && objectMouseOver.typeOfHit == RayTraceResult.Type.BLOCK;
+                for (int i = excludeFirst ? 1 : 0; i < breakCoordinates.size(); i++) {
+                    BlockPos coordinate = breakCoordinates.get(i);
+
+                    IBlockState blockState = player.world.getBlockState(coordinate);
+                    if (!blockState.getBlock().isAir(blockState, player.world, coordinate)) {
+                        if (SurvivalHelper.canBreak(player.world, player, coordinate) || i == 0) {
+                            AxisAlignedBB boundingBox = blockState.getBoundingBox(player.world, coordinate);
+                            RenderHandler.renderBlockOutline(coordinate, boundingBox, new Vec3d(0f, 0f, 0f));
+                        }
+                    }
+                }
+            }
+            RenderHandler.endLines();
+        }
+    }
+
+    //Whether to draw any block previews or outlines
+    public static boolean doRenderBlockPreviews(ModifierSettings modifierSettings, ModeSettings modeSettings, BlockPos startPos) {
+        return modeSettings.getBuildMode() != BuildModes.BuildModeEnum.NORMAL ||
+               (startPos != null && BuildModifiers.isEnabled(modifierSettings, startPos)) ||
+               BuildConfig.visuals.alwaysShowBlockPreview;
+    }
+
+    protected static int renderBlockPreviews(List<BlockPos> coordinates, List<IBlockState> blockStates,
+                                              List<ItemStack> itemStacks, float dissolve, BlockPos firstPos,
+                                              BlockPos secondPos, boolean checkCanPlace, boolean red) {
+        EntityPlayer player = Minecraft.getMinecraft().player;
+        ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        BlockRendererDispatcher dispatcher = Minecraft.getMinecraft().getBlockRendererDispatcher();
+        int blocksValid = 0;
+
+        if (coordinates.isEmpty()) return blocksValid;
+
+        for (int i = coordinates.size() - 1; i >= 0; i--) {
+            BlockPos blockPos = coordinates.get(i);
+            IBlockState blockState = blockStates.get(i);
+            ItemStack itemstack = itemStacks.isEmpty() ? ItemStack.EMPTY : itemStacks.get(i);
+            if (CompatHelper.isItemBlockProxy(itemstack))
+                itemstack = CompatHelper.getItemBlockByState(itemstack, blockState);
+
+            //Check if can place
+            //If check is turned off, check if blockstate is the same (for dissolve effect)
+            if ((!checkCanPlace /*&& player.world.getNewBlockState(blockPos) == blockState*/) || //TODO enable (breaks breaking shader)
+                SurvivalHelper.canPlace(player.world, player, blockPos, blockState, itemstack, modifierSettings.doQuickReplace(), EnumFacing.UP)) {
+
+                ShaderHandler.useShader(ShaderHandler.dissolve, generateShaderCallback(dissolve,
+                        new Vec3d(blockPos), new Vec3d(firstPos), new Vec3d(secondPos),
+                        blockPos == secondPos, red));
+                RenderHandler.renderBlockPreview(dispatcher, blockPos, blockState);
+                blocksValid++;
+            }
+        }
+        return blocksValid;
+    }
+
+    public static void onBlocksPlaced() {
+        onBlocksPlaced(previousCoordinates, previousItemStacks, previousBlockStates, previousFirstPos, previousSecondPos);
+    }
+
+    public static void onBlocksPlaced(List<BlockPos> coordinates, List<ItemStack> itemStacks, List<IBlockState> blockStates,
+                                      BlockPos firstPos, BlockPos secondPos) {
+        EntityPlayerSP player = Minecraft.getMinecraft().player;
+        ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+
+        //Check if block previews are enabled
+        if (doRenderBlockPreviews(modifierSettings, modeSettings, firstPos)) {
+
+            //Save current coordinates, blockstates and itemstacks
+            if (!coordinates.isEmpty() && blockStates.size() == coordinates.size() &&
+                coordinates.size() > 1 && coordinates.size() < BuildConfig.visuals.shaderTreshold) {
+
+                placedDataList.add(new PlacedData(ClientProxy.ticksInGame, coordinates, blockStates,
+                        itemStacks, firstPos, secondPos, false));
+            }
+        }
+
+    }
+
+    public static void onBlocksBroken() {
+        onBlocksBroken(previousCoordinates, previousItemStacks, previousBlockStates, previousFirstPos, previousSecondPos);
+    }
+
+    public static void onBlocksBroken(List<BlockPos> coordinates, List<ItemStack> itemStacks, List<IBlockState> blockStates,
+                                      BlockPos firstPos, BlockPos secondPos) {
+        EntityPlayerSP player = Minecraft.getMinecraft().player;
+        ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+
+        //Check if block previews are enabled
+        if (doRenderBlockPreviews(modifierSettings, modeSettings, firstPos)) {
+
+            //Save current coordinates, blockstates and itemstacks
+            if (!coordinates.isEmpty() && blockStates.size() == coordinates.size() &&
+                coordinates.size() > 1 && coordinates.size() < BuildConfig.visuals.shaderTreshold) {
+
+                sortOnDistanceToPlayer(coordinates, player);
+
+                placedDataList.add(new PlacedData(ClientProxy.ticksInGame, coordinates, blockStates,
+                        itemStacks, firstPos, secondPos, true));
+            }
+        }
+
+    }
+
+    private static Consumer<Integer> generateShaderCallback(final float dissolve, final Vec3d blockpos,
+                                                            final Vec3d firstpos, final Vec3d secondpos,
+                                                            final boolean highlight, final boolean red) {
+        Minecraft mc = Minecraft.getMinecraft();
+        return (Integer shader) -> {
+            int percentileUniform = ARBShaderObjects.glGetUniformLocationARB(shader, "dissolve");
+            int highlightUniform = ARBShaderObjects.glGetUniformLocationARB(shader, "highlight");
+            int redUniform = ARBShaderObjects.glGetUniformLocationARB(shader, "red");
+            int blockposUniform = ARBShaderObjects.glGetUniformLocationARB(shader, "blockpos");
+            int firstposUniform = ARBShaderObjects.glGetUniformLocationARB(shader, "firstpos");
+            int secondposUniform = ARBShaderObjects.glGetUniformLocationARB(shader, "secondpos");
+            int imageUniform = ARBShaderObjects.glGetUniformLocationARB(shader, "image");
+            int maskUniform = ARBShaderObjects.glGetUniformLocationARB(shader, "mask");
+
+            GlStateManager.enableTexture2D();
+            GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
+
+            //mask
+            ARBShaderObjects.glUniform1iARB(maskUniform, secondaryTextureUnit);
+            OpenGlHelper.setActiveTexture(ARBMultitexture.GL_TEXTURE0_ARB + secondaryTextureUnit);
+            GL11.glBindTexture(GL11.GL_TEXTURE_2D, mc.renderEngine.getTexture(ShaderHandler.shaderMaskTextureLocation).getGlTextureId());
+
+            //image
+            ARBShaderObjects.glUniform1iARB(imageUniform, primaryTextureUnit);
+            OpenGlHelper.setActiveTexture(ARBMultitexture.GL_TEXTURE0_ARB + primaryTextureUnit);
+            GL11.glBindTexture(GL11.GL_TEXTURE_2D, mc.renderEngine.getTexture(TextureMap.LOCATION_BLOCKS_TEXTURE).getGlTextureId());
+
+            //blockpos
+            ARBShaderObjects.glUniform3fARB(blockposUniform, (float) blockpos.x, (float) blockpos.y, (float) blockpos.z);
+            ARBShaderObjects.glUniform3fARB(firstposUniform, (float) firstpos.x, (float) firstpos.y, (float) firstpos.z);
+            ARBShaderObjects.glUniform3fARB(secondposUniform, (float) secondpos.x, (float) secondpos.y, (float) secondpos.z);
+
+            //dissolve
+            ARBShaderObjects.glUniform1fARB(percentileUniform, dissolve);
+            //highlight
+            ARBShaderObjects.glUniform1iARB(highlightUniform, highlight ? 1 : 0);
+            //red
+            ARBShaderObjects.glUniform1iARB(redUniform, red ? 1 : 0);
+        };
+    }
+
+    private static void sortOnDistanceToPlayer(List<BlockPos> coordinates, EntityPlayer player) {
+
+        Collections.sort(coordinates, (lhs, rhs) -> {
+            // -1 - less than, 1 - greater than, 0 - equal
+            double lhsDistanceToPlayer = new Vec3d(lhs).subtract(player.getPositionEyes(1f)).lengthSquared();
+            double rhsDistanceToPlayer = new Vec3d(rhs).subtract(player.getPositionEyes(1f)).lengthSquared();
+            return (int) Math.signum(lhsDistanceToPlayer - rhsDistanceToPlayer);
+        });
+
+    }
+}

src/main/java/nl/requios/effortlessbuilding/render/ModifierRenderer.java

@@ -0,0 +1,175 @@
+package nl.requios.effortlessbuilding.render;
+
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.util.math.Vec3d;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import nl.requios.effortlessbuilding.buildmodifier.Mirror;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.util.Color;
+
+@SideOnly(Side.CLIENT)
+public class ModifierRenderer {
+
+    protected static final Color colorX = new Color(255, 72, 52);
+    protected static final Color colorY = new Color(67, 204, 51);
+    protected static final Color colorZ = new Color(52, 247, 255);
+    protected static final Color colorRadial = new Color(52, 247, 255);
+    protected static final int lineAlpha = 200;
+    protected static final int planeAlpha = 75;
+    protected static final Vec3d epsilon = new Vec3d(0.001, 0.001, 0.001); //prevents z-fighting
+
+    public static void render(ModifierSettingsManager.ModifierSettings modifierSettings) {
+        RenderHandler.beginLines();
+
+        //Mirror lines and areas
+        Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
+        if (m != null && m.enabled && (m.mirrorX || m.mirrorY || m.mirrorZ))
+        {
+            Vec3d pos = m.position.add(epsilon);
+            int radius = m.radius;
+
+            if (m.mirrorX)
+            {
+                Vec3d posA = new Vec3d(pos.x, pos.y - radius, pos.z - radius);
+                Vec3d posB = new Vec3d(pos.x, pos.y + radius, pos.z + radius);
+
+                drawMirrorPlane(posA, posB, colorX, m.drawLines, m.drawPlanes, true);
+            }
+            if (m.mirrorY)
+            {
+                Vec3d posA = new Vec3d(pos.x - radius, pos.y, pos.z - radius);
+                Vec3d posB = new Vec3d(pos.x + radius, pos.y, pos.z + radius);
+
+                drawMirrorPlaneY(posA, posB, colorY, m.drawLines, m.drawPlanes);
+            }
+            if (m.mirrorZ)
+            {
+                Vec3d posA = new Vec3d(pos.x - radius, pos.y - radius, pos.z);
+                Vec3d posB = new Vec3d(pos.x + radius, pos.y + radius, pos.z);
+
+                drawMirrorPlane(posA, posB, colorZ, m.drawLines, m.drawPlanes, true);
+            }
+
+            //Draw axis coordinated colors if two or more axes are enabled
+            //(If only one is enabled the lines are that planes color)
+            if (m.drawLines && ((m.mirrorX && m.mirrorY) || (m.mirrorX && m.mirrorZ) || (m.mirrorY && m.mirrorZ)))
+            {
+                drawMirrorLines(m);
+            }
+        }
+
+        //Radial mirror lines and areas
+        RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
+        if (r != null && r.enabled)
+        {
+            Vec3d pos = r.position.add(epsilon);
+            int radius = r.radius;
+
+            float angle = 2f * ((float) Math.PI) / r.slices;
+            Vec3d relStartVec = new Vec3d(radius, 0, 0);
+            if (r.slices%4 == 2) relStartVec = relStartVec.rotateYaw(angle / 2f);
+
+            for (int i = 0; i < r.slices; i++) {
+                Vec3d relNewVec = relStartVec.rotateYaw(angle * i);
+                Vec3d newVec = pos.add(relNewVec);
+
+                Vec3d posA = new Vec3d(pos.x, pos.y - radius, pos.z);
+                Vec3d posB = new Vec3d(newVec.x, pos.y + radius, newVec.z);
+                drawMirrorPlane(posA, posB, colorRadial, r.drawLines, r.drawPlanes, false);
+            }
+        }
+
+        RenderHandler.endLines();
+    }
+
+
+    //----Mirror----
+
+    protected static void drawMirrorPlane(Vec3d posA, Vec3d posB, Color c, boolean drawLines, boolean drawPlanes, boolean drawVerticalLines) {
+
+        GL11.glColor4d(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha);
+        Tessellator tessellator = Tessellator.getInstance();
+        BufferBuilder bufferBuilder = tessellator.getBuffer();
+
+        if (drawPlanes) {
+            bufferBuilder.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION_COLOR);
+
+            bufferBuilder.pos(posA.x, posA.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            bufferBuilder.pos(posA.x, posB.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            bufferBuilder.pos(posB.x, posA.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            bufferBuilder.pos(posB.x, posB.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+
+            tessellator.draw();
+        }
+
+        if (drawLines) {
+            Vec3d middle = posA.add(posB).scale(0.5);
+            bufferBuilder.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
+
+            bufferBuilder.pos(posA.x, middle.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            bufferBuilder.pos(posB.x, middle.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            if (drawVerticalLines) {
+                bufferBuilder.pos(middle.x, posA.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+                bufferBuilder.pos(middle.x, posB.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            }
+
+            tessellator.draw();
+        }
+    }
+
+    protected static void drawMirrorPlaneY(Vec3d posA, Vec3d posB, Color c, boolean drawLines, boolean drawPlanes) {
+
+        GL11.glColor4d(c.getRed(), c.getGreen(), c.getBlue(), c.getAlpha());
+        Tessellator tessellator = Tessellator.getInstance();
+        BufferBuilder bufferBuilder = tessellator.getBuffer();
+
+        if (drawPlanes) {
+            bufferBuilder.begin(GL11.GL_TRIANGLE_STRIP, DefaultVertexFormats.POSITION_COLOR);
+
+            bufferBuilder.pos(posA.x, posA.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            bufferBuilder.pos(posA.x, posA.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            bufferBuilder.pos(posB.x, posA.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+            bufferBuilder.pos(posB.x, posA.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), planeAlpha).endVertex();
+
+            tessellator.draw();
+        }
+
+        if (drawLines) {
+            Vec3d middle = posA.add(posB).scale(0.5);
+            bufferBuilder.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
+
+            bufferBuilder.pos(middle.x, middle.y, posA.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            bufferBuilder.pos(middle.x, middle.y, posB.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            bufferBuilder.pos(posA.x, middle.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+            bufferBuilder.pos(posB.x, middle.y, middle.z).color(c.getRed(), c.getGreen(), c.getBlue(), lineAlpha).endVertex();
+
+            tessellator.draw();
+        }
+    }
+
+    protected static void drawMirrorLines(Mirror.MirrorSettings m) {
+
+        Vec3d pos = m.position.add(epsilon);
+
+        GL11.glColor4d(100, 100, 100, 255);
+        GL11.glLineWidth(2);
+        Tessellator tessellator = Tessellator.getInstance();
+        BufferBuilder bufferBuilder = tessellator.getBuffer();
+
+        bufferBuilder.begin(GL11.GL_LINES, DefaultVertexFormats.POSITION_COLOR);
+
+        bufferBuilder.pos(pos.x - m.radius, pos.y, pos.z).color(colorX.getRed(), colorX.getGreen(), colorX.getBlue(), lineAlpha).endVertex();
+        bufferBuilder.pos(pos.x + m.radius, pos.y, pos.z).color(colorX.getRed(), colorX.getGreen(), colorX.getBlue(), lineAlpha).endVertex();
+        bufferBuilder.pos(pos.x, pos.y - m.radius, pos.z).color(colorY.getRed(), colorY.getGreen(), colorY.getBlue(), lineAlpha).endVertex();
+        bufferBuilder.pos(pos.x, pos.y + m.radius, pos.z).color(colorY.getRed(), colorY.getGreen(), colorY.getBlue(), lineAlpha).endVertex();
+        bufferBuilder.pos(pos.x, pos.y, pos.z - m.radius).color(colorZ.getRed(), colorZ.getGreen(), colorZ.getBlue(), lineAlpha).endVertex();
+        bufferBuilder.pos(pos.x, pos.y, pos.z + m.radius).color(colorZ.getRed(), colorZ.getGreen(), colorZ.getBlue(), lineAlpha).endVertex();
+
+        tessellator.draw();
+    }
+}

src/main/java/nl/requios/effortlessbuilding/render/RenderHandler.java

@@ -0,0 +1,336 @@
+package nl.requios.effortlessbuilding.render;
+
+import net.minecraft.block.state.IBlockState;
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.audio.PositionedSoundRecord;
+import net.minecraft.client.entity.EntityPlayerSP;
+import net.minecraft.client.gui.ScaledResolution;
+import net.minecraft.client.renderer.BlockRendererDispatcher;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.RenderGlobal;
+import net.minecraft.client.renderer.texture.TextureMap;
+import net.minecraft.client.resources.I18n;
+import net.minecraft.client.settings.KeyBinding;
+import net.minecraft.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.init.SoundEvents;
+import net.minecraft.util.EnumHand;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.SoundCategory;
+import net.minecraft.util.SoundEvent;
+import net.minecraft.util.math.AxisAlignedBB;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.IWorldEventListener;
+import net.minecraft.world.World;
+import net.minecraftforge.client.event.RenderGameOverlayEvent;
+import net.minecraftforge.client.event.RenderWorldLastEvent;
+import net.minecraftforge.fml.common.Mod;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import net.minecraftforge.fml.relauncher.Side;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.ModeOptions;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.gui.buildmode.RadialMenu;
+import nl.requios.effortlessbuilding.compatibility.CompatHelper;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+import nl.requios.effortlessbuilding.helper.SurvivalHelper;
+import nl.requios.effortlessbuilding.network.ModeActionMessage;
+import nl.requios.effortlessbuilding.network.ModeSettingsMessage;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
+import org.lwjgl.input.Mouse;
+import org.lwjgl.opengl.GL11;
+import org.lwjgl.opengl.GL14;
+
+import javax.annotation.Nullable;
+import java.util.List;
+
+/***
+ * Main render class for Effortless Building
+ */
+@Mod.EventBusSubscriber(Side.CLIENT)
+public class RenderHandler implements IWorldEventListener {
+
+    @SubscribeEvent
+    public static void onRender(RenderWorldLastEvent event) {
+        EntityPlayer player = Minecraft.getMinecraft().player;
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+
+        begin(event.getPartialTicks());
+
+        //Mirror and radial mirror lines and areas
+        ModifierRenderer.render(modifierSettings);
+
+        //Render block previews
+        BlockPreviewRenderer.render(player, modifierSettings, modeSettings);
+
+        end();
+    }
+
+    @SubscribeEvent
+    //Display Radial Menu
+    public static void onRenderGameOverlay(final RenderGameOverlayEvent.Post event ) {
+        Minecraft mc = Minecraft.getMinecraft();
+        EntityPlayerSP player = mc.player;
+
+        //check if chisel and bits tool in hand (and has menu)
+        final boolean hasChiselInHand = CompatHelper.chiselsAndBitsProxy.isHoldingChiselTool(EnumHand.MAIN_HAND);
+
+        final RenderGameOverlayEvent.ElementType type = event.getType();
+        if (type == RenderGameOverlayEvent.ElementType.ALL && !hasChiselInHand) {
+            final boolean wasVisible = RadialMenu.instance.isVisible();
+
+            if (ClientProxy.keyBindings[3].isKeyDown()) {
+                if (ReachHelper.getMaxReach(player) > 0) {
+                    RadialMenu.instance.actionUsed = false;
+                    RadialMenu.instance.raiseVisibility();
+                } else if (ClientProxy.keyBindings[3].isPressed()) {
+                    EffortlessBuilding.log(player, "Build modes are disabled until your reach has increased. Increase your reach with craftable reach upgrades.");
+                }
+            } else {
+                if (!RadialMenu.instance.actionUsed) {
+                    ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+
+                    if (RadialMenu.instance.switchTo != null) {
+                        playRadialMenuSound();
+                        modeSettings.setBuildMode(RadialMenu.instance.switchTo);
+                        ModeSettingsManager.setModeSettings(player, modeSettings);
+                        EffortlessBuilding.packetHandler.sendToServer(new ModeSettingsMessage(modeSettings));
+
+                        EffortlessBuilding.log(player, I18n.format(modeSettings.getBuildMode().name), true);
+                    }
+
+                    //Perform button action
+                    ModeOptions.ActionEnum action = RadialMenu.instance.doAction;
+                    if (action != null) {
+                        ModeOptions.performAction(player, action);
+                        EffortlessBuilding.packetHandler.sendToServer(new ModeActionMessage(action));
+                    }
+
+                    playRadialMenuSound();
+                }
+
+                RadialMenu.instance.actionUsed = true;
+                RadialMenu.instance.decreaseVisibility();
+            }
+
+            if (RadialMenu.instance.isVisible()) {
+
+                final ScaledResolution res = event.getResolution();
+                RadialMenu.instance.configure(res.getScaledWidth(), res.getScaledHeight());
+
+                if (!wasVisible) {
+                    mc.inGameHasFocus = false;
+                    mc.mouseHelper.ungrabMouseCursor();
+                }
+
+                if (mc.inGameHasFocus) {
+                    KeyBinding.unPressAllKeys();
+                }
+
+                final int mouseX = Mouse.getX() * res.getScaledWidth() / mc.displayWidth;
+                final int mouseY = res.getScaledHeight() - Mouse.getY() * res.getScaledHeight() / mc.displayHeight - 1;
+
+                net.minecraftforge.client.ForgeHooksClient.drawScreen(RadialMenu.instance, mouseX, mouseY, event.getPartialTicks());
+            } else {
+                if (wasVisible && RadialMenu.instance.doAction != ModeOptions.ActionEnum.OPEN_MODIFIER_SETTINGS) {
+                    mc.setIngameFocus();
+                }
+            }
+        }
+    }
+
+    public static void playRadialMenuSound() {
+        final float volume = 0.1f;
+        if (volume >= 0.0001f) {
+            final PositionedSoundRecord psr = new PositionedSoundRecord(SoundEvents.UI_BUTTON_CLICK, SoundCategory.MASTER,
+                    volume, 1.0f, Minecraft.getMinecraft().player.getPosition());
+            Minecraft.getMinecraft().getSoundHandler().playSound(psr);
+        }
+    }
+
+    private static void begin(float partialTicks) {
+        EntityPlayer player = Minecraft.getMinecraft().player;
+        double playerX = player.prevPosX + (player.posX - player.prevPosX) * partialTicks;
+        double playerY = player.prevPosY + (player.posY - player.prevPosY) * partialTicks;
+        double playerZ = player.prevPosZ + (player.posZ - player.prevPosZ) * partialTicks;
+        Vec3d playerPos = new Vec3d(playerX, playerY, playerZ);
+
+        GL11.glPushMatrix();
+        GL11.glTranslated(-playerPos.x, -playerPos.y, -playerPos.z);
+
+        GL11.glDepthMask(false);
+    }
+
+    protected static void beginLines() {
+        GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
+        GL11.glDisable(GL11.GL_CULL_FACE);
+        GL11.glDisable(GL11.GL_LIGHTING);
+        GL11.glDisable(GL11.GL_TEXTURE_2D);
+
+        GL11.glEnable(GL11.GL_BLEND);
+        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+
+        GL11.glLineWidth(2);
+    }
+
+    protected static void endLines() {
+        GL11.glPopAttrib();
+    }
+
+    protected static void beginBlockPreviews() {
+        GL11.glPushAttrib(GL11.GL_ENABLE_BIT);
+        GL11.glEnable(GL11.GL_CULL_FACE);
+        GL11.glEnable(GL11.GL_TEXTURE_2D);
+//        Minecraft.getMinecraft().renderEngine.bindTexture(TextureMap.LOCATION_BLOCKS_TEXTURE);
+        Minecraft.getMinecraft().renderEngine.bindTexture(ShaderHandler.shaderMaskTextureLocation);
+
+        GlStateManager.enableBlend();
+        GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
+        GL14.glBlendColor(1F, 1F, 1F, 0.8f);
+    }
+
+    protected static void endBlockPreviews() {
+        ShaderHandler.releaseShader();
+        GlStateManager.disableBlend();
+
+        GL11.glPopAttrib();
+    }
+
+    private static void end() {
+        GL11.glDepthMask(true);
+        GL11.glPopMatrix();
+    }
+
+    protected static void renderBlockPreview(BlockRendererDispatcher dispatcher, BlockPos blockPos, IBlockState blockState) {
+        if (blockState == null) return;
+
+        GlStateManager.pushMatrix();
+        GlStateManager.translate(blockPos.getX(), blockPos.getY(), blockPos.getZ());
+        GlStateManager.rotate(-90.0F, 0.0F, 1.0F, 0.0F);
+        GlStateManager.translate(-0.01f, -0.01f, 0.01f);
+        GlStateManager.scale(1.02f, 1.02f, 1.02f);
+
+        try {
+            dispatcher.renderBlockBrightness(blockState, 0.85f);
+        } catch (NullPointerException e) {
+            EffortlessBuilding.logger.warn("RenderHandler::renderBlockPreview cannot render " + blockState.getBlock().toString());
+
+            //Render outline as backup
+            GlStateManager.popMatrix();
+//            ShaderHandler.releaseShader();
+            GL11.glDisable(GL11.GL_LIGHTING);
+            renderBlockOutline(blockPos, new Vec3d(1f, 1f, 1f));
+            GL11.glEnable(GL11.GL_LIGHTING);
+            GlStateManager.pushMatrix();
+        }
+
+        GlStateManager.popMatrix();
+    }
+
+    protected static void renderBlockOutline(BlockPos pos, Vec3d color) {
+        renderBlockOutline(pos, pos, color);
+    }
+
+    //Renders outline. Pos1 has to be minimal x,y,z and pos2 maximal x,y,z
+    protected static void renderBlockOutline(BlockPos pos1, BlockPos pos2, Vec3d color) {
+        GL11.glLineWidth(2);
+
+        AxisAlignedBB aabb = new AxisAlignedBB(pos1, pos2.add(1, 1, 1)).grow(0.0020000000949949026);
+
+        RenderGlobal.drawSelectionBoundingBox(aabb, (float) color.x, (float) color.y, (float) color.z, 0.4f);
+    }
+
+    //Renders outline with given bounding box
+    protected static void renderBlockOutline(BlockPos pos, AxisAlignedBB boundingBox, Vec3d color) {
+        GL11.glLineWidth(2);
+
+        AxisAlignedBB aabb = boundingBox.offset(pos).grow(0.0020000000949949026);
+
+        RenderGlobal.drawSelectionBoundingBox(aabb, (float) color.x, (float) color.y, (float) color.z, 0.4f);
+    }
+
+
+
+    //IWORLDEVENTLISTENER IMPLEMENTATION
+    @Override
+    public void notifyBlockUpdate(World worldIn, BlockPos pos, IBlockState oldState, IBlockState newState, int flags) {
+
+    }
+
+    @Override
+    public void notifyLightSet(BlockPos pos) {
+
+    }
+
+    @Override
+    public void markBlockRangeForRenderUpdate(int x1, int y1, int z1, int x2, int y2, int z2) {
+
+    }
+
+    @Override
+    public void playSoundToAllNearExcept(@Nullable EntityPlayer player, SoundEvent soundIn, SoundCategory category,
+                                         double x, double y, double z, float volume, float pitch) {
+
+    }
+
+    @Override
+    public void playRecord(SoundEvent soundIn, BlockPos pos) {
+
+    }
+
+    @Override
+    public void spawnParticle(int particleID, boolean ignoreRange, double xCoord, double yCoord, double zCoord,
+                              double xSpeed, double ySpeed, double zSpeed, int... parameters) {
+
+    }
+
+    @Override
+    public void spawnParticle(int id, boolean ignoreRange, boolean p_190570_3_, double x, double y, double z,
+                              double xSpeed, double ySpeed, double zSpeed, int... parameters) {
+
+    }
+
+    @Override
+    public void onEntityAdded(Entity entityIn) {
+
+    }
+
+    @Override
+    public void onEntityRemoved(Entity entityIn) {
+
+    }
+
+    @Override
+    public void broadcastSound(int soundID, BlockPos pos, int data) {
+
+    }
+
+    @Override
+    public void playEvent(EntityPlayer player, int type, BlockPos blockPosIn, int data) {
+
+    }
+
+    //Sends breaking progress for all coordinates to renderglobal, so all blocks get visually broken
+    @Override
+    public void sendBlockBreakProgress(int breakerId, BlockPos pos, int progress) {
+        Minecraft mc = Minecraft.getMinecraft();
+
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
+        if (!BuildModifiers.isEnabled(modifierSettings, pos)) return;
+
+        List<BlockPos> coordinates = BuildModifiers.findCoordinates(mc.player, pos);
+        for (int i = 1; i < coordinates.size(); i++) {
+            BlockPos coordinate = coordinates.get(i);
+            if (SurvivalHelper.canBreak(mc.world, mc.player, coordinate)) {
+                //Send i as entity id because only one block can be broken per id
+                //Unless i happens to be the player id, then take something else
+                int fakeId = mc.player.getEntityId() != i ? i : coordinates.size();
+                mc.renderGlobal.sendBlockBreakProgress(fakeId, coordinate, progress);
+            }
+        }
+    }
+}

src/main/java/nl/requios/effortlessbuilding/render/ShaderHandler.java

@@ -0,0 +1,195 @@
+/**
+ * This class was created by <Vazkii>. It's distributed as
+ * part of the Botania Mod. Get the Source Code in github:
+ * https://github.com/Vazkii/Botania
+ *
+ * Modified by Requios
+ *
+ * Botania is Open Source and distributed under the
+ * Botania License: http://botaniamod.net/license.php
+ *
+ * File Created @ [Apr 9, 2014, 11:20:26 PM (GMT)]
+ */
+package nl.requios.effortlessbuilding.render;
+
+import net.minecraft.client.renderer.OpenGlHelper;
+import net.minecraft.util.ResourceLocation;
+import nl.requios.effortlessbuilding.BuildConfig;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
+import org.apache.logging.log4j.Level;
+import org.lwjgl.opengl.*;
+
+import java.io.BufferedReader;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.nio.charset.StandardCharsets;
+import java.util.function.Consumer;
+
+public final class ShaderHandler {
+
+    private static final int VERT_ST = ARBVertexShader.GL_VERTEX_SHADER_ARB;
+    private static final int FRAG_ST = ARBFragmentShader.GL_FRAGMENT_SHADER_ARB;
+
+    private static final int VERT = 1;
+    private static final int FRAG = 2;
+
+    private static final String VERT_EXTENSION = ".vert";
+    private static final String FRAG_EXTENSION = ".frag";
+
+    public static int rawColor;
+    public static int dissolve;
+
+    public static ResourceLocation shaderMaskTextureLocation = new ResourceLocation(EffortlessBuilding.MODID, "textures/shader_mask.png");
+
+    public static void init() {
+        if(!doUseShaders())
+            return;
+
+        rawColor = createProgram("/assets/effortlessbuilding/shaders/raw_color", FRAG);
+        dissolve = createProgram("/assets/effortlessbuilding/shaders/dissolve", VERT + FRAG);
+    }
+
+    public static void useShader(int shader, Consumer<Integer> callback) {
+        if(!doUseShaders())
+            return;
+
+        ARBShaderObjects.glUseProgramObjectARB(shader);
+
+        if(shader != 0) {
+            int time = ARBShaderObjects.glGetUniformLocationARB(shader, "time");
+            ARBShaderObjects.glUniform1iARB(time, ClientProxy.ticksInGame);
+
+            if(callback != null)
+                callback.accept(shader);
+        }
+    }
+
+    public static void useShader(int shader) {
+        useShader(shader, null);
+    }
+
+    public static void releaseShader() {
+        useShader(0);
+    }
+
+    public static boolean doUseShaders() {
+        return BuildConfig.visuals.useShaders && OpenGlHelper.shadersSupported;
+    }
+
+    private static int createProgram(String s, int sides) {
+        boolean vert = (sides & VERT) != 0;
+        boolean frag = (sides & FRAG) != 0;
+
+        return createProgram(vert ? s + VERT_EXTENSION : null, frag ? s + FRAG_EXTENSION : null);
+    }
+
+    // Most of the code taken from the LWJGL wiki
+    // http://lwjgl.org/wiki/index.php?title=GLSL_Shaders_with_LWJGL
+
+    private static int createProgram(String vert, String frag) {
+        int vertId = 0, fragId = 0, program;
+        if(vert != null)
+            vertId = createShader(vert, VERT_ST);
+        if(frag != null)
+            fragId = createShader(frag, FRAG_ST);
+
+        program = ARBShaderObjects.glCreateProgramObjectARB();
+        if(program == 0)
+            return 0;
+
+        if(vert != null)
+            ARBShaderObjects.glAttachObjectARB(program, vertId);
+        if(frag != null)
+            ARBShaderObjects.glAttachObjectARB(program, fragId);
+
+        ARBShaderObjects.glLinkProgramARB(program);
+        if(ARBShaderObjects.glGetObjectParameteriARB(program, ARBShaderObjects.GL_OBJECT_LINK_STATUS_ARB) == GL11.GL_FALSE) {
+            EffortlessBuilding.logger.log(Level.ERROR, getLogInfo(program));
+            return 0;
+        }
+
+        ARBShaderObjects.glValidateProgramARB(program);
+        if (ARBShaderObjects.glGetObjectParameteriARB(program, ARBShaderObjects.GL_OBJECT_VALIDATE_STATUS_ARB) == GL11.GL_FALSE) {
+            EffortlessBuilding.logger.log(Level.ERROR, getLogInfo(program));
+            return 0;
+        }
+
+        return program;
+    }
+
+    private static int createShader(String filename, int shaderType){
+        int shader = 0;
+        try {
+            shader = ARBShaderObjects.glCreateShaderObjectARB(shaderType);
+
+            if(shader == 0)
+                return 0;
+
+            ARBShaderObjects.glShaderSourceARB(shader, readFileAsString(filename));
+            ARBShaderObjects.glCompileShaderARB(shader);
+
+            if (ARBShaderObjects.glGetObjectParameteriARB(shader, ARBShaderObjects.GL_OBJECT_COMPILE_STATUS_ARB) == GL11.GL_FALSE)
+                throw new RuntimeException("Error creating shader: " + getLogInfo(shader));
+
+            return shader;
+        }
+        catch(Exception e) {
+            ARBShaderObjects.glDeleteObjectARB(shader);
+            e.printStackTrace();
+            return -1;
+        }
+    }
+
+    private static String getLogInfo(int obj) {
+        return ARBShaderObjects.glGetInfoLogARB(obj, ARBShaderObjects.glGetObjectParameteriARB(obj, ARBShaderObjects.GL_OBJECT_INFO_LOG_LENGTH_ARB));
+    }
+
+    private static String readFileAsString(String filename) throws Exception {
+        StringBuilder source = new StringBuilder();
+        InputStream in = ShaderHandler.class.getResourceAsStream(filename);
+        Exception exception = null;
+        BufferedReader reader;
+
+        if(in == null)
+            return "";
+
+        try {
+            reader = new BufferedReader(new InputStreamReader(in, StandardCharsets.UTF_8));
+
+            Exception innerExc= null;
+            try {
+                String line;
+                while((line = reader.readLine()) != null)
+                    source.append(line).append('\n');
+            } catch(Exception exc) {
+                exception = exc;
+            } finally {
+                try {
+                    reader.close();
+                } catch(Exception exc) {
+                    innerExc = exc;
+                }
+            }
+
+            if(innerExc != null)
+                throw innerExc;
+        } catch(Exception exc) {
+            exception = exc;
+        } finally {
+            try {
+                in.close();
+            } catch(Exception exc) {
+                if(exception == null)
+                    exception = exc;
+                else exc.printStackTrace();
+            }
+
+            if(exception != null)
+                throw exception;
+        }
+
+        return source.toString();
+    }
+
+}

src/main/resources/assets/effortlessbuilding/lang/en_us.lang

@@ -1,5 +1,52 @@
 key.effortlessbuilding.category=Effortless Building
-key.hud.desc=Open Settings
+key.effortlessbuilding.hud.desc=Modifier Menu
-key.replace.desc=Switch Replace Mode
+key.effortlessbuilding.replace.desc=Toggle QuickReplace
+key.effortlessbuilding.creative.desc=Toggle Survival/Creative Mode
+key.effortlessbuilding.mode.desc=Radial Menu
+key.effortlessbuilding.undo.desc=Undo
+key.effortlessbuilding.redo.desc=Redo
+key.effortlessbuilding.altplacement.desc=Alternative placement
 
 item.effortlessbuilding:randomizer_bag.name=Randomizer Bag
+item.effortlessbuilding:reach_upgrade1.name=Reach Upgrade 1
+item.effortlessbuilding:reach_upgrade2.name=Reach Upgrade 2
+item.effortlessbuilding:reach_upgrade3.name=Reach Upgrade 3
+
+effortlessbuilding.mode.normal=Normal
+effortlessbuilding.mode.normal_plus=Normal+
+effortlessbuilding.mode.line=Line
+effortlessbuilding.mode.wall=Wall
+effortlessbuilding.mode.floor=Floor
+effortlessbuilding.mode.diagonal_line=Diagonal Line
+effortlessbuilding.mode.diagonal_wall=Diagonal Wall
+effortlessbuilding.mode.slope_floor=Slope Floor
+effortlessbuilding.mode.cube=Cube
+effortlessbuilding.mode.circle=Circle
+effortlessbuilding.mode.cylinder=Cylinder
+effortlessbuilding.mode.sphere=Sphere
+
+effortlessbuilding.action.undo=Undo
+effortlessbuilding.action.redo=Redo
+effortlessbuilding.action.replace=Replace
+effortlessbuilding.action.open_modifier_settings=Open Modifier Settings
+
+effortlessbuilding.action.build_speed=Build Speed
+effortlessbuilding.action.filling=Filling
+effortlessbuilding.action.raised_edge=Raised Edge
+effortlessbuilding.action.thickness=Line Thickness
+effortlessbuilding.action.circle_start=Start Point
+
+effortlessbuilding.action.normal_speed=Normal
+effortlessbuilding.action.fast_speed=Fast
+effortlessbuilding.action.full=Filled
+effortlessbuilding.action.hollow=Hollow
+effortlessbuilding.action.skeleton=Skeleton
+effortlessbuilding.action.short_edge=Short Edge
+effortlessbuilding.action.long_edge=Long Edge
+effortlessbuilding.action.thickness_1=1 Block Thick
+effortlessbuilding.action.thickness_3=3 Blocks Thick
+effortlessbuilding.action.thickness_5=5 Blocks Thick
+effortlessbuilding.action.start_center=Middle
+effortlessbuilding.action.start_corner=Corner
+
+commands.reach.usage=/reach <level>

src/main/resources/assets/effortlessbuilding/models/item/randomizer_bag.json

@@ -1,6 +1,6 @@
 {
     "parent": "item/generated",
     "textures": {
-        "layer0": "items/fireball"
+        "layer0": "effortlessbuilding:items/randomizerbag"
     }
 }

src/main/resources/assets/effortlessbuilding/models/item/reach_upgrade1.json

@@ -0,0 +1,6 @@
+{
+    "parent": "item/generated",
+    "textures": {
+        "layer0": "effortlessbuilding:items/reachupgrade1"
+    }
+}

src/main/resources/assets/effortlessbuilding/models/item/reach_upgrade2.json

@@ -0,0 +1,6 @@
+{
+    "parent": "item/generated",
+    "textures": {
+        "layer0": "effortlessbuilding:items/reachupgrade2"
+    }
+}

src/main/resources/assets/effortlessbuilding/models/item/reach_upgrade3.json

@@ -0,0 +1,6 @@
+{
+    "parent": "item/generated",
+    "textures": {
+        "layer0": "effortlessbuilding:items/reachupgrade3"
+    }
+}

src/main/resources/assets/effortlessbuilding/recipes/_factories.json

@@ -0,0 +1,5 @@
+{
+    "conditions": {
+        "enable_reach_upgrades": "nl.requios.effortlessbuilding.helper.ReachConditionFactory"
+    }
+}