Implemented BuildModes and Wall.

Renamed buildSettings to modifierSettings etc.
Added mode capability, message, settings.
Added icons for normal, normal+, line, wall and floor.

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

@@ -55,8 +55,7 @@ public class BuildConfig {
     }
 
     public static class Visuals {
-        @Comment({"Show a block preview if you have a block in hand,",
+        @Comment({"Show a block preview if you have a block in hand on build mode Normal"})
-                 "even when mirror and array are off."})
         public boolean alwaysShowBlockPreview = false;
     }
 }

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

@@ -17,7 +17,8 @@ import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
 import net.minecraftforge.fml.common.network.NetworkRegistry;
 import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper;
 import net.minecraftforge.fml.relauncher.Side;
-import nl.requios.effortlessbuilding.capability.BuildModifierCapabilityManager;
+import nl.requios.effortlessbuilding.capability.ModeCapabilityManager;
+import nl.requios.effortlessbuilding.capability.ModifierCapabilityManager;
 import nl.requios.effortlessbuilding.command.CommandReach;
 import nl.requios.effortlessbuilding.gui.RandomizerBagGuiHandler;
 import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
@@ -26,7 +27,8 @@ import nl.requios.effortlessbuilding.item.ItemReachUpgrade2;
 import nl.requios.effortlessbuilding.item.ItemReachUpgrade3;
 import nl.requios.effortlessbuilding.network.BlockBrokenMessage;
 import nl.requios.effortlessbuilding.network.BlockPlacedMessage;
-import nl.requios.effortlessbuilding.network.BuildSettingsMessage;
+import nl.requios.effortlessbuilding.network.ModeSettingsMessage;
+import nl.requios.effortlessbuilding.network.ModifierSettingsMessage;
 import nl.requios.effortlessbuilding.proxy.IProxy;
 import org.apache.logging.log4j.Logger;
 
@@ -74,16 +76,19 @@ public class EffortlessBuilding
     {
         logger = event.getModLog();
 
-        CapabilityManager.INSTANCE.register(
+        CapabilityManager.INSTANCE.register(ModifierCapabilityManager.IModifierCapability.class, new ModifierCapabilityManager.Storage(), ModifierCapabilityManager.ModifierCapability.class);
-                BuildModifierCapabilityManager.IBuildModifierCapability.class, new BuildModifierCapabilityManager.Storage(), BuildModifierCapabilityManager.BuildModifierCapability.class);
+        CapabilityManager.INSTANCE.register(ModeCapabilityManager.IModeCapability.class, new ModeCapabilityManager.Storage(), ModeCapabilityManager.ModeCapability.class);
 
-        EffortlessBuilding.packetHandler.registerMessage(BuildSettingsMessage.MessageHandler.class, BuildSettingsMessage.class, 0, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ModifierSettingsMessage.MessageHandler.class, ModifierSettingsMessage.class, 0, Side.SERVER);
-        EffortlessBuilding.packetHandler.registerMessage(BuildSettingsMessage.MessageHandler.class, BuildSettingsMessage.class, 0, Side.CLIENT);
+        EffortlessBuilding.packetHandler.registerMessage(ModifierSettingsMessage.MessageHandler.class, ModifierSettingsMessage.class, 0, Side.CLIENT);
 
-        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 1, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ModeSettingsMessage.MessageHandler.class, ModeSettingsMessage.class, 1, Side.SERVER);
-        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 1, Side.CLIENT);
+        EffortlessBuilding.packetHandler.registerMessage(ModeSettingsMessage.MessageHandler.class, ModeSettingsMessage.class, 1, Side.CLIENT);
 
-        EffortlessBuilding.packetHandler.registerMessage(BlockBrokenMessage.MessageHandler.class, BlockBrokenMessage.class, 2, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 2, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 2, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(BlockBrokenMessage.MessageHandler.class, BlockBrokenMessage.class, 3, Side.SERVER);
 
         proxy.preInit(event);
     }

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

@@ -4,6 +4,7 @@ import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.EntityPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.item.Item;
 import net.minecraft.item.ItemBlock;
 import net.minecraft.util.ResourceLocation;
@@ -18,9 +19,13 @@ import net.minecraftforge.event.world.BlockEvent;
 import net.minecraftforge.fml.client.event.ConfigChangedEvent;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
 import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
-import nl.requios.effortlessbuilding.capability.BuildModifierCapabilityManager;
+import nl.requios.effortlessbuilding.capability.ModeCapabilityManager;
+import nl.requios.effortlessbuilding.capability.ModifierCapabilityManager;
 import nl.requios.effortlessbuilding.helper.SurvivalHelper;
+import nl.requios.effortlessbuilding.network.BlockPlacedMessage;
 
 import java.util.List;
 
@@ -48,7 +53,8 @@ public class EventHandler
     @SubscribeEvent
     public static void attachCapabilities(AttachCapabilitiesEvent<Entity> event) {
         if (event.getObject() instanceof EntityPlayer) {
-            event.addCapability(new ResourceLocation(EffortlessBuilding.MODID, "BuildModifier"), new BuildModifierCapabilityManager.Provider());
+            event.addCapability(new ResourceLocation(EffortlessBuilding.MODID, "BuildModifier"), new ModifierCapabilityManager.Provider());
+            event.addCapability(new ResourceLocation(EffortlessBuilding.MODID, "BuildMode"), new ModeCapabilityManager.Provider());
         }
     }
 
@@ -67,14 +73,27 @@ public class EventHandler
 //    }
 
     @SubscribeEvent
+    //Only called serverside
     public static void onBlockPlaced(BlockEvent.PlaceEvent event) {
-        //Still call it to cancel event
+        //Cancel event if necessary
-        BuildModifiers.onBlockPlaced(event);
+        BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(event.getPlayer()).getBuildMode();
+        if (buildMode != BuildModes.BuildModeEnum.Normal) {
+            event.setCanceled(true);
+        } else {
+            //Send message to client, which sends message back with raytrace info
+            EffortlessBuilding.packetHandler.sendTo(new BlockPlacedMessage(), (EntityPlayerMP) event.getPlayer());
+        }
     }
 
     @SubscribeEvent
     public static void onBlockBroken(BlockEvent.BreakEvent event) {
-        BuildModifiers.onBlockBroken(event);
+        //Cancel event if necessary
+        BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(event.getPlayer()).getBuildMode();
+        if (buildMode != BuildModes.BuildModeEnum.Normal) {
+            event.setCanceled(true);
+        } else {
+            BuildModes.onBlockBroken(event);
+        }
     }
 
     @SubscribeEvent

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

@@ -1,13 +0,0 @@
-package nl.requios.effortlessbuilding.buildmode;
-
-import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.util.math.BlockPos;
-
-import java.util.List;
-
-public interface BuildMode {
-
-    List<BlockPos> onRightClick(EntityPlayer player, BlockPos startPos);
-
-    List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos);
-}

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

@@ -1,7 +1,20 @@
 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 net.minecraft.world.World;
