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 = "1.12.2-2.0"
+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.5.2768"
+    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.

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,47 +6,6 @@
 ##
 ##############################################################################
 
-# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS=""
-
-APP_NAME="Gradle"
-APP_BASE_NAME=`basename "$0"`
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD="maximum"
-
-warn ( ) {
-    echo "$*"
-}
-
-die ( ) {
-    echo
-    echo "$*"
-    echo
-    exit 1
-}
-
-# OS specific support (must be 'true' or 'false').
-cygwin=false
-msys=false
-darwin=false
-case "`uname`" in
-  CYGWIN* )
-    cygwin=true
-    ;;
-  Darwin* )
-    darwin=true
-    ;;
-  MINGW* )
-    msys=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"
@@ -61,9 +20,49 @@ while [ -h "$PRG" ] ; do
     fi
 done
 SAVED="`pwd`"
-cd "`dirname \"$PRG\"`/" >&-
+cd "`dirname \"$PRG\"`/" >/dev/null
 APP_HOME="`pwd -P`"
-cd "$SAVED" >&-
+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"
+
+warn () {
+    echo "$*"
+}
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+}
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "`uname`" in
+  CYGWIN* )
+    cygwin=true
+    ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
+esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
@@ -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/BuildConfig.java

@@ -52,10 +52,24 @@ public class BuildConfig {
                  "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"})
+        @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.",

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

@@ -39,7 +39,7 @@ public class EffortlessBuilding
 {
     public static final String MODID = "effortlessbuilding";
     public static final String NAME = "Effortless Building";
-    public static final String VERSION = "1.12.2-2.0";
+    public static final String VERSION = "1.12.2-2.16";
 
     @Mod.Instance(EffortlessBuilding.MODID)
     public static EffortlessBuilding instance;
@@ -86,14 +86,26 @@ public class EffortlessBuilding
         EffortlessBuilding.packetHandler.registerMessage(ModeSettingsMessage.MessageHandler.class, ModeSettingsMessage.class, 1, Side.SERVER);
         EffortlessBuilding.packetHandler.registerMessage(ModeSettingsMessage.MessageHandler.class, ModeSettingsMessage.class, 1, Side.CLIENT);
 
-        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 2, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ModeActionMessage.MessageHandler.class, ModeActionMessage.class, 2, Side.SERVER);
-        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 2, Side.CLIENT);
+        EffortlessBuilding.packetHandler.registerMessage(ModeActionMessage.MessageHandler.class, ModeActionMessage.class, 2, Side.CLIENT);
 
-        EffortlessBuilding.packetHandler.registerMessage(BlockBrokenMessage.MessageHandler.class, BlockBrokenMessage.class, 3, Side.SERVER);
+        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(CancelModeMessage.MessageHandler.class, CancelModeMessage.class, 4, Side.SERVER);
+        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(RequestLookAtMessage.MessageHandler.class, RequestLookAtMessage.class, 5, 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);
     }

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

@@ -5,11 +5,12 @@ 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.SoundEvent;
 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;
@@ -22,17 +23,25 @@ import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 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.BlockPlacedMessage;
+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
 {
@@ -77,35 +86,49 @@ public class EventHandler
 //    }
 
     @SubscribeEvent
-    //Only called serverside
+    //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 || modifierSettings.doQuickReplace()) {
+        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
+            //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(), (EntityPlayerMP) player);
+            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) {
+        if (event.getWorld().isRemote) return;
+
         //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())) {
+        if (buildMode != BuildModes.BuildModeEnum.NORMAL && ReachHelper.canBreakFar(event.getPlayer())) {
             event.setCanceled(true);
         } else {
-            //Normal mode, let vanilla handle block breaking
+            //NORMAL mode, let vanilla handle block breaking
             //But modifiers should still work
-            BuildModes.onBlockBroken(event);
+            //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());
         }
     }
 
@@ -145,4 +168,39 @@ public class EventHandler
 
         //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/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

@@ -4,12 +4,16 @@ 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 net.minecraftforge.event.world.BlockEvent;
 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.compatibility.CompatHelper;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
+import nl.requios.effortlessbuilding.helper.SurvivalHelper;
 import nl.requios.effortlessbuilding.network.BlockBrokenMessage;
 import nl.requios.effortlessbuilding.network.BlockPlacedMessage;
 
@@ -18,6 +22,8 @@ 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
@@ -26,22 +32,27 @@ public class BuildModes {
     public static Dictionary<EntityPlayer, Boolean> currentlyBreakingServer = new Hashtable<>();
 
     public enum BuildModeEnum {
-        Normal ("Normal", new Normal()),
+        NORMAL("effortlessbuilding.mode.normal", new Normal()),
-        NormalPlus ("Normal+", new NormalPlus()),
+        NORMAL_PLUS("effortlessbuilding.mode.normal_plus", new NormalPlus(), OptionEnum.BUILD_SPEED),
-        Line ("Line", new Line()),
+        LINE("effortlessbuilding.mode.line", new Line() /*, OptionEnum.THICKNESS*/),
-        Wall ("Wall", new Wall()),
+        WALL("effortlessbuilding.mode.wall", new Wall(), OptionEnum.FILL),
-        Floor ("Floor", new Floor()),
+        FLOOR("effortlessbuilding.mode.floor", new Floor(), OptionEnum.FILL),
-        DiagonalLine ("", new DiagonalLine()),
+        DIAGONAL_LINE("effortlessbuilding.mode.diagonal_line", new DiagonalLine() /*, OptionEnum.THICKNESS*/),
-        DiagonalWall ("", new DiagonalWall()),
+        DIAGONAL_WALL("effortlessbuilding.mode.diagonal_wall", new DiagonalWall() /*, OptionEnum.FILL*/),
-        SlopeFloor ("", new SlopeFloor()),
+        SLOPE_FLOOR("effortlessbuilding.mode.slope_floor", new SlopeFloor(), OptionEnum.RAISED_EDGE),
-        Cube ("", new Cube());
+        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) {
+        BuildModeEnum(String name, IBuildMode instance, OptionEnum... options) {
             this.name = name;
             this.instance = instance;
+            this.options = options;
         }
     }
 
@@ -61,7 +72,6 @@ public class BuildModes {
         ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
         ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
         BuildModeEnum buildMode = modeSettings.getBuildMode();
-        int maxReach = ReachHelper.getMaxReach(player);
 
         BlockPos startPos = null;
 
@@ -70,7 +80,8 @@ public class BuildModes {
 
             //Offset in direction of sidehit if not quickreplace and not replaceable
             boolean replaceable = player.world.getBlockState(startPos).getBlock().isReplaceable(player.world, startPos);
-            if (!modifierSettings.doQuickReplace() && !replaceable) {
+            boolean becomesDoubleSlab = SurvivalHelper.doesBecomeDoubleSlab(player, startPos, message.getSideHit());
+            if (!modifierSettings.doQuickReplace() && !replaceable && !becomesDoubleSlab) {
                 startPos = startPos.offset(message.getSideHit());
             }
 
@@ -80,7 +91,8 @@ public class BuildModes {
             }
 
             //Check if player reach does not exceed startpos
-            if (player.getPosition().distanceSq(startPos) > maxReach * maxReach) {
+            int maxReach = ReachHelper.getMaxReach(player);
+            if (buildMode != BuildModeEnum.NORMAL && player.getPosition().distanceSq(startPos) > maxReach * maxReach) {
                 EffortlessBuilding.log(player, "Placement exceeds your reach.");
                 return;
             }
@@ -107,7 +119,7 @@ public class BuildModes {
         Vec3d hitVec = buildMode.instance.getHitVec(player);
         if (hitVec == null) hitVec = message.getHitVec();
 
-        BuildModifiers.onBlockPlaced(player, coordinates, sideHit, hitVec);
+        BuildModifiers.onBlockPlaced(player, coordinates, sideHit, hitVec, message.getPlaceStartPos());
 
         //Only works when finishing a buildmode is equal to placing some blocks
         //No intermediate blocks allowed
@@ -117,19 +129,11 @@ public class BuildModes {
 
     //Use a network message to break blocks in the distance using clientside mouse input
     public static void onBlockBrokenMessage(EntityPlayer player, BlockBrokenMessage message) {
-        BlockPos blockPos = message.getBlockPos();
+        BlockPos startPos = message.isBlockHit() ? message.getBlockPos() : null;
-
+        onBlockBroken(player, startPos, true);
-        if (ReachHelper.canBreakFar(player) && message.isBlockHit() &&
-            !CompatHelper.chiselsAndBitsProxy.isHoldingChiselTool(EnumHand.MAIN_HAND)) {
-
-            BlockEvent.BreakEvent event = new BlockEvent.BreakEvent(player.world, blockPos, player.world.getBlockState(blockPos), player);
-            onBlockBroken(event);
-        }
     }
 
-    public static void onBlockBroken(BlockEvent.BreakEvent event) {
+    public static void onBlockBroken(EntityPlayer player, BlockPos startPos, boolean breakStartPos) {
-        EntityPlayer player = event.getPlayer();
-        BlockPos pos = event.getPos();
 
         //Check if not in the middle of placing
         Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
@@ -139,18 +143,30 @@ public class BuildModes {
             return;
         }
 
-        //get coordinates
+        //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, pos, EnumFacing.UP, Vec3d.ZERO, true);
+        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
+        //Let buildmodifiers break blocks
-        BuildModifiers.onBlockBroken(player, coordinates);
+        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) {
@@ -169,4 +185,61 @@ public class BuildModes {
 
         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/Cube.java

@@ -1,36 +0,0 @@
-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.ArrayList;
-import java.util.List;
-
-public class Cube implements IBuildMode {
-    @Override
-    public void initialize(EntityPlayer player) {
-
-    }
-
-    @Override
-    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace) {
-        return new ArrayList<>();
-    }
-
-    @Override
-    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace) {
-        return new ArrayList<>();
-    }
-
-    @Override
-    public EnumFacing getSideHit(EntityPlayer player) {
-        return null;
-    }
-
-    @Override
-    public Vec3d getHitVec(EntityPlayer player) {
-        return null;
-    }
-}

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

@@ -1,36 +0,0 @@
-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.ArrayList;
-import java.util.List;
-
-public class DiagonalLine implements IBuildMode {
-    @Override
-    public void initialize(EntityPlayer player) {
-
-    }
-
-    @Override
-    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace) {
-        return new ArrayList<>();
-    }
-
-    @Override
-    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace) {
-        return new ArrayList<>();
-    }
-
-    @Override
-    public EnumFacing getSideHit(EntityPlayer player) {
-        return null;
-    }
-
-    @Override
-    public Vec3d getHitVec(EntityPlayer player) {
-        return null;
-    }
-}

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

@@ -1,36 +0,0 @@
-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.ArrayList;
-import java.util.List;
-
-public class DiagonalWall implements IBuildMode {
-    @Override
-    public void initialize(EntityPlayer player) {
-
-    }
-
-    @Override
-    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace) {
-        return new ArrayList<>();
-    }
-
-    @Override
-    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace) {
-        return new ArrayList<>();
-    }
-
-    @Override
-    public EnumFacing getSideHit(EntityPlayer player) {
-        return null;
-    }
-
-    @Override
-    public Vec3d getHitVec(EntityPlayer player) {
-        return null;
-    }
-}

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

@@ -1,146 +0,0 @@
-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.RayTraceResult;
-import net.minecraft.util.math.Vec3d;
-import nl.requios.effortlessbuilding.helper.ReachHelper;
-
-import java.util.*;
-
-public class Floor 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
-    Dictionary<UUID, Integer> rightClickClientTable = new Hashtable<>();
-    Dictionary<UUID, Integer> rightClickServerTable = new Hashtable<>();
-    Dictionary<UUID, BlockPos> firstPosTable = new Hashtable<>();
-    Dictionary<UUID, EnumFacing> sideHitTable = new Hashtable<>();
-    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 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 wall
-
-            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 {
-            Vec3d look = player.getLookVec();
-            Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
-
-            //try on z axis
-            double y = firstPos.getY();
-
-            //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;
-
-            Vec3d yBound = new Vec3d(x, y, z);
-
-            //distance to player
-            double yDistSquared = yBound.subtract(start).lengthSquared();
-
-
-            int reach = ReachHelper.getPlacementReach(player) * 4; //4 times as much as normal placement reach
-
-            //check if its not behind the player and its not too close and not too far
-            boolean yValid = yBound.subtract(start).dotProduct(look) > 0 &&
-                             yDistSquared > 4 && yDistSquared < reach * reach;
-
-            //select the one that is closest to the player and is valid
-            Vec3d selected = null;
-            if (yValid) selected = yBound;
-
-            if (selected == null) return list;
-
-            //check if it doesnt go through blocks
-            if (!skipRaytrace) {
-                RayTraceResult rayTraceResult = player.world.rayTraceBlocks(start, selected, false, true, false);
-                if (rayTraceResult != null && rayTraceResult.typeOfHit == RayTraceResult.Type.BLOCK) {
-                    //return empty list
-                    return list;
-                }
-            }
-
-            BlockPos secondPos = new BlockPos(selected);
-
-            //Add whole wall
-            //Limit amount of blocks you can place per row
-            int limit = ReachHelper.getMaxBlocksPlacedAtOnce(player);
-
-            int x1 = firstPos.getX(), x2 = secondPos.getX();
-            int y1 = firstPos.getY(), y2 = secondPos.getY();
-            int z1 = firstPos.getZ(), z2 = secondPos.getZ();
-
-            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) {
-
-                    //check if whole row fits within limit
-                    if (Math.abs(y1 - y2) < limit - list.size()) {
-
-                        for (int m = y1; y1 < y2 ? m <= y2 : m >= y2; m += y1 < y2 ? 1 : -1) {
-                            list.add(new BlockPos(l, m, n));
-                        }
-                    }
-                }
-            }
-        }
-
-        return list;
-    }
-
-    @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/Line.java

@@ -1,222 +0,0 @@
-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.RayTraceResult;
-import net.minecraft.util.math.Vec3d;
-import nl.requios.effortlessbuilding.helper.ReachHelper;
-
-import java.util.*;
-
-public class Line 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
-    Dictionary<UUID, Integer> rightClickClientTable = new Hashtable<>();
-    Dictionary<UUID, Integer> rightClickServerTable = new Hashtable<>();
-    Dictionary<UUID, BlockPos> firstPosTable = new Hashtable<>();
-    Dictionary<UUID, EnumFacing> sideHitTable = new Hashtable<>();
-    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 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 wall
-
-            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 {
-            Vec3d look = player.getLookVec();
-            Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
-
-
-
-            //try on x axis
-            double x = firstPos.getX();
-
-            //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;
-
-            Vec3d xBound = new Vec3d(x, y, z);
-            Vec3d xBoundLine = toLongestLine(xBound, firstPos);
-            double xDistToLine = xBoundLine.subtract(xBound).lengthSquared();
-
-            //distance to player
-            double xDistSquared = xBound.subtract(start).lengthSquared();
-
-
-
-            //try on y axis
-            y = firstPos.getY();
-
-            //then x and z are
-            x = (y - start.y) / look.y * look.x + start.x;
-            z = (y - start.y) / look.y * look.z + start.z;
-
-            Vec3d yBound = new Vec3d(x, y, z);
-            Vec3d yBoundLine = toLongestLine(yBound, firstPos);
-            double yDistToLine = yBoundLine.subtract(yBound).lengthSquared();
-
-            //distance to player
-            double yDistSquared = yBound.subtract(start).lengthSquared();
-
-
-
-            //try on z axis
-            z = firstPos.getZ();
-
-            //then x and y are
-            x = (z - start.z) / look.z * look.x + start.x;
-            y = (z - start.z) / look.z * look.y + start.y;
-
-            Vec3d zBound = new Vec3d(x, y, z);
-            Vec3d zBoundLine = toLongestLine(zBound, firstPos);
-            double zDistToLine = zBoundLine.subtract(zBound).lengthSquared();
-
-            //distance to player
-            double zDistSquared = zBound.subtract(start).lengthSquared();
-
-
-
-            int reach = ReachHelper.getPlacementReach(player) * 4; //4 times as much as normal placement reach
-
-            //check if its not behind the player and its not too close and not too far
-            boolean xValid = xBound.subtract(start).dotProduct(look) > 0 &&
-                             xDistSquared > 4 && xDistSquared < reach * reach;
-
-            boolean yValid = yBound.subtract(start).dotProduct(look) > 0 &&
-                             yDistSquared > 4 && yDistSquared < reach * reach;
-
-            boolean zValid = zBound.subtract(start).dotProduct(look) > 0 &&
-                             zDistSquared > 4 && zDistSquared < reach * reach;
-
-            //select the one that is closest (from wall position to its line counterpart) and is valid
-            //TODO: if multiple are very close, choose closest to player
-            Vec3d selected = null;
-            double selectedDistToLine = 0;
-
-            if (xValid) {
-                selected = xBoundLine;
-                selectedDistToLine = xDistToLine;
-            } else if (yValid) {
-                selected = yBoundLine;
-                selectedDistToLine = yDistToLine;
-            } else if (zValid) {
-                selected = zBoundLine;
-                selectedDistToLine = yDistToLine;
-            }
-
-            if (yValid && yDistToLine < selectedDistToLine) selected = yBoundLine;
-            if (zValid && zDistToLine < selectedDistToLine) selected = zBoundLine;
-
-            if (selected == null) return list;
-
-            //check if it doesnt go through blocks
-            if (!skipRaytrace) {
-                RayTraceResult rayTraceResult = player.world.rayTraceBlocks(start, selected, false, true, false);
-                if (rayTraceResult != null && rayTraceResult.typeOfHit == RayTraceResult.Type.BLOCK) {
-                    //return empty list
-                    return list;
-                }
-            }
-
-            BlockPos secondPos = new BlockPos(selected);
-
-            int axisLimit = ReachHelper.getMaxBlocksPerAxis(player);
-
-            //Add whole line
-
-            int x1 = firstPos.getX(), x2 = secondPos.getX();
-            int y1 = firstPos.getY(), y2 = secondPos.getY();
-            int z1 = firstPos.getZ(), z2 = secondPos.getZ();
-
-            outerloop:
-            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) {
-                        if (list.size() >= axisLimit) break outerloop;
-                        list.add(new BlockPos(l, m, n));
-                    }
-                }
-            }
-        }
-
-        return list;
-    }
-
-    //Make it 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;
-    }
-
-    @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/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

@@ -3,8 +3,6 @@ package nl.requios.effortlessbuilding.buildmode;
 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.EffortlessBuilding;
 import nl.requios.effortlessbuilding.capability.ModeCapabilityManager;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
@@ -55,7 +53,7 @@ public class ModeSettingsManager {
     }
 
     public static class ModeSettings {
-        private BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.Normal;
+        private BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.NORMAL;
 
         public ModeSettings() {
         }
@@ -73,25 +71,7 @@ public class ModeSettingsManager {
         }
     }
 
-    @SubscribeEvent
+    public static void handleNewPlayer(EntityPlayer player){
-    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);
-    }
-
-    @SubscribeEvent
-    public static void onPlayerChangedDimension(PlayerEvent.PlayerChangedDimensionEvent event) {
-        EntityPlayer player = event.player;
-        handleNewPlayer(player);
-    }
-
-    private static void handleNewPlayer(EntityPlayer player){
         if (getModeSettings(player) == null) {
             setModeSettings(player, new ModeSettings());
         }

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

@@ -1,36 +0,0 @@
-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.ArrayList;
-import java.util.List;
-
-public class SlopeFloor implements IBuildMode {
-    @Override
-    public void initialize(EntityPlayer player) {
-
-    }
-
-    @Override
-    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace) {
-        return new ArrayList<>();
-    }
-
-    @Override
-    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace) {
-        return new ArrayList<>();
-    }
-
-    @Override
-    public EnumFacing getSideHit(EntityPlayer player) {
-        return null;
-    }
-
-    @Override
-    public Vec3d getHitVec(EntityPlayer player) {
-        return null;
-    }
-}

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/Wall.java