+import net.minecraftforge.event.world.BlockEvent;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.*;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
+import nl.requios.effortlessbuilding.helper.SurvivalHelper;
+import nl.requios.effortlessbuilding.network.BlockBrokenMessage;
+import nl.requios.effortlessbuilding.network.BlockPlacedMessage;
+
+import java.util.ArrayList;
+import java.util.List;
 
 public class BuildModes {
 
@@ -10,7 +23,12 @@ public class BuildModes {
         NormalPlus ("Normal+", new NormalPlus()),
         Line ("Line", new Line()),
         Wall ("Wall", new Wall()),
-        Floor ("Floor", new Floor())
+        Floor ("Floor", new Floor()),
+        Normal2 ("Normal", new Normal()),
+        NormalPlus2 ("Normal+", new NormalPlus()),
+        Line2 ("Line", new Line()),
+        Wall2 ("Wall", new Wall()),
+        Floor2 ("Floor", new Floor())
         ;
 //        DiagonalLine,
 //        DiagonalWall,
@@ -18,28 +36,99 @@ public class BuildModes {
 //        Cube;
 
         public String name;
-        public final BuildMode instance;
+        public final IBuildMode instance;
 
-        BuildModeEnum(String name, BuildMode instance) {
+        BuildModeEnum(String name, IBuildMode instance) {
             this.name = name;
             this.instance = instance;
         }
     }
 
-    protected static BuildModeEnum buildMode = BuildModeEnum.Normal;
+    //Uses a network message to get the previous raytraceresult from the player
+    //The server could keep track of all raytraceresults but this might lag with many players
+    //Raytraceresult is needed for sideHit and hitVec
+    public static void onBlockPlacedMessage(EntityPlayer player, BlockPlacedMessage message) {
 
-    public static BuildModeEnum getBuildMode() {
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-        return buildMode;
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+        BuildModeEnum buildMode = modeSettings.getBuildMode();
+        int maxReach = ReachHelper.getMaxReach(player);
+
+        BlockPos startPos = null;
+
+        if (message.isBlockHit() && message.getBlockPos() != null) {
+            startPos = message.getBlockPos();
+
+            //Offset in direction of sidehit if not quickreplace and not replaceable
+            boolean replaceable = player.world.getBlockState(startPos).getBlock().isReplaceable(player.world, startPos);
+            if (!modifierSettings.doQuickReplace() && !replaceable) {
+                startPos = startPos.offset(message.getSideHit());
             }
 
-    public static void setBuildMode(EntityPlayer player, BuildModeEnum buildMode) {
+            //Get under tall grass and other replaceable blocks
-        if (player.world.isRemote) {
+            if (modifierSettings.doQuickReplace() && replaceable) {
-            //TODO send to server
+                startPos = startPos.down();
-            BuildModes.buildMode = buildMode;
+            }
-            EffortlessBuilding.log(player, BuildModes.buildMode.name, true);
+
-        } else {
+            //Check if player reach does not exceed startpos
-            //TODO cancel previous mode's action
+            if (player.getPosition().distanceSq(startPos) > maxReach * maxReach) {
-            BuildModes.buildMode = buildMode;
+                EffortlessBuilding.log(player, "Placement exceeds your reach.");
+                return;
             }
         }
+        //Even when no starting block is found, call buildmode instance
+        //We might want to place things in the air
+        List<BlockPos> posList = buildMode.instance.onRightClick(player, startPos, message.getSideHit(), message.getHitVec());
+
+        //Limit number of blocks you can place
+        int limit = ReachHelper.getMaxBlocksPlacedAtOnce(player);
+        if (posList.size() > limit) {
+            posList = posList.subList(0, limit);
+        }
+
+        EnumFacing sideHit = buildMode.instance.getSideHit(player);
+        if (sideHit == null) sideHit = message.getSideHit();
+
+        Vec3d hitVec = buildMode.instance.getHitVec(player);
+        if (hitVec == null) hitVec = message.getHitVec();
+
+        BuildModifiers.onBlockPlaced(player, posList, sideHit, hitVec);
+
+    }
+
+
+    //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();
+        if (ReachHelper.canBreakFar(player) && message.isBlockHit()) {
+            BlockEvent.BreakEvent event = new BlockEvent.BreakEvent(player.world, blockPos, player.world.getBlockState(blockPos), player);
+            onBlockBroken(event);
+        }
+    }
+
+    public static void onBlockBroken(BlockEvent.BreakEvent event) {
+        World world = event.getWorld();
+        BlockPos pos = event.getPos();
+
+        if (world.isRemote) return;
+
+        //get coordinates
+        List<BlockPos> coordinates = findCoordinates(event.getPlayer(), pos);
+
+        //let buildmodifiers break blocks
+        BuildModifiers.onBlockBroken(event.getPlayer(), coordinates);
+    }
+
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos) {
+        List<BlockPos> coordinates = new ArrayList<>();
+
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+        coordinates.addAll(modeSettings.getBuildMode().instance.findCoordinates(player, startPos));
+
+        return coordinates;
+    }
+
+    public static void initializeMode(EntityPlayer player) {
+        ModeSettingsManager.getModeSettings(player).getBuildMode().instance.initialize(player);
+    }
 }

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

@@ -1,18 +1,36 @@
 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 Floor implements BuildMode {
+public class Floor implements IBuildMode {
     @Override
-    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos startPos) {
+    public void initialize(EntityPlayer player) {
+
+    }
+
+    @Override
+    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public EnumFacing getSideHit(EntityPlayer player) {
         return null;
     }
 
     @Override
-    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos) {
+    public Vec3d getHitVec(EntityPlayer player) {
         return null;
     }
 }

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

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

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

@@ -1,18 +1,36 @@
 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 Line implements BuildMode {
+public class Line implements IBuildMode {
     @Override
-    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos startPos) {
+    public void initialize(EntityPlayer player) {
+
+    }
+
+    @Override
+    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos) {
+        return new ArrayList<>();
+    }
+
+    @Override
+    public EnumFacing getSideHit(EntityPlayer player) {
         return null;
     }
 
     @Override
-    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos) {
+    public Vec3d getHitVec(EntityPlayer player) {
         return null;
     }
 }

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

@@ -0,0 +1,100 @@
+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;
+import nl.requios.effortlessbuilding.network.ModeSettingsMessage;
+
+@Mod.EventBusSubscriber
+public class ModeSettingsManager {
+
+    //Retrieves the buildsettings of a player through the modifierCapability capability
+    //Never returns null
+    public static ModeSettings getModeSettings(EntityPlayer player) {
+        if (player.hasCapability(ModeCapabilityManager.modeCapability, null)) {
+            ModeCapabilityManager.IModeCapability capability = player.getCapability(
+                    ModeCapabilityManager.modeCapability, null);
+            if (capability.getModeData() == null) {
+                capability.setModeData(new ModeSettings());
+            }
+            return capability.getModeData();
+        }
+        throw new IllegalArgumentException("Player does not have modeCapability capability");
+    }
+
+    public static void setModeSettings(EntityPlayer player, ModeSettings modeSettings) {
+        if (player == null) {
+            EffortlessBuilding.log("Cannot set buildsettings, player is null");
+            return;
+        }
+        if (player.hasCapability(ModeCapabilityManager.modeCapability, null)) {
+            ModeCapabilityManager.IModeCapability capability = player.getCapability(
+                    ModeCapabilityManager.modeCapability, null);
+
+            capability.setModeData(modeSettings);
+
+            //Initialize new mode
+            BuildModes.initializeMode(player);
+        } else {
+            EffortlessBuilding.log(player, "Saving buildsettings failed.");
+        }
+    }
+
+    public static String sanitize(ModeSettings modeSettings, EntityPlayer player) {
+        int maxReach = ReachHelper.getMaxReach(player);
+        String error = "";
+
+        //TODO sanitize
+
+        return error;
+    }
+
+    public static class ModeSettings {
+        private BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.Normal;
+
+        public ModeSettings() {
+        }
+
+        public ModeSettings(BuildModes.BuildModeEnum buildMode) {
+            this.buildMode = buildMode;
+        }
+
+        public BuildModes.BuildModeEnum getBuildMode() {
+            return this.buildMode;
+        }
+
+        public void setBuildMode(BuildModes.BuildModeEnum buildMode) {
+            this.buildMode = buildMode;
+        }
+    }
+
+    @SubscribeEvent
+    public static void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
+        EntityPlayer player = event.player;
+        handleNewPlayer(player);
+    }
+
+    @SubscribeEvent
+    public static void onPlayerRespawn(PlayerEvent.PlayerRespawnEvent event) {
+        EntityPlayer player = event.player;
+        handleNewPlayer(player);
+    }
+
+    private static void handleNewPlayer(EntityPlayer player){
+        if (getModeSettings(player) == null) {
+            setModeSettings(player, new ModeSettings());
+        }
+
+        //Only on server
+        if (!player.world.isRemote) {
+            //Send to client
+            ModeSettingsMessage msg = new ModeSettingsMessage(getModeSettings(player));
+            EffortlessBuilding.packetHandler.sendTo(msg, (EntityPlayerMP) player);
+        }
+    }
+}

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

@@ -1,23 +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.ArrayList;
 import java.util.List;
 
-public class Normal implements BuildMode {
+public class Normal implements IBuildMode {
     @Override
-    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos startPos) {
+    public void initialize(EntityPlayer player) {
+
+    }
+
+    @Override
+    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec) {
         List<BlockPos> list = new ArrayList<>();
-        list.add(startPos);
+        list.add(blockPos);
         return list;
     }
 
     @Override
-    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos) {
+    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos) {
         List<BlockPos> list = new ArrayList<>();
-        list.add(startPos);
+        list.add(blockPos);
         return list;
     }
+
+    @Override
+    public EnumFacing getSideHit(EntityPlayer player) {
+        return null;
+    }
+
+    @Override
+    public Vec3d getHitVec(EntityPlayer player) {
+        return null;
+    }
 }

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

@@ -1,23 +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.ArrayList;
 import java.util.List;
 
-public class NormalPlus implements BuildMode {
+public class NormalPlus implements IBuildMode {
     @Override
-    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos startPos) {
+    public void initialize(EntityPlayer player) {
+
+    }
+
+    @Override
+    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec) {
         List<BlockPos> list = new ArrayList<>();
-        list.add(startPos);
+        list.add(blockPos);
         return list;
     }
 
     @Override
-    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos) {
+    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos) {
         List<BlockPos> list = new ArrayList<>();
-        list.add(startPos);
+        list.add(blockPos);
         return list;
     }
+
+    @Override
+    public EnumFacing getSideHit(EntityPlayer player) {
+        return null;
+    }
+
+    @Override
+    public Vec3d getHitVec(EntityPlayer player) {
+        return null;
+    }
 }

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

@@ -1,18 +1,154 @@
 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.EffortlessBuilding;
+import nl.requios.effortlessbuilding.helper.ReachHelper;
 
-import java.util.List;
+import java.util.*;
+
+public class Wall implements IBuildMode {
+    Dictionary<UUID, Integer> rightClickNrTable = new Hashtable<>();
+    Dictionary<UUID, BlockPos> firstPosTable = new Hashtable<>();
+    Dictionary<UUID, EnumFacing> sideHitTable = new Hashtable<>();
+    Dictionary<UUID, Vec3d> hitVecTable = new Hashtable<>();
 
-public class Wall implements BuildMode {
     @Override
-    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos startPos) {
+    public void initialize(EntityPlayer player) {
-        return null;
+        rightClickNrTable.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> findCoordinates(EntityPlayer player, BlockPos startPos) {
+    public List<BlockPos> onRightClick(EntityPlayer player, BlockPos blockPos, EnumFacing sideHit, Vec3d hitVec) {
-        return null;
+        List<BlockPos> list = new ArrayList<>();
+
+        int rightClickNr = rightClickNrTable.get(player.getUniqueID());
+        rightClickNr++;
+        rightClickNrTable.put(player.getUniqueID(), rightClickNr);
+
+        if (rightClickNr == 1) {
+            //If clicking in air, reset and try again
+            if (blockPos == null) {
+                rightClickNrTable.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);
+            rightClickNrTable.put(player.getUniqueID(), 0);
+        }
+
+        return list;
+    }
+
+    @Override
+    public List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos) {
+        List<BlockPos> list = new ArrayList<>();
+        int rightClickNr = rightClickNrTable.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();
+
+            //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();
+
+            int reach = ReachHelper.getMaxReach(player); //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 to the player and is valid
+            Vec3d selected = null;
+            if (xValid) selected = xBound;
+            if (zValid && zDistSquared < xDistSquared) selected = zBound;
+
+            if (selected == null) return list;
+
+            //check if it doesnt go through blocks
+            RayTraceResult rayTraceResult = player.world.rayTraceBlocks(start, selected, false, false, 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/buildmodifier/Array.java

@@ -9,7 +9,6 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.math.Vec3i;
 import net.minecraftforge.items.IItemHandler;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
 
 import java.util.ArrayList;
@@ -46,7 +45,7 @@ public class Array {
         List<BlockPos> coordinates = new ArrayList<>();
 
         //find arraysettings for the player
-        ArraySettings a = BuildSettingsManager.getBuildSettings(player).getArraySettings();
+        ArraySettings a = ModifierSettingsManager.getModifierSettings(player).getArraySettings();
         if (!isEnabled(a)) return coordinates;
 
         BlockPos pos = startPos;
@@ -64,7 +63,7 @@ public class Array {
         List<IBlockState> blockStates = new ArrayList<>();
 
         //find arraysettings for the player that placed the block
-        ArraySettings a = BuildSettingsManager.getBuildSettings(player).getArraySettings();
+        ArraySettings a = ModifierSettingsManager.getModifierSettings(player).getArraySettings();
         if (!isEnabled(a)) return blockStates;
 
         BlockPos pos = startPos;

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

@@ -3,65 +3,40 @@ 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.item.ItemBlock;
 import net.minecraft.item.ItemStack;
 import net.minecraft.util.EnumFacing;
 import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.RayTraceResult;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.world.World;
 import net.minecraftforge.event.world.BlockEvent;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
 import nl.requios.effortlessbuilding.helper.SurvivalHelper;
 import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
 import nl.requios.effortlessbuilding.network.BlockBrokenMessage;
-import nl.requios.effortlessbuilding.network.BlockPlacedMessage;
 
 import java.util.ArrayList;
+import java.util.Arrays;
 import java.util.List;
 
 public class BuildModifiers {
 
-    //Uses a network message to get the previous raytraceresult from the player
+    //Called from BuildModes
-    //The server could keep track of all raytraceresults but this might lag with many players
+    public static void onBlockPlaced(EntityPlayer player, List<BlockPos> posList, EnumFacing sideHit, Vec3d hitVec) {
-    //Raytraceresult is needed for sideHit and hitVec
-    public static void onBlockPlacedMessage(EntityPlayer player, BlockPlacedMessage message) {
-        if (!message.isBlockHit() || message.getBlockPos() == null) return;
-
         World world = player.world;
         ItemRandomizerBag.renewRandomness();
 
-        BlockPos startPos = message.getBlockPos();
-
-        //Offset in direction of sidehit if not quickreplace and not replaceable
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(player);
-        boolean replaceable = world.getBlockState(startPos).getBlock().isReplaceable(player.world, startPos);
-        if (!buildSettings.doQuickReplace() && !replaceable) {
-            startPos = startPos.offset(message.getSideHit());
-        }
-
-        //Get under tall grass and other replaceable blocks
-        if (buildSettings.doQuickReplace() && replaceable) {
-            startPos = startPos.down();
-        }
-
-        //Check if player reach does not exceed startpos
-        int maxReach = ReachHelper.getMaxReach(player);
-        if (player.getPosition().distanceSq(startPos) > maxReach * maxReach) {
-            EffortlessBuilding.log(player, "Placement exceeds your reach.");
-            return;
-        }
-
         //Format hitvec to 0.x
-        Vec3d hitVec = message.getHitVec();
         hitVec = new Vec3d(Math.abs(hitVec.x - ((int) hitVec.x)), Math.abs(hitVec.y - ((int) hitVec.y)), Math.abs(hitVec.z - ((int) hitVec.z)));
 
         //find coordinates and blockstates
-        List<BlockPos> coordinates = findCoordinates(player, startPos);
+        List<BlockPos> coordinates = findCoordinates(player, posList);
         List<ItemStack> itemStacks = new ArrayList<>();
-        List<IBlockState> blockStates = findBlockStates(player, startPos, hitVec, message.getSideHit(), itemStacks);
+        List<IBlockState> blockStates = findBlockStates(player, posList, hitVec, sideHit, itemStacks);
 
         //check if valid blockstates
         if (blockStates.size() == 0 || coordinates.size() != blockStates.size()) return;
@@ -80,73 +55,52 @@ public class BuildModifiers {
         }
     }
 
-    public static void onBlockPlaced(BlockEvent.PlaceEvent event) {
+    public static void onBlockBroken(EntityPlayer player, List<BlockPos> posList) {
-        if (event.getWorld().isRemote) return;
+        World world = player.world;
 
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(event.getPlayer());
+        List<BlockPos> coordinates = findCoordinates(player, posList);
-        //Only use own place event if anything is enabled
-        if (isEnabled(buildSettings, event.getPos())) {
-            //EffortlessBuilding.packetHandler.sendTo(new BlockPlacedMessage(), (EntityPlayerMP) event.getPlayer());
-            event.setCanceled(true);
-        }
 
-    }
+        if (coordinates.isEmpty()) return;
-
-    //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();
-        if (ReachHelper.canBreakFar(player) && message.isBlockHit()) {
-            BlockEvent.BreakEvent event = new BlockEvent.BreakEvent(player.world, blockPos, player.world.getBlockState(blockPos), player);
-            onBlockBroken(event);
-        }
-    }
-
-    public static void onBlockBroken(BlockEvent.BreakEvent event) {
-        World world = event.getWorld();
-        BlockPos pos = event.getPos();
-
-        if (world.isRemote) return;
-
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(event.getPlayer());
-        //Only use own break event if anything is enabled
-        if (isEnabled(buildSettings, pos)) {
-            //get coordinates
-            List<BlockPos> coordinates = findCoordinates(event.getPlayer(), pos);
 
         //If the player is going to instabreak grass or a plant, only break other instabreaking things
-            boolean onlyInstaBreaking = world.getBlockState(pos).getBlockHardness(
+        boolean onlyInstaBreaking = world.getBlockState(posList.get(0)).getBlockHardness(world, posList.get(0)) == 0f;
-                    world, pos) == 0f;
 
         //break all those blocks
         for (BlockPos coordinate : coordinates) {
             if (world.isBlockLoaded(coordinate, false)) {
                 if (!onlyInstaBreaking || world.getBlockState(coordinate).getBlockHardness(world, coordinate) == 0f) {
-                        SurvivalHelper.breakBlock(world, event.getPlayer(), coordinate);
+                    SurvivalHelper.breakBlock(world, player, coordinate);
-                    }
                 }
             }
         }
     }
 
-    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos) {
+    public static List<BlockPos> findCoordinates(EntityPlayer player, List<BlockPos> posList) {
         List<BlockPos> coordinates = new ArrayList<>();
-        //Add current block being placed too
+        //Add current blocks being placed too
-        coordinates.add(startPos);
+        coordinates.addAll(posList);
 
-        List<BlockPos> arrayCoordinates = Array.findCoordinates(player, startPos);
+        //Find mirror/array/radial mirror coordinates for each blockpos
+        for (BlockPos blockPos : posList) {
+            List<BlockPos> arrayCoordinates = Array.findCoordinates(player, blockPos);
             coordinates.addAll(arrayCoordinates);
-        coordinates.addAll(Mirror.findCoordinates(player, startPos));
+            coordinates.addAll(Mirror.findCoordinates(player, blockPos));
-        coordinates.addAll(RadialMirror.findCoordinates(player, startPos));
+            coordinates.addAll(RadialMirror.findCoordinates(player, blockPos));
             //get mirror for each array coordinate
             for (BlockPos coordinate : arrayCoordinates) {
                 coordinates.addAll(Mirror.findCoordinates(player, coordinate));
                 coordinates.addAll(RadialMirror.findCoordinates(player, coordinate));
             }
+        }
 
         return coordinates;
     }
 
-    public static List<IBlockState> findBlockStates(EntityPlayer player, BlockPos startPos, Vec3d hitVec, EnumFacing facing, List<ItemStack> itemStacks) {
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos) {
+        return findCoordinates(player, new ArrayList<>(Arrays.asList(blockPos)));
+    }
+
+    public static List<IBlockState> findBlockStates(EntityPlayer player, List<BlockPos> posList, Vec3d hitVec, EnumFacing facing, List<ItemStack> itemStacks) {
         List<IBlockState> blockStates = new ArrayList<>();
         itemStacks.clear();
 
@@ -165,17 +119,22 @@ public class BuildModifiers {
         ItemRandomizerBag.resetRandomness();
         if (itemStack.getItem() instanceof ItemRandomizerBag) itemBlock = ItemRandomizerBag.pickRandomStack(ItemRandomizerBag.getBagInventory(itemStack));
 
-        IBlockState blockState = getBlockStateFromItem(itemBlock, player, startPos, facing, hitVec, EnumHand.MAIN_HAND);
+        //Add blocks in posList first
-        //Add current block being placed too
+        for (BlockPos blockPos : posList) {
+            IBlockState blockState = getBlockStateFromItem(itemBlock, player, blockPos, facing, hitVec, EnumHand.MAIN_HAND);
             blockStates.add(blockState);
             itemStacks.add(itemStack);
+        }
 
-        List<IBlockState> arrayBlockStates = Array.findBlockStates(player, startPos, blockState, itemStack, itemStacks);
+        for (BlockPos blockPos : posList) {
+            IBlockState blockState = getBlockStateFromItem(itemBlock, player, blockPos, facing, hitVec, EnumHand.MAIN_HAND);
+
+            List<IBlockState> arrayBlockStates = Array.findBlockStates(player, blockPos, blockState, itemStack, itemStacks);
             blockStates.addAll(arrayBlockStates);
-        blockStates.addAll(Mirror.findBlockStates(player, startPos, blockState, itemStack, itemStacks));
+            blockStates.addAll(Mirror.findBlockStates(player, blockPos, blockState, itemStack, itemStacks));
-        blockStates.addAll(RadialMirror.findBlockStates(player, startPos, blockState, itemStack, itemStacks));
+            blockStates.addAll(RadialMirror.findBlockStates(player, blockPos, blockState, itemStack, itemStacks));
             //add mirror for each array coordinate
-        List<BlockPos> arrayCoordinates = Array.findCoordinates(player, startPos);
+            List<BlockPos> arrayCoordinates = Array.findCoordinates(player, blockPos);
             for (int i = 0; i < arrayCoordinates.size(); i++) {
                 BlockPos coordinate = arrayCoordinates.get(i);
                 IBlockState blockState1 = arrayBlockStates.get(i);
@@ -191,15 +150,16 @@ public class BuildModifiers {
 //                blockStates.set(i, blockStates.get(i).getBlock().getStateForPlacement(player.world, coordinates.get(i), facing,
 //                        (float) hitVec.x, (float) hitVec.y, (float) hitVec.z, itemStacks.get(i).getMetadata(), player, EnumHand.MAIN_HAND));
 //            }
+        }
 
         return blockStates;
     }
 
-    public static boolean isEnabled(BuildSettingsManager.BuildSettings buildSettings, BlockPos startPos) {
+    public static boolean isEnabled(ModifierSettingsManager.ModifierSettings modifierSettings, BlockPos startPos) {
-        return Mirror.isEnabled(buildSettings.getMirrorSettings(), startPos) ||
+        return Mirror.isEnabled(modifierSettings.getMirrorSettings(), startPos) ||
-               Array.isEnabled(buildSettings.getArraySettings()) ||
+               Array.isEnabled(modifierSettings.getArraySettings()) ||
-               RadialMirror.isEnabled(buildSettings.getRadialMirrorSettings(), startPos) ||
+               RadialMirror.isEnabled(modifierSettings.getRadialMirrorSettings(), startPos) ||
-               buildSettings.doQuickReplace();
+               modifierSettings.doQuickReplace();
     }
 
     public static IBlockState getBlockStateFromItem(ItemStack itemStack, EntityPlayer player, BlockPos blockPos, EnumFacing facing, Vec3d hitVec, EnumHand hand) {

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

@@ -12,7 +12,6 @@ import net.minecraft.util.EnumHand;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Vec3d;
 import net.minecraftforge.items.IItemHandler;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
 
 import java.util.ArrayList;
@@ -50,7 +49,7 @@ public class Mirror {
         List<BlockPos> coordinates = new ArrayList<>();
 
         //find mirrorsettings for the player
-        MirrorSettings m = BuildSettingsManager.getBuildSettings(player).getMirrorSettings();
+        MirrorSettings m = ModifierSettingsManager.getModifierSettings(player).getMirrorSettings();
         if (!isEnabled(m, startPos)) return coordinates;
 
         if (m.mirrorX) coordinateMirrorX(m, startPos, coordinates);
@@ -90,7 +89,7 @@ public class Mirror {
         List<IBlockState> blockStates = new ArrayList<>();
 
         //find mirrorsettings for the player
-        MirrorSettings m = BuildSettingsManager.getBuildSettings(player).getMirrorSettings();
+        MirrorSettings m = ModifierSettingsManager.getModifierSettings(player).getMirrorSettings();
         if (!isEnabled(m, startPos)) return blockStates;
 
         //Randomizer bag synergy

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

@@ -1,54 +1,52 @@
-package nl.requios.effortlessbuilding;
+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.buildmodifier.Array;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.buildmodifier.Mirror;
+import nl.requios.effortlessbuilding.capability.ModifierCapabilityManager;
-import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
-import nl.requios.effortlessbuilding.capability.BuildModifierCapabilityManager;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
-import nl.requios.effortlessbuilding.network.BuildSettingsMessage;
+import nl.requios.effortlessbuilding.network.ModifierSettingsMessage;
 
 @Mod.EventBusSubscriber
-public class BuildSettingsManager {
+public class ModifierSettingsManager {
 
-    //Retrieves the buildsettings of a player through the buildModifierCapability capability
+    //Retrieves the buildsettings of a player through the modifierCapability capability
     //Never returns null
-    public static BuildSettings getBuildSettings(EntityPlayer player){
+    public static ModifierSettings getModifierSettings(EntityPlayer player){
-        if (player.hasCapability(BuildModifierCapabilityManager.buildModifierCapability, null)) {
+        if (player.hasCapability(ModifierCapabilityManager.modifierCapability, null)) {
-            BuildModifierCapabilityManager.IBuildModifierCapability capability = player.getCapability(
+            ModifierCapabilityManager.IModifierCapability capability = player.getCapability(
-                    BuildModifierCapabilityManager.buildModifierCapability, null);
+                    ModifierCapabilityManager.modifierCapability, null);
-            if (capability.getBuildModifierData() == null) {
+            if (capability.getModifierData() == null) {
-                capability.setBuildModifierData(new BuildSettings());
+                capability.setModifierData(new ModifierSettings());
             }
-            return capability.getBuildModifierData();
+            return capability.getModifierData();
         }
-        throw new IllegalArgumentException("Player does not have buildModifierCapability capability");
+        throw new IllegalArgumentException("Player does not have modifierCapability capability");
     }
 
-    public static void setBuildSettings(EntityPlayer player, BuildSettings buildSettings) {
+    public static void setModifierSettings(EntityPlayer player, ModifierSettings modifierSettings) {
         if (player == null) {
             EffortlessBuilding.log("Cannot set buildsettings, player is null");
             return;
         }
-        if (player.hasCapability(BuildModifierCapabilityManager.buildModifierCapability, null)) {
+        if (player.hasCapability(ModifierCapabilityManager.modifierCapability, null)) {
-            BuildModifierCapabilityManager.IBuildModifierCapability capability = player.getCapability(
+            ModifierCapabilityManager.IModifierCapability capability = player.getCapability(
-                    BuildModifierCapabilityManager.buildModifierCapability, null);
+                    ModifierCapabilityManager.modifierCapability, null);
-            capability.setBuildModifierData(buildSettings);
+            capability.setModifierData(modifierSettings);
         } else {
             EffortlessBuilding.log(player, "Saving buildsettings failed.");
         }
     }
 
-    public static String sanitize(BuildSettings buildSettings, EntityPlayer player) {
+    public static String sanitize(ModifierSettings modifierSettings, EntityPlayer player) {
         int maxReach = ReachHelper.getMaxReach(player);
         String error = "";
 
         //Mirror settings
-        Mirror.MirrorSettings m = buildSettings.getMirrorSettings();
+        Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
         if (m.radius < 1) {
             m.radius = 1;
             error += "Mirror size has to be at least 1. This has been corrected. ";
@@ -59,7 +57,7 @@ public class BuildSettingsManager {
         }
 
         //Array settings
-        Array.ArraySettings a = buildSettings.getArraySettings();
+        Array.ArraySettings a = modifierSettings.getArraySettings();
         if (a.count < 0) {
             a.count = 0;
             error += "Array count may not be negative. It has been reset to 0.";
@@ -71,7 +69,7 @@ public class BuildSettingsManager {
         }
 
         //Radial mirror settings
-        RadialMirror.RadialMirrorSettings r = buildSettings.getRadialMirrorSettings();
+        RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
         if (r.slices < 2) {
             r.slices = 2;
             error += "Radial mirror needs to have at least 2 slices. Slices has been set to 2.";
@@ -87,30 +85,30 @@ public class BuildSettingsManager {
         }
 
         //Other
-        if (buildSettings.reachUpgrade < 0) {
+        if (modifierSettings.reachUpgrade < 0) {
-            buildSettings.reachUpgrade = 0;
+            modifierSettings.reachUpgrade = 0;
         }
-        if (buildSettings.reachUpgrade > 3) {
+        if (modifierSettings.reachUpgrade > 3) {
-            buildSettings.reachUpgrade = 3;
+            modifierSettings.reachUpgrade = 3;
         }
 
         return error;
     }
 
-    public static class BuildSettings {
+    public static class ModifierSettings {
         private Mirror.MirrorSettings mirrorSettings;
         private Array.ArraySettings arraySettings;
         private RadialMirror.RadialMirrorSettings radialMirrorSettings;
         private boolean quickReplace = false;
         private int reachUpgrade = 0;
 
-        public BuildSettings() {
+        public ModifierSettings() {
             mirrorSettings = new Mirror.MirrorSettings();
             arraySettings = new Array.ArraySettings();
             radialMirrorSettings = new RadialMirror.RadialMirrorSettings();
         }
 
-        public BuildSettings(Mirror.MirrorSettings mirrorSettings, Array.ArraySettings arraySettings,
+        public ModifierSettings(Mirror.MirrorSettings mirrorSettings, Array.ArraySettings arraySettings,
                                 RadialMirror.RadialMirrorSettings radialMirrorSettings, boolean quickReplace, int reachUpgrade) {
             this.mirrorSettings = mirrorSettings;
             this.arraySettings = arraySettings;
@@ -179,14 +177,14 @@ public class BuildSettingsManager {
     }
 
     private static void handleNewPlayer(EntityPlayer player){
-        if (getBuildSettings(player) == null) {
+        if (getModifierSettings(player) == null) {
-            setBuildSettings(player, new BuildSettings());
+            setModifierSettings(player, new ModifierSettings());
         }
 
         //Only on server
         if (!player.world.isRemote) {
             //Send to client
-            BuildSettingsMessage msg = new BuildSettingsMessage(getBuildSettings(player));
+            ModifierSettingsMessage msg = new ModifierSettingsMessage(getModifierSettings(player));
             EffortlessBuilding.packetHandler.sendTo(msg, (EntityPlayerMP) player);
         }
     }

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

@@ -11,7 +11,6 @@ import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.MathHelper;
 import net.minecraft.util.math.Vec3d;
 import net.minecraftforge.items.IItemHandler;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
 
 import java.util.ArrayList;
@@ -49,7 +48,7 @@ public class RadialMirror {
         List<BlockPos> coordinates = new ArrayList<>();
 
         //find radial mirror settings for the player
-        RadialMirrorSettings r = BuildSettingsManager.getBuildSettings(player).getRadialMirrorSettings();
+        RadialMirrorSettings r = ModifierSettingsManager.getModifierSettings(player).getRadialMirrorSettings();
         if (!isEnabled(r, startPos)) return coordinates;
 
         //get angle between slices
@@ -83,7 +82,7 @@ public class RadialMirror {
         List<BlockPos> coordinates = new ArrayList<>(); //to keep track of duplicates
 
         //find radial mirror settings for the player that placed the block
-        RadialMirrorSettings r = BuildSettingsManager.getBuildSettings(player).getRadialMirrorSettings();
+        RadialMirrorSettings r = ModifierSettingsManager.getModifierSettings(player).getRadialMirrorSettings();
         if (!isEnabled(r, startPos)) return blockStates;
 
 

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

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

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

@@ -11,7 +11,6 @@ import net.minecraftforge.common.capabilities.ICapabilitySerializable;
 import net.minecraftforge.event.entity.player.PlayerEvent;
 import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
-import nl.requios.effortlessbuilding.BuildSettingsManager.BuildSettings;
 import nl.requios.effortlessbuilding.buildmodifier.Array;
 import nl.requios.effortlessbuilding.buildmodifier.Mirror;
 import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
@@ -19,41 +18,43 @@ import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
 import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
+import static nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager.*;
+
 @Mod.EventBusSubscriber
-public class BuildModifierCapabilityManager {
+public class ModifierCapabilityManager {
 
-    @CapabilityInject(IBuildModifierCapability.class)
+    @CapabilityInject(IModifierCapability.class)
-    public final static Capability<IBuildModifierCapability> buildModifierCapability = null;
+    public final static Capability<IModifierCapability> modifierCapability = null;
 
-    public interface IBuildModifierCapability {
+    public interface IModifierCapability {
-        BuildSettings getBuildModifierData();
+        ModifierSettings getModifierData();
 
-        void setBuildModifierData(BuildSettings buildSettings);
+        void setModifierData(ModifierSettings modifierSettings);
     }
 
-    public static class BuildModifierCapability implements IBuildModifierCapability {
+    public static class ModifierCapability implements IModifierCapability {
-        private BuildSettings buildSettings;
+        private ModifierSettings modifierSettings;
 
         @Override
-        public BuildSettings getBuildModifierData() {
+        public ModifierSettings getModifierData() {
-            return buildSettings;
+            return modifierSettings;
         }
 
         @Override
-        public void setBuildModifierData(BuildSettings buildSettings) {
+        public void setModifierData(ModifierSettings modifierSettings) {
-            this.buildSettings = buildSettings;
+            this.modifierSettings = modifierSettings;
         }
     }
 
-    public static class Storage implements Capability.IStorage<IBuildModifierCapability> {
+    public static class Storage implements Capability.IStorage<IModifierCapability> {
         @Override
-        public NBTBase writeNBT(Capability<IBuildModifierCapability> capability, IBuildModifierCapability instance, EnumFacing side) {
+        public NBTBase writeNBT(Capability<IModifierCapability> capability, IModifierCapability instance, EnumFacing side) {
             NBTTagCompound compound = new NBTTagCompound();
-            BuildSettings buildSettings = instance.getBuildModifierData();
+            ModifierSettings modifierSettings = instance.getModifierData();
-            if (buildSettings == null) buildSettings = new BuildSettings();
+            if (modifierSettings == null) modifierSettings = new ModifierSettings();
 
             //MIRROR
-            Mirror.MirrorSettings m = buildSettings.getMirrorSettings();
+            Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
             if (m == null) m = new Mirror.MirrorSettings();
             compound.setBoolean("mirrorEnabled", m.enabled);
             compound.setDouble("mirrorPosX", m.position.x);
@@ -67,7 +68,7 @@ public class BuildModifierCapabilityManager {
             compound.setBoolean("mirrorDrawPlanes", m.drawPlanes);
 
             //ARRAY
-            Array.ArraySettings a = buildSettings.getArraySettings();
+            Array.ArraySettings a = modifierSettings.getArraySettings();
             if (a == null) a = new Array.ArraySettings();
             compound.setBoolean("arrayEnabled", a.enabled);
             compound.setInteger("arrayOffsetX", a.offset.getX());
@@ -75,12 +76,12 @@ public class BuildModifierCapabilityManager {
             compound.setInteger("arrayOffsetZ", a.offset.getZ());
             compound.setInteger("arrayCount", a.count);
 
-            compound.setInteger("reachUpgrade", buildSettings.getReachUpgrade());
+            compound.setInteger("reachUpgrade", modifierSettings.getReachUpgrade());
 
             //compound.setBoolean("quickReplace", buildSettings.doQuickReplace()); dont save quickreplace
 
             //RADIAL MIRROR
-            RadialMirror.RadialMirrorSettings r = buildSettings.getRadialMirrorSettings();
+            RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
             if (r == null) r = new RadialMirror.RadialMirrorSettings();
             compound.setBoolean("radialMirrorEnabled", r.enabled);
             compound.setDouble("radialMirrorPosX", r.position.x);
@@ -96,7 +97,7 @@ public class BuildModifierCapabilityManager {
         }
 
         @Override
-        public void readNBT(Capability<IBuildModifierCapability> capability, IBuildModifierCapability instance, EnumFacing side, NBTBase nbt) {
+        public void readNBT(Capability<IModifierCapability> capability, IModifierCapability instance, EnumFacing side, NBTBase nbt) {
             NBTTagCompound compound = (NBTTagCompound) nbt;
 
             //MIRROR
@@ -131,41 +132,42 @@ public class BuildModifierCapabilityManager {
             RadialMirror.RadialMirrorSettings radialMirrorSettings = new RadialMirror.RadialMirrorSettings(radialMirrorEnabled, radialMirrorPosition,
                     radialMirrorSlices, radialMirrorAlternate, radialMirrorRadius, radialMirrorDrawLines, radialMirrorDrawPlanes);
 
-            BuildSettings buildSettings = new BuildSettings(mirrorSettings, arraySettings, radialMirrorSettings, false, reachUpgrade);
+            ModifierSettings
-            instance.setBuildModifierData(buildSettings);
+                    modifierSettings = new ModifierSettings(mirrorSettings, arraySettings, radialMirrorSettings, false, reachUpgrade);
+            instance.setModifierData(modifierSettings);
         }
     }
 
     public static class Provider implements ICapabilitySerializable<NBTBase> {
-        IBuildModifierCapability inst = buildModifierCapability.getDefaultInstance();
+        IModifierCapability inst = modifierCapability.getDefaultInstance();
 
         @Override
         public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
-            return capability == buildModifierCapability;
+            return capability == modifierCapability;
         }
 
         @Override
         public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
-            if (capability == buildModifierCapability) return buildModifierCapability.<T>cast(inst);
+            if (capability == modifierCapability) return modifierCapability.<T>cast(inst);
             return null;
         }
 
         @Override
         public NBTBase serializeNBT() {
-            return buildModifierCapability.getStorage().writeNBT(buildModifierCapability, inst, null);
+            return modifierCapability.getStorage().writeNBT(modifierCapability, inst, null);
         }
 
         @Override
         public void deserializeNBT(NBTBase nbt) {
-            buildModifierCapability.getStorage().readNBT(buildModifierCapability, inst, null, nbt);
+            modifierCapability.getStorage().readNBT(modifierCapability, inst, null, nbt);
         }
     }
 
     // Allows for the capability to persist after death.
     @SubscribeEvent
     public static void clonePlayer(PlayerEvent.Clone event) {
-        IBuildModifierCapability original = event.getOriginal().getCapability(buildModifierCapability, null);
+        IModifierCapability original = event.getOriginal().getCapability(modifierCapability, null);
-        IBuildModifierCapability clone = event.getEntity().getCapability(buildModifierCapability, null);
+        IModifierCapability clone = event.getEntity().getCapability(modifierCapability, null);
-        clone.setBuildModifierData(original.getBuildModifierData());
+        clone.setModifierData(original.getModifierData());
     }
 }

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

@@ -7,9 +7,9 @@ import net.minecraft.command.WrongUsageException;
 import net.minecraft.entity.player.EntityPlayerMP;
 import net.minecraft.server.MinecraftServer;
 import net.minecraft.util.text.TextComponentString;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.network.BuildSettingsMessage;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.network.ModifierSettingsMessage;
 
 public class CommandReach extends CommandBase {
     @Override
@@ -31,13 +31,14 @@ public class CommandReach extends CommandBase {
         if (sender instanceof EntityPlayerMP) {
             EntityPlayerMP player = (EntityPlayerMP) sender;
             //Set reach level to args[0]
-            BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(player);
+            ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-            buildSettings.setReachUpgrade(Integer.valueOf(args[0]));
+            modifierSettings.setReachUpgrade(Integer.valueOf(args[0]));
-            BuildSettingsManager.setBuildSettings(player, buildSettings);
+            ModifierSettingsManager.setModifierSettings(player, modifierSettings);
             //Send to client
-            EffortlessBuilding.packetHandler.sendTo(new BuildSettingsMessage(buildSettings), player);
+            EffortlessBuilding.packetHandler.sendTo(new ModifierSettingsMessage(modifierSettings), player);
 
-            sender.sendMessage(new TextComponentString("Reach level of " + sender.getName() + " set to " + buildSettings.getReachUpgrade()));
+            sender.sendMessage(new TextComponentString("Reach level of " + sender.getName() + " set to " + modifierSettings
+                    .getReachUpgrade()));
         }
     }
 }

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

@@ -1,10 +1,9 @@
-package nl.requios.effortlessbuilding.gui;
+package nl.requios.effortlessbuilding.gui.buildmode;
 
 import java.io.IOException;
 import java.util.ArrayList;
 import java.util.concurrent.TimeUnit;
 
-import nl.requios.effortlessbuilding.buildmode.BuildModes;
 import nl.requios.effortlessbuilding.proxy.ClientProxy;
 import org.lwjgl.opengl.GL11;
 

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

@@ -1,13 +1,13 @@
-package nl.requios.effortlessbuilding.gui;
+package nl.requios.effortlessbuilding.gui.buildmodifier;
 
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiScreen;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraftforge.fml.client.config.GuiCheckBox;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmodifier.Array;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.gui.elements.GuiCollapsibleScrollEntry;
 import nl.requios.effortlessbuilding.gui.elements.GuiNumberField;
 import nl.requios.effortlessbuilding.gui.elements.GuiScrollPane;
@@ -58,9 +58,9 @@ public class ArraySettingsGui extends GuiCollapsibleScrollEntry {
         textArrayCount.setTooltip("How many copies should be made.");
         arrayNumberFieldList.add(textArrayCount);
 
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(mc.player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
-        if (buildSettings != null) {
+        if (modifierSettings != null) {
-            Array.ArraySettings a = buildSettings.getArraySettings();
+            Array.ArraySettings a = modifierSettings.getArraySettings();
             buttonArrayEnabled.setIsChecked(a.enabled);
             textArrayOffsetX.setNumber(a.offset.getX());
             textArrayOffsetY.setNumber(a.offset.getY());

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

@@ -1,4 +1,4 @@
-package nl.requios.effortlessbuilding.gui;
+package nl.requios.effortlessbuilding.gui.buildmodifier;
 
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiScreen;
@@ -6,9 +6,9 @@ import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraftforge.fml.client.config.GuiCheckBox;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmodifier.Mirror;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.gui.elements.GuiCollapsibleScrollEntry;
 import nl.requios.effortlessbuilding.gui.elements.GuiIconButton;
 import nl.requios.effortlessbuilding.gui.elements.GuiNumberField;
@@ -98,9 +98,9 @@ public class MirrorSettingsGui extends GuiCollapsibleScrollEntry {
         buttonDrawPlanes.setTooltip("Show area");
         mirrorIconButtonList.add(buttonDrawPlanes);
 
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(mc.player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
-        if (buildSettings != null) {
+        if (modifierSettings != null) {
-            Mirror.MirrorSettings m = buildSettings.getMirrorSettings();
+            Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
             buttonMirrorEnabled.setIsChecked(m.enabled);
             textMirrorPosX.setNumber(m.position.x);
             textMirrorPosY.setNumber(m.position.y);

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

@@ -1,19 +1,19 @@
-package nl.requios.effortlessbuilding.gui;
+package nl.requios.effortlessbuilding.gui.buildmodifier;
 
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiScreen;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmodifier.Array;
 import nl.requios.effortlessbuilding.buildmodifier.Mirror;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
 import nl.requios.effortlessbuilding.gui.elements.GuiScrollPane;
-import nl.requios.effortlessbuilding.network.BuildSettingsMessage;
+import nl.requios.effortlessbuilding.network.ModifierSettingsMessage;
 import nl.requios.effortlessbuilding.proxy.ClientProxy;
 
 import java.io.IOException;
 
-public class SettingsGui extends GuiScreen {
+public class ModifierSettingsGui extends GuiScreen {
 
     private GuiScrollPane scrollPane;
     private GuiButton buttonClose;
@@ -118,20 +118,20 @@ public class SettingsGui extends GuiScreen {
         Array.ArraySettings a = arraySettingsGui.getArraySettings();
         RadialMirror.RadialMirrorSettings r = radialMirrorSettingsGui.getRadialMirrorSettings();
 
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(mc.player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
-        if (buildSettings == null) buildSettings = new BuildSettingsManager.BuildSettings();
+        if (modifierSettings == null) modifierSettings = new ModifierSettingsManager.ModifierSettings();
-        buildSettings.setMirrorSettings(m);
+        modifierSettings.setMirrorSettings(m);
-        buildSettings.setArraySettings(a);
+        modifierSettings.setArraySettings(a);
-        buildSettings.setRadialMirrorSettings(r);
+        modifierSettings.setRadialMirrorSettings(r);
 
         //Sanitize
-        String error = BuildSettingsManager.sanitize(buildSettings, mc.player);
+        String error = ModifierSettingsManager.sanitize(modifierSettings, mc.player);
         if (!error.isEmpty()) EffortlessBuilding.log(mc.player, error);
 
-        BuildSettingsManager.setBuildSettings(mc.player, buildSettings);
+        ModifierSettingsManager.setModifierSettings(mc.player, modifierSettings);
 
         //Send to server
-        EffortlessBuilding.packetHandler.sendToServer(new BuildSettingsMessage(buildSettings));
+        EffortlessBuilding.packetHandler.sendToServer(new ModifierSettingsMessage(modifierSettings));
     }
 
 }

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

@@ -1,4 +1,4 @@
-package nl.requios.effortlessbuilding.gui;
+package nl.requios.effortlessbuilding.gui.buildmodifier;
 
 import net.minecraft.client.gui.GuiButton;
 import net.minecraft.client.gui.GuiScreen;
@@ -6,8 +6,8 @@ import net.minecraft.util.ResourceLocation;
 import net.minecraft.util.math.Vec3d;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraftforge.fml.client.config.GuiCheckBox;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
 import nl.requios.effortlessbuilding.gui.elements.GuiCollapsibleScrollEntry;
 import nl.requios.effortlessbuilding.gui.elements.GuiIconButton;
@@ -98,9 +98,9 @@ public class RadialMirrorSettingsGui extends GuiCollapsibleScrollEntry {
         buttonRadialMirrorAlternate = new GuiCheckBox(id++, left + 140, y, " Alternate", false);
         radialMirrorButtonList.add(buttonRadialMirrorAlternate);
 
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(mc.player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
-        if (buildSettings != null) {
+        if (modifierSettings != null) {
-            RadialMirror.RadialMirrorSettings r = buildSettings.getRadialMirrorSettings();
+            RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
             buttonRadialMirrorEnabled.setIsChecked(r.enabled);
             textRadialMirrorPosX.setNumber(r.position.x);
             textRadialMirrorPosY.setNumber(r.position.y);

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

@@ -2,7 +2,7 @@ package nl.requios.effortlessbuilding.helper;
 
 import net.minecraft.entity.player.EntityPlayer;
 import nl.requios.effortlessbuilding.BuildConfig;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 
 public class ReachHelper {
     public static int getMaxReach(EntityPlayer player) {
@@ -11,7 +11,7 @@ public class ReachHelper {
         if (!BuildConfig.reach.enableReachUpgrades) return BuildConfig.reach.maxReachLevel3;
 
         //Check buildsettings for reachUpgrade
-        int reachUpgrade = BuildSettingsManager.getBuildSettings(player).getReachUpgrade();
+        int reachUpgrade = ModifierSettingsManager.getModifierSettings(player).getReachUpgrade();
         switch (reachUpgrade) {
             case 0: return BuildConfig.reach.maxReachLevel0;
             case 1: return BuildConfig.reach.maxReachLevel1;
@@ -21,6 +21,15 @@ public class ReachHelper {
         return BuildConfig.reach.maxReachLevel0;
     }
 
+    public static int getPlacementReach(EntityPlayer player) {
+        return getMaxReach(player) / 4;
+    }
+
+    public static int getMaxBlocksPlacedAtOnce(EntityPlayer player) {
+        if (player.isCreative()) return 1000000;
+        return getMaxReach(player) / 2;
+    }
+
     public static boolean canBreakFar(EntityPlayer player) {
         return player.isCreative() || BuildConfig.survivalBalancers.breakFar;
     }

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

@@ -3,6 +3,7 @@ package nl.requios.effortlessbuilding.helper;
 import net.minecraft.block.Block;
 import net.minecraft.block.state.IBlockState;
 import net.minecraft.client.Minecraft;
+import net.minecraft.client.entity.EntityPlayerSP;
 import net.minecraft.client.renderer.*;
 import net.minecraft.client.renderer.texture.TextureMap;
 import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
@@ -24,9 +25,13 @@ import net.minecraftforge.fml.common.Mod;
 import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import net.minecraftforge.fml.relauncher.Side;
 import nl.requios.effortlessbuilding.BuildConfig;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
+import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
+import nl.requios.effortlessbuilding.buildmode.IBuildMode;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
 import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
 import nl.requios.effortlessbuilding.buildmodifier.Mirror;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
 import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
 import nl.requios.effortlessbuilding.proxy.ClientProxy;
@@ -127,13 +132,14 @@ public class RenderHelper implements IWorldEventListener {
     @SubscribeEvent
     public static void onRender(RenderWorldLastEvent event) {
         EntityPlayer player = Minecraft.getMinecraft().player;
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(player);
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
 
         begin(event.getPartialTicks());
 
         beginLines();
         //Mirror lines and areas
-        Mirror.MirrorSettings m = buildSettings.getMirrorSettings();
+        Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
         if (m != null && m.enabled && (m.mirrorX || m.mirrorY || m.mirrorZ))
         {
             Vec3d pos = m.position.add(epsilon);
@@ -170,7 +176,7 @@ public class RenderHelper implements IWorldEventListener {
         }
 
         //Radial mirror lines and areas
-        RadialMirror.RadialMirrorSettings r = buildSettings.getRadialMirrorSettings();
+        RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
         if (r != null && r.enabled)
         {
             Vec3d pos = r.position.add(epsilon);
@@ -193,30 +199,59 @@ public class RenderHelper implements IWorldEventListener {
 
         //Render block previews
         RayTraceResult lookingAt = ClientProxy.getLookingAt(player);
-        //Checking for null is necessary! Even in vanilla when looking down ladders it is occasionally null (instead of Type MISS)
+        if (modeSettings.getBuildMode() == BuildModes.BuildModeEnum.Normal) lookingAt = Minecraft.getMinecraft().objectMouseOver;
-        if (lookingAt != null && lookingAt.typeOfHit == RayTraceResult.Type.BLOCK)
-        {
-            beginBlockPreviews();
-            BlockRendererDispatcher dispatcher = Minecraft.getMinecraft().getBlockRendererDispatcher();
-            BlockPos startPos = lookingAt.getBlockPos();
 
-            //Check if tool (or none) in hand
         ItemStack mainhand = player.getHeldItemMainhand();
         boolean toolInHand = !(!mainhand.isEmpty() && (mainhand.getItem() instanceof ItemBlock || mainhand.getItem() instanceof ItemRandomizerBag));
-            boolean replaceable =
+
-                    player.world.getBlockState(startPos).getBlock().isReplaceable(player.world, startPos);
+        BlockPos startPos = null;
-            if (!buildSettings.doQuickReplace() && !toolInHand && !replaceable) {
+        EnumFacing sideHit = null;
+        Vec3d hitVec = null;
+
+        //Checking for null is necessary! Even in vanilla when looking down ladders it is occasionally null (instead of Type MISS)
+        if (lookingAt != null && lookingAt.typeOfHit == RayTraceResult.Type.BLOCK) {
+            startPos = lookingAt.getBlockPos();
+
+            //Check if tool (or none) in hand
+            boolean replaceable = player.world.getBlockState(startPos).getBlock().isReplaceable(player.world, startPos);
+            if (!modifierSettings.doQuickReplace() && !toolInHand && !replaceable) {
                 startPos = startPos.offset(lookingAt.sideHit);
             }
 
             //Get under tall grass and other replaceable blocks
-            if (buildSettings.doQuickReplace() && !toolInHand && replaceable) {
+            if (modifierSettings.doQuickReplace() && !toolInHand && replaceable) {
                 startPos = startPos.down();
             }
 
-            if (BuildModifiers.isEnabled(buildSettings, startPos) || BuildConfig.visuals.alwaysShowBlockPreview) {
+            sideHit = lookingAt.sideHit;
+            hitVec = lookingAt.hitVec;
+        }
+
+        //Dont render if in normal mode and modifiers are disabled
+        //Unless alwaysShowBlockPreview is true in config
+        if (modeSettings.getBuildMode() != BuildModes.BuildModeEnum.Normal ||
+            (startPos != null && BuildModifiers.isEnabled(modifierSettings, startPos)) ||
+            BuildConfig.visuals.alwaysShowBlockPreview) {
+
+            beginBlockPreviews();
+
+            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) {
+                BlockRendererDispatcher dispatcher = Minecraft.getMinecraft().getBlockRendererDispatcher();
+
                 //get coordinates
-                List<BlockPos> newCoordinates = BuildModifiers.findCoordinates(player, startPos);
+                List<BlockPos> startCoordinates = BuildModes.findCoordinates(player, startPos);
+
+                //Limit number of blocks you can place
+                int limit = ReachHelper.getMaxBlocksPlacedAtOnce(player);
+                if (startCoordinates.size() > limit) {
+                    startCoordinates = startCoordinates.subList(0, limit);
+                }
+
+                List<BlockPos> newCoordinates = BuildModifiers.findCoordinates(player, startCoordinates);
 
                 //check if they are different from previous
                 if (!BuildModifiers.compareCoordinates(previousCoordinates, newCoordinates)) {
@@ -225,11 +260,10 @@ public class RenderHelper implements IWorldEventListener {
                     ItemRandomizerBag.renewRandomness();
                 }
 
-                Vec3d hitVec = lookingAt.hitVec;
                 hitVec = new Vec3d(Math.abs(hitVec.x - ((int) hitVec.x)), Math.abs(hitVec.y - ((int) hitVec.y)),
                         Math.abs(hitVec.z - ((int) hitVec.z)));
                 List<ItemStack> itemStacks = new ArrayList<>();
-                List<IBlockState> blockStates = BuildModifiers.findBlockStates(player, startPos, hitVec, lookingAt.sideHit, itemStacks);
+                List<IBlockState> blockStates = BuildModifiers.findBlockStates(player, startCoordinates, hitVec, lookingAt.sideHit, itemStacks);
 
                 //check if valid blockstates
                 if (blockStates.size() != 0 && newCoordinates.size() == blockStates.size()) {
@@ -425,8 +459,8 @@ public class RenderHelper implements IWorldEventListener {
     public void sendBlockBreakProgress(int breakerId, BlockPos pos, int progress) {
         Minecraft mc = Minecraft.getMinecraft();
 
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(mc.player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
-        if (!BuildModifiers.isEnabled(buildSettings, pos)) return;
+        if (!BuildModifiers.isEnabled(modifierSettings, pos)) return;
 
         List<BlockPos> coordinates = BuildModifiers.findCoordinates(mc.player, pos);
         for (int i = 1; i < coordinates.size(); i++) {

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

@@ -21,8 +21,8 @@ import net.minecraft.world.IBlockAccess;
 import net.minecraft.world.World;
 import net.minecraftforge.items.IItemHandler;
 import net.minecraftforge.items.ItemHandlerHelper;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
 
 import javax.annotation.Nonnull;
@@ -216,7 +216,7 @@ public class SurvivalHelper {
         }
 
         //Check quickreplace
-        if (placer instanceof EntityPlayer && BuildSettingsManager.getBuildSettings(((EntityPlayer) placer)).doQuickReplace()) {
+        if (placer instanceof EntityPlayer && ModifierSettingsManager.getModifierSettings(((EntityPlayer) placer)).doQuickReplace()) {
             return true;
         }
 

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

@@ -10,8 +10,8 @@ import net.minecraft.util.*;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraft.world.World;
 import nl.requios.effortlessbuilding.BuildConfig;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
 
 import javax.annotation.Nullable;
@@ -35,10 +35,10 @@ public class ItemReachUpgrade1 extends Item {
             return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
         }
 
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-        int currentLevel = buildSettings.getReachUpgrade();
+        int currentLevel = modifierSettings.getReachUpgrade();
         if (currentLevel == 0) {
-            buildSettings.setReachUpgrade(1);
+            modifierSettings.setReachUpgrade(1);
 
             if (world.isRemote) EffortlessBuilding.log(player, "Upgraded reach to " + ReachHelper.getMaxReach(player));
             player.setHeldItem(hand, ItemStack.EMPTY);

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

@@ -9,8 +9,8 @@ import net.minecraft.util.*;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraft.world.World;
 import nl.requios.effortlessbuilding.BuildConfig;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
 
 import javax.annotation.Nullable;
@@ -34,10 +34,10 @@ public class ItemReachUpgrade2 extends Item {
             return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
         }
 
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-        int currentLevel = buildSettings.getReachUpgrade();
+        int currentLevel = modifierSettings.getReachUpgrade();
         if (currentLevel == 1) {
-            buildSettings.setReachUpgrade(2);
+            modifierSettings.setReachUpgrade(2);
             if (world.isRemote) EffortlessBuilding.log(player, "Upgraded reach to " + ReachHelper.getMaxReach(player));
             player.setHeldItem(hand, ItemStack.EMPTY);
 

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

@@ -9,8 +9,8 @@ import net.minecraft.util.*;
 import net.minecraft.util.text.TextFormatting;
 import net.minecraft.world.World;
 import nl.requios.effortlessbuilding.BuildConfig;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
 
 import javax.annotation.Nullable;
@@ -34,10 +34,10 @@ public class ItemReachUpgrade3 extends Item {
             return new ActionResult<>(EnumActionResult.PASS, player.getHeldItem(hand));
         }
 
-        BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(player);
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-        int currentLevel = buildSettings.getReachUpgrade();
+        int currentLevel = modifierSettings.getReachUpgrade();
         if (currentLevel == 2) {
-            buildSettings.setReachUpgrade(3);
+            modifierSettings.setReachUpgrade(3);
             if (world.isRemote) EffortlessBuilding.log(player, "Upgraded reach to " + ReachHelper.getMaxReach(player));
             player.setHeldItem(hand, ItemStack.EMPTY);
 

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

@@ -10,6 +10,7 @@ import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 import net.minecraftforge.fml.relauncher.Side;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
 import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
 
 public class BlockBrokenMessage implements IMessage {
@@ -80,7 +81,7 @@ public class BlockBrokenMessage implements IMessage {
             if (ctx.side == Side.SERVER) {
                 //Received serverside
                 EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
-                    BuildModifiers.onBlockBrokenMessage(ctx.getServerHandler().player, message);
+                    BuildModes.onBlockBrokenMessage(ctx.getServerHandler().player, message);
                 });
             }
             // No response packet

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

@@ -10,6 +10,7 @@ import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 import net.minecraftforge.fml.relauncher.Side;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
 import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
 import nl.requios.effortlessbuilding.proxy.ClientProxy;
 
@@ -85,7 +86,7 @@ public class BlockPlacedMessage implements IMessage {
             } else {
                 //Received serverside
                 EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
-                    BuildModifiers.onBlockPlacedMessage(ctx.getServerHandler().player, message);
+                    BuildModes.onBlockPlacedMessage(ctx.getServerHandler().player, message);
                 });
                 // No response packet
                 return null;

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

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

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

@@ -8,28 +8,29 @@ import net.minecraft.util.math.Vec3d;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
 import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
-import nl.requios.effortlessbuilding.BuildSettingsManager.BuildSettings;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmodifier.Array;
 import nl.requios.effortlessbuilding.buildmodifier.Mirror;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
 
-public class BuildSettingsMessage implements IMessage {
+import static nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager.*;
 
-    private BuildSettings buildSettings;
+public class ModifierSettingsMessage implements IMessage {
 
-    public BuildSettingsMessage() {
+    private ModifierSettings modifierSettings;
+
+    public ModifierSettingsMessage() {
     }
 
-    public BuildSettingsMessage(BuildSettings buildSettings) {
+    public ModifierSettingsMessage(ModifierSettings modifierSettings) {
-        this.buildSettings = buildSettings;
+        this.modifierSettings = modifierSettings;
     }
 
     @Override
     public void toBytes(ByteBuf buf) {
         //MIRROR
-        Mirror.MirrorSettings m = buildSettings.getMirrorSettings();
+        Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
         buf.writeBoolean(m != null);
         if (m != null) {
             buf.writeBoolean(m.enabled);
@@ -45,7 +46,7 @@ public class BuildSettingsMessage implements IMessage {
         }
 
         //ARRAY
-        Array.ArraySettings a = buildSettings.getArraySettings();
+        Array.ArraySettings a = modifierSettings.getArraySettings();
         buf.writeBoolean(a != null);
         if (a != null) {
             buf.writeBoolean(a.enabled);
@@ -55,12 +56,12 @@ public class BuildSettingsMessage implements IMessage {
             buf.writeInt(a.count);
         }
 
-        buf.writeBoolean(buildSettings.doQuickReplace());
+        buf.writeBoolean(modifierSettings.doQuickReplace());
 
-        buf.writeInt(buildSettings.getReachUpgrade());
+        buf.writeInt(modifierSettings.getReachUpgrade());
 
         //RADIAL MIRROR
-        RadialMirror.RadialMirrorSettings r = buildSettings.getRadialMirrorSettings();
+        RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
         buf.writeBoolean(r != null);
         if (r != null) {
             buf.writeBoolean(r.enabled);
@@ -119,19 +120,19 @@ public class BuildSettingsMessage implements IMessage {
                             radialMirrorAlternate, radialMirrorRadius, radialMirrorDrawLines, radialMirrorDrawPlanes);
         }
 
-        buildSettings = new BuildSettings(m, a, r, quickReplace, reachUpgrade);
+        modifierSettings = new ModifierSettings(m, a, r, quickReplace, reachUpgrade);
     }
 
     // The params of the IMessageHandler are <REQ, REPLY>
-    public static class MessageHandler implements IMessageHandler<BuildSettingsMessage, IMessage> {
+    public static class MessageHandler implements IMessageHandler<ModifierSettingsMessage, IMessage> {
         // Do note that the default constructor is required, but implicitly defined in this case
 
         @Override
-        public IMessage onMessage(BuildSettingsMessage message, MessageContext ctx) {
+        public IMessage onMessage(ModifierSettingsMessage message, MessageContext ctx) {
             //EffortlessBuilding.log("message received on " + ctx.side + " side");
 
             // The value that was sent
-            BuildSettings buildSettings = message.buildSettings;
+            ModifierSettings modifierSettings = message.modifierSettings;
 
             // Execute the action on the main server thread by adding it as a scheduled task
             IThreadListener threadListener = EffortlessBuilding.proxy.getThreadListenerFromContext(ctx);
@@ -139,9 +140,9 @@ public class BuildSettingsMessage implements IMessage {
                 EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
 
                 // Sanitize
-                BuildSettingsManager.sanitize(buildSettings, player);
+                ModifierSettingsManager.sanitize(modifierSettings, player);
 
-                BuildSettingsManager.setBuildSettings(player, buildSettings);
+                ModifierSettingsManager.setModifierSettings(player, modifierSettings);
             });
             // No response packet
             return null;

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

@@ -43,18 +43,19 @@ import net.minecraftforge.fml.common.gameevent.InputEvent;
 import net.minecraftforge.fml.common.gameevent.TickEvent;
 import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 import net.minecraftforge.fml.relauncher.Side;
-import nl.requios.effortlessbuilding.BuildSettingsManager;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmode.BuildModes;
-import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
+import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
-import nl.requios.effortlessbuilding.gui.RadialMenu;
+import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
-import nl.requios.effortlessbuilding.gui.SettingsGui;
+import nl.requios.effortlessbuilding.gui.buildmode.RadialMenu;
+import nl.requios.effortlessbuilding.gui.buildmodifier.ModifierSettingsGui;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
 import nl.requios.effortlessbuilding.helper.RenderHelper;
 import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
 import nl.requios.effortlessbuilding.network.BlockBrokenMessage;
 import nl.requios.effortlessbuilding.network.BlockPlacedMessage;
-import nl.requios.effortlessbuilding.network.BuildSettingsMessage;
+import nl.requios.effortlessbuilding.network.ModeSettingsMessage;
+import nl.requios.effortlessbuilding.network.ModifierSettingsMessage;
 import org.lwjgl.input.Keyboard;
 import org.lwjgl.input.Mouse;
 
@@ -202,9 +203,11 @@ public class ClientProxy implements IProxy {
         Minecraft mc = Minecraft.getMinecraft();
         EntityPlayerSP player = mc.player;
 
-        if (Minecraft.getMinecraft().currentScreen != null) return;
+        if (Minecraft.getMinecraft().currentScreen != null ||
-
+            ModeSettingsManager.getModeSettings(player).getBuildMode() == BuildModes.BuildModeEnum.Normal ||
-        if (!BuildModifiers.isEnabled(BuildSettingsManager.getBuildSettings(player), player.getPosition())) return;
+            RadialMenu.instance.isVisible()) {
+            return;
+        }
 
         if (mc.gameSettings.keyBindUseItem.isPressed()) {
             //KeyBinding.setKeyBindState(mc.gameSettings.keyBindUseItem.getKeyCode(), false);
@@ -212,13 +215,15 @@ public class ClientProxy implements IProxy {
             ItemStack currentItemStack = player.getHeldItem(EnumHand.MAIN_HAND);
             if (currentItemStack.getItem() instanceof ItemBlock ||
                 (currentItemStack.getItem() instanceof ItemRandomizerBag && !player.isSneaking())) {
+
                 //find position in distance
                 RayTraceResult lookingAt = getLookingAt(player);
-                if (lookingAt != null && lookingAt.typeOfHit == RayTraceResult.Type.BLOCK) {
                 EffortlessBuilding.packetHandler.sendToServer(new BlockPlacedMessage(lookingAt));
 
                 //play sound if further than normal
-                    if ((lookingAt.hitVec.subtract(player.getPositionEyes(1f))).lengthSquared() > 25f) {
+                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);
@@ -228,7 +233,6 @@ public class ClientProxy implements IProxy {
                 }
             }
         }
-        }
 
         if (mc.gameSettings.keyBindAttack.isKeyDown()) {
             //KeyBinding.setKeyBindState(mc.gameSettings.keyBindAttack.getKeyCode(), false);
@@ -271,7 +275,7 @@ public class ClientProxy implements IProxy {
                 EffortlessBuilding.log(player, "Effortless Building is disabled until your reach has increased. Increase your reach with craftable reach upgrades.");
             } else {
                 if (Minecraft.getMinecraft().currentScreen == null) {
-                    Minecraft.getMinecraft().displayGuiScreen(new SettingsGui());
+                    Minecraft.getMinecraft().displayGuiScreen(new ModifierSettingsGui());
                 } else {
                     player.closeScreen();
                 }
@@ -280,10 +284,11 @@ public class ClientProxy implements IProxy {
 
         //QuickReplace toggle
         if (keyBindings[1].isPressed()) {
-            BuildSettingsManager.BuildSettings buildSettings = BuildSettingsManager.getBuildSettings(player);
+            ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-            buildSettings.setQuickReplace(!buildSettings.doQuickReplace());
+            modifierSettings.setQuickReplace(!modifierSettings.doQuickReplace());
-            EffortlessBuilding.log(player, "Set "+ TextFormatting.GOLD + "Quick Replace " + TextFormatting.RESET + (buildSettings.doQuickReplace() ? "on" : "off"));
+            EffortlessBuilding.log(player, "Set "+ TextFormatting.GOLD + "Quick Replace " + TextFormatting.RESET + (
-            EffortlessBuilding.packetHandler.sendToServer(new BuildSettingsMessage(buildSettings));
+                    modifierSettings.doQuickReplace() ? "on" : "off"));
+            EffortlessBuilding.packetHandler.sendToServer(new ModifierSettingsMessage(modifierSettings));
         }
 
         //Creative/survival mode toggle
@@ -326,9 +331,11 @@ public class ClientProxy implements IProxy {
 
     @SubscribeEvent
     public static void onRenderGameOverlay(final RenderGameOverlayEvent.Post event ) {
+        EntityPlayerSP player = Minecraft.getMinecraft().player;
+
         //final ChiselToolType tool = getHeldToolType( lastHand );
         final RenderGameOverlayEvent.ElementType type = event.getType();
-        //TODO check if chisel tool in hand (and has menu)
+        //TODO check if chisel and bits tool in hand (and has menu)
         if (type == RenderGameOverlayEvent.ElementType.ALL)
         {
             final boolean wasVisible = RadialMenu.instance.isVisible();
@@ -342,10 +349,16 @@ public class ClientProxy implements IProxy {
             {
                 if ( !RadialMenu.instance.actionUsed )
                 {
+                    ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+
                     if ( RadialMenu.instance.switchTo != null )
                     {
                         ClientProxy.playRadialMenuSound();
-                        BuildModes.setBuildMode(Minecraft.getMinecraft().player, RadialMenu.instance.switchTo);
+                        modeSettings.setBuildMode(RadialMenu.instance.switchTo);
+                        ModeSettingsManager.setModeSettings(player, modeSettings);
+                        EffortlessBuilding.packetHandler.sendToServer(new ModeSettingsMessage(modeSettings));
+
+                        EffortlessBuilding.log(player, modeSettings.getBuildMode().name, true);
                     }
 
                     //TODO change buildmode settings
@@ -404,7 +417,7 @@ public class ClientProxy implements IProxy {
 //        World world = player.world;
 
         //base distance off of player ability (config)
-        float raytraceRange = ReachHelper.getMaxReach(player) / 4f;
+        float raytraceRange = ReachHelper.getPlacementReach(player);
 
 //        Vec3d look = player.getLookVec();
 //        Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);