@@ -1,179 +0,0 @@
-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.RayTraceResult;
-import net.minecraft.util.math.Vec3d;
-import nl.requios.effortlessbuilding.helper.ReachHelper;
-
-import java.util.*;
-
-public class Wall 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
-    Dictionary<UUID, Integer> rightClickClientTable = new Hashtable<>();
-    Dictionary<UUID, Integer> rightClickServerTable = new Hashtable<>();
-    Dictionary<UUID, BlockPos> firstPosTable = new Hashtable<>();
-    Dictionary<UUID, EnumFacing> sideHitTable = new Hashtable<>();
-    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 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 wall
-
-            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 {
-            Vec3d look = player.getLookVec();
-            Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
-
-            //try on x axis
-            double x = firstPos.getX();
-
-            //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;
-
-            Vec3d xBound = new Vec3d(x, y, z);
-
-            //distance to player
-            double xDistSquared = xBound.subtract(start).lengthSquared();
-
-            //angle to look
-            //double xAngle = xBound.subtract(new Vec3d(firstPos)).normalize().dotProduct(look);
-
-            //try on z axis
-            z = firstPos.getZ();
-
-            //then x and y are
-            x = (z - start.z) / look.z * look.x + start.x;
-            y = (z - start.z) / look.z * look.y + start.y;
-
-            Vec3d zBound = new Vec3d(x, y, z);
-
-            //distance to player
-            double zDistSquared = zBound.subtract(start).lengthSquared();
-
-            //angle to look
-            //double zAngle = zBound.subtract(new Vec3d(firstPos)).normalize().dotProduct(look);
-
-            int reach = ReachHelper.getPlacementReach(player) * 4; //4 times as much as normal placement reach
-            
-            //check if its not behind the player and its not too close and not too far
-            boolean xValid = xBound.subtract(start).dotProduct(look) > 0 &&
-                             xDistSquared > 4 && xDistSquared < reach * reach;
-            
-            boolean zValid = zBound.subtract(start).dotProduct(look) > 0 &&
-                             zDistSquared > 4 && zDistSquared < reach * reach;
-            
-            //select the one that is closest and is valid
-            Vec3d selected = null;
-            if (xValid)
-                selected = xBound;
-            else if (zValid)
-                selected = zBound;
-            if (zValid && zDistSquared < xDistSquared/*Math.abs(zAngle) < Math.abs(xAngle)*/) selected = zBound;
-
-            if (selected == null) return list;
-
-            //check if it doesnt go through blocks
-            if (!skipRaytrace) {
-                RayTraceResult rayTraceResult = player.world.rayTraceBlocks(start, selected, false, true, false);
-                if (rayTraceResult != null && rayTraceResult.typeOfHit == RayTraceResult.Type.BLOCK) {
-                    //return empty list
-                    return list;
-                }
-            }
-            
-            BlockPos secondPos = new BlockPos(selected);
-
-            //Add whole wall
-            //Limit amount of blocks you can place per row
-            int limit = ReachHelper.getMaxBlocksPlacedAtOnce(player);
-            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;
-            if (x1 - x2 > axisLimit) x2 = x1 - axisLimit;
-            if (y2 - y1 > axisLimit) y2 = y1 + axisLimit;
-            if (y1 - y2 > axisLimit) y2 = y1 - axisLimit;
-            if (z2 - z1 > axisLimit) z2 = z1 + axisLimit;
-            if (z1 - z2 > axisLimit) z2 = z1 - axisLimit;
-
-            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) {
-
-                    //check if whole row fits within limit
-                    if (Math.abs(y1 - y2) < limit - list.size()) {
-
-                        for (int m = y1; y1 < y2 ? m <= y2 : m >= y2; m += y1 < y2 ? 1 : -1) {
-                            list.add(new BlockPos(l, m, n));
-                        }
-                    }
-                }
-            }
-        }
-
-        return list;
-    }
-
-    @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/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

@@ -1,9 +1,10 @@
-package nl.requios.effortlessbuilding.buildmode;
+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;
@@ -17,14 +18,14 @@ public class Normal implements IBuildMode {
     @Override
     public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace) {
         List<BlockPos> list = new ArrayList<>();
-        list.add(blockPos);
+        if (blockPos != null) list.add(blockPos);
         return list;
     }
 
     @Override
     public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace) {
         List<BlockPos> list = new ArrayList<>();
-        list.add(blockPos);
+        if (blockPos != null) list.add(blockPos);
         return list;
     }
 

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

@@ -1,9 +1,10 @@
-package nl.requios.effortlessbuilding.buildmode;
+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;
@@ -17,14 +18,14 @@ public class NormalPlus implements IBuildMode {
     @Override
     public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec, boolean skipRaytrace) {
         List<BlockPos> list = new ArrayList<>();
-        list.add(blockPos);
+        if (blockPos != null) list.add(blockPos);
         return list;
     }
 
     @Override
     public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos, boolean skipRaytrace) {
         List<BlockPos> list = new ArrayList<>();
-        list.add(blockPos);
+        if (blockPos != null) list.add(blockPos);
         return list;
     }
 

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/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

@@ -3,7 +3,7 @@ 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.entity.player.EntityPlayerMP;
+import net.minecraft.init.Blocks;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumFacing;
@@ -11,21 +11,18 @@ 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.EffortlessBuilding;
 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.network.BlockPlacedMessage;
 import nl.requios.effortlessbuilding.render.BlockPreviewRenderer;
 
-import java.util.ArrayList;
+import java.util.*;
-import java.util.Arrays;
-import java.util.List;
 
 public class BuildModifiers {
 
     //Called from BuildModes
-    public static void onBlockPlaced(EntityPlayer player, List<BlockPos> startCoordinates, EnumFacing sideHit, Vec3d hitVec) {
+    public static void onBlockPlaced(EntityPlayer player, List<BlockPos> startCoordinates, EnumFacing sideHit, Vec3d hitVec, boolean placeStartPos) {
         World world = player.world;
         ItemRandomizerBag.renewRandomness();
 
@@ -40,49 +37,113 @@ public class BuildModifiers {
         //check if valid blockstates
         if (blockStates.size() == 0 || coordinates.size() != blockStates.size()) return;
 
-        if (world.isRemote) {
+        //remember previous blockstates for undo
-            BlockPreviewRenderer.onBlocksPlaced();
+        List<IBlockState> previousBlockStates = new ArrayList<>(coordinates.size());
-            return;
+        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 = 0; i < coordinates.size(); i++) {
+            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);
                     }
+                    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> posList) {
+    public static void onBlockBroken(EntityPlayer player, List<BlockPos> startCoordinates, boolean breakStartPos) {
         World world = player.world;
 
-        List<BlockPos> coordinates = findCoordinates(player, posList);
+        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();
-            return;
+
+            //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 = world.getBlockState(posList.get(0)).getBlockHardness(world, posList.get(0)) == 0f;
+            boolean onlyInstaBreaking = !player.isCreative() &&
+                                        world.getBlockState(startCoordinates.get(0)).getBlockHardness(world, startCoordinates.get(0)) == 0f;
 
             //break all those blocks
-        for (BlockPos coordinate : coordinates) {
+            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);
+                        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) {
@@ -183,6 +244,16 @@ public class BuildModifiers {
         if (coordinates1 == null && coordinates2 == null) return true;
         if (coordinates1 == null || coordinates2 == null) return false;
 
-        return coordinates1.equals(coordinates2);
+        //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/ModifierSettingsManager.java

@@ -3,8 +3,6 @@ package nl.requios.effortlessbuilding.buildmodifier;
 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.BuildConfig;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.capability.ModifierCapabilityManager;
@@ -171,33 +169,18 @@ public class ModifierSettingsManager {
                 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);
         }
     }
 
-    @SubscribeEvent
+    public static void handleNewPlayer(EntityPlayer player){
-    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);
-    }
-
-    @SubscribeEvent
-    public static void onPlayerChangedDimension(PlayerEvent.PlayerChangedDimensionEvent event) {
-        EntityPlayer player = event.player;
-        handleNewPlayer(player);
-    }
-
-    private static void handleNewPlayer(EntityPlayer player){
         if (getModifierSettings(player) == null) {
             setModifierSettings(player, new ModifierSettings());
         }

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/ModeCapabilityManager.java

@@ -3,8 +3,6 @@ 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;
@@ -66,7 +64,7 @@ public class ModeCapabilityManager {
 
             //TODO add mode settings
 
-            ModeSettings modeSettings = new ModeSettings(BuildModes.BuildModeEnum.Normal);
+            ModeSettings modeSettings = new ModeSettings(BuildModes.BuildModeEnum.NORMAL);
             instance.setModeData(modeSettings);
         }
     }

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

@@ -102,7 +102,10 @@ public class ModifierCapabilityManager {
 
             //MIRROR
             boolean mirrorEnabled = compound.getBoolean("mirrorEnabled");
-            Vec3d mirrorPosition = new Vec3d(compound.getDouble("mirrorPosX"), compound.getDouble("mirrorPosY"), compound.getDouble("mirrorPosZ"));
+            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");
@@ -113,7 +116,10 @@ public class ModifierCapabilityManager {
 
             //ARRAY
             boolean arrayEnabled = compound.getBoolean("arrayEnabled");
-            BlockPos arrayOffset = new BlockPos(compound.getInteger("arrayOffsetX"), compound.getInteger("arrayOffsetY"), compound.getInteger("arrayOffsetZ"));
+            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);
 
@@ -123,7 +129,10 @@ public class ModifierCapabilityManager {
 
             //RADIAL MIRROR
             boolean radialMirrorEnabled = compound.getBoolean("radialMirrorEnabled");
-            Vec3d radialMirrorPosition = new Vec3d(compound.getDouble("radialMirrorPosX"), compound.getDouble("radialMirrorPosY"), compound.getDouble("radialMirrorPosZ"));
+            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");
@@ -132,8 +141,7 @@ public class ModifierCapabilityManager {
             RadialMirror.RadialMirrorSettings radialMirrorSettings = new RadialMirror.RadialMirrorSettings(radialMirrorEnabled, radialMirrorPosition,
                     radialMirrorSlices, radialMirrorAlternate, radialMirrorRadius, radialMirrorDrawLines, radialMirrorDrawPlanes);
 
-            ModifierSettings
+            ModifierSettings modifierSettings = new ModifierSettings(mirrorSettings, arraySettings, radialMirrorSettings, false, reachUpgrade);
-                    modifierSettings = new ModifierSettings(mirrorSettings, arraySettings, radialMirrorSettings, false, reachUpgrade);
             instance.setModifierData(modifierSettings);
         }
     }

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

@@ -1,9 +1,11 @@
 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;
@@ -35,40 +37,54 @@ public class CompatHelper {
     // /dank/null, or plain old blocks.
     public static boolean isItemBlockProxy(ItemStack stack) {
         Item item = stack.getItem();
-        if(item instanceof ItemBlock)
+        if (item instanceof ItemBlock)
             return true;
-        if((item instanceof ItemRandomizerBag))
+        if ((item instanceof ItemRandomizerBag))
             return true;
-        if(item == dankNullItem)
+        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 stack) {
+    public static ItemStack getItemBlockFromStack(ItemStack proxy) {
-        Item item = stack.getItem();
+        Item proxyItem = proxy.getItem();
-        if(item instanceof ItemRandomizerBag) {
+
-            return ItemRandomizerBag.pickRandomStack(ItemRandomizerBag.getBagInventory(stack));
+        if (proxyItem instanceof ItemBlock)
-        } else if(item == dankNullItem) {
+            return proxy;
-            int index = 0;
+
-            if(stack.hasTagCompound() && stack.getTagCompound().hasKey("selectedIndex"))
+        //Randomizer Bag
-                index = stack.getTagCompound().getInteger("selectedIndex");
+        if (proxyItem instanceof ItemRandomizerBag) {
-            return stack.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null).getStackInSlot(index);
+            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)
+        if (stack.getItem() instanceof ItemBlock)
             return stack;
-        else if(stack.getItem() instanceof ItemRandomizerBag) {
+        else if (stack.getItem() instanceof ItemRandomizerBag) {
             IItemHandler bagInventory = ItemRandomizerBag.getBagInventory(stack);
             return ItemRandomizerBag.findStack(bagInventory, blockItem);
-        } else if(stack.getItem() == dankNullItem) {
+        } else if (stack.getItem() == dankNullItem) {
             int index = itemHandlerSlotForItem(stack, blockItem);
-            if(index >= 0)
+            if (index >= 0)
                 return stack.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null).getStackInSlot(index);
         }
         return ItemStack.EMPTY;
@@ -76,8 +92,11 @@ public class CompatHelper {
 
     // 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) {
+    public static void shrinkStack(ItemStack origStack, ItemStack curStack, EntityPlayer player) {
-        if(origStack.getItem() == dankNullItem) {
+        //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
@@ -86,10 +105,10 @@ public class CompatHelper {
 
     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++) {
+        for (int i = 0; i < handler.getSlots(); i++) {
             ItemStack ref = handler.getStackInSlot(i);
-            if(ref.getItem() instanceof ItemBlock)
+            if (ref.getItem() instanceof ItemBlock)
-                if(ref.getItem() == blockItem)
+                if (ref.getItem() == blockItem)
                     return i;
         }
         return -1;

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

@@ -109,26 +109,22 @@ public class RandomizerBagContainer extends Container {
     @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:
-        ItemStack clickItemStack = super.slotClick(slot, dragType, clickTypeIn, player);
+        if (slot >= 0 && getSlot(slot) != null && getSlot(slot).getStack().equals(player.getHeldItem(EnumHand.MAIN_HAND))) {
-        if (slot >= 0 && getSlot(slot) != null && getSlot(slot).getStack() == player.getHeldItem(EnumHand.MAIN_HAND)) {
             return ItemStack.EMPTY;
         }
-        return clickItemStack;
+        return super.slotClick(slot, dragType, clickTypeIn, player);
     }
 
     /**
      * Callback for when the crafting gui is closed.
      */
-//    @Override
+    @Override
-//    public void onContainerClosed(EntityPlayer player)
+    public void onContainerClosed(EntityPlayer player)
-//    {
+    {
-//        if(player.inventory.getItemStack() != null)
+        super.onContainerClosed(player);
-//        {
+        if(!player.world.isRemote)
-//            player.entityDropItem(player.inventory.getItemStack(), 0.5f);
+        {
-//        }
+            detectAndSendChanges();
-//        if(!player.world.isRemote)
+        }
-//        {
+    }
-//            detectAndSendChanges();
-//        }
-//    }
 }

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

@@ -3,8 +3,14 @@ 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;
@@ -20,6 +26,7 @@ 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
@@ -33,7 +40,7 @@ public class RadialMenu extends GuiScreen {
     private float visibility = 0.0f;
     private Stopwatch lastChange = Stopwatch.createStarted();
     public BuildModeEnum switchTo = null;
-    //public ButtonAction doAction = null;
+    public ActionEnum doAction = null;
     public boolean actionUsed = false;
 
     private float clampVis(final float f) {
@@ -50,6 +57,10 @@ public class RadialMenu extends GuiScreen {
         lastChange = Stopwatch.createStarted();
     }
 
+    public void setVisibility(float visibility) {
+        this.visibility = visibility;
+    }
+
     public boolean isVisible() {
         return visibility > 0.001;
     }
@@ -67,34 +78,18 @@ public class RadialMenu extends GuiScreen {
         public double y1, y2;
         public boolean highlighted;
 
-        //public final ButtonAction action;
+        public final ActionEnum action;
-        public TextureAtlasSprite icon;
-        public int color;
         public String name;
         public EnumFacing textSide;
 
-        public MenuButton(final String name, /*final ButtonAction action,*/ final double x, final double y,
+        public MenuButton(final String name, final ActionEnum action, final double x, final double y,
-                final TextureAtlasSprite ico, final EnumFacing textSide) {
+                final EnumFacing textSide) {
-            this.name = name;
+            this.name = I18n.format(name);
-            //this.action = action;
+            this.action = action;
-            x1 = x;
+            x1 = x - 10;
-            x2 = x + 18;
+            x2 = x + 10;
-            y1 = y;
+            y1 = y - 10;
-            y2 = y + 18;
+            y2 = y + 10;
-            icon = ico;
-            color = 0xffffff;
-            this.textSide = textSide;
-        }
-
-        public MenuButton(final String name, /*final ButtonAction action,*/ final double x, final double y,
-                final int col, final EnumFacing textSide) {
-            this.name = name;
-            //this.action = action;
-            x1 = x;
-            x2 = x + 18;
-            y1 = y;
-            y2 = y + 18;
-            color = col;
             this.textSide = textSide;
         }
 
@@ -115,13 +110,9 @@ public class RadialMenu extends GuiScreen {
 
     @Override
     public void drawScreen(final int mouseX, final int mouseY, final float partialTicks) {
-        //TODO chisels compat
+        if (!isVisible()) return;
-//        final ChiselToolType tool = ClientSide.instance.getHeldToolType( EnumHand.MAIN_HAND );
+
-//
+        BuildModeEnum currentBuildMode = ModeSettingsManager.getModeSettings(Minecraft.getMinecraft().player).getBuildMode();
-//        if ( tool != null )
-//        {
-//            return;
-//        }
 
         GlStateManager.pushMatrix();
         GlStateManager.translate( 0.0F, 0.0F, 200.0F );
@@ -148,9 +139,10 @@ public class RadialMenu extends GuiScreen {
         final double mouseYCenter = mouseY - middleY;
         double mouseRadians = Math.atan2(mouseYCenter, mouseXCenter);
 
-        final double ringInnerEdge = 20;
+        final double ringInnerEdge = 30;
-        final double ringOuterEdge = 50;
+        final double ringOuterEdge = 65;
-        final double textDistance = 65;
+        final double textDistance = 75;
+        final double buttonDistance = 105;
         final double quarterCircle = Math.PI / 2.0;
 
         if ( mouseRadians < -quarterCircle ) {
@@ -160,16 +152,30 @@ public class RadialMenu extends GuiScreen {
         final ArrayList<MenuRegion> modes = new ArrayList<MenuRegion>();
         final ArrayList<MenuButton> buttons = new ArrayList<MenuButton>();
 
-//        buttons.add( new MenuButton( "mod.chiselsandbits.other.undo", ButtonAction.UNDO, textDistance, -20, ClientSide.undoIcon, EnumFacing.EAST ) );
+        //Add build modes
-//        buttons.add( new MenuButton( "mod.chiselsandbits.other.redo", ButtonAction.REDO, textDistance, 4, ClientSide.redoIcon, EnumFacing.EAST ) );
-
         for (final BuildModeEnum mode : BuildModeEnum.values()) {
             modes.add(new MenuRegion(mode));
         }
 
-        switchTo = null;
+        //Add actions
-        //doAction = null;
+        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;
@@ -203,7 +209,7 @@ public class RadialMenu extends GuiScreen {
                 float a = 0.5f;
 
                 //check if current mode
-                int buildMode = ModeSettingsManager.getModeSettings(Minecraft.getMinecraft().player).getBuildMode().ordinal();
+                int buildMode = currentBuildMode.ordinal();
                 if (buildMode == i) {
                     r = 0f;
                     g = 0.5f;
@@ -217,9 +223,9 @@ public class RadialMenu extends GuiScreen {
                                               || inTriangle(x1m1, y1m1, x1m2, y1m2, x2m2, y2m2, mouseXCenter, mouseYCenter);
 
                 if (beginRadians <= mouseRadians && mouseRadians <= endRadians && isMouseInQuad) {
-                    r = 0.6f;//0.6f;
+                    r = 0.6f;
-                    g = 0.8f;//0.3f;
+                    g = 0.8f;
-                    b = 1f;//0.0f;
+                    b = 1f;
                     a = 0.6f;
                     menuRegion.highlighted = true;
                     switchTo = menuRegion.mode;
@@ -234,20 +240,40 @@ public class RadialMenu extends GuiScreen {
             }
         }
 
+        //Draw action backgrounds
         for (final MenuButton btn : buttons) {
-            final float a = 0.5f;
+            float r = 0.5f;
-            float f = 0f;
+            float g = 0.5f;
+            float b = 0.5f;
+            float a = 0.5f;
 
-            if (btn.x1 <= mouseXCenter && btn.x2 >= mouseXCenter && btn.y1 <= mouseYCenter && btn.y2 >= mouseYCenter) {
+            //highlight when active option
-                f = 1;
+            if (btn.action == getBuildSpeed() ||
-                btn.highlighted = true;
+                btn.action == getFill() ||
-                //doAction = btn.action;
+                btn.action == getCubeFill() ||
+                btn.action == getRaisedEdge() ||
+                btn.action == getLineThickness() ||
+                btn.action == getCircleStart()) {
+                r = 0.0f;
+                g = 0.5f;
+                b = 1f;
+                a = 0.6f;
             }
 
-            buffer.pos(middleX + btn.x1, middleY + btn.y1, zLevel).color(f, f, f, a).endVertex();
+            //highlight when mouse over
-            buffer.pos(middleX + btn.x1, middleY + btn.y2, zLevel).color(f, f, f, a).endVertex();
+            if (btn.x1 <= mouseXCenter && btn.x2 >= mouseXCenter && btn.y1 <= mouseYCenter && btn.y2 >= mouseYCenter) {
-            buffer.pos(middleX + btn.x2, middleY + btn.y2, zLevel).color(f, f, f, a).endVertex();
+                r = 0.6f;
-            buffer.pos(middleX + btn.x2, middleY + btn.y1, zLevel).color(f, f, f, a).endVertex();
+                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();
@@ -263,72 +289,83 @@ public class RadialMenu extends GuiScreen {
 
         buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX_COLOR);
 
-        for (final MenuRegion mnuRgn : modes) {
+        //Draw buildmode icons
+        for (final MenuRegion menuRegion : modes) {
 
-            final double x = (mnuRgn.x1 + mnuRgn.x2) * 0.5 * (ringOuterEdge * 0.6 + 0.4 * ringInnerEdge);
+            final double x = (menuRegion.x1 + menuRegion.x2) * 0.5 * (ringOuterEdge * 0.6 + 0.4 * ringInnerEdge);
-            final double y = (mnuRgn.y1 + mnuRgn.y2) * 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(mnuRgn.mode);
+            final TextureAtlasSprite sprite = ClientProxy.getBuildModeIcon(menuRegion.mode);
 
-            final double scalex = 16 * 0.5;
+            final double x1 = x - 8;
-            final double scaley = 16 * 0.5;
+            final double x2 = x + 8;
-            final double x1 = x - scalex;
+            final double y1 = y - 8;
-            final double x2 = x + scalex;
+            final double y2 = y + 8;
-            final double y1 = y - scaley;
-            final double y2 = y + scaley;
 
             final float f = 1f;
             final float a = 1f;
 
-            final double u1 = 0f;
-            final double u2 = 16f;
-            final double v1 = 0f;
-            final double v2 = 16f;
-
-            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();
-        }
-
-        for (final MenuButton btn : buttons) {
-
-            final float f = switchTo == null ? 1.0f : 0.5f;
-            final float a = 1.0f;
-
             final double u1 = 0;
             final double u2 = 16;
             final double v1 = 0;
             final double v2 = 16;
 
-            final TextureAtlasSprite sprite = btn.icon == null ? Minecraft.getMinecraft().getTextureMapBlocks().getAtlasSprite(ModelLoader.White.LOCATION.toString()) : btn.icon;
+            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();
+        }
 
-            final double btnx1 = btn.x1 + 1;
+        //Draw action icons
-            final double btnx2 = btn.x2 - 1;
+        for (final MenuButton button : buttons) {
-            final double btny1 = btn.y1 + 1;
-            final double btny2 = btn.y2 - 1;
 
-            final float red = f * ((btn.color >> 16 & 0xff) / 255.0f);
+            final float f = 1f;
-            final float green = f * ((btn.color >> 8 & 0xff) / 255.0f);
+            final float a = 1f;
-            final float blue = f * ((btn.color & 0xff) / 255.0f);
 
-            buffer.pos(middleX + btnx1, middleY + btny1, zLevel).tex(sprite.getInterpolatedU(u1), sprite.getInterpolatedV(v1)).color(red, green, blue, a).endVertex();
+            final double u1 = 0;
-            buffer.pos(middleX + btnx1, middleY + btny2, zLevel).tex(sprite.getInterpolatedU(u1), sprite.getInterpolatedV(v2)).color(red, green, blue, a).endVertex();
+            final double u2 = 16;
-            buffer.pos(middleX + btnx2, middleY + btny2, zLevel).tex(sprite.getInterpolatedU(u2), sprite.getInterpolatedV(v2)).color(red, green, blue, a).endVertex();
+            final double v1 = 0;
-            buffer.pos(middleX + btnx2, middleY + btny1, zLevel).tex(sprite.getInterpolatedU(u2), sprite.getInterpolatedV(v1)).color(red, green, blue, a).endVertex();
+            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();
 
-        for (final MenuRegion mnuRgn : modes) {
+        //Draw strings
+        //fontRenderer.drawStringWithShadow("Actions", (int) (middleX - buttonDistance - 13) - fontRenderer.getStringWidth("Actions") * 0.5f, (int) middleY - 38, 0xffffffff);
 
-            if (mnuRgn.highlighted) {
+        //Draw option strings
-                final double x = (mnuRgn.x1 + mnuRgn.x2) * 0.5;
+        for (int i = 0; i < currentBuildMode.options.length; i++) {
-                final double y = (mnuRgn.y1 + mnuRgn.y2) * 0.5;
+            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);
+                final int fixed_y = (int) (y * textDistance) - fontRenderer.FONT_HEIGHT / 2;
-                final String text = mnuRgn.mode.name;
+                final String text = I18n.format(menuRegion.mode.name);
 
                 if ( x <= -0.2 ) {
                     fixed_x -= fontRenderer.getStringWidth(text);
@@ -340,29 +377,62 @@ public class RadialMenu extends GuiScreen {
             }
         }
 
-        for (final MenuButton btn : buttons) {
+        //Draw action text
-            if (btn.highlighted) {
+        for (final MenuButton button : buttons) {
-                final String text = btn.name;
+            if (button.highlighted) {
+                String text = TextFormatting.AQUA + button.name;
+                int wrap = 120;
+                String keybind = "";
+                String keybindFormatted = "";
 
-                if (btn.textSide == EnumFacing.WEST) {
+                //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) + ")";
 
-                    fontRenderer.drawStringWithShadow( text, (int) ( middleX + btn.x1 - 8 ) - fontRenderer.getStringWidth( text ),
+                if (button.textSide == EnumFacing.WEST) {
-                            (int) ( middleY + btn.y1 + 6 ), 0xffffffff );
 
-                } else if (btn.textSide == EnumFacing.EAST) {
+                    fontRenderer.drawSplitString( text, (int) (middleX + button.x1 - 8 ) - fontRenderer.getStringWidth(text),
+                            (int) (middleY + button.y1 + 6), wrap, 0xffffffff);
 
-                    fontRenderer.drawStringWithShadow( text, (int) ( middleX + btn.x2 + 8 ),
+                } else if (button.textSide == EnumFacing.EAST) {
-                            (int) ( middleY + btn.y1 + 6 ), 0xffffffff );
 
-                } else if (btn.textSide == EnumFacing.UP) {
+                    fontRenderer.drawSplitString(text, (int) (middleX + button.x2 + 8),
+                            (int) (middleY + button.y1 + 6 ), wrap, 0xffffffff);
 
-                    fontRenderer.drawStringWithShadow( text, (int) ( middleX + ( btn.x1 + btn.x2 ) * 0.5 - fontRenderer.getStringWidth( text ) * 0.5 ),
+                } else if (button.textSide == EnumFacing.UP || button.textSide == EnumFacing.NORTH) {
-                            (int) ( middleY + btn.y1 - 14 ), 0xffffffff );
 
-                } else if (btn.textSide == EnumFacing.DOWN) {
+                    fontRenderer.drawSplitString( keybindFormatted, (int) (middleX + (button.x1 + button.x2) * 0.5 - fontRenderer.getStringWidth(keybindFormatted) * 0.5),
+                            (int) (middleY + button.y1 - 26), wrap,0xffffffff);
 
-                    fontRenderer.drawStringWithShadow( text, (int) ( middleX + ( btn.x1 + btn.x2 ) * 0.5 - fontRenderer.getStringWidth( text ) * 0.5 ),
+                    fontRenderer.drawSplitString( text, (int) (middleX + (button.x1 + button.x2) * 0.5 - fontRenderer.getStringWidth(text) * 0.5),
-                            (int) ( middleY + btn.y1 + 24 ), 0xffffffff );
+                            (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);
 
                 }
 
@@ -387,14 +457,20 @@ public class RadialMenu extends GuiScreen {
     /**
      * Called when the mouse is clicked. Args : mouseX, mouseY, clickedButton
      */
+    @Override
     protected void mouseClicked(int mouseX, int mouseY, int mouseButton ) {
-        if (mouseButton == 0) {
+        EffortlessBuilding.log("mouse clicked");
-            this.mc.displayGuiScreen(null);
 
-            if (this.mc.currentScreen == null) {
+//        KeyBinding.updateKeyBindState();
-                this.mc.setIngameFocus();
+//        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/elements/GuiScrollPane.java

@@ -10,6 +10,7 @@ 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;
@@ -73,22 +74,24 @@ public class GuiScrollPane extends GuiListExtended {
             int insideLeft = this.left + this.width / 2 - this.getListWidth() / 2 + 2;
             int insideTop = this.top + 4 - (int)this.amountScrolled;
 
-            if (this.hasListHeader)
+            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();
@@ -96,6 +99,7 @@ public class GuiScrollPane extends GuiListExtended {
 //            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();
@@ -103,6 +107,7 @@ public class GuiScrollPane extends GuiListExtended {
 //            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();
@@ -110,6 +115,7 @@ public class GuiScrollPane extends GuiListExtended {
 //            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();
@@ -137,12 +143,14 @@ public class GuiScrollPane extends GuiListExtended {
                 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();
@@ -184,8 +192,7 @@ public class GuiScrollPane extends GuiListExtended {
     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 = posY - this.top - this.headerPadding + (int)this.amountScrolled - 4; //click height in content dimensions
+        int relativeMouseY = getRelativeMouseY(mouseY, 0);
-        //int slotIndex = relativeMouseY / this.slotHeight;
 
         //Iterate over every entry until relativeMouseY falls within its height
         for (int i = 0; i < listEntries.size(); i++) {
@@ -201,24 +208,32 @@ public class GuiScrollPane extends GuiListExtended {
     @Override
     public boolean mouseClicked(int mouseX, int mouseY, int mouseEvent)
     {
-        if (this.isMouseYWithinSlotBounds(mouseY))
+        int selectedSlot = this.getSlotIndexFromScreenCoords(mouseX, mouseY);
-        {
+        int relativeX = getRelativeMouseX(mouseX);
-            int i = this.getSlotIndexFromScreenCoords(mouseX, mouseY);
 
-            if (i >= 0)
+        //Always pass through mouseclicked, to be able to unfocus textfields
-            {
+        for (int i = 0; i < this.listEntries.size(); i++) {
-                int j = this.left + this.width / 2 - this.getListWidth() / 2 + 2;
+            int relativeY = getRelativeMouseY(mouseY, i);
-                int k = this.top + 4 - this.getAmountScrolled() + getContentHeight(i) + this.headerPadding;
+            this.getListEntry(i).mousePressed(selectedSlot, mouseX, mouseY, mouseEvent, relativeX, relativeY);
-                int relativeX = mouseX - j;
+        }
-                int relativeY = mouseY - k;
 
-                if (this.getListEntry(i).mousePressed(i, mouseX, mouseY, mouseEvent, relativeX, relativeY))
+
-                {
+//        if (this.isMouseYWithinSlotBounds(mouseY))
-                    this.setEnabled(false);
+//        {
-                    return true;
+//            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;
     }
@@ -228,10 +243,8 @@ public class GuiScrollPane extends GuiListExtended {
     {
         for (int i = 0; i < this.getSize(); ++i)
         {
-            int j = this.left + this.width / 2 - this.getListWidth() / 2 + 2;
+            int relativeX = getRelativeMouseX(mouseX);
-            int k = this.top + 4 - this.getAmountScrolled() + getContentHeight(i) + this.headerPadding;
+            int relativeY = getRelativeMouseY(mouseY, i);
-            int relativeX = x - j;
-            int relativeY = y - k;
             this.getListEntry(i).mouseReleased(i, x, y, mouseEvent, relativeX, relativeY);
         }
 
@@ -246,9 +259,8 @@ public class GuiScrollPane extends GuiListExtended {
                 this.mouseY <= this.bottom) {
                 int i = this.left + (this.width - this.getListWidth()) / 2;
                 int j = this.left + (this.width + this.getListWidth()) / 2;
-                int relativeMouseY = this.mouseY - this.top - this.headerPadding + (int) this.amountScrolled -
-                                     4; //click height in content dimensions
                 int slotIndex = getSlotIndexFromScreenCoords(this.mouseX, this.mouseY);
+                int relativeMouseY = getRelativeMouseY(mouseY, slotIndex);
 
                 if (slotIndex > -1) {
                     this.elementClicked(slotIndex, false, this.mouseX, this.mouseY);
@@ -265,9 +277,8 @@ public class GuiScrollPane extends GuiListExtended {
                     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 relativeMouseY = this.mouseY - this.top - this.headerPadding + (int) this.amountScrolled -
-                                             4; //click height in content dimensions
                         int slotIndex = getSlotIndexFromScreenCoords(this.mouseX, this.mouseY);
+                        int relativeMouseY = getRelativeMouseY(mouseY, slotIndex);
 
                         if (slotIndex > -1) {
                             boolean flag = slotIndex == this.selectedElement &&
@@ -383,6 +394,26 @@ public class GuiScrollPane extends GuiListExtended {
         }
     }
 
+    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) {

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/ReachHelper.java

@@ -28,12 +28,20 @@ public class ReachHelper {
 
     public static int getMaxBlocksPlacedAtOnce(EntityPlayer player) {
         if (player.isCreative()) return 1000000;
-        return getMaxReach(player) * 5;
+        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(MathHelper.sqrt(getMaxReach(player)));
+        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) {

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

@@ -2,34 +2,31 @@ 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.enchantment.EnchantmentHelper;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
 import net.minecraft.init.Blocks;
-import net.minecraft.init.Enchantments;
-import net.minecraft.item.Item;
 import net.minecraft.item.ItemBlock;
+import net.minecraft.item.ItemSlab;
 import net.minecraft.item.ItemStack;
-import net.minecraft.stats.StatList;
 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 net.minecraftforge.items.ItemHandlerHelper;
+import nl.requios.effortlessbuilding.BuildConfig;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.compatibility.CompatHelper;
 
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
-import java.util.ArrayList;
-import java.util.List;
 
 public class SurvivalHelper {
 
@@ -37,20 +34,29 @@ public class SurvivalHelper {
     //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 skipCollisionCheck, boolean playSound) {
+                                     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))
+        if (CompatHelper.isItemBlockProxy(itemstack))
             itemstack = CompatHelper.getItemBlockByState(itemstack, blockState);
 
-        if(!(itemstack.getItem() instanceof ItemBlock))
+        if (!(itemstack.getItem() instanceof ItemBlock))
             return false;
         Block block = ((ItemBlock) itemstack.getItem()).getBlock();
 
-        if (canPlace(world, player, pos, blockState, itemstack, skipCollisionCheck, facing.getOpposite())) {
+
+        //More manual with ItemBlock#placeBlockAt
+        if (skipPlaceCheck || canPlace(world, player, pos, blockState, itemstack, skipCollisionCheck, facing.getOpposite())) {
             //Drop existing block
             dropBlock(world, player, pos);
 
@@ -65,23 +71,46 @@ public class SurvivalHelper {
             }
 
             if (!player.isCreative() && Block.getBlockFromItem(itemstack.getItem()) == block) {
-                CompatHelper.shrinkStack(origstack, itemstack);
+                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) {
+    public static boolean breakBlock(World world, EntityPlayer player, BlockPos pos, boolean skipChecks) {
         if (!world.isBlockLoaded(pos, false)) return false;
 
         //Check if can break
-        if (canBreak(world, player, pos))
+        if (skipChecks || canBreak(world, player, pos)) {
-        {
+//            player.addStat(StatList.getBlockStats(world.getNewBlockState(pos).getBlock()));
-//            player.addStat(StatList.getBlockStats(world.getBlockState(pos).getBlock()));
 //            player.addExhaustion(0.005F);
 
             //Drop existing block
@@ -170,7 +199,14 @@ public class SurvivalHelper {
 
         IBlockState state = world.getBlockState(pos);
         state = state.getBlock().getActualState(state, world, pos);
-        if (state.getMaterial().isToolNotRequired()) return true;
+
+        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;
     }
@@ -202,6 +238,11 @@ public class SurvivalHelper {
             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) {
@@ -266,4 +307,29 @@ public class SurvivalHelper {
 
         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/item/ItemRandomizerBag.java

@@ -20,6 +20,9 @@ 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;
 
@@ -52,6 +55,14 @@ public class ItemRandomizerBag extends Item {
             player.openGui(EffortlessBuilding.instance, EffortlessBuilding.RANDOMIZER_BAG_GUI, world, 0, 0, 0);
         } else {
             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;
+            }
+
             //Use item
             //Get bag inventory
             ItemStack bag = player.getHeldItem(hand);
@@ -73,7 +84,7 @@ public class ItemRandomizerBag extends Item {
             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, true);
+            SurvivalHelper.placeBlock(world, player, pos, blockState, toPlace, facing, new Vec3d(hitX, hitY, hitZ), false, false, true);
 
             //Synergy
             //Works without calling

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

@@ -55,12 +55,6 @@ public class ItemReachUpgrade1 extends Item {
         return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
     }
 
-    @Override
-    public ItemStack onItemUseFinish(ItemStack stack, World worldIn, EntityLivingBase entityLiving) {
-        EffortlessBuilding.log("used");
-        return ItemStack.EMPTY;
-    }
-
     @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);

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/BlockPlacedMessage.java

@@ -25,19 +25,22 @@ public class BlockPlacedMessage implements IMessage {
     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) {
+    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() {
@@ -56,6 +59,10 @@ public class BlockPlacedMessage implements IMessage {
         return hitVec;
     }
 
+    public boolean getPlaceStartPos() {
+        return placeStartPos;
+    }
+
     @Override
     public void toBytes(ByteBuf buf) {
         buf.writeBoolean(blockHit);
@@ -66,6 +73,7 @@ public class BlockPlacedMessage implements IMessage {
         buf.writeDouble(hitVec.x);
         buf.writeDouble(hitVec.y);
         buf.writeDouble(hitVec.z);
+        buf.writeBoolean(placeStartPos);
     }
 
     @Override
@@ -74,6 +82,7 @@ public class BlockPlacedMessage implements IMessage {
         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>

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

@@ -29,16 +29,12 @@ public class ModeSettingsMessage implements IMessage {
     @Override
     public void toBytes(ByteBuf buf) {
         buf.writeInt(modeSettings.getBuildMode().ordinal());
-
-        //TODO add mode settings
     }
 
     @Override
     public void fromBytes(ByteBuf buf) {
         BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.values()[buf.readInt()];
 
-        //TODO add mode settings
-
         modeSettings = new ModeSettings(buildMode);
     }
 

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

@@ -1,34 +1,49 @@
 package nl.requios.effortlessbuilding.network;
 
 import io.netty.buffer.ByteBuf;
-import net.minecraft.util.EnumFacing;
+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.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.BlockSet;
-import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
+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>
@@ -42,7 +57,15 @@ public class RequestLookAtMessage implements IMessage {
             if (ctx.side == Side.CLIENT){
                 //Received clientside
                 //Send back your info
-                return new BlockPlacedMessage(ClientProxy.previousLookAt);
+
+//                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

@@ -9,10 +9,12 @@ 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;
@@ -25,6 +27,9 @@ 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;
@@ -32,7 +37,6 @@ 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.Event;
 import net.minecraftforge.fml.common.eventhandler.EventPriority;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.common.gameevent.InputEvent;
@@ -41,6 +45,7 @@ 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.buildmode.ModeOptions;
 import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
 import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.gui.buildmode.RadialMenu;
@@ -52,6 +57,7 @@ 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)
@@ -59,11 +65,13 @@ 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) {
@@ -73,14 +81,24 @@ public class ClientProxy implements IProxy {
     @Override
     public void init(FMLInitializationEvent event) {
         // register key bindings
-        keyBindings = new KeyBinding[4];
+        keyBindings = new KeyBinding[7];
 
         // instantiate the key bindings
-        keyBindings[0] = new KeyBinding("key.effortlessbuilding.hud.desc", Keyboard.KEY_ADD, "key.effortlessbuilding.category");
+        keyBindings[0] = new KeyBinding("key.effortlessbuilding.hud.desc", KeyConflictContext.UNIVERSAL, Keyboard.KEY_ADD, "key.effortlessbuilding.category");
-        keyBindings[1] = new KeyBinding("key.effortlessbuilding.replace.desc", Keyboard.KEY_SUBTRACT, "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", Keyboard.KEY_NONE, "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", Keyboard.KEY_LMENU, "key.effortlessbuilding.category");
+        keyBindings[3] = new KeyBinding("key.effortlessbuilding.mode.desc", KeyConflictContext.IN_GAME, Keyboard.KEY_LMENU, "key.effortlessbuilding.category") {
-//        keyBindings[4] = new KeyBinding("Reload shaders", Keyboard.KEY_TAB, "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) {
@@ -136,130 +154,29 @@ public class ClientProxy implements IProxy {
             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);
     }
 
-    @SubscribeEvent
+    public static TextureAtlasSprite getModeOptionIcon(ModeOptions.ActionEnum action) {
-    public static void onMouseInput(InputEvent.MouseInputEvent event) {
+        return modeOptionIcons.get(action);
-        Minecraft mc = Minecraft.getMinecraft();
-        EntityPlayerSP player = mc.player;
-
-        if (Minecraft.getMinecraft().currentScreen != null ||
-            ModeSettingsManager.getModeSettings(player).getBuildMode() == BuildModes.BuildModeEnum.Normal ||
-            RadialMenu.instance.isVisible()) {
-            return;
-        }
-
-        if (mc.gameSettings.keyBindUseItem.isPressed()) {
-            //KeyBinding.setKeyBindState(mc.gameSettings.keyBindUseItem.getKeyCode(), false);
-
-            ItemStack currentItemStack = player.getHeldItem(EnumHand.MAIN_HAND);
-            if (CompatHelper.isItemBlockProxy(currentItemStack) && !player.isSneaking()) {
-
-                //find position in distance
-                RayTraceResult lookingAt = getLookingAt(player);
-                BuildModes.onBlockPlacedMessage(player, new BlockPlacedMessage(lookingAt));
-                EffortlessBuilding.packetHandler.sendToServer(new BlockPlacedMessage(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, blockPos, soundtype.getPlaceSound(), SoundCategory.BLOCKS,
-                            (soundtype.getVolume() + 1.0F) / 2.0F, soundtype.getPitch() * 0.8F);
-                    player.swingArm(EnumHand.MAIN_HAND);
-                }
-            }
-        }
-
-        if (mc.gameSettings.keyBindAttack.isKeyDown()) {
-            //KeyBinding.setKeyBindState(mc.gameSettings.keyBindAttack.getKeyCode(), false);
-
-            //Break block in distance in creative (or survival if enabled in config)
-            if (ReachHelper.canBreakFar(player)) {
-                if (breakCooldown <= 0) {
-                    breakCooldown = 6;
-                    RayTraceResult lookingAt = getLookingAt(player);
-
-                    BuildModes.onBlockBrokenMessage(player, new BlockBrokenMessage(lookingAt));
-                    EffortlessBuilding.packetHandler.sendToServer(new BlockBrokenMessage(lookingAt));
-
-                    //play sound
-                    if (lookingAt != null && lookingAt.typeOfHit == RayTraceResult.Type.BLOCK) {
-                        BlockPos blockPos = lookingAt.getBlockPos();
-                        IBlockState state = player.world.getBlockState(blockPos);
-                        SoundType soundtype = state.getBlock().getSoundType(state, player.world, blockPos, player);
-                        player.world.playSound(player, blockPos, soundtype.getBreakSound(), SoundCategory.BLOCKS,
-                                (soundtype.getVolume() + 1.0F) / 2.0F, soundtype.getPitch() * 0.8F);
-                        player.swingArm(EnumHand.MAIN_HAND);
-                    }
-                } else {
-                    breakCooldown--;
-                }
-            }
-
-            //EffortlessBuilding.packetHandler.sendToServer(new CancelModeMessage());
-
-        } else {
-            breakCooldown = 0;
-        }
-        event.setResult(Event.Result.ALLOW);
-    }
-
-    @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 HUD
-        if (keyBindings[0].isPressed()) {
-            //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 (Minecraft.getMinecraft().currentScreen == null) {
-                    Minecraft.getMinecraft().displayGuiScreen(new ModifierSettingsGui());
-                } else {
-                    player.closeScreen();
-                }
-            }
-        }
-
-        //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");
-            }
-        }
-
-//        if (keyBindings[4].isPressed()) {
-//            //TODO remove
-//            ShaderHandler.init();
-//            EffortlessBuilding.log(player, "Reloaded shaders");
-//        }
-
     }
 
     @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;
@@ -290,6 +207,188 @@ public class ClientProxy implements IProxy {
 
     }
 
+    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;
@@ -298,6 +397,7 @@ public class ClientProxy implements IProxy {
         }
     }
 
+    @Nullable
     public static RayTraceResult getLookingAt(EntityPlayer player) {
 //        World world = player.world;
 
@@ -310,4 +410,8 @@ public class ClientProxy implements IProxy {
         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/render/BlockPreviewRenderer.java

@@ -1,5 +1,6 @@
 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;
@@ -11,10 +12,8 @@ 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.math.BlockPos;
+import net.minecraft.util.SoundCategory;
-import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.*;
-import net.minecraft.util.math.RayTraceResult;
-import net.minecraft.util.math.Vec3d;
 import net.minecraftforge.fml.relauncher.Side;
 import net.minecraftforge.fml.relauncher.SideOnly;
 import nl.requios.effortlessbuilding.BuildConfig;
@@ -27,6 +26,7 @@ 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;
@@ -72,7 +72,8 @@ public class BlockPreviewRenderer {
 
     private static List<PlacedData> placedDataList = new ArrayList<>();
 
-    private static final int secondaryTextureUnit = 7;
+    private static final int primaryTextureUnit = 0;
+    private static final int secondaryTextureUnit = 2;
 
     public static void render(EntityPlayer player, ModifierSettings modifierSettings, ModeSettings modeSettings) {
 
@@ -99,7 +100,7 @@ public class BlockPreviewRenderer {
 
         //Render block previews
         RayTraceResult lookingAt = ClientProxy.getLookingAt(player);
-        if (modeSettings.getBuildMode() == BuildModes.BuildModeEnum.Normal) lookingAt = Minecraft.getMinecraft().objectMouseOver;
+        if (modeSettings.getBuildMode() == BuildModes.BuildModeEnum.NORMAL) lookingAt = Minecraft.getMinecraft().objectMouseOver;
 
         ItemStack mainhand = player.getHeldItemMainhand();
         boolean toolInHand = !(!mainhand.isEmpty() && CompatHelper.isItemBlockProxy(mainhand));
@@ -114,7 +115,8 @@ public class BlockPreviewRenderer {
 
             //Check if tool (or none) in hand
             boolean replaceable = player.world.getBlockState(startPos).getBlock().isReplaceable(player.world, startPos);
-            if (!modifierSettings.doQuickReplace() && !toolInHand && !replaceable) {
+            boolean becomesDoubleSlab = SurvivalHelper.doesBecomeDoubleSlab(player, startPos, lookingAt.sideHit);
+            if (!modifierSettings.doQuickReplace() && !toolInHand && !replaceable && !becomesDoubleSlab) {
                 startPos = startPos.offset(lookingAt.sideHit);
             }
 
@@ -131,9 +133,13 @@ public class BlockPreviewRenderer {
         //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) {
 
@@ -158,12 +164,7 @@ public class BlockPreviewRenderer {
 
                 List<BlockPos> newCoordinates = BuildModifiers.findCoordinates(player, startCoordinates);
 
-                Collections.sort(newCoordinates, (lhs, rhs) -> {
+                sortOnDistanceToPlayer(newCoordinates, player);
-                    // -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);
-                });
 
                 hitVec = new Vec3d(Math.abs(hitVec.x - ((int) hitVec.x)), Math.abs(hitVec.y - ((int) hitVec.y)),
                         Math.abs(hitVec.z - ((int) hitVec.z)));
@@ -194,22 +195,28 @@ public class BlockPreviewRenderer {
                     //if so, renew randomness of randomizer bag
                     ItemRandomizerBag.renewRandomness();
                     //and play sound (max once every tick)
-                    if (startCoordinates.size() > 1 && blockStates.size() > 1 && soundTime < ClientProxy.ticksInGame - 0) {
+                    if (newCoordinates.size() > 1 && blockStates.size() > 1 && soundTime < ClientProxy.ticksInGame - 0) {
                         soundTime = ClientProxy.ticksInGame;
-                        //player.playSound(EffortlessBuilding.SOUND_BUILD_CLICK, 0.2f, 1f);
+
-                        player.playSound(blockStates.get(0).getBlock().getSoundType(blockStates.get(0), player.world,
+                        if (blockStates.get(0) != null) {
-                                newCoordinates.get(0), player).getPlaceSound(), 0.3f, 1f);
+                            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();
 
-                        renderBlockPreviews(newCoordinates, blockStates, itemStacks, 0f, firstPos, secondPos, !breaking, breaking);
+                        blockCount = renderBlockPreviews(newCoordinates, blockStates, itemStacks, 0f, firstPos, secondPos, !breaking, breaking);
 
                         RenderHandler.endBlockPreviews();
                     } else {
@@ -220,12 +227,44 @@ public class BlockPreviewRenderer {
                         if (breaking) color = new Vec3d(1f, 0f, 0f);
 
                         for (int i = newCoordinates.size() - 1; i >= 0; i--) {
-                            RenderHandler.renderBlockOutline(newCoordinates.get(i), color);
+                            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();
@@ -244,7 +283,8 @@ public class BlockPreviewRenderer {
                     IBlockState blockState = player.world.getBlockState(coordinate);
                     if (!blockState.getBlock().isAir(blockState, player.world, coordinate)) {
                         if (SurvivalHelper.canBreak(player.world, player, coordinate) || i == 0) {
-                            RenderHandler.renderBlockOutline(coordinate, new Vec3d(0f, 0f, 0f));
+                            AxisAlignedBB boundingBox = blockState.getBoundingBox(player.world, coordinate);
+                            RenderHandler.renderBlockOutline(coordinate, boundingBox, new Vec3d(0f, 0f, 0f));
                         }
                     }
                 }
@@ -255,19 +295,20 @@ public class BlockPreviewRenderer {
 
     //Whether to draw any block previews or outlines
     public static boolean doRenderBlockPreviews(ModifierSettings modifierSettings, ModeSettings modeSettings, BlockPos startPos) {
-        return modeSettings.getBuildMode() != BuildModes.BuildModeEnum.Normal ||
+        return modeSettings.getBuildMode() != BuildModes.BuildModeEnum.NORMAL ||
                (startPos != null && BuildModifiers.isEnabled(modifierSettings, startPos)) ||
                BuildConfig.visuals.alwaysShowBlockPreview;
     }
 
-    protected static void renderBlockPreviews(List<BlockPos> coordinates, List<IBlockState> blockStates,
+    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;
+        if (coordinates.isEmpty()) return blocksValid;
 
         for (int i = coordinates.size() - 1; i >= 0; i--) {
             BlockPos blockPos = coordinates.get(i);
@@ -278,50 +319,64 @@ public class BlockPreviewRenderer {
 
             //Check if can place
             //If check is turned off, check if blockstate is the same (for dissolve effect)
-            if ((!checkCanPlace /*&& player.world.getBlockState(blockPos) == blockState*/) ||
+            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, previousFirstPos)) {
+        if (doRenderBlockPreviews(modifierSettings, modeSettings, firstPos)) {
 
             //Save current coordinates, blockstates and itemstacks
-            if (!previousCoordinates.isEmpty() && previousBlockStates.size() == previousCoordinates.size() &&
+            if (!coordinates.isEmpty() && blockStates.size() == coordinates.size() &&
-                previousCoordinates.size() > 1 && previousCoordinates.size() < BuildConfig.visuals.shaderTreshold) {
+                coordinates.size() > 1 && coordinates.size() < BuildConfig.visuals.shaderTreshold) {
 
-                placedDataList.add(new PlacedData(ClientProxy.ticksInGame, previousCoordinates, previousBlockStates,
+                placedDataList.add(new PlacedData(ClientProxy.ticksInGame, coordinates, blockStates,
-                        previousItemStacks, previousFirstPos, previousSecondPos, false));
+                        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, previousFirstPos)) {
+        if (doRenderBlockPreviews(modifierSettings, modeSettings, firstPos)) {
 
             //Save current coordinates, blockstates and itemstacks
-            if (!previousCoordinates.isEmpty() && previousBlockStates.size() == previousCoordinates.size() &&
+            if (!coordinates.isEmpty() && blockStates.size() == coordinates.size() &&
-                previousCoordinates.size() > 1 && previousCoordinates.size() < BuildConfig.visuals.shaderTreshold) {
+                coordinates.size() > 1 && coordinates.size() < BuildConfig.visuals.shaderTreshold) {
 
-                placedDataList.add(new PlacedData(ClientProxy.ticksInGame, previousCoordinates, previousBlockStates,
+                sortOnDistanceToPlayer(coordinates, player);
-                        previousItemStacks, previousFirstPos, previousSecondPos, true));
+
+                placedDataList.add(new PlacedData(ClientProxy.ticksInGame, coordinates, blockStates,
+                        itemStacks, firstPos, secondPos, true));
             }
         }
 
@@ -341,20 +396,18 @@ public class BlockPreviewRenderer {
             int imageUniform = ARBShaderObjects.glGetUniformLocationARB(shader, "image");
             int maskUniform = ARBShaderObjects.glGetUniformLocationARB(shader, "mask");
 
-            //image
-            OpenGlHelper.setActiveTexture(ARBMultitexture.GL_TEXTURE0_ARB);
-            GL11.glBindTexture(GL11.GL_TEXTURE_2D, mc.renderEngine.getTexture(TextureMap.LOCATION_BLOCKS_TEXTURE).getGlTextureId());
-            ARBShaderObjects.glUniform1iARB(imageUniform, 0);
-
-            OpenGlHelper.setActiveTexture(ARBMultitexture.GL_TEXTURE0_ARB + secondaryTextureUnit);
-
             GlStateManager.enableTexture2D();
             GL11.glGetInteger(GL11.GL_TEXTURE_BINDING_2D);
 
             //mask
-            GL11.glBindTexture(GL11.GL_TEXTURE_2D,
-                    mc.renderEngine.getTexture(new ResourceLocation(EffortlessBuilding.MODID, "textures/shader_mask.png")).getGlTextureId());
             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);
@@ -369,4 +422,15 @@ public class BlockPreviewRenderer {
             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/RenderHandler.java

@@ -9,6 +9,7 @@ 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;
@@ -28,6 +29,7 @@ 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;
@@ -35,6 +37,7 @@ 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;
@@ -88,19 +91,24 @@ public class RenderHandler implements IWorldEventListener {
                     EffortlessBuilding.log(player, "Build modes are disabled until your reach has increased. Increase your reach with craftable reach upgrades.");
                 }
             } else {
-                if ( !RadialMenu.instance.actionUsed ) {
+                if (!RadialMenu.instance.actionUsed) {
                     ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
 
-                    if ( RadialMenu.instance.switchTo != null ) {
+                    if (RadialMenu.instance.switchTo != null) {
                         playRadialMenuSound();
                         modeSettings.setBuildMode(RadialMenu.instance.switchTo);
                         ModeSettingsManager.setModeSettings(player, modeSettings);
                         EffortlessBuilding.packetHandler.sendToServer(new ModeSettingsMessage(modeSettings));
 
-                        EffortlessBuilding.log(player, modeSettings.getBuildMode().name, true);
+                        EffortlessBuilding.log(player, I18n.format(modeSettings.getBuildMode().name), true);
                     }
 
-                    //TODO change buildmode settings
+                    //Perform button action
+                    ModeOptions.ActionEnum action = RadialMenu.instance.doAction;
+                    if (action != null) {
+                        ModeOptions.performAction(player, action);
+                        EffortlessBuilding.packetHandler.sendToServer(new ModeActionMessage(action));
+                    }
 
                     playRadialMenuSound();
                 }
@@ -123,12 +131,12 @@ public class RenderHandler implements IWorldEventListener {
                     KeyBinding.unPressAllKeys();
                 }
 
-                final int k1 = Mouse.getX() * res.getScaledWidth() / mc.displayWidth;
+                final int mouseX = Mouse.getX() * res.getScaledWidth() / mc.displayWidth;
-                final int l1 = res.getScaledHeight() - Mouse.getY() * res.getScaledHeight() / mc.displayHeight - 1;
+                final int mouseY = res.getScaledHeight() - Mouse.getY() * res.getScaledHeight() / mc.displayHeight - 1;
 
-                net.minecraftforge.client.ForgeHooksClient.drawScreen(RadialMenu.instance, k1, l1, event.getPartialTicks());
+                net.minecraftforge.client.ForgeHooksClient.drawScreen(RadialMenu.instance, mouseX, mouseY, event.getPartialTicks());
             } else {
-                if (wasVisible) {
+                if (wasVisible && RadialMenu.instance.doAction != ModeOptions.ActionEnum.OPEN_MODIFIER_SETTINGS) {
                     mc.setIngameFocus();
                 }
             }
@@ -177,8 +185,8 @@ public class RenderHandler implements IWorldEventListener {
         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(TextureMap.LOCATION_BLOCKS_TEXTURE);
-        Minecraft.getMinecraft().renderEngine.bindTexture(new ResourceLocation(EffortlessBuilding.MODID, "textures/shader_mask.png"));
+        Minecraft.getMinecraft().renderEngine.bindTexture(ShaderHandler.shaderMaskTextureLocation);
 
         GlStateManager.enableBlend();
         GlStateManager.blendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA);
@@ -188,6 +196,7 @@ public class RenderHandler implements IWorldEventListener {
     protected static void endBlockPreviews() {
         ShaderHandler.releaseShader();
         GlStateManager.disableBlend();
+
         GL11.glPopAttrib();
     }
 
@@ -197,12 +206,28 @@ public class RenderHandler implements IWorldEventListener {
     }
 
     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();
     }
 
@@ -219,6 +244,15 @@ public class RenderHandler implements IWorldEventListener {
         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

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

@@ -13,6 +13,7 @@
 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;
@@ -39,6 +40,8 @@ public final class ShaderHandler {
     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;

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

@@ -3,10 +3,50 @@ key.effortlessbuilding.hud.desc=Modifier Menu
 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/shaders/dissolve.frag

@@ -31,9 +31,7 @@ void main() {
         float placeFromFirst = length(worldpos - firstposc) / firstToSecond;
         float placeFromSecond = length(worldpos - secondposc) / firstToSecond;
         place = (placeFromFirst + (1.0 - placeFromSecond)) / 2.0;
-    } else {
+    } //else only one block
-        //only one block
-    }
 
     //find 2d texture coordinate for noise texture based on world position
     vec2 maskcoord = vec2(worldpos.y, worldpos.z);
@@ -80,8 +78,8 @@ void main() {
 //    color.rgb += vec3(0.5 - smoothstep(0, 0.5, distToEdge)) * 0.5;
 
     //add flat shading
-    if (abs(normal.x) > 0.5)
+//    if (abs(normal.x) > 0.5)
-        color.rgb -= 0.0;
+//        color.rgb -= 0.0;
     if (abs(normal.y) > 0.5)
         color.rgb += 0.05;
     if (abs(normal.z) > 0.5)