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

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

.gitattributes

@@ -1,5 +0,0 @@
-# Disable autocrlf on generated files, they always generate with LF
-# Add any extra files or paths here to make git stop saying they
-# are changed when only line endings change.
-src/generated/**/.cache/cache text eol=lf
-src/generated/**/*.json text eol=lf

.gitignore

@@ -1,26 +1,43 @@
-# eclipse
+## Based on GitHub's Eclipse .gitignore
-bin
-*.launch
-.settings
-.metadata
-.classpath
-.project
 
-# idea
+classes/
-out
+run/
-*.ipr
+.gradle/
-*.iws
+build/
+gradle-app.setting
+
+## IntelliJ IDEA
+
+.idea/
 *.iml
-.idea
+*.iws
+*.ipr
 
-# gradle
+## Eclipse
-build
-.gradle
 
-# other
+eclipse/
-eclipse
+*.pydevproject
-run
+.project
-logs/*
+.metadata
+bin/
+tmp/
+*.tmp
+*.bak
+*.swp
+*~.nib
+local.properties
+.classpath
+.settings/
+.loadpath
 
-# Files from Forge MDK
+# External tool builders
-forge*changelog.txt
+.externalToolBuilders/
+
+# Locally stored "Eclipse launch configurations"
+*.launch
+
+# CDT-specific
+.cproject
+
+# PDT-specific
+.buildpath

LICENSE.txt

@@ -1,520 +0,0 @@
-Unless noted below, Minecraft Forge, Forge Mod Loader, and all 
-parts herein are licensed under the terms of the LGPL 2.1 found
-here http://www.gnu.org/licenses/old-licenses/lgpl-2.1.txt and 
-copied below.
-
-Homepage: http://minecraftforge.net/
-          https://github.com/MinecraftForge/MinecraftForge
-          
-
-A note on authorship:
-All source artifacts are property of their original author, with
-the exclusion of the contents of the patches directory and others
-copied from it from time to time. Authorship of the contents of
-the patches directory is retained by the Minecraft Forge project.
-This is because the patches are partially machine generated
-artifacts, and are changed heavily due to the way forge works.
-Individual attribution within them is impossible.
-
-Consent:
-All contributions to Forge must consent to the release of any
-patch content to the Forge project.
-
-A note on infectivity:
-The LGPL is chosen specifically so that projects may depend on Forge
-features without being infected with its license. That is the 
-purpose of the LGPL. Mods and others using this code via ordinary
-Java mechanics for referencing libraries are specifically not bound
-by Forge's license for the Mod code.
-
-
-=== MCP Data ===
-This software includes data from the Minecraft Coder Pack (MCP), with kind permission
-from them. The license to MCP data is not transitive - distribution of this data by
-third parties requires independent licensing from the MCP team. This data is not
-redistributable without permission from the MCP team.
-
-=== Sharing ===
-I grant permission for some parts of FML to be redistributed outside the terms of the LGPL, for the benefit of
-the minecraft modding community. All contributions to these parts should be licensed under the same additional grant.
-
--- Runtime patcher --
-License is granted to redistribute the runtime patcher code (src/main/java/net/minecraftforge/fml/common/patcher
-and subdirectories) under any alternative open source license as classified by the OSI (http://opensource.org/licenses)
-
--- ASM transformers --
-License is granted to redistribute the ASM transformer code (src/main/java/net/minecraftforge/common/asm/ and subdirectories)
-under any alternative open source license as classified by the OSI (http://opensource.org/licenses)
-
-=========================================================================
-This software includes portions from the Apache Maven project at
-http://maven.apache.org/ specifically the ComparableVersion.java code. It is
-included based on guidelines at
-http://www.softwarefreedom.org/resources/2007/gpl-non-gpl-collaboration.html
-with notices intact. The only change is a non-functional change of package name.
-
-This software contains a partial repackaging of javaxdelta, a BSD licensed program for generating
-binary differences and applying them, sourced from the subversion at http://sourceforge.net/projects/javaxdelta/
-authored by genman, heikok, pivot.
-The only changes are to replace some Trove collection types with standard Java collections, and repackaged.
-=========================================================================
-
-
-                  GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 2.1, February 1999
-
- Copyright (C) 1991, 1999 Free Software Foundation, Inc.
- 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301  USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-[This is the first released version of the Lesser GPL.  It also counts
- as the successor of the GNU Library Public License, version 2, hence
- the version number 2.1.]
-
-                            Preamble
-
-  The licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-Licenses are intended to guarantee your freedom to share and change
-free software--to make sure the software is free for all its users.
-
-  This license, the Lesser General Public License, applies to some
-specially designated software packages--typically libraries--of the
-Free Software Foundation and other authors who decide to use it.  You
-can use it too, but we suggest you first think carefully about whether
-this license or the ordinary General Public License is the better
-strategy to use in any particular case, based on the explanations below.
-
-  When we speak of free software, we are referring to freedom of use,
-not price.  Our General Public Licenses are designed to make sure that
-you have the freedom to distribute copies of free software (and charge
-for this service if you wish); that you receive source code or can get
-it if you want it; that you can change the software and use pieces of
-it in new free programs; and that you are informed that you can do
-these things.
-
-  To protect your rights, we need to make restrictions that forbid
-distributors to deny you these rights or to ask you to surrender these
-rights.  These restrictions translate to certain responsibilities for
-you if you distribute copies of the library or if you modify it.
-
-  For example, if you distribute copies of the library, whether gratis
-or for a fee, you must give the recipients all the rights that we gave
-you.  You must make sure that they, too, receive or can get the source
-code.  If you link other code with the library, you must provide
-complete object files to the recipients, so that they can relink them
-with the library after making changes to the library and recompiling
-it.  And you must show them these terms so they know their rights.
-
-  We protect your rights with a two-step method: (1) we copyright the
-library, and (2) we offer you this license, which gives you legal
-permission to copy, distribute and/or modify the library.
-
-  To protect each distributor, we want to make it very clear that
-there is no warranty for the free library.  Also, if the library is
-modified by someone else and passed on, the recipients should know
-that what they have is not the original version, so that the original
-author's reputation will not be affected by problems that might be
-introduced by others.
-
-  Finally, software patents pose a constant threat to the existence of
-any free program.  We wish to make sure that a company cannot
-effectively restrict the users of a free program by obtaining a
-restrictive license from a patent holder.  Therefore, we insist that
-any patent license obtained for a version of the library must be
-consistent with the full freedom of use specified in this license.
-
-  Most GNU software, including some libraries, is covered by the
-ordinary GNU General Public License.  This license, the GNU Lesser
-General Public License, applies to certain designated libraries, and
-is quite different from the ordinary General Public License.  We use
-this license for certain libraries in order to permit linking those
-libraries into non-free programs.
-
-  When a program is linked with a library, whether statically or using
-a shared library, the combination of the two is legally speaking a
-combined work, a derivative of the original library.  The ordinary
-General Public License therefore permits such linking only if the
-entire combination fits its criteria of freedom.  The Lesser General
-Public License permits more lax criteria for linking other code with
-the library.
-
-  We call this license the "Lesser" General Public License because it
-does Less to protect the user's freedom than the ordinary General
-Public License.  It also provides other free software developers Less
-of an advantage over competing non-free programs.  These disadvantages
-are the reason we use the ordinary General Public License for many
-libraries.  However, the Lesser license provides advantages in certain
-special circumstances.
-
-  For example, on rare occasions, there may be a special need to
-encourage the widest possible use of a certain library, so that it becomes
-a de-facto standard.  To achieve this, non-free programs must be
-allowed to use the library.  A more frequent case is that a free
-library does the same job as widely used non-free libraries.  In this
-case, there is little to gain by limiting the free library to free
-software only, so we use the Lesser General Public License.
-
-  In other cases, permission to use a particular library in non-free
-programs enables a greater number of people to use a large body of
-free software.  For example, permission to use the GNU C Library in
-non-free programs enables many more people to use the whole GNU
-operating system, as well as its variant, the GNU/Linux operating
-system.
-
-  Although the Lesser General Public License is Less protective of the
-users' freedom, it does ensure that the user of a program that is
-linked with the Library has the freedom and the wherewithal to run
-that program using a modified version of the Library.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.  Pay close attention to the difference between a
-"work based on the library" and a "work that uses the library".  The
-former contains code derived from the library, whereas the latter must
-be combined with the library in order to run.
-
-                  GNU LESSER GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License Agreement applies to any software library or other
-program which contains a notice placed by the copyright holder or
-other authorized party saying it may be distributed under the terms of
-this Lesser General Public License (also called "this License").
-Each licensee is addressed as "you".
-
-  A "library" means a collection of software functions and/or data
-prepared so as to be conveniently linked with application programs
-(which use some of those functions and data) to form executables.
-
-  The "Library", below, refers to any such software library or work
-which has been distributed under these terms.  A "work based on the
-Library" means either the Library or any derivative work under
-copyright law: that is to say, a work containing the Library or a
-portion of it, either verbatim or with modifications and/or translated
-straightforwardly into another language.  (Hereinafter, translation is
-included without limitation in the term "modification".)
-
-  "Source code" for a work means the preferred form of the work for
-making modifications to it.  For a library, complete source code means
-all the source code for all modules it contains, plus any associated
-interface definition files, plus the scripts used to control compilation
-and installation of the library.
-
-  Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running a program using the Library is not restricted, and output from
-such a program is covered only if its contents constitute a work based
-on the Library (independent of the use of the Library in a tool for
-writing it).  Whether that is true depends on what the Library does
-and what the program that uses the Library does.
-
-  1. You may copy and distribute verbatim copies of the Library's
-complete source code as you receive it, in any medium, provided that
-you conspicuously and appropriately publish on each copy an
-appropriate copyright notice and disclaimer of warranty; keep intact
-all the notices that refer to this License and to the absence of any
-warranty; and distribute a copy of this License along with the
-Library.
-
-  You may charge a fee for the physical act of transferring a copy,
-and you may at your option offer warranty protection in exchange for a
-fee.
-
-  2. You may modify your copy or copies of the Library or any portion
-of it, thus forming a work based on the Library, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) The modified work must itself be a software library.
-
-    b) You must cause the files modified to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    c) You must cause the whole of the work to be licensed at no
-    charge to all third parties under the terms of this License.
-
-    d) If a facility in the modified Library refers to a function or a
-    table of data to be supplied by an application program that uses
-    the facility, other than as an argument passed when the facility
-    is invoked, then you must make a good faith effort to ensure that,
-    in the event an application does not supply such function or
-    table, the facility still operates, and performs whatever part of
-    its purpose remains meaningful.
-
-    (For example, a function in a library to compute square roots has
-    a purpose that is entirely well-defined independent of the
-    application.  Therefore, Subsection 2d requires that any
-    application-supplied function or table used by this function must
-    be optional: if the application does not supply it, the square
-    root function must still compute square roots.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Library,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Library, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote
-it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Library.
-
-In addition, mere aggregation of another work not based on the Library
-with the Library (or with a work based on the Library) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may opt to apply the terms of the ordinary GNU General Public
-License instead of this License to a given copy of the Library.  To do
-this, you must alter all the notices that refer to this License, so
-that they refer to the ordinary GNU General Public License, version 2,
-instead of to this License.  (If a newer version than version 2 of the
-ordinary GNU General Public License has appeared, then you can specify
-that version instead if you wish.)  Do not make any other change in
-these notices.
-
-  Once this change is made in a given copy, it is irreversible for
-that copy, so the ordinary GNU General Public License applies to all
-subsequent copies and derivative works made from that copy.
-
-  This option is useful when you wish to copy part of the code of
-the Library into a program that is not a library.
-
-  4. You may copy and distribute the Library (or a portion or
-derivative of it, under Section 2) in object code or executable form
-under the terms of Sections 1 and 2 above provided that you accompany
-it with the complete corresponding machine-readable source code, which
-must be distributed under the terms of Sections 1 and 2 above on a
-medium customarily used for software interchange.
-
-  If distribution of object code is made by offering access to copy
-from a designated place, then offering equivalent access to copy the
-source code from the same place satisfies the requirement to
-distribute the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  5. A program that contains no derivative of any portion of the
-Library, but is designed to work with the Library by being compiled or
-linked with it, is called a "work that uses the Library".  Such a
-work, in isolation, is not a derivative work of the Library, and
-therefore falls outside the scope of this License.
-
-  However, linking a "work that uses the Library" with the Library
-creates an executable that is a derivative of the Library (because it
-contains portions of the Library), rather than a "work that uses the
-library".  The executable is therefore covered by this License.
-Section 6 states terms for distribution of such executables.
-
-  When a "work that uses the Library" uses material from a header file
-that is part of the Library, the object code for the work may be a
-derivative work of the Library even though the source code is not.
-Whether this is true is especially significant if the work can be
-linked without the Library, or if the work is itself a library.  The
-threshold for this to be true is not precisely defined by law.
-
-  If such an object file uses only numerical parameters, data
-structure layouts and accessors, and small macros and small inline
-functions (ten lines or less in length), then the use of the object
-file is unrestricted, regardless of whether it is legally a derivative
-work.  (Executables containing this object code plus portions of the
-Library will still fall under Section 6.)
-
-  Otherwise, if the work is a derivative of the Library, you may
-distribute the object code for the work under the terms of Section 6.
-Any executables containing that work also fall under Section 6,
-whether or not they are linked directly with the Library itself.
-
-  6. As an exception to the Sections above, you may also combine or
-link a "work that uses the Library" with the Library to produce a
-work containing portions of the Library, and distribute that work
-under terms of your choice, provided that the terms permit
-modification of the work for the customer's own use and reverse
-engineering for debugging such modifications.
-
-  You must give prominent notice with each copy of the work that the
-Library is used in it and that the Library and its use are covered by
-this License.  You must supply a copy of this License.  If the work
-during execution displays copyright notices, you must include the
-copyright notice for the Library among them, as well as a reference
-directing the user to the copy of this License.  Also, you must do one
-of these things:
-
-    a) Accompany the work with the complete corresponding
-    machine-readable source code for the Library including whatever
-    changes were used in the work (which must be distributed under
-    Sections 1 and 2 above); and, if the work is an executable linked
-    with the Library, with the complete machine-readable "work that
-    uses the Library", as object code and/or source code, so that the
-    user can modify the Library and then relink to produce a modified
-    executable containing the modified Library.  (It is understood
-    that the user who changes the contents of definitions files in the
-    Library will not necessarily be able to recompile the application
-    to use the modified definitions.)
-
-    b) Use a suitable shared library mechanism for linking with the
-    Library.  A suitable mechanism is one that (1) uses at run time a
-    copy of the library already present on the user's computer system,
-    rather than copying library functions into the executable, and (2)
-    will operate properly with a modified version of the library, if
-    the user installs one, as long as the modified version is
-    interface-compatible with the version that the work was made with.
-
-    c) Accompany the work with a written offer, valid for at
-    least three years, to give the same user the materials
-    specified in Subsection 6a, above, for a charge no more
-    than the cost of performing this distribution.
-
-    d) If distribution of the work is made by offering access to copy
-    from a designated place, offer equivalent access to copy the above
-    specified materials from the same place.
-
-    e) Verify that the user has already received a copy of these
-    materials or that you have already sent this user a copy.
-
-  For an executable, the required form of the "work that uses the
-Library" must include any data and utility programs needed for
-reproducing the executable from it.  However, as a special exception,
-the materials to be distributed need not include anything that is
-normally distributed (in either source or binary form) with the major
-components (compiler, kernel, and so on) of the operating system on
-which the executable runs, unless that component itself accompanies
-the executable.
-
-  It may happen that this requirement contradicts the license
-restrictions of other proprietary libraries that do not normally
-accompany the operating system.  Such a contradiction means you cannot
-use both them and the Library together in an executable that you
-distribute.
-
-  7. You may place library facilities that are a work based on the
-Library side-by-side in a single library together with other library
-facilities not covered by this License, and distribute such a combined
-library, provided that the separate distribution of the work based on
-the Library and of the other library facilities is otherwise
-permitted, and provided that you do these two things:
-
-    a) Accompany the combined library with a copy of the same work
-    based on the Library, uncombined with any other library
-    facilities.  This must be distributed under the terms of the
-    Sections above.
-
-    b) Give prominent notice with the combined library of the fact
-    that part of it is a work based on the Library, and explaining
-    where to find the accompanying uncombined form of the same work.
-
-  8. You may not copy, modify, sublicense, link with, or distribute
-the Library except as expressly provided under this License.  Any
-attempt otherwise to copy, modify, sublicense, link with, or
-distribute the Library is void, and will automatically terminate your
-rights under this License.  However, parties who have received copies,
-or rights, from you under this License will not have their licenses
-terminated so long as such parties remain in full compliance.
-
-  9. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Library or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Library (or any work based on the
-Library), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Library or works based on it.
-
-  10. Each time you redistribute the Library (or any work based on the
-Library), the recipient automatically receives a license from the
-original licensor to copy, distribute, link with or modify the Library
-subject to these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties with
-this License.
-
-  11. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Library at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Library by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Library.
-
-If any portion of this section is held invalid or unenforceable under any
-particular circumstance, the balance of the section is intended to apply,
-and the section as a whole is intended to apply in other circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  12. If the distribution and/or use of the Library is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Library under this License may add
-an explicit geographical distribution limitation excluding those countries,
-so that distribution is permitted only in or among countries not thus
-excluded.  In such case, this License incorporates the limitation as if
-written in the body of this License.
-
-  13. The Free Software Foundation may publish revised and/or new
-versions of the Lesser General Public License from time to time.
-Such new versions will be similar in spirit to the present version,
-but may differ in detail to address new problems or concerns.
-
-Each version is given a distinguishing version number.  If the Library
-specifies a version number of this License which applies to it and
-"any later version", you have the option of following the terms and
-conditions either of that version or of any later version published by
-the Free Software Foundation.  If the Library does not specify a
-license version number, you may choose any version ever published by
-the Free Software Foundation.
-
-  14. If you wish to incorporate parts of the Library into other free
-programs whose distribution conditions are incompatible with these,
-write to the author to ask for permission.  For software which is
-copyrighted by the Free Software Foundation, write to the Free
-Software Foundation; we sometimes make exceptions for this.  Our
-decision will be guided by the two goals of preserving the free status
-of all derivatives of our free software and of promoting the sharing
-and reuse of software generally.
-
-                            NO WARRANTY
-
-  15. BECAUSE THE LIBRARY IS LICENSED FREE OF CHARGE, THERE IS NO
-WARRANTY FOR THE LIBRARY, TO THE EXTENT PERMITTED BY APPLICABLE LAW.
-EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR
-OTHER PARTIES PROVIDE THE LIBRARY "AS IS" WITHOUT WARRANTY OF ANY
-KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE
-IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE
-LIBRARY IS WITH YOU.  SHOULD THE LIBRARY PROVE DEFECTIVE, YOU ASSUME
-THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN
-WRITING WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY
-AND/OR REDISTRIBUTE THE LIBRARY AS PERMITTED ABOVE, BE LIABLE TO YOU
-FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR
-CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE
-LIBRARY (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING
-RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A
-FAILURE OF THE LIBRARY TO OPERATE WITH ANY OTHER SOFTWARE), EVEN IF
-SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH
-DAMAGES.
-
-                     END OF TERMS AND CONDITIONS

README.md

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

README.txt

@@ -1,53 +0,0 @@
--------------------------------------------
-Source installation information for modders
--------------------------------------------
-This code follows the Minecraft Forge installation methodology. It will apply
-some small patches to the vanilla MCP source code, giving you and it access 
-to some of the data and functions you need to build a successful mod.
-
-Note also that the patches are built against "unrenamed" MCP source code (aka
-srgnames) - this means that you will not be able to read them directly against
-normal code.
-
-Source pack installation information:
-
-Standalone source installation
-==============================
-
-See the Forge Documentation online for more detailed instructions:
-http://mcforge.readthedocs.io/en/latest/gettingstarted/
-
-Step 1: Open your command-line and browse to the folder where you extracted the zip file.
-
-Step 2: You're left with a choice.
-If you prefer to use Eclipse:
-1. Run the following command: "gradlew genEclipseRuns" (./gradlew genEclipseRuns if you are on Mac/Linux)
-2. Open Eclipse, Import > Existing Gradle Project > Select Folder 
-   or run "gradlew eclipse" to generate the project.
-(Current Issue)
-4. Open Project > Run/Debug Settings > Edit runClient and runServer > Environment
-5. Edit MOD_CLASSES to show [modid]%%[Path]; 2 times rather then the generated 4.
-
-If you prefer to use IntelliJ:
-1. Open IDEA, and import project.
-2. Select your build.gradle file and have it import.
-3. Run the following command: "gradlew genIntellijRuns" (./gradlew genIntellijRuns if you are on Mac/Linux)
-4. Refresh the Gradle Project in IDEA if required.
-
-If at any point you are missing libraries in your IDE, or you've run into problems you can run "gradlew --refresh-dependencies" to refresh the local cache. "gradlew clean" to reset everything {this does not affect your code} and then start the processs again.
-
-Should it still not work, 
-Refer to #ForgeGradle on EsperNet for more information about the gradle environment.
-or the Forge Project Discord discord.gg/UvedJ9m
-
-Forge source installation
-=========================
-MinecraftForge ships with this code and installs it as part of the forge
-installation process, no further action is required on your part.
-
-LexManos' Install Video
-=======================
-https://www.youtube.com/watch?v=8VEdtQLuLO0&feature=youtu.be
-
-For more details update more often refer to the Forge Forums:
-http://www.minecraftforge.net/forum/index.php/topic,14048.0.html

build.gradle

@@ -1,169 +1,82 @@
-plugins {
+buildscript {
-    id 'eclipse'
+    repositories {
-    id 'maven-publish'
+        jcenter()
-    id 'net.minecraftforge.gradle' version '5.1.+'
+        maven { url = "http://files.minecraftforge.net/maven" }
-}
+    }
-
+    dependencies {
-version = '1.19-2.40'
+        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
-group = 'nl.requios.effortlessbuilding'
-archivesBaseName = 'effortlessbuilding'
-
-// Mojang ships Java 17 to end users in 1.18+, so your mod should target Java 17.
-java.toolchain.languageVersion = JavaLanguageVersion.of(17)
-
-println "Java: ${System.getProperty 'java.version'}, JVM: ${System.getProperty 'java.vm.version'} (${System.getProperty 'java.vendor'}), Arch: ${System.getProperty 'os.arch'}"
-minecraft {
-    // The mappings can be changed at any time, and must be in the following format.
-    // snapshot_YYYYMMDD   Snapshot are built nightly.
-    // stable_#            Stables are built at the discretion of the MCP team.
-    // Use non-default mappings at your own risk. they may not always work.
-    // Simply re-run your setup task after changing the mappings to update your workspace.
-    mappings channel: 'official', version: '1.19.2'
-    accessTransformer = file('src/main/resources/META-INF/accesstransformer.cfg')
-    // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
-
-    // Default run configurations.
-    // These can be tweaked, removed, or duplicated as needed.
-    runs {
-        client {
-            workingDirectory project.file('run')
-
-            // Recommended logging data for a userdev environment (SCAN,REGISTRIES,REGISTRYDUMP)
-            property 'forge.logging.markers', 'REGISTRIES'
-
-            // Recommended logging level for the console
-            property 'forge.logging.console.level', 'debug'
-
-            // Comma-separated list of namespaces to load gametests from. Empty = all namespaces.
-            property 'forge.enabledGameTestNamespaces', 'effortlessbuilding'
-			
-            mods {
-                effortlessbuilding {
-                    source sourceSets.main
-                }
-            }
-        }
-
-        server {
-            workingDirectory project.file('run')
-
-            property 'forge.logging.markers', 'REGISTRIES'
-
-            property 'forge.logging.console.level', 'debug'
-
-            property 'forge.enabledGameTestNamespaces', 'effortlessbuilding'
-
-            mods {
-                effortlessbuilding {
-                    source sourceSets.main
-                }
-            }
-        }
-		
-        // This run config launches GameTestServer and runs all registered gametests, then exits.
-        // By default, the server will crash when no gametests are provided.
-        // The gametest system is also enabled by default for other run configs under the /test command.
-        gameTestServer {
-            workingDirectory project.file('run')
-
-            property 'forge.logging.markers', 'REGISTRIES'
-
-            property 'forge.logging.console.level', 'debug'
-
-            property 'forge.enabledGameTestNamespaces', 'effortlessbuilding'
-
-            mods {
-                effortlessbuilding {
-                    source sourceSets.main
-                }
-            }
-        }
-
-        data {
-			workingDirectory project.file('run')
-
-            property 'forge.logging.markers', 'REGISTRIES'
-
-            property 'forge.logging.console.level', 'debug'
-
-            // Specify the modid for data generation, where to output the resulting resource, and where to look for existing resources.
-            args '--mod', 'effortlessbuilding', '--all', '--output', file('src/generated/resources/'), '--existing', file('src/main/resources/')
-
-            mods {
-                effortlessbuilding {
-                    source sourceSets.main
-                }
-            }
-        }
     }
 }
+apply plugin: 'net.minecraftforge.gradle.forge'
+//Only edit below this line, the above code adds and enables the necessary things for Forge to be setup.
 
-// Include resources generated by data generators.
+
-sourceSets.main.resources { srcDir 'src/generated/resources' }
+version = "1.12.2-2.16"
+group = "nl.requios.effortlessbuilding" // http://maven.apache.org/guides/mini/guide-naming-conventions.html
+archivesBaseName = "effortlessbuilding"
+
+sourceCompatibility = targetCompatibility = '1.8' // Need this here so eclipse task generates correctly.
+compileJava {
+    sourceCompatibility = targetCompatibility = '1.8'
+}
+
+minecraft {
+    version = "1.12.2-14.23.5.2825"
+    runDir = "run"
+    
+    // the mappings can be changed at any time, and must be in the following format.
+    // snapshot_YYYYMMDD   snapshot are built nightly.
+    // stable_#            stables are built at the discretion of the MCP team.
+    // Use non-default mappings at your own risk. they may not always work.
+    // simply re-run your setup task after changing the mappings to update your workspace.
+    mappings = "stable_39"
+    // makeObfSourceJar = false // an Srg named sources jar is made by default. uncomment this to disable.
+}
 
 repositories {
-    // Put repositories for dependencies here
+	flatDir { dirs 'libs' }
-    // ForgeGradle automatically adds the Forge maven and Maven Central for you
-
-    // If you have mod jar dependencies in ./libs, you can declare them as a repository like so:
-    // flatDir {
-    //     dir 'libs'
-    // }
 }
 
 dependencies {
-    // Specify the version of Minecraft to use. If this is any group other than 'net.minecraft', it is assumed
+    // you may put jars on which you depend on in ./libs
-    // that the dep is a ForgeGradle 'patcher' dependency, and its patches will be applied.
+    // or you may define them like so..
-    // The userdev artifact is a special name and will get all sorts of transformations applied to it.
+    //compile "some.group:artifact:version:classifier"
-    minecraft 'net.minecraftforge:forge:1.19.2-43.1.47'
+    //compile "some.group:artifact:version"
       
-    // Real mod deobf dependency examples - these get remapped to your current mappings
+    // real examples
-    // compileOnly fg.deobf("mezz.jei:jei-${mc_version}:${jei_version}:api") // Adds JEI API as a compile dependency
+    //compile 'com.mod-buildcraft:buildcraft:6.0.8:dev'  // adds buildcraft to the dev env
-    // runtimeOnly fg.deobf("mezz.jei:jei-${mc_version}:${jei_version}") // Adds the full JEI mod as a runtime dependency
+    //compile 'com.googlecode.efficient-java-matrix-library:ejml:0.24' // adds ejml to the dev env
-    // implementation fg.deobf("com.tterrag.registrate:Registrate:MC${mc_version}-${registrate_version}") // Adds registrate as a dependency
 
-    // Examples using mod jars from ./libs
+    // the 'provided' configuration is for optional dependencies that exist at compile-time but might not at runtime.
-    // implementation fg.deobf("blank:coolmod-${mc_version}:${coolmod_version}")
+    //provided 'com.mod-buildcraft:buildcraft:6.0.8:dev'
 
-    // For more info...
+    // the deobf configurations:  'deobfCompile' and 'deobfProvided' are the same as the normal compile and provided,
+    // except that these dependencies get remapped to your current MCP mappings
+    //deobfCompile 'com.mod-buildcraft:buildcraft:6.0.8:dev'
+    //deobfProvided 'com.mod-buildcraft:buildcraft:6.0.8:dev'
+	provided 'mod.chiselsandbits:chiselsandbits:14.30'
+
+    // for more info...
     // http://www.gradle.org/docs/current/userguide/artifact_dependencies_tutorial.html
     // http://www.gradle.org/docs/current/userguide/dependency_management.html
+
 }
 
-// Example for how to get properties into the manifest for reading by the runtime..
+processResources {
-jar {
+    // this will ensure that this task is redone when the versions change.
-    manifest {
+    inputs.property "version", project.version
-        attributes([
+    inputs.property "mcversion", project.minecraft.version
-            "Specification-Title": "effortlessbuilding",
+
-            "Specification-Vendor": "requios",
+    // replace stuff in mcmod.info, nothing else
-            "Specification-Version": "1", // We are version 1 of ourselves
+    from(sourceSets.main.resources.srcDirs) {
-            "Implementation-Title": project.name,
+        include 'mcmod.info'
-            "Implementation-Version": project.jar.archiveVersion,
+                
-            "Implementation-Vendor" :"requios",
+        // replace version and mcversion
-            "Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ")
+        expand 'version':project.version, 'mcversion':project.minecraft.version
-        ])
+    }
+        
+    // copy everything else except the mcmod.info
+    from(sourceSets.main.resources.srcDirs) {
+        exclude 'mcmod.info'
     }
 }
-
-// Example configuration to allow publishing using the maven-publish plugin
-// This is the preferred method to reobfuscate your jar file
-jar.finalizedBy('reobfJar')
-// However if you are in a multi-project build, dev time needs unobfed jar files, so you can delay the obfuscation until publishing by doing
-// publish.dependsOn('reobfJar')
-
-publishing {
-    publications {
-        mavenJava(MavenPublication) {
-            artifact jar
-        }
-    }
-    repositories {
-        maven {
-            url "file://${project.projectDir}/mcmodsrepo"
-        }
-    }
-}
-
-tasks.withType(JavaCompile).configureEach {
-    options.encoding = 'UTF-8' // Use the UTF-8 charset for Java compilation
-}

gradle.properties

@@ -1,4 +0,0 @@
-# Sets default memory used for gradle commands. Can be overridden by user or command line properties.
-# This is required to provide enough memory for the Minecraft decompilation process.
-org.gradle.jvmargs=-Xmx3G
-org.gradle.daemon=false

gradle/wrapper/gradle-wrapper.properties

@@ -1,5 +1,5 @@
 distributionBase=GRADLE_USER_HOME
 distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-7.3-bin.zip
+distributionUrl=https\://services.gradle.org/distributions/gradle-4.8.1-bin.zip
 zipStoreBase=GRADLE_USER_HOME
 zipStorePath=wrapper/dists

gradlew

@@ -1,129 +1,78 @@
-#!/bin/sh
+#!/usr/bin/env sh
-
-#
-# Copyright <20> 2015-2021 the original authors.
-#
-# Licensed under the Apache License, Version 2.0 (the "License");
-# you may not use this file except in compliance with the License.
-# You may obtain a copy of the License at
-#
-#      https://www.apache.org/licenses/LICENSE-2.0
-#
-# Unless required by applicable law or agreed to in writing, software
-# distributed under the License is distributed on an "AS IS" BASIS,
-# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-# See the License for the specific language governing permissions and
-# limitations under the License.
-#
 
 ##############################################################################
-#
+##
-#   Gradle start up script for POSIX generated by Gradle.
+##  Gradle start up script for UN*X
-#
+##
-#   Important for running:
-#
-#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
-#       noncompliant, but you have some other compliant shell such as ksh or
-#       bash, then to run this script, type that shell name before the whole
-#       command line, like:
-#
-#           ksh Gradle
-#
-#       Busybox and similar reduced shells will NOT work, because this script
-#       requires all of these POSIX shell features:
-#         * functions;
-#         * expansions <20>$var<61>, <20>${var}<7D>, <20>${var:-default}<7D>, <20>${var+SET}<7D>,
-#           <20>${var#prefix}<7D>, <20>${var%suffix}<7D>, and <20>$( cmd )<29>;
-#         * compound commands having a testable exit status, especially <20>case<73>;
-#         * various built-in commands including <20>command<6E>, <20>set<65>, and <20>ulimit<69>.
-#
-#   Important for patching:
-#
-#   (2) This script targets any POSIX shell, so it avoids extensions provided
-#       by Bash, Ksh, etc; in particular arrays are avoided.
-#
-#       The "traditional" practice of packing multiple parameters into a
-#       space-separated string is a well documented source of bugs and security
-#       problems, so this is (mostly) avoided, by progressively accumulating
-#       options in "$@", and eventually passing that to Java.
-#
-#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
-#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
-#       see the in-line comments for details.
-#
-#       There are tweaks for specific operating systems such as AIX, CygWin,
-#       Darwin, MinGW, and NonStop.
-#
-#   (3) This script is generated from the Groovy template
-#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
-#       within the Gradle project.
-#
-#       You can find Gradle at https://github.com/gradle/gradle/.
-#
 ##############################################################################
 
 # Attempt to set APP_HOME
-
 # Resolve links: $0 may be a link
-app_path=$0
+PRG="$0"
-
+# Need this for relative symlinks.
-# Need this for daisy-chained symlinks.
+while [ -h "$PRG" ] ; do
-while
+    ls=`ls -ld "$PRG"`
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    link=`expr "$ls" : '.*-> \(.*\)$'`
-    [ -h "$app_path" ]
+    if expr "$link" : '/.*' > /dev/null; then
-do
+        PRG="$link"
-    ls=$( ls -ld "$app_path" )
+    else
-    link=${ls#*' -> '}
+        PRG=`dirname "$PRG"`"/$link"
-    case $link in             #(
+    fi
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
 done
-
+SAVED="`pwd`"
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+cd "`dirname \"$PRG\"`/" >/dev/null
+APP_HOME="`pwd -P`"
+cd "$SAVED" >/dev/null
 
 APP_NAME="Gradle"
-APP_BASE_NAME=${0##*/}
+APP_BASE_NAME=`basename "$0"`
 
 # Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+DEFAULT_JVM_OPTS=""
 
 # Use the maximum available, or set MAX_FD != -1 to use that value.
-MAX_FD=maximum
+MAX_FD="maximum"
 
 warn () {
     echo "$*"
-} >&2
+}
 
 die () {
     echo
     echo "$*"
     echo
     exit 1
-} >&2
+}
 
 # OS specific support (must be 'true' or 'false').
 cygwin=false
 msys=false
 darwin=false
 nonstop=false
-case "$( uname )" in                #(
+case "`uname`" in
-  CYGWIN* )         cygwin=true  ;; #(
+  CYGWIN* )
-  Darwin* )         darwin=true  ;; #(
+    cygwin=true
-  MSYS* | MINGW* )  msys=true    ;; #(
+    ;;
-  NONSTOP* )        nonstop=true ;;
+  Darwin* )
+    darwin=true
+    ;;
+  MINGW* )
+    msys=true
+    ;;
+  NONSTOP* )
+    nonstop=true
+    ;;
 esac
 
 CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
 
-
 # Determine the Java command to use to start the JVM.
 if [ -n "$JAVA_HOME" ] ; then
     if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
         # IBM's JDK on AIX uses strange locations for the executables
-        JAVACMD=$JAVA_HOME/jre/sh/java
+        JAVACMD="$JAVA_HOME/jre/sh/java"
     else
-        JAVACMD=$JAVA_HOME/bin/java
+        JAVACMD="$JAVA_HOME/bin/java"
     fi
     if [ ! -x "$JAVACMD" ] ; then
         die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
@@ -132,7 +81,7 @@ Please set the JAVA_HOME variable in your environment to match the
 location of your Java installation."
     fi
 else
-    JAVACMD=java
+    JAVACMD="java"
     which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
 
 Please set the JAVA_HOME variable in your environment to match the
@@ -140,95 +89,84 @@ location of your Java installation."
 fi
 
 # Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then
-    case $MAX_FD in #(
+    MAX_FD_LIMIT=`ulimit -H -n`
-      max*)
+    if [ $? -eq 0 ] ; then
-        MAX_FD=$( ulimit -H -n ) ||
+        if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then
-            warn "Could not query maximum file descriptor limit"
+            MAX_FD="$MAX_FD_LIMIT"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
         fi
-        # Roll the args list around exactly as many times as the number of
+        ulimit -n $MAX_FD
-        # args, so each arg winds up back in the position where it started, but
+        if [ $? -ne 0 ] ; then
-        # possibly modified.
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        #
+        fi
-        # NB: a `for` loop captures its iteration list before it begins, so
+    else
-        # changing the positional parameters here affects neither the number of
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-        # iterations, nor the values presented in `arg`.
+    fi
-        shift                   # remove old arg
-        set -- "$@" "$arg"      # push replacement arg
-    done
 fi
 
-# Collect all arguments for the java command;
+# For Darwin, add options to specify how the application appears in the dock
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+if $darwin; then
-#     shell script including quotes and variable substitutions, so put them in
+    GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\""
-#     double quotes to make sure that they get re-expanded; and
+fi
-#   * put everything else in single quotes, so that it's not re-expanded.
 
-set -- \
+# For Cygwin, switch paths to Windows format before running java
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+if $cygwin ; then
-        -classpath "$CLASSPATH" \
+    APP_HOME=`cygpath --path --mixed "$APP_HOME"`
-        org.gradle.wrapper.GradleWrapperMain \
+    CLASSPATH=`cygpath --path --mixed "$CLASSPATH"`
-        "$@"
+    JAVACMD=`cygpath --unix "$JAVACMD"`
 
-# Use "xargs" to parse quoted args.
+    # We build the pattern for arguments to be converted via cygpath
-#
+    ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null`
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+    SEP=""
-#
+    for dir in $ROOTDIRSRAW ; do
-# In Bash we could simply go:
+        ROOTDIRS="$ROOTDIRS$SEP$dir"
-#
+        SEP="|"
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+    done
-#   set -- "${ARGS[@]}" "$@"
+    OURCYGPATTERN="(^($ROOTDIRS))"
-#
+    # Add a user-defined pattern to the cygpath arguments
-# but POSIX shell has neither arrays nor command substitution, so instead we
+    if [ "$GRADLE_CYGPATTERN" != "" ] ; then
-# post-process each arg (as a line of input to sed) to backslash-escape any
+        OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)"
-# character that might be a shell metacharacter, then use eval to reverse
+    fi
-# that process (while maintaining the separation between arguments), and wrap
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-# the whole thing up as a single "set" statement.
+    i=0
-#
+    for arg in "$@" ; do
-# This will of course break if any of these variables contains a newline or
+        CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -`
-# an unmatched quote.
+        CHECK2=`echo "$arg"|egrep -c "^-"`                                 ### Determine if an option
-#
 
-eval "set -- $(
+        if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then                    ### Added a condition
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+            eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"`
-        xargs -n1 |
+        else
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+            eval `echo args$i`="\"$arg\""
-        tr '\n' ' '
+        fi
-    )" '"$@"'
+        i=$((i+1))
+    done
+    case $i in
+        (0) set -- ;;
+        (1) set -- "$args0" ;;
+        (2) set -- "$args0" "$args1" ;;
+        (3) set -- "$args0" "$args1" "$args2" ;;
+        (4) set -- "$args0" "$args1" "$args2" "$args3" ;;
+        (5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;;
+        (6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;;
+        (7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;;
+        (8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;;
+        (9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;;
+    esac
+fi
+
+# Escape application args
+save () {
+    for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done
+    echo " "
+}
+APP_ARGS=$(save "$@")
+
+# Collect all arguments for the java command, following the shell quoting and substitution rules
+eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS"
+
+# by default we should be in the correct project dir, but when run from Finder on Mac, the cwd is wrong
+if [ "$(uname)" = "Darwin" ] && [ "$HOME" = "$PWD" ]; then
+  cd "$(dirname "$0")"
+fi
 
 exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,19 +1,3 @@
-@rem
-@rem Copyright 2015 the original author or authors.
-@rem
-@rem Licensed under the Apache License, Version 2.0 (the "License");
-@rem you may not use this file except in compliance with the License.
-@rem You may obtain a copy of the License at
-@rem
-@rem      https://www.apache.org/licenses/LICENSE-2.0
-@rem
-@rem Unless required by applicable law or agreed to in writing, software
-@rem distributed under the License is distributed on an "AS IS" BASIS,
-@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-@rem See the License for the specific language governing permissions and
-@rem limitations under the License.
-@rem
-
 @if "%DEBUG%" == "" @echo off
 @rem ##########################################################################
 @rem
@@ -29,18 +13,15 @@ if "%DIRNAME%" == "" set DIRNAME=.
 set APP_BASE_NAME=%~n0
 set APP_HOME=%DIRNAME%
 
-@rem Resolve any "." and ".." in APP_HOME to make it shorter.
-for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
-
 @rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
-set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+set DEFAULT_JVM_OPTS=
 
 @rem Find java.exe
 if defined JAVA_HOME goto findJavaFromJavaHome
 
 set JAVA_EXE=java.exe
 %JAVA_EXE% -version >NUL 2>&1
-if "%ERRORLEVEL%" == "0" goto execute
+if "%ERRORLEVEL%" == "0" goto init
 
 echo.
 echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
@@ -54,7 +35,7 @@ goto fail
 set JAVA_HOME=%JAVA_HOME:"=%
 set JAVA_EXE=%JAVA_HOME%/bin/java.exe
 
-if exist "%JAVA_EXE%" goto execute
+if exist "%JAVA_EXE%" goto init
 
 echo.
 echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
@@ -64,14 +45,28 @@ echo location of your Java installation.
 
 goto fail
 
+:init
+@rem Get command-line arguments, handling Windows variants
+
+if not "%OS%" == "Windows_NT" goto win9xME_args
+
+:win9xME_args
+@rem Slurp the command line arguments.
+set CMD_LINE_ARGS=
+set _SKIP=2
+
+:win9xME_args_slurp
+if "x%~1" == "x" goto execute
+
+set CMD_LINE_ARGS=%*
+
 :execute
 @rem Setup the command line
 
 set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
 
-
 @rem Execute Gradle
-"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %CMD_LINE_ARGS%
 
 :end
 @rem End local scope for the variables with windows NT shell

settings.gradle

@@ -1,6 +0,0 @@
-pluginManagement {
-    repositories {
-        gradlePluginPortal()
-        maven { url = 'https://maven.minecraftforge.net/' }
-    }
-}

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

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

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

@@ -1,113 +1,150 @@
 package nl.requios.effortlessbuilding;
 
-import net.minecraft.network.chat.Component;
+import net.minecraft.block.Block;
-import net.minecraft.world.entity.player.Player;
+import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.world.inventory.AbstractContainerMenu;
+import net.minecraft.item.Item;
-import net.minecraft.world.inventory.MenuType;
+import net.minecraft.util.ResourceLocation;
-import net.minecraft.world.item.Item;
+import net.minecraft.util.SoundEvent;
-import net.minecraftforge.common.capabilities.RegisterCapabilitiesEvent;
+import net.minecraft.util.text.TextComponentString;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.common.capabilities.CapabilityManager;
-import net.minecraftforge.fml.DistExecutor;
+import net.minecraftforge.common.config.Config;
-import net.minecraftforge.fml.ModLoadingContext;
+import net.minecraftforge.common.config.ConfigManager;
 import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.fml.config.ModConfig;
+import net.minecraftforge.fml.common.Mod.EventHandler;
-import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
+import net.minecraftforge.fml.common.SidedProxy;
-import net.minecraftforge.fml.event.lifecycle.FMLCommonSetupEvent;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
+import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
-import net.minecraftforge.network.IContainerFactory;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
-import net.minecraftforge.registries.RegistryObject;
+import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
-import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.fml.common.network.NetworkRegistry;
-import net.minecraftforge.registries.ForgeRegistries;
+import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper;
+import net.minecraftforge.fml.relauncher.Side;
+import nl.requios.effortlessbuilding.buildmode.BuildModes;
 import nl.requios.effortlessbuilding.capability.ModeCapabilityManager;
 import nl.requios.effortlessbuilding.capability.ModifierCapabilityManager;
+import nl.requios.effortlessbuilding.command.CommandReach;
 import nl.requios.effortlessbuilding.compatibility.CompatHelper;
-import nl.requios.effortlessbuilding.gui.DiamondRandomizerBagContainer;
+import nl.requios.effortlessbuilding.gui.RandomizerBagGuiHandler;
-import nl.requios.effortlessbuilding.gui.GoldenRandomizerBagContainer;
+import nl.requios.effortlessbuilding.item.ItemRandomizerBag;
-import nl.requios.effortlessbuilding.gui.RandomizerBagContainer;
+import nl.requios.effortlessbuilding.item.ItemReachUpgrade1;
-import nl.requios.effortlessbuilding.item.*;
+import nl.requios.effortlessbuilding.item.ItemReachUpgrade2;
-import nl.requios.effortlessbuilding.network.PacketHandler;
+import nl.requios.effortlessbuilding.item.ItemReachUpgrade3;
-import nl.requios.effortlessbuilding.proxy.ClientProxy;
+import nl.requios.effortlessbuilding.network.*;
 import nl.requios.effortlessbuilding.proxy.IProxy;
-import nl.requios.effortlessbuilding.proxy.ServerProxy;
-import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 
-@Mod(EffortlessBuilding.MODID)
+@Mod(modid = EffortlessBuilding.MODID, name = EffortlessBuilding.NAME, version = EffortlessBuilding.VERSION)
-public class EffortlessBuilding {
+@Mod.EventBusSubscriber
+public class EffortlessBuilding
+{
+    public static final String MODID = "effortlessbuilding";
+    public static final String NAME = "Effortless Building";
+    public static final String VERSION = "1.12.2-2.16";
 
-	public static final String MODID = "effortlessbuilding";
+    @Mod.Instance(EffortlessBuilding.MODID)
-	public static final Logger logger = LogManager.getLogger();
+    public static EffortlessBuilding instance;
 
-	public static EffortlessBuilding instance;
+    public static Logger logger;
-	public static IProxy proxy = DistExecutor.runForDist(() -> ClientProxy::new, () -> ServerProxy::new);
 
-	//Registration
+    @SidedProxy(
-	private static final DeferredRegister<Item> ITEMS = DeferredRegister.create(ForgeRegistries.ITEMS, MODID);
+        clientSide="nl.requios.effortlessbuilding.proxy.ClientProxy",
-	private static final DeferredRegister<MenuType<?>> CONTAINERS = DeferredRegister.create(ForgeRegistries.MENU_TYPES, EffortlessBuilding.MODID);
+        serverSide="nl.requios.effortlessbuilding.proxy.ServerProxy"
+    )
+    public static IProxy proxy;
 
-	public static final RegistryObject<Item> RANDOMIZER_BAG_ITEM = ITEMS.register("randomizer_bag", RandomizerBagItem::new);
+    public static final SimpleNetworkWrapper packetHandler = NetworkRegistry.INSTANCE.newSimpleChannel(EffortlessBuilding.MODID);
-	public static final RegistryObject<Item> GOLDEN_RANDOMIZER_BAG_ITEM = ITEMS.register("golden_randomizer_bag", GoldenRandomizerBagItem::new);
-	public static final RegistryObject<Item> DIAMOND_RANDOMIZER_BAG_ITEM = ITEMS.register("diamond_randomizer_bag", DiamondRandomizerBagItem::new);
-	public static final RegistryObject<Item> REACH_UPGRADE_1_ITEM = ITEMS.register("reach_upgrade1", ReachUpgrade1Item::new);
-	public static final RegistryObject<Item> REACH_UPGRADE_2_ITEM = ITEMS.register("reach_upgrade2", ReachUpgrade2Item::new);
-	public static final RegistryObject<Item> REACH_UPGRADE_3_ITEM = ITEMS.register("reach_upgrade3", ReachUpgrade3Item::new);
 
-	public static final RegistryObject<MenuType<RandomizerBagContainer>> RANDOMIZER_BAG_CONTAINER = CONTAINERS.register("randomizer_bag", () -> registerContainer(RandomizerBagContainer::new));
+    public static final ItemRandomizerBag ITEM_RANDOMIZER_BAG = new ItemRandomizerBag();
-	public static final RegistryObject<MenuType<GoldenRandomizerBagContainer>> GOLDEN_RANDOMIZER_BAG_CONTAINER = CONTAINERS.register("golden_randomizer_bag", () -> registerContainer(GoldenRandomizerBagContainer::new));
+    public static final ItemReachUpgrade1 ITEM_REACH_UPGRADE_1 = new ItemReachUpgrade1();
-	public static final RegistryObject<MenuType<DiamondRandomizerBagContainer>> DIAMOND_RANDOMIZER_BAG_CONTAINER = CONTAINERS.register("diamond_randomizer_bag", () -> registerContainer(DiamondRandomizerBagContainer::new));
+    public static final ItemReachUpgrade2 ITEM_REACH_UPGRADE_2 = new ItemReachUpgrade2();
+    public static final ItemReachUpgrade3 ITEM_REACH_UPGRADE_3 = new ItemReachUpgrade3();
 
-	public EffortlessBuilding() {
+    public static final Block[] BLOCKS = {
-		instance = this;
+    };
 
-		// Register ourselves for server and other game events we are interested in
+    public static final Item[] ITEMS = {
-		FMLJavaModLoadingContext.get().getModEventBus().register(this);
+            ITEM_RANDOMIZER_BAG,
+            ITEM_REACH_UPGRADE_1,
+            ITEM_REACH_UPGRADE_2,
+            ITEM_REACH_UPGRADE_3
+    };
 
-		ITEMS.register(FMLJavaModLoadingContext.get().getModEventBus());
+    public static final int RANDOMIZER_BAG_GUI = 0;
-		CONTAINERS.register(FMLJavaModLoadingContext.get().getModEventBus());
 
-		//Register config
+    @EventHandler
-		ModLoadingContext.get().registerConfig(ModConfig.Type.COMMON, BuildConfig.spec);
+    // preInit "Run before anything else. Read your config, create blocks, items, etc, and register them with the GameRegistry."
-	}
+    public void preInit(FMLPreInitializationEvent event)
+    {
+        logger = event.getModLog();
 
-	public static <T extends AbstractContainerMenu> MenuType<T> registerContainer(IContainerFactory<T> fact){
+        CapabilityManager.INSTANCE.register(ModifierCapabilityManager.IModifierCapability.class, new ModifierCapabilityManager.Storage(), ModifierCapabilityManager.ModifierCapability.class);
-		MenuType<T> type = new MenuType<T>(fact);
+        CapabilityManager.INSTANCE.register(ModeCapabilityManager.IModeCapability.class, new ModeCapabilityManager.Storage(), ModeCapabilityManager.ModeCapability.class);
-		return type;
-	}
 
-	@SubscribeEvent
+        EffortlessBuilding.packetHandler.registerMessage(ModifierSettingsMessage.MessageHandler.class, ModifierSettingsMessage.class, 0, Side.SERVER);
-	public void setup(final FMLCommonSetupEvent event) {
+        EffortlessBuilding.packetHandler.registerMessage(ModifierSettingsMessage.MessageHandler.class, ModifierSettingsMessage.class, 0, Side.CLIENT);
-		PacketHandler.register();
 
-		proxy.setup(event);
+        EffortlessBuilding.packetHandler.registerMessage(ModeSettingsMessage.MessageHandler.class, ModeSettingsMessage.class, 1, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ModeSettingsMessage.MessageHandler.class, ModeSettingsMessage.class, 1, Side.CLIENT);
 
-		CompatHelper.setup();
+        EffortlessBuilding.packetHandler.registerMessage(ModeActionMessage.MessageHandler.class, ModeActionMessage.class, 2, Side.SERVER);
-	}
+        EffortlessBuilding.packetHandler.registerMessage(ModeActionMessage.MessageHandler.class, ModeActionMessage.class, 2, Side.CLIENT);
 
-	@SubscribeEvent
+        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 3, Side.SERVER);
-	public void clientSetup(final FMLClientSetupEvent event) {
+        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 3, Side.CLIENT);
-		proxy.clientSetup(event);
-	}
 
-	@SubscribeEvent
+        EffortlessBuilding.packetHandler.registerMessage(BlockBrokenMessage.MessageHandler.class, BlockBrokenMessage.class, 4, Side.SERVER);
-	public void registerCapabilities(RegisterCapabilitiesEvent event){
+        EffortlessBuilding.packetHandler.registerMessage(BlockBrokenMessage.MessageHandler.class, BlockBrokenMessage.class, 4, Side.CLIENT);
-		event.register(ModifierCapabilityManager.IModifierCapability.class);
-		event.register(ModeCapabilityManager.IModeCapability.class);
-	}
 
-	public static void log(String msg) {
+        EffortlessBuilding.packetHandler.registerMessage(CancelModeMessage.MessageHandler.class, CancelModeMessage.class, 5, Side.SERVER);
-		logger.info(msg);
+        EffortlessBuilding.packetHandler.registerMessage(CancelModeMessage.MessageHandler.class, CancelModeMessage.class, 5, Side.CLIENT);
-	}
 
-	public static void log(Player player, String msg) {
+        EffortlessBuilding.packetHandler.registerMessage(RequestLookAtMessage.MessageHandler.class, RequestLookAtMessage.class, 6, Side.SERVER);
-		log(player, msg, false);
+        EffortlessBuilding.packetHandler.registerMessage(RequestLookAtMessage.MessageHandler.class, RequestLookAtMessage.class, 6, Side.CLIENT);
-	}
 
-	public static void log(Player player, String msg, boolean actionBar) {
+        EffortlessBuilding.packetHandler.registerMessage(AddUndoMessage.MessageHandler.class, AddUndoMessage.class, 7, Side.SERVER);
-		player.displayClientMessage(Component.literal(msg), actionBar);
+        EffortlessBuilding.packetHandler.registerMessage(AddUndoMessage.MessageHandler.class, AddUndoMessage.class, 7, Side.CLIENT);
-	}
 
-	//Log with translation supported, call either on client or server (which then sends a message)
+        EffortlessBuilding.packetHandler.registerMessage(ClearUndoMessage.MessageHandler.class, ClearUndoMessage.class, 8, Side.SERVER);
-	public static void logTranslate(Player player, String prefix, String translationKey, String suffix, boolean actionBar) {
+        EffortlessBuilding.packetHandler.registerMessage(ClearUndoMessage.MessageHandler.class, ClearUndoMessage.class, 8, Side.CLIENT);
-		proxy.logTranslate(player, prefix, translationKey, suffix, actionBar);
+
-	}
+        proxy.preInit(event);
+    }
+
+    @EventHandler
+    // Do your mod setup. Build whatever data structures you care about.
+    // Register network handlers
+    public void init(FMLInitializationEvent event)
+    {
+        ConfigManager.sync(MODID, Config.Type.INSTANCE);
+        NetworkRegistry.INSTANCE.registerGuiHandler(EffortlessBuilding.instance, new RandomizerBagGuiHandler());
+
+        proxy.init(event);
+    }
+
+    @EventHandler
+    // postInit "Handle interaction with other mods, complete your setup based on this."
+    public void postInit(FMLPostInitializationEvent event)
+    {
+        proxy.postInit(event);
+        CompatHelper.postInit();
+    }
+
+    @EventHandler
+    public void serverStarting(FMLServerStartingEvent event)
+    {
+        event.registerServerCommand(new CommandReach());
+        proxy.serverStarting(event);
+    }
+
+    public static void log(String msg){
+        logger.info(msg);
+    }
+
+    public static void log(EntityPlayer player, String msg){
+        log(player, msg, false);
+    }
+
+    public static void log(EntityPlayer player, String msg, boolean actionBar){
+        player.sendStatusMessage(new TextComponentString(msg), actionBar);
+    }
 }

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

@@ -1,175 +1,206 @@
 package nl.requios.effortlessbuilding;
 
-import net.minecraft.world.InteractionHand;
+import net.minecraft.block.Block;
-import net.minecraft.world.item.BlockItem;
+import net.minecraft.block.state.IBlockState;
-import net.minecraft.world.item.ItemStack;
+import net.minecraft.entity.Entity;
-import net.minecraft.world.level.block.Blocks;
+import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.world.entity.Entity;
+import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraft.world.entity.player.Player;
+import net.minecraft.init.Blocks;
-import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.item.Item;
-import net.minecraft.resources.ResourceLocation;
+import net.minecraft.item.ItemBlock;
-import net.minecraftforge.common.util.FakePlayer;
+import net.minecraft.util.ResourceLocation;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import net.minecraftforge.common.config.Config;
+import net.minecraftforge.common.config.ConfigManager;
 import net.minecraftforge.event.AttachCapabilitiesEvent;
-import net.minecraftforge.event.RegisterCommandsEvent;
+import net.minecraftforge.event.RegistryEvent;
 import net.minecraftforge.event.entity.player.PlayerEvent;
-import net.minecraftforge.event.level.BlockEvent;
+import net.minecraftforge.event.world.BlockEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
+import net.minecraftforge.fml.client.event.ConfigChangedEvent;
 import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.network.PacketDistributor;
+import net.minecraftforge.fml.common.eventhandler.SubscribeEvent;
 import nl.requios.effortlessbuilding.buildmode.BuildModes;
 import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
+import nl.requios.effortlessbuilding.buildmodifier.BlockSet;
+import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
 import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.buildmodifier.UndoRedo;
 import nl.requios.effortlessbuilding.capability.ModeCapabilityManager;
 import nl.requios.effortlessbuilding.capability.ModifierCapabilityManager;
-import nl.requios.effortlessbuilding.compatibility.CompatHelper;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
+import nl.requios.effortlessbuilding.helper.SurvivalHelper;
 import nl.requios.effortlessbuilding.network.AddUndoMessage;
+import nl.requios.effortlessbuilding.network.BlockBrokenMessage;
 import nl.requios.effortlessbuilding.network.ClearUndoMessage;
-import nl.requios.effortlessbuilding.network.PacketHandler;
 import nl.requios.effortlessbuilding.network.RequestLookAtMessage;
+import scala.actors.threadpool.Arrays;
 
-@Mod.EventBusSubscriber(modid = EffortlessBuilding.MODID, bus = Mod.EventBusSubscriber.Bus.FORGE)
+import java.util.ArrayList;
-public class EventHandler {
+import java.util.List;
 
-	@SubscribeEvent
+import static net.minecraftforge.fml.common.gameevent.PlayerEvent.*;
-	public static void attachCapabilities(AttachCapabilitiesEvent<Entity> event) {
-		if (event.getObject() instanceof FakePlayer) return;
-		if (event.getObject() instanceof Player) {
-			event.addCapability(new ResourceLocation(EffortlessBuilding.MODID, "build_modifier"), new ModifierCapabilityManager.Provider());
-			event.addCapability(new ResourceLocation(EffortlessBuilding.MODID, "build_mode"), new ModeCapabilityManager.Provider());
-		}
-	}
 
-	@SubscribeEvent
+@Mod.EventBusSubscriber
-	public static void onBlockPlaced(BlockEvent.EntityPlaceEvent event) {
+public class EventHandler
-		if (event.getLevel().isClientSide()) return;
+{
 
-		if (!(event.getEntity() instanceof Player)) return;
+    @SubscribeEvent
+    public static void registerBlocks(RegistryEvent.Register<Block> event)
+    {
+        event.getRegistry().registerAll(EffortlessBuilding.BLOCKS);
+    }
 
-		if (event.getEntity() instanceof FakePlayer) return;
+    @SubscribeEvent
+    public static void registerItems(RegistryEvent.Register<Item> event)
+    {
+        event.getRegistry().registerAll(EffortlessBuilding.ITEMS);
 
-		//Cancel event if necessary
+        for (Block block : EffortlessBuilding.BLOCKS)
-		ServerPlayer player = ((ServerPlayer) event.getEntity());
+        {
-		BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(player).getBuildMode();
+            event.getRegistry().register(new ItemBlock(block).setRegistryName(block.getRegistryName()));
-		ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        }
+    }
 
-		if (buildMode != BuildModes.BuildModeEnum.NORMAL) {
+    @SubscribeEvent
+    public static void attachCapabilities(AttachCapabilitiesEvent<Entity> event) {
+        if (event.getObject() instanceof EntityPlayer) {
+            event.addCapability(new ResourceLocation(EffortlessBuilding.MODID, "BuildModifier"), new ModifierCapabilityManager.Provider());
+            event.addCapability(new ResourceLocation(EffortlessBuilding.MODID, "BuildMode"), new ModeCapabilityManager.Provider());
+        }
+    }
 
-			//Only cancel if itemblock in hand
+    @SubscribeEvent
-			//Fixed issue with e.g. Create Wrench shift-rightclick disassembling being cancelled.
+    public static void onConfigChangedEvent(ConfigChangedEvent.OnConfigChangedEvent event)
-			ItemStack currentItemStack = player.getItemInHand(InteractionHand.MAIN_HAND);
+    {
-			if (currentItemStack.getItem() instanceof BlockItem ||
+        if (event.getModID().equals(EffortlessBuilding.MODID))
-				(CompatHelper.isItemBlockProxy(currentItemStack) && !player.isShiftKeyDown())) {
+        {
-				event.setCanceled(true);
+            ConfigManager.sync(EffortlessBuilding.MODID, Config.Type.INSTANCE);
-			}
+        }
+    }
 
-		} else if (modifierSettings.doQuickReplace()) {
+//    @SubscribeEvent
-			//Cancel event and send message if QuickReplace
+//    public static void onServerTick(TickEvent.ServerTickEvent event) {
-			event.setCanceled(true);
-			PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> player), new RequestLookAtMessage(true));
-			PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> player), new AddUndoMessage(event.getPos(), event.getBlockSnapshot().getReplacedBlock(), event.getState()));
-		} else {
-			//NORMAL mode, let vanilla handle block placing
-			//But modifiers should still work
-
-			//Send message to client, which sends message back with raytrace info
-			PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> player), new RequestLookAtMessage(false));
-			PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> player), new AddUndoMessage(event.getPos(), event.getBlockSnapshot().getReplacedBlock(), event.getState()));
-		}
-
-//        Stat<ResourceLocation> blocksPlacedStat = StatList.CUSTOM.get(new ResourceLocation(EffortlessBuilding.MODID, "blocks_placed"));
-//        player.getStats().increment(player, blocksPlacedStat, 1);
 //
-//        System.out.println(player.getStats().getValue(blocksPlacedStat));
+//    }
-	}
 
-	@SubscribeEvent
+    @SubscribeEvent
-	public static void onBlockBroken(BlockEvent.BreakEvent event) {
+    //Only called serverside (except with lilypads...)
-		if (event.getLevel().isClientSide()) return;
+    public static void onBlockPlaced(BlockEvent.PlaceEvent event) {
+        if (event.getWorld().isRemote) return;
 
-		if (event.getPlayer() instanceof FakePlayer) return;
+        //Cancel event if necessary
+        EntityPlayer player = event.getPlayer();
+        BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(player).getBuildMode();
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
 
-		//Cancel event if necessary
+        if (buildMode != BuildModes.BuildModeEnum.NORMAL) {
-		//If cant break far then dont cancel event ever
+            event.setCanceled(true);
-		BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(event.getPlayer()).getBuildMode();
+        } else if (modifierSettings.doQuickReplace()) {
-		if (buildMode != BuildModes.BuildModeEnum.NORMAL && ReachHelper.canBreakFar(event.getPlayer())) {
+            //Cancel event and send message if QuickReplace
-			event.setCanceled(true);
+            event.setCanceled(true);
-		} else {
+            EffortlessBuilding.packetHandler.sendTo(new RequestLookAtMessage(true), (EntityPlayerMP) player);
-			//NORMAL mode, let vanilla handle block breaking
+            EffortlessBuilding.packetHandler.sendTo(new AddUndoMessage(event.getPos(), event.getBlockSnapshot().getReplacedBlock(), event.getState()), (EntityPlayerMP) player);
-			//But modifiers and QuickReplace should still work
+        } else {
-			//Dont break the original block yourself, otherwise Tinkers Hammer and Veinminer won't work
+            //NORMAL mode, let vanilla handle block placing
-			BuildModes.onBlockBroken(event.getPlayer(), event.getPos(), false);
+            //But modifiers should still work
 
-			//Add to undo stack in client
+            //Send message to client, which sends message back with raytrace info
-			if (event.getPlayer() instanceof ServerPlayer && event.getState() != null && event.getPos() != null) {
+            EffortlessBuilding.packetHandler.sendTo(new RequestLookAtMessage(false), (EntityPlayerMP) player);
-				PacketDistributor.PacketTarget packetTarget = PacketDistributor.PLAYER.with(() -> (ServerPlayer) event.getPlayer());
+            EffortlessBuilding.packetHandler.sendTo(new AddUndoMessage(event.getPos(), event.getBlockSnapshot().getReplacedBlock(), event.getState()), (EntityPlayerMP) player);
-				if (packetTarget != null)
+        }
-					PacketHandler.INSTANCE.send(packetTarget, new AddUndoMessage(event.getPos(), event.getState(), Blocks.AIR.defaultBlockState()));
+    }
-			}
-		}
-	}
 
-	@SubscribeEvent
+    @SubscribeEvent
-	public static void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
+    public static void onBlockBroken(BlockEvent.BreakEvent event) {
-		if (event.getEntity() instanceof FakePlayer) return;
+        if (event.getWorld().isRemote) return;
-		Player player = event.getEntity();
-		ModifierSettingsManager.handleNewPlayer(player);
-		ModeSettingsManager.handleNewPlayer(player);
-	}
 
-	@SubscribeEvent
+        //Cancel event if necessary
-	public static void onPlayerLoggedOut(PlayerEvent.PlayerLoggedOutEvent event) {
+        //If cant break far then dont cancel event ever
-		if (event.getEntity() instanceof FakePlayer) return;
+        BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(event.getPlayer()).getBuildMode();
-		Player player = event.getEntity();
+        if (buildMode != BuildModes.BuildModeEnum.NORMAL && ReachHelper.canBreakFar(event.getPlayer())) {
-		if (player.getCommandSenderWorld().isClientSide) return;
+            event.setCanceled(true);
+        } else {
+            //NORMAL mode, let vanilla handle block breaking
+            //But modifiers should still work
+            //Dont break the original block yourself, otherwise Tinkers Hammer and Veinminer won't work
+            BuildModes.onBlockBroken(event.getPlayer(), event.getPos(), false);
 
-		UndoRedo.clear(player);
+            //Add to undo stack in client
-		PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) player), new ClearUndoMessage());
+            EffortlessBuilding.packetHandler.sendTo(new AddUndoMessage(event.getPos(), event.getState(), Blocks.AIR.getDefaultState()), (EntityPlayerMP) event.getPlayer());
-	}
+        }
+    }
 
-	@SubscribeEvent
+    @SubscribeEvent
-	public static void onPlayerRespawn(PlayerEvent.PlayerRespawnEvent event) {
+    public static void breakSpeed(PlayerEvent.BreakSpeed event) {
-		if (event.getEntity() instanceof FakePlayer) return;
+        //Disable if config says so
-		Player player = event.getEntity();
+        if (!BuildConfig.survivalBalancers.increasedMiningTime) return;
-		ModifierSettingsManager.handleNewPlayer(player);
-		ModeSettingsManager.handleNewPlayer(player);
-	}
 
-	@SubscribeEvent
+        EntityPlayer player = event.getEntityPlayer();
-	public static void onPlayerChangedDimension(PlayerEvent.PlayerChangedDimensionEvent event) {
+        World world = player.world;
-		if (event.getEntity() instanceof FakePlayer) return;
+        BlockPos pos = event.getPos();
-		Player player = event.getEntity();
-		if (player.getCommandSenderWorld().isClientSide) return;
 
-		//Set build mode to normal
+        //EffortlessBuilding.log(player, String.valueOf(event.getNewSpeed()));
-		ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
-		modeSettings.setBuildMode(BuildModes.BuildModeEnum.NORMAL);
-		ModeSettingsManager.setModeSettings(player, modeSettings);
 
-		//Disable modifiers
+        float originalBlockHardness = event.getState().getBlockHardness(world, pos);
-		ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        if (originalBlockHardness < 0) return; //Dont break bedrock
-		modifierSettings.getMirrorSettings().enabled = false;
+        float totalBlockHardness = 0;
-		modifierSettings.getRadialMirrorSettings().enabled = false;
+        //get coordinates
-		modifierSettings.getArraySettings().enabled = false;
+        List<BlockPos> coordinates = BuildModifiers.findCoordinates(player, pos);
-		ModifierSettingsManager.setModifierSettings(player, modifierSettings);
+        for (int i = 1; i < coordinates.size(); i++) {
+            BlockPos coordinate = coordinates.get(i);
+            //get existing blockstates at those coordinates
+            IBlockState blockState = world.getBlockState(coordinate);
+            //add hardness for each blockstate, if can break
+            if (SurvivalHelper.canBreak(world, player, coordinate))
+                totalBlockHardness += blockState.getBlockHardness(world, coordinate);
+        }
 
-		ModifierSettingsManager.handleNewPlayer(player);
+        //Grabbing percentage from config
-		ModeSettingsManager.handleNewPlayer(player);
+        float percentage = (float) BuildConfig.survivalBalancers.miningTimePercentage / 100;
+        totalBlockHardness *= percentage;
+        totalBlockHardness += originalBlockHardness;
 
-		UndoRedo.clear(player);
+        float newSpeed = event.getOriginalSpeed() / totalBlockHardness * originalBlockHardness;
-		PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) player), new ClearUndoMessage());
+        if (Float.isNaN(newSpeed) || newSpeed == 0f) newSpeed = 1f;
-	}
+        event.setNewSpeed(newSpeed);
 
-	@SubscribeEvent
+        //EffortlessBuilding.log(player, String.valueOf(event.getNewSpeed()));
-	public static void onPlayerClone(PlayerEvent.Clone event) {
+    }
-		if (event.getEntity() instanceof FakePlayer) return;
-		//Attach capabilities on death, otherwise crash
-		Player oldPlayer = event.getOriginal();
-		oldPlayer.revive();
 
-		Player newPlayer = event.getEntity();
+    @SubscribeEvent
-		ModifierSettingsManager.setModifierSettings(newPlayer, ModifierSettingsManager.getModifierSettings(oldPlayer));
+    public static void onPlayerLoggedIn(PlayerLoggedInEvent event) {
-		ModeSettingsManager.setModeSettings(newPlayer, ModeSettingsManager.getModeSettings(oldPlayer));
+        EntityPlayer player = event.player;
-	}
+        ModifierSettingsManager.handleNewPlayer(player);
+        ModeSettingsManager.handleNewPlayer(player);
+    }
+
+    @SubscribeEvent
+    public static void onPlayerLoggedOut(PlayerLoggedOutEvent event) {
+        EntityPlayer player = event.player;
+        if (player.getEntityWorld().isRemote) return;
+
+        UndoRedo.clear(player);
+        EffortlessBuilding.packetHandler.sendTo(new ClearUndoMessage(), (EntityPlayerMP) player);
+    }
+
+    @SubscribeEvent
+    public static void onPlayerRespawn(PlayerRespawnEvent event) {
+        EntityPlayer player = event.player;
+        ModifierSettingsManager.handleNewPlayer(player);
+        ModeSettingsManager.handleNewPlayer(player);
+    }
+
+    @SubscribeEvent
+    public static void onPlayerChangedDimension(PlayerChangedDimensionEvent event) {
+        EntityPlayer player = event.player;
+        if (player.getEntityWorld().isRemote) return;
+
+        ModifierSettingsManager.handleNewPlayer(player);
+        ModeSettingsManager.handleNewPlayer(player);
+
+        UndoRedo.clear(player);
+        EffortlessBuilding.packetHandler.sendTo(new ClearUndoMessage(), (EntityPlayerMP) player);
+    }
 }

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

@@ -1,51 +0,0 @@
-package nl.requios.effortlessbuilding;
-
-import com.mojang.blaze3d.platform.InputConstants;
-import com.mojang.blaze3d.vertex.DefaultVertexFormat;
-import net.minecraft.client.KeyMapping;
-import net.minecraft.client.renderer.ShaderInstance;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.RegisterKeyMappingsEvent;
-import net.minecraftforge.client.event.RegisterShadersEvent;
-import net.minecraftforge.client.settings.KeyConflictContext;
-import net.minecraftforge.client.settings.KeyModifier;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
-import nl.requios.effortlessbuilding.proxy.ClientProxy;
-import nl.requios.effortlessbuilding.render.BuildRenderTypes;
-import org.lwjgl.glfw.GLFW;
-
-import java.io.IOException;
-
-@Mod.EventBusSubscriber(bus = Mod.EventBusSubscriber.Bus.MOD, value = {Dist.CLIENT})
-public class ModClientEventHandler {
-
-	@SubscribeEvent
-	public static void registerKeyMappings(RegisterKeyMappingsEvent event) {
-		EffortlessBuilding.log("Registering KeyMappings!");
-
-		// register key bindings
-		ClientProxy.keyBindings = new KeyMapping[6];
-
-		// instantiate the key bindings
-		ClientProxy.keyBindings[0] = new KeyMapping("key.effortlessbuilding.hud.desc", KeyConflictContext.IN_GAME, InputConstants.getKey(GLFW.GLFW_KEY_KP_ADD, 0), "key.effortlessbuilding.category");
-		ClientProxy.keyBindings[1] = new KeyMapping("key.effortlessbuilding.replace.desc", KeyConflictContext.IN_GAME, InputConstants.getKey(GLFW.GLFW_KEY_KP_SUBTRACT, 0), "key.effortlessbuilding.category");
-		ClientProxy.keyBindings[2] = new KeyMapping("key.effortlessbuilding.mode.desc", KeyConflictContext.IN_GAME, InputConstants.getKey(GLFW.GLFW_KEY_LEFT_ALT, 0), "key.effortlessbuilding.category");
-		ClientProxy.keyBindings[3] = new KeyMapping("key.effortlessbuilding.undo.desc", KeyConflictContext.IN_GAME, KeyModifier.CONTROL, InputConstants.getKey(GLFW.GLFW_KEY_Z, 0), "key.effortlessbuilding.category");
-		ClientProxy.keyBindings[4] = new KeyMapping("key.effortlessbuilding.redo.desc", KeyConflictContext.IN_GAME, KeyModifier.CONTROL, InputConstants.getKey(GLFW.GLFW_KEY_Y, 0), "key.effortlessbuilding.category");
-		ClientProxy.keyBindings[5] = new KeyMapping("key.effortlessbuilding.altplacement.desc", KeyConflictContext.IN_GAME, InputConstants.getKey(GLFW.GLFW_KEY_LEFT_CONTROL, 0), "key.effortlessbuilding.category");
-
-		for (KeyMapping keyBinding : ClientProxy.keyBindings) {
-			event.register(keyBinding);
-		}
-	}
-
-	@SubscribeEvent
-	public static void registerShaders(RegisterShadersEvent event) throws IOException {
-		event.registerShader(new ShaderInstance(event.getResourceManager(),
-				new ResourceLocation(EffortlessBuilding.MODID, "dissolve"),
-				DefaultVertexFormat.BLOCK),
-				shaderInstance -> BuildRenderTypes.dissolveShaderInstance = shaderInstance);
-	}
-}

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

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

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

@@ -1,16 +1,17 @@
 package nl.requios.effortlessbuilding.buildmode;
 
-import com.mojang.math.Vector4f;
+import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.world.entity.player.Player;
+import net.minecraft.util.EnumFacing;
-import net.minecraft.core.Direction;
+import net.minecraft.util.EnumHand;
-import net.minecraft.core.BlockPos;
+import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.level.ClipContext;
+import net.minecraft.util.math.RayTraceResult;
-import net.minecraft.world.phys.HitResult;
+import net.minecraft.util.math.Vec3d;
-import net.minecraft.world.phys.Vec3;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmode.buildmodes.*;
-import nl.requios.effortlessbuilding.buildmodifier.BuildModifiers;
+import nl.requios.effortlessbuilding.buildmode.buildmodes.Circle;
-import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
+import nl.requios.effortlessbuilding.buildmode.buildmodes.Cylinder;
+import nl.requios.effortlessbuilding.buildmode.buildmodes.Sphere;
+import nl.requios.effortlessbuilding.buildmodifier.*;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
 import nl.requios.effortlessbuilding.helper.SurvivalHelper;
 import nl.requios.effortlessbuilding.network.BlockBrokenMessage;
@@ -21,282 +22,224 @@ import java.util.Dictionary;
 import java.util.Hashtable;
 import java.util.List;
 
-import static nl.requios.effortlessbuilding.buildmode.ModeOptions.OptionEnum;
+import static nl.requios.effortlessbuilding.buildmode.ModeOptions.*;
 
 public class BuildModes {
 
-	//Static variables are shared between client and server in singleplayer
+    //Static variables are shared between client and server in singleplayer
-	//We need them separate
+    //We need them separate
-	public static Dictionary<Player, Boolean> currentlyBreakingClient = new Hashtable<>();
+    public static Dictionary<EntityPlayer, Boolean> currentlyBreakingClient = new Hashtable<>();
-	public static Dictionary<Player, Boolean> currentlyBreakingServer = new Hashtable<>();
+    public static Dictionary<EntityPlayer, Boolean> currentlyBreakingServer = new Hashtable<>();
 
-	//Uses a network message to get the previous raytraceresult from the player
+    public enum BuildModeEnum {
-	//The server could keep track of all raytraceresults but this might lag with many players
+        NORMAL("effortlessbuilding.mode.normal", new Normal()),
-	//Raytraceresult is needed for sideHit and hitVec
+        NORMAL_PLUS("effortlessbuilding.mode.normal_plus", new NormalPlus(), OptionEnum.BUILD_SPEED),
-	public static void onBlockPlacedMessage(Player player, BlockPlacedMessage message) {
+        LINE("effortlessbuilding.mode.line", new Line() /*, OptionEnum.THICKNESS*/),
+        WALL("effortlessbuilding.mode.wall", new Wall(), OptionEnum.FILL),
+        FLOOR("effortlessbuilding.mode.floor", new Floor(), OptionEnum.FILL),
+        DIAGONAL_LINE("effortlessbuilding.mode.diagonal_line", new DiagonalLine() /*, OptionEnum.THICKNESS*/),
+        DIAGONAL_WALL("effortlessbuilding.mode.diagonal_wall", new DiagonalWall() /*, OptionEnum.FILL*/),
+        SLOPE_FLOOR("effortlessbuilding.mode.slope_floor", new SlopeFloor(), OptionEnum.RAISED_EDGE),
+        CIRCLE("effortlessbuilding.mode.circle", new Circle(), OptionEnum.CIRCLE_START, OptionEnum.FILL),
+        CYLINDER("effortlessbuilding.mode.cylinder", new Cylinder(), OptionEnum.CIRCLE_START, OptionEnum.FILL),
+        SPHERE("effortlessbuilding.mode.sphere", new Sphere(), OptionEnum.CIRCLE_START, OptionEnum.FILL),
+        CUBE("effortlessbuilding.mode.cube", new Cube(), OptionEnum.CUBE_FILL);
 
-		//Check if not in the middle of breaking
+        public String name;
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
+        public IBuildMode instance;
-		if (currentlyBreaking.get(player) != null && currentlyBreaking.get(player)) {
+        public OptionEnum[] options;
-			//Cancel breaking
-			initializeMode(player);
-			return;
-		}
 
-		ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+        BuildModeEnum(String name, IBuildMode instance, OptionEnum... options) {
-		ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+            this.name = name;
-		BuildModeEnum buildMode = modeSettings.getBuildMode();
+            this.instance = instance;
+            this.options = options;
+        }
+    }
 
-		BlockPos startPos = null;
+    //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) {
 
-		if (message.isBlockHit() && message.getBlockPos() != null) {
+        //Check if not in the middle of breaking
-			startPos = message.getBlockPos();
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
+        if (currentlyBreaking.get(player) != null && currentlyBreaking.get(player)) {
+            //Cancel breaking
+            initializeMode(player);
+            return;
+        }
 
-			//Offset in direction of sidehit if not quickreplace and not replaceable
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-			boolean replaceable = player.level.getBlockState(startPos).getMaterial().isReplaceable();
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
-			boolean becomesDoubleSlab = SurvivalHelper.doesBecomeDoubleSlab(player, startPos, message.getSideHit());
+        BuildModeEnum buildMode = modeSettings.getBuildMode();
-			if (!modifierSettings.doQuickReplace() && !replaceable && !becomesDoubleSlab) {
-				startPos = startPos.relative(message.getSideHit());
-			}
 
-			//Get under tall grass and other replaceable blocks
+        BlockPos startPos = null;
-			if (modifierSettings.doQuickReplace() && replaceable) {
-				startPos = startPos.below();
-			}
 
-			//Check if player reach does not exceed startpos
+        if (message.isBlockHit() && message.getBlockPos() != null) {
-			int maxReach = ReachHelper.getMaxReach(player);
+            startPos = message.getBlockPos();
-			if (buildMode != BuildModeEnum.NORMAL && player.blockPosition().distSqr(startPos) > maxReach * maxReach) {
-				EffortlessBuilding.log(player, "Placement exceeds your reach.");
-				return;
-			}
-		}
 
-		//Even when no starting block is found, call buildmode instance
+            //Offset in direction of sidehit if not quickreplace and not replaceable
-		//We might want to place things in the air
+            boolean replaceable = player.world.getBlockState(startPos).getBlock().isReplaceable(player.world, startPos);
-		List<BlockPos> coordinates = buildMode.instance.onRightClick(player, startPos, message.getSideHit(), message.getHitVec(), modifierSettings.doQuickReplace());
+            boolean becomesDoubleSlab = SurvivalHelper.doesBecomeDoubleSlab(player, startPos, message.getSideHit());
+            if (!modifierSettings.doQuickReplace() && !replaceable && !becomesDoubleSlab) {
+                startPos = startPos.offset(message.getSideHit());
+            }
 
-		if (coordinates.isEmpty()) {
+            //Get under tall grass and other replaceable blocks
-			currentlyBreaking.put(player, false);
+            if (modifierSettings.doQuickReplace() && replaceable) {
-			return;
+                startPos = startPos.down();
-		}
+            }
 
-		//Limit number of blocks you can place
+            //Check if player reach does not exceed startpos
-		int limit = ReachHelper.getMaxBlocksPlacedAtOnce(player);
+            int maxReach = ReachHelper.getMaxReach(player);
-		if (coordinates.size() > limit) {
+            if (buildMode != BuildModeEnum.NORMAL && player.getPosition().distanceSq(startPos) > maxReach * maxReach) {
-			coordinates = coordinates.subList(0, limit);
+                EffortlessBuilding.log(player, "Placement exceeds your reach.");
-		}
+                return;
+            }
+        }
 
-		Direction sideHit = buildMode.instance.getSideHit(player);
+        //Even when no starting block is found, call buildmode instance
-		if (sideHit == null) sideHit = message.getSideHit();
+        //We might want to place things in the air
+        List<BlockPos> coordinates = buildMode.instance.onRightClick(player, startPos, message.getSideHit(), message.getHitVec(), modifierSettings.doQuickReplace());
 
-		Vec3 hitVec = buildMode.instance.getHitVec(player);
+        if (coordinates.isEmpty()) {
-		if (hitVec == null) hitVec = message.getHitVec();
+            currentlyBreaking.put(player, false);
+            return;
+        }
 
-		BuildModifiers.onBlockPlaced(player, coordinates, sideHit, hitVec, message.getPlaceStartPos());
+        //Limit number of blocks you can place
+        int limit = ReachHelper.getMaxBlocksPlacedAtOnce(player);
+        if (coordinates.size() > limit) {
+            coordinates = coordinates.subList(0, limit);
+        }
 
-		//Only works when finishing a buildmode is equal to placing some blocks
+        EnumFacing sideHit = buildMode.instance.getSideHit(player);
-		//No intermediate blocks allowed
+        if (sideHit == null) sideHit = message.getSideHit();
-		currentlyBreaking.remove(player);
-	}
 
-	//Use a network message to break blocks in the distance using clientside mouse input
+        Vec3d hitVec = buildMode.instance.getHitVec(player);
-	public static void onBlockBrokenMessage(Player player, BlockBrokenMessage message) {
+        if (hitVec == null) hitVec = message.getHitVec();
-		BlockPos startPos = message.isBlockHit() ? message.getBlockPos() : null;
-		onBlockBroken(player, startPos, true);
-	}
 
-	public static void onBlockBroken(Player player, BlockPos startPos, boolean breakStartPos) {
+        BuildModifiers.onBlockPlaced(player, coordinates, sideHit, hitVec, message.getPlaceStartPos());
 
-		//Check if not in the middle of placing
+        //Only works when finishing a buildmode is equal to placing some blocks
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
+        //No intermediate blocks allowed
-		if (currentlyBreaking.get(player) != null && !currentlyBreaking.get(player)) {
+        currentlyBreaking.remove(player);
-			//Cancel placing
-			initializeMode(player);
-			return;
-		}
 
-		if (!ReachHelper.canBreakFar(player)) return;
+    }
 
-		//If first click
+    //Use a network message to break blocks in the distance using clientside mouse input
-		if (currentlyBreaking.get(player) == null) {
+    public static void onBlockBrokenMessage(EntityPlayer player, BlockBrokenMessage message) {
-			//If startpos is null, dont do anything
+        BlockPos startPos = message.isBlockHit() ? message.getBlockPos() : null;
-			if (startPos == null) return;
+        onBlockBroken(player, startPos, true);
-		}
+    }
 
-		ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
+    public static void onBlockBroken(EntityPlayer player, BlockPos startPos, boolean breakStartPos) {
-		ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
 
-		//Get coordinates
+        //Check if not in the middle of placing
-		BuildModeEnum buildMode = modeSettings.getBuildMode();
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
-		List<BlockPos> coordinates = buildMode.instance.onRightClick(player, startPos, Direction.UP, Vec3.ZERO, true);
+        if (currentlyBreaking.get(player) != null && !currentlyBreaking.get(player)) {
+            //Cancel placing
+            initializeMode(player);
+            return;
+        }
 
-		if (coordinates.isEmpty()) {
+        //If first click
-			currentlyBreaking.put(player, true);
+        if (currentlyBreaking.get(player) == null) {
-			return;
+            //If startpos is null, dont do anything
-		}
+            if (startPos == null) return;
+        }
 
-		//Let buildmodifiers break blocks
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-		BuildModifiers.onBlockBroken(player, coordinates, breakStartPos);
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
 
-		//Only works when finishing a buildmode is equal to breaking some blocks
+        //Get coordinates
-		//No intermediate blocks allowed
+        BuildModeEnum buildMode = modeSettings.getBuildMode();
-		currentlyBreaking.remove(player);
+        List<BlockPos> coordinates = buildMode.instance.onRightClick(player, startPos, EnumFacing.UP, Vec3d.ZERO, true);
-	}
 
-	public static List<BlockPos> findCoordinates(Player player, BlockPos startPos, boolean skipRaytrace) {
+        if (coordinates.isEmpty()) {
-		List<BlockPos> coordinates = new ArrayList<>();
+            currentlyBreaking.put(player, true);
+            return;
+        }
 
-		ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
+        //Let buildmodifiers break blocks
-		coordinates.addAll(modeSettings.getBuildMode().instance.findCoordinates(player, startPos, skipRaytrace));
+        BuildModifiers.onBlockBroken(player, coordinates, breakStartPos);
 
-		return coordinates;
+        //Only works when finishing a buildmode is equal to breaking some blocks
-	}
+        //No intermediate blocks allowed
+        currentlyBreaking.remove(player);
+    }
 
-	public static void initializeMode(Player player) {
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos, boolean skipRaytrace) {
-		//Resetting mode, so not placing or breaking
+        List<BlockPos> coordinates = new ArrayList<>();
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
-		currentlyBreaking.remove(player);
 
-		ModeSettingsManager.getModeSettings(player).getBuildMode().instance.initialize(player);
+        ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
-	}
+        coordinates.addAll(modeSettings.getBuildMode().instance.findCoordinates(player, startPos, skipRaytrace));
 
-	public static boolean isCurrentlyPlacing(Player player) {
+        return coordinates;
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
+    }
-		return currentlyBreaking.get(player) != null && !currentlyBreaking.get(player);
-	}
 
-	public static boolean isCurrentlyBreaking(Player player) {
+    public static void initializeMode(EntityPlayer player) {
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
+        //Resetting mode, so not placing or breaking
-		return currentlyBreaking.get(player) != null && currentlyBreaking.get(player);
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
-	}
+        currentlyBreaking.remove(player);
 
-	//Either placing or breaking
+        ModeSettingsManager.getModeSettings(player).getBuildMode().instance.initialize(player);
-	public static boolean isActive(Player player) {
+    }
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
-		return currentlyBreaking.get(player) != null;
-	}
 
-	//Find coordinates on a line bound by a plane
+    public static boolean isCurrentlyPlacing(EntityPlayer player) {
-	public static Vec3 findXBound(double x, Vec3 start, Vec3 look) {
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
-		//then y and z are
+        return currentlyBreaking.get(player) != null && !currentlyBreaking.get(player);
-		double y = (x - start.x) / look.x * look.y + start.y;
+    }
-		double z = (x - start.x) / look.x * look.z + start.z;
 
-		return new Vec3(x, y, z);
+    public static boolean isCurrentlyBreaking(EntityPlayer player) {
-	}
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
+        return currentlyBreaking.get(player) != null && currentlyBreaking.get(player);
+    }
+
+    //Either placing or breaking
+    public static boolean isActive(EntityPlayer player) {
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
+        return currentlyBreaking.get(player) != null;
+    }
 
 
-	//-- Common build mode functionality --//
+    //Find coordinates on a line bound by a plane
+    public static Vec3d findXBound(double x, Vec3d start, Vec3d look) {
+        //then y and z are
+        double y = (x - start.x) / look.x * look.y + start.y;
+        double z = (x - start.x) / look.x * look.z + start.z;
 
-	public static Vec3 findYBound(double y, Vec3 start, Vec3 look) {
+        return new Vec3d(x, y, z);
-		//then x and z are
+    }
-		double x = (y - start.y) / look.y * look.x + start.x;
-		double z = (y - start.y) / look.y * look.z + start.z;
 
-		return new Vec3(x, y, z);
+    public static Vec3d findYBound(double y, Vec3d start, Vec3d look) {
-	}
+        //then x and z are
+        double x = (y - start.y) / look.y * look.x + start.x;
+        double z = (y - start.y) / look.y * look.z + start.z;
 
-	public static Vec3 findZBound(double z, Vec3 start, Vec3 look) {
+        return new Vec3d(x, y, z);
-		//then x and y are
+    }
-		double x = (z - start.z) / look.z * look.x + start.x;
-		double y = (z - start.z) / look.z * look.y + start.y;
 
-		return new Vec3(x, y, z);
+    public static Vec3d findZBound(double z, Vec3d start, Vec3d look) {
-	}
+        //then x and y are
+        double x = (z - start.z) / look.z * look.x + start.x;
+        double y = (z - start.z) / look.z * look.y + start.y;
 
-	//Use this instead of player.getLookVec() in any buildmodes code
+        return new Vec3d(x, y, z);
-	public static Vec3 getPlayerLookVec(Player player) {
+    }
-		Vec3 lookVec = player.getLookAngle();
-		double x = lookVec.x;
-		double y = lookVec.y;
-		double z = lookVec.z;
 
-		//Further calculations (findXBound etc) don't like any component being 0 or 1 (e.g. dividing by 0)
+    public static boolean isCriteriaValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace, Vec3d lineBound, Vec3d planeBound, double distToPlayerSq) {
-		//isCriteriaValid below will take up to 2 minutes to raytrace blocks towards infinity if that is the case
+        boolean intersects = false;
-		//So make sure they are close to but never exactly 0 or 1
+        if (!skipRaytrace) {
-		if (Math.abs(x) < 0.0001) x = 0.0001;
+            //collision within a 1 block radius to selected is fine
-		if (Math.abs(x - 1.0) < 0.0001) x = 0.9999;
+            RayTraceResult rayTraceResult = player.world.rayTraceBlocks(start, lineBound, false, true, false);
-		if (Math.abs(x + 1.0) < 0.0001) x = -0.9999;
+            intersects = rayTraceResult != null && rayTraceResult.typeOfHit == RayTraceResult.Type.BLOCK &&
+                         planeBound.subtract(rayTraceResult.hitVec).lengthSquared() > 4;
+        }
 
-		if (Math.abs(y) < 0.0001) y = 0.0001;
+        return planeBound.subtract(start).dotProduct(look) > 0 &&
-		if (Math.abs(y - 1.0) < 0.0001) y = 0.9999;
+               distToPlayerSq > 2 && distToPlayerSq < reach * reach &&
-		if (Math.abs(y + 1.0) < 0.0001) y = -0.9999;
+               !intersects;
+    }
 
-		if (Math.abs(z) < 0.0001) z = 0.0001;
-		if (Math.abs(z - 1.0) < 0.0001) z = 0.9999;
-		if (Math.abs(z + 1.0) < 0.0001) z = -0.9999;
-
-		return new Vec3(x, y, z);
-	}
-
-	public static boolean isCriteriaValid(Vec3 start, Vec3 look, int reach, Player player, boolean skipRaytrace, Vec3 lineBound, Vec3 planeBound, double distToPlayerSq) {
-		boolean intersects = false;
-		if (!skipRaytrace) {
-			//collision within a 1 block radius to selected is fine
-			ClipContext rayTraceContext = new ClipContext(start, lineBound, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, player);
-			HitResult rayTraceResult = player.level.clip(rayTraceContext);
-			intersects = rayTraceResult != null && rayTraceResult.getType() == HitResult.Type.BLOCK &&
-				planeBound.subtract(rayTraceResult.getLocation()).lengthSqr() > 4;
-		}
-
-		return planeBound.subtract(start).dot(look) > 0 &&
-			distToPlayerSq > 2 && distToPlayerSq < reach * reach &&
-			!intersects;
-	}
-
-	public enum BuildModeEnum {
-		NORMAL("normal", new Normal(), BuildModeCategoryEnum.BASIC),
-		NORMAL_PLUS("normal_plus", new NormalPlus(), BuildModeCategoryEnum.BASIC, OptionEnum.BUILD_SPEED),
-		LINE("line", new Line(), BuildModeCategoryEnum.BASIC /*, OptionEnum.THICKNESS*/),
-		WALL("wall", new Wall(), BuildModeCategoryEnum.BASIC, OptionEnum.FILL),
-		FLOOR("floor", new Floor(), BuildModeCategoryEnum.BASIC, OptionEnum.FILL),
-		CUBE("cube", new Cube(), BuildModeCategoryEnum.BASIC, OptionEnum.CUBE_FILL),
-		DIAGONAL_LINE("diagonal_line", new DiagonalLine(),  BuildModeCategoryEnum.DIAGONAL /*, OptionEnum.THICKNESS*/),
-		DIAGONAL_WALL("diagonal_wall", new DiagonalWall(),  BuildModeCategoryEnum.DIAGONAL /*, OptionEnum.FILL*/),
-		SLOPE_FLOOR("slope_floor", new SlopeFloor(), BuildModeCategoryEnum.DIAGONAL, OptionEnum.RAISED_EDGE),
-		CIRCLE("circle", new Circle(), BuildModeCategoryEnum.CIRCULAR, OptionEnum.CIRCLE_START, OptionEnum.FILL),
-		CYLINDER("cylinder", new Cylinder(), BuildModeCategoryEnum.CIRCULAR, OptionEnum.CIRCLE_START, OptionEnum.FILL),
-		SPHERE("sphere", new Sphere(), BuildModeCategoryEnum.CIRCULAR, OptionEnum.CIRCLE_START, OptionEnum.FILL);
-//		PYRAMID("pyramid", new Pyramid(), BuildModeCategoryEnum.ROOF),
-//		CONE("cone", new Cone(), BuildModeCategoryEnum.ROOF),
-//		DOME("dome", new Dome(), BuildModeCategoryEnum.ROOF);
-
-		private final String name;
-		public final IBuildMode instance;
-		public final BuildModeCategoryEnum category;
-		public final OptionEnum[] options;
-
-		BuildModeEnum(String name, IBuildMode instance, BuildModeCategoryEnum category, OptionEnum... options) {
-			this.name = name;
-			this.instance = instance;
-			this.category = category;
-			this.options = options;
-		}
-		
-		public String getName() {
-			return name;
-		}
-
-		public String getNameKey() {
-			return "effortlessbuilding.mode." + name;
-		}
-
-		public String getDescriptionKey() {
-			return "effortlessbuilding.modedescription." + name;
-		}
-	}
-
-	public enum BuildModeCategoryEnum {
-		BASIC(new Vector4f(0f, .5f, 1f, .8f)),
-		DIAGONAL(new Vector4f(0.56f, 0.28f, 0.87f, .8f)),
-		CIRCULAR(new Vector4f(0.29f, 0.76f, 0.3f, 1f)),
-		ROOF(new Vector4f(0.83f, 0.87f, 0.23f, .8f));
-
-		public final Vector4f color;
-
-		BuildModeCategoryEnum(Vector4f color) {
-			this.color = color;
-		}
-	}
 }

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

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

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

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

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

@@ -1,97 +1,86 @@
 package nl.requios.effortlessbuilding.buildmode;
 
-import net.minecraft.world.entity.player.Player;
+import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.entity.player.EntityPlayerMP;
-import net.minecraftforge.common.util.LazyOptional;
 import net.minecraftforge.fml.common.Mod;
-import net.minecraftforge.network.PacketDistributor;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.capability.ModeCapabilityManager;
 import nl.requios.effortlessbuilding.helper.ReachHelper;
 import nl.requios.effortlessbuilding.network.ModeSettingsMessage;
-import nl.requios.effortlessbuilding.network.PacketHandler;
-
-import javax.annotation.Nonnull;
 
 @Mod.EventBusSubscriber
 public class ModeSettingsManager {
 
-	//Retrieves the buildsettings of a player through the modeCapability capability
+    //Retrieves the buildsettings of a player through the modifierCapability capability
-	//Never returns null
+    //Never returns null
-	@Nonnull
+    public static ModeSettings getModeSettings(EntityPlayer player) {
-	public static ModeSettings getModeSettings(Player player) {
+        if (player.hasCapability(ModeCapabilityManager.modeCapability, null)) {
-		LazyOptional<ModeCapabilityManager.IModeCapability> modeCapability =
+            ModeCapabilityManager.IModeCapability capability = player.getCapability(
-			player.getCapability(ModeCapabilityManager.MODE_CAPABILITY, null);
+                    ModeCapabilityManager.modeCapability, null);
+            if (capability.getModeData() == null) {
+                capability.setModeData(new ModeSettings());
+            }
+            return capability.getModeData();
+        }
+        throw new IllegalArgumentException("Player does not have modeCapability capability");
+    }
 
-		if (modeCapability.isPresent()) {
+    public static void setModeSettings(EntityPlayer player, ModeSettings modeSettings) {
-			ModeCapabilityManager.IModeCapability capability = modeCapability.orElse(null);
+        if (player == null) {
-			if (capability.getModeData() == null){
+            EffortlessBuilding.log("Cannot set buildsettings, player is null");
-				capability.setModeData(new ModeSettings());
+            return;
-			}
+        }
-			return capability.getModeData();
+        if (player.hasCapability(ModeCapabilityManager.modeCapability, null)) {
-		}
+            ModeCapabilityManager.IModeCapability capability = player.getCapability(
+                    ModeCapabilityManager.modeCapability, null);
 
-//		EffortlessBuilding.logger.warn("Player does not have modeCapability: " + player);
+            capability.setModeData(modeSettings);
-		//Return dummy settings
-		return new ModeSettings();
-	}
 
-	public static void setModeSettings(Player player, ModeSettings modeSettings) {
+            //Initialize new mode
-		if (player == null) {
+            BuildModes.initializeMode(player);
-			EffortlessBuilding.log("Cannot set buildmode settings, player is null");
+        } else {
-			return;
+            EffortlessBuilding.log(player, "Saving buildsettings failed.");
-		}
+        }
-		LazyOptional<ModeCapabilityManager.IModeCapability> modeCapability =
+    }
-			player.getCapability(ModeCapabilityManager.MODE_CAPABILITY, null);
 
-		modeCapability.ifPresent((capability) -> {
+    public static String sanitize(ModeSettings modeSettings, EntityPlayer player) {
-			capability.setModeData(modeSettings);
+        int maxReach = ReachHelper.getMaxReach(player);
+        String error = "";
 
-			BuildModes.initializeMode(player);
+        //TODO sanitize
-		});
 
-		if (!modeCapability.isPresent()) {
+        return error;
-			EffortlessBuilding.log(player, "Saving buildmode settings failed.");
+    }
-		}
-	}
 
-	public static String sanitize(ModeSettings modeSettings, Player player) {
+    public static class ModeSettings {
-		int maxReach = ReachHelper.getMaxReach(player);
+        private BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.NORMAL;
-		String error = "";
 
-		//TODO sanitize
+        public ModeSettings() {
+        }
 
-		return error;
+        public ModeSettings(BuildModes.BuildModeEnum buildMode) {
-	}
+            this.buildMode = buildMode;
+        }
 
-	public static void handleNewPlayer(Player player) {
+        public BuildModes.BuildModeEnum getBuildMode() {
-		//Makes sure player has mode settings (if it doesnt it will create it)
+            return this.buildMode;
-		getModeSettings(player);
+        }
 
-		//Only on server
+        public void setBuildMode(BuildModes.BuildModeEnum buildMode) {
-		if (!player.level.isClientSide) {
+            this.buildMode = buildMode;
-			//Send to client
+        }
-			ModeSettingsMessage msg = new ModeSettingsMessage(getModeSettings(player));
+    }
-			PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) player), msg);
-		}
-	}
 
-	public static class ModeSettings {
+    public static void handleNewPlayer(EntityPlayer player){
-		private BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.NORMAL;
+        if (getModeSettings(player) == null) {
+            setModeSettings(player, new ModeSettings());
+        }
 
-		public ModeSettings() {
+        //Only on server
-		}
+        if (!player.world.isRemote) {
-
+            //Send to client
-		public ModeSettings(BuildModes.BuildModeEnum buildMode) {
+            ModeSettingsMessage msg = new ModeSettingsMessage(getModeSettings(player));
-			this.buildMode = buildMode;
+            EffortlessBuilding.packetHandler.sendTo(msg, (EntityPlayerMP) player);
-		}
+        }
-
+    }
-		public BuildModes.BuildModeEnum getBuildMode() {
-			return this.buildMode;
-		}
-
-		public void setBuildMode(BuildModes.BuildModeEnum buildMode) {
-			this.buildMode = buildMode;
-		}
-	}
 }

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

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

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

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

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

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

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

@@ -1,31 +0,0 @@
-package nl.requios.effortlessbuilding.buildmode.buildmodes;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.entity.player.Player;
-import nl.requios.effortlessbuilding.buildmode.ThreeClicksBuildMode;
-
-import java.util.List;
-
-public class Cone extends ThreeClicksBuildMode {
-
-	@Override
-	protected BlockPos findSecondPos(Player player, BlockPos firstPos, boolean skipRaytrace) {
-		return Floor.findFloor(player, firstPos, skipRaytrace);
-	}
-
-	@Override
-	protected BlockPos findThirdPos(Player player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
-		return findHeight(player, secondPos, skipRaytrace);
-	}
-
-	@Override
-	protected List<BlockPos> getIntermediateBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2) {
-		return Floor.getFloorBlocks(player, x1, y1, z1, x2, y2, z2);
-	}
-
-	@Override
-	protected List<BlockPos> getFinalBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
-		//TODO
-		return SlopeFloor.getSlopeFloorBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
-	}
-}

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

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

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

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

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

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

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

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

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

@@ -1,31 +0,0 @@
-package nl.requios.effortlessbuilding.buildmode.buildmodes;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.entity.player.Player;
-import nl.requios.effortlessbuilding.buildmode.ThreeClicksBuildMode;
-
-import java.util.List;
-
-public class Dome extends ThreeClicksBuildMode {
-
-	@Override
-	protected BlockPos findSecondPos(Player player, BlockPos firstPos, boolean skipRaytrace) {
-		return Floor.findFloor(player, firstPos, skipRaytrace);
-	}
-
-	@Override
-	protected BlockPos findThirdPos(Player player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
-		return findHeight(player, secondPos, skipRaytrace);
-	}
-
-	@Override
-	protected List<BlockPos> getIntermediateBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2) {
-		return Floor.getFloorBlocks(player, x1, y1, z1, x2, y2, z2);
-	}
-
-	@Override
-	protected List<BlockPos> getFinalBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
-		//TODO
-		return SlopeFloor.getSlopeFloorBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
-	}
-}

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

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

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

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

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

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

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

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

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

@@ -1,34 +0,0 @@
-package nl.requios.effortlessbuilding.buildmode.buildmodes;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.entity.player.Player;
-import nl.requios.effortlessbuilding.buildmode.ModeOptions;
-import nl.requios.effortlessbuilding.buildmode.ThreeClicksBuildMode;
-import nl.requios.effortlessbuilding.helper.ReachHelper;
-
-import java.util.ArrayList;
-import java.util.List;
-
-public class Pyramid extends ThreeClicksBuildMode {
-
-	@Override
-	protected BlockPos findSecondPos(Player player, BlockPos firstPos, boolean skipRaytrace) {
-		return Floor.findFloor(player, firstPos, skipRaytrace);
-	}
-
-	@Override
-	protected BlockPos findThirdPos(Player player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
-		return findHeight(player, secondPos, skipRaytrace);
-	}
-
-	@Override
-	protected List<BlockPos> getIntermediateBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2) {
-		return Floor.getFloorBlocks(player, x1, y1, z1, x2, y2, z2);
-	}
-
-	@Override
-	protected List<BlockPos> getFinalBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
-		//TODO
-		return SlopeFloor.getSlopeFloorBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
-	}
-}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,108 +1,104 @@
 package nl.requios.effortlessbuilding.capability;
 
-import net.minecraft.nbt.CompoundTag;
+import net.minecraft.nbt.NBTBase;
-import net.minecraft.nbt.Tag;
+import net.minecraft.nbt.NBTTagCompound;
-import net.minecraft.core.Direction;
+import net.minecraft.util.EnumFacing;
-import net.minecraftforge.common.capabilities.*;
+import net.minecraftforge.common.capabilities.Capability;
-import net.minecraftforge.common.util.LazyOptional;
+import net.minecraftforge.common.capabilities.CapabilityInject;
+import net.minecraftforge.common.capabilities.ICapabilitySerializable;
 import net.minecraftforge.event.entity.player.PlayerEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
 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 nl.requios.effortlessbuilding.buildmode.ModeSettingsManager.ModeSettings;
+import static nl.requios.effortlessbuilding.buildmode.ModeSettingsManager.*;
 
 @Mod.EventBusSubscriber
 public class ModeCapabilityManager {
 
-	public static Capability<IModeCapability> MODE_CAPABILITY = CapabilityManager.get(new CapabilityToken<>(){});
+    @CapabilityInject(IModeCapability.class)
+    public final static Capability<IModeCapability> modeCapability = null;
 
-	// Allows for the capability to persist after death.
+    public interface IModeCapability {
-	@SubscribeEvent
+        ModeSettings getModeData();
-	public static void clonePlayer(PlayerEvent.Clone event) {
-		LazyOptional<IModeCapability> original = event.getOriginal().getCapability(MODE_CAPABILITY, null);
-		LazyOptional<IModeCapability> clone = event.getEntity().getCapability(MODE_CAPABILITY, null);
-		clone.ifPresent(cloneModeCapability ->
-			original.ifPresent(originalModeCapability ->
-				cloneModeCapability.setModeData(originalModeCapability.getModeData())));
-	}
 
-	public interface IModeCapability {
+        void setModeData(ModeSettings modeSettings);
-		ModeSettings getModeData();
+    }
 
-		void setModeData(ModeSettings modeSettings);
+    public static class ModeCapability implements IModeCapability {
-	}
+        private ModeSettings modeSettings;
 
-	public static class ModeCapability implements IModeCapability {
+        @Override
-		private ModeSettings modeSettings;
+        public ModeSettings getModeData() {
+            return modeSettings;
+        }
 
-		@Override
+        @Override
-		public ModeSettings getModeData() {
+        public void setModeData(ModeSettings modeSettings) {
-			return modeSettings;
+            this.modeSettings = modeSettings;
-		}
+        }
+    }
 
-		@Override
+    public static class Storage implements Capability.IStorage<IModeCapability> {
-		public void setModeData(ModeSettings modeSettings) {
+        @Override
-			this.modeSettings = modeSettings;
+        public NBTBase writeNBT(Capability<IModeCapability> capability, IModeCapability instance, EnumFacing side) {
-		}
+            NBTTagCompound compound = new NBTTagCompound();
-	}
+            ModeSettings modeSettings = instance.getModeData();
+            if (modeSettings == null) modeSettings = new ModeSettings();
 
-	public static class Provider extends CapabilityProvider<Provider> implements ICapabilitySerializable<Tag> {
+            //compound.setInteger("buildMode", modeSettings.getBuildMode().ordinal());
 
-		private IModeCapability instance = new ModeCapability();
+            //TODO add mode settings
-		private LazyOptional<IModeCapability> modeCapabilityOptional = LazyOptional.of(() -> instance);
 
-		public Provider() {
+            return compound;
-			super(Provider.class);
+        }
-			gatherCapabilities();
-		}
 
-		@Nonnull
+        @Override
-		@Override
+        public void readNBT(Capability<IModeCapability> capability, IModeCapability instance, EnumFacing side, NBTBase nbt) {
-		public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
+            NBTTagCompound compound = (NBTTagCompound) nbt;
-			if (cap == MODE_CAPABILITY) return modeCapabilityOptional.cast();
-			return LazyOptional.empty();
-		}
 
-		@Override
+            //BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.values()[compound.getInteger("buildMode")];
-		public void invalidateCaps() {
-			super.invalidateCaps();
-			modeCapabilityOptional.invalidate();
-		}
 
-		@Override
+            //TODO add mode settings
-		public void reviveCaps() {
-			super.reviveCaps();
-			modeCapabilityOptional = LazyOptional.of(() -> instance);
-		}
 
-		@Override
+            ModeSettings modeSettings = new ModeSettings(BuildModes.BuildModeEnum.NORMAL);
-		public Tag serializeNBT() {
+            instance.setModeData(modeSettings);
-			CompoundTag compound = new CompoundTag();
+        }
-			ModeSettings modeSettings = instance.getModeData();
+    }
-			if (modeSettings == null) modeSettings = new ModeSettings();
 
-			//compound.putInteger("buildMode", modeSettings.getBuildMode().ordinal());
+    public static class Provider implements ICapabilitySerializable<NBTBase> {
+        IModeCapability inst = modeCapability.getDefaultInstance();
 
-			//TODO add mode settings
+        @Override
+        public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
+            return capability == modeCapability;
+        }
 
-			return compound;
+        @Override
-		}
+        public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
+            if (capability == modeCapability) return modeCapability.<T>cast(inst);
+            return null;
+        }
 
-		@Override
+        @Override
-		public void deserializeNBT(Tag nbt) {
+        public NBTBase serializeNBT() {
-			CompoundTag compound = (CompoundTag) nbt;
+            return modeCapability.getStorage().writeNBT(modeCapability, inst, null);
+        }
 
-			//BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.values()[compound.getInteger("buildMode")];
+        @Override
+        public void deserializeNBT(NBTBase nbt) {
+            modeCapability.getStorage().readNBT(modeCapability, inst, null, nbt);
+        }
+    }
 
-			//TODO add mode settings
+    // Allows for the capability to persist after death.
-
+    @SubscribeEvent
-			ModeSettings modeSettings = new ModeSettings(BuildModes.BuildModeEnum.NORMAL);
+    public static void clonePlayer(PlayerEvent.Clone event) {
-			instance.setModeData(modeSettings);
+        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

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

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

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

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

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

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

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

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

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

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

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

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

@@ -1,148 +0,0 @@
-package nl.requios.effortlessbuilding.gui;
-
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.entity.player.Inventory;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.inventory.AbstractContainerMenu;
-import net.minecraft.world.inventory.ClickType;
-import net.minecraft.world.inventory.MenuType;
-import net.minecraft.world.inventory.Slot;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.items.IItemHandler;
-import net.minecraftforge.items.ItemStackHandler;
-import net.minecraftforge.items.SlotItemHandler;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.item.DiamondRandomizerBagItem;
-
-public class DiamondRandomizerBagContainer extends AbstractContainerMenu {
-
-	private static final int INV_START = DiamondRandomizerBagItem.INV_SIZE,
-			INV_END = INV_START + 26,
-			HOTBAR_START = INV_END + 1,
-			HOTBAR_END = HOTBAR_START + 8;
-	private final IItemHandler bagInventory;
-
-	public DiamondRandomizerBagContainer(MenuType<?> type, int id){
-		super(type, id);
-		bagInventory = null;
-	}
-
-	//Client
-	public DiamondRandomizerBagContainer(int id, Inventory playerInventory, FriendlyByteBuf packetBuffer) {
-		this(id, playerInventory);
-	}
-
-	//Server?
-	public DiamondRandomizerBagContainer(int containerId, Inventory playerInventory) {
-		this(containerId, playerInventory, new ItemStackHandler(DiamondRandomizerBagItem.INV_SIZE));
-	}
-
-	public DiamondRandomizerBagContainer(int containerId, Inventory playerInventory, IItemHandler inventory) {
-		super(EffortlessBuilding.DIAMOND_RANDOMIZER_BAG_CONTAINER.get(), containerId);
-		bagInventory = inventory;
-
-		for (int i = 0; i < 3; ++i) {
-			for (int j = 0; j < 9; ++j) {
-				this.addSlot(new SlotItemHandler(bagInventory, j + i * 9, 8 + j * 18, 18 + i * 18));
-			}
-		}
-
-		// add player inventory slots
-		for (int i = 0; i < 3; ++i) {
-			for (int j = 0; j < 9; ++j) {
-				addSlot(new Slot(playerInventory, j + i * 9 + 9, 8 + j * 18, 84 + i * 18));
-			}
-		}
-
-		// add hotbar slots
-		for (int i = 0; i < 9; ++i) {
-			addSlot(new Slot(playerInventory, i, 8 + i * 18, 142));
-		}
-	}
-
-    @Override
-	public boolean stillValid(Player playerIn) {
-		return true;
-	}
-
-	@Override
-	public Slot getSlot(int parSlotIndex) {
-		if (parSlotIndex >= slots.size())
-			parSlotIndex = slots.size() - 1;
-		return super.getSlot(parSlotIndex);
-	}
-
-	@Override
-	public ItemStack quickMoveStack(Player playerIn, int slotIndex) {
-		ItemStack itemstack = ItemStack.EMPTY;
-		Slot slot = this.slots.get(slotIndex);
-
-		if (slot != null && slot.hasItem()) {
-			ItemStack itemstack1 = slot.getItem();
-			itemstack = itemstack1.copy();
-
-			// If item is in our custom inventory
-			if (slotIndex < INV_START) {
-				// try to place in player inventory / action bar
-				if (!this.moveItemStackTo(itemstack1, INV_START, HOTBAR_END + 1, true)) {
-					return ItemStack.EMPTY;
-				}
-
-				slot.onQuickCraft(itemstack1, itemstack);
-			}
-			// Item is in inventory / hotbar, try to place in custom inventory or armor slots
-			else {
-				/**
-				 * Implementation number 1: Shift-click into your custom inventory
-				 */
-				if (slotIndex >= INV_START) {
-					// place in custom inventory
-					if (!this.moveItemStackTo(itemstack1, 0, INV_START, false)) {
-						return ItemStack.EMPTY;
-					}
-				}
-			}
-
-			if (itemstack1.getCount() == 0) {
-				slot.set(ItemStack.EMPTY);
-			} else {
-				slot.setChanged();
-			}
-
-			if (itemstack1.getCount() == itemstack.getCount()) {
-				return ItemStack.EMPTY;
-			}
-
-			slot.onTake(playerIn, itemstack1);
-		}
-
-		return itemstack;
-	}
-
-	/**
-	 * You should override this method to prevent the player from moving the stack that
-	 * opened the inventory, otherwise if the player moves it, the inventory will not
-	 * be able to save properly
-	 */
-	@Override
-	public void clicked(int slot, int dragType, ClickType clickTypeIn, Player player) {
-		// this will prevent the player from interacting with the item that opened the inventory:
-		if (slot >= 0 && getSlot(slot) != null && getSlot(slot).getItem().equals(player.getItemInHand(InteractionHand.MAIN_HAND))) {
-			//Do nothing;
-			return;
-		}
-		super.clicked(slot, dragType, clickTypeIn, player);
-	}
-
-	/**
-	 * Callback for when the crafting gui is closed.
-	 */
-	@Override
-	public void removed(Player player) {
-		super.removed(player);
-		if (!player.level.isClientSide) {
-			broadcastChanges();
-		}
-	}
-}

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

@@ -1,49 +0,0 @@
-package nl.requios.effortlessbuilding.gui;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.entity.player.Inventory;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@OnlyIn(Dist.CLIENT)
-@ParametersAreNonnullByDefault
-public class DiamondRandomizerBagScreen extends AbstractContainerScreen<DiamondRandomizerBagContainer> {
-	private Inventory inventory;
-
-	private static final ResourceLocation guiTextures = new ResourceLocation(EffortlessBuilding.MODID, "textures/gui/container/diamondrandomizerbag.png");
-
-	public DiamondRandomizerBagScreen(DiamondRandomizerBagContainer randomizerBagContainer, Inventory playerInventory, Component title) {
-		super(randomizerBagContainer, playerInventory, title);
-		this.inventory = playerInventory;
-		imageHeight = 167;
-	}
-
-	@Override
-	public void render(PoseStack ms, int mouseX, int mouseY, float partialTicks) {
-		renderBackground(ms);
-		super.render(ms, mouseX, mouseY, partialTicks);
-		this.renderTooltip(ms, mouseX, mouseY);
-	}
-
-	@Override
-	protected void renderLabels(PoseStack ms, int mouseX, int mouseY) {
-		this.font.draw(ms, this.title, 8, 6, 0x404040);
-		this.font.draw(ms, this.playerInventoryTitle, 8, imageHeight - 96 + 2, 0x404040);
-	}
-
-	@Override
-	protected void renderBg(PoseStack ms, float partialTicks, int mouseX, int mouseY) {
-		RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1f);
-		RenderSystem.setShaderTexture(0, guiTextures);
-		int marginHorizontal = (width - imageWidth) / 2;
-		int marginVertical = (height - imageHeight) / 2;
-		blit(ms, marginHorizontal, marginVertical, 0, 0, imageWidth, imageHeight);
-	}
-}

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

@@ -1,146 +0,0 @@
-package nl.requios.effortlessbuilding.gui;
-
-import net.minecraft.network.FriendlyByteBuf;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.entity.player.Inventory;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.inventory.AbstractContainerMenu;
-import net.minecraft.world.inventory.ClickType;
-import net.minecraft.world.inventory.MenuType;
-import net.minecraft.world.inventory.Slot;
-import net.minecraft.world.item.ItemStack;
-import net.minecraftforge.items.IItemHandler;
-import net.minecraftforge.items.ItemStackHandler;
-import net.minecraftforge.items.SlotItemHandler;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.item.GoldenRandomizerBagItem;
-
-public class GoldenRandomizerBagContainer extends AbstractContainerMenu {
-
-	private static final int INV_START = GoldenRandomizerBagItem.INV_SIZE,
-			INV_END = INV_START + 26,
-			HOTBAR_START = INV_END + 1,
-			HOTBAR_END = HOTBAR_START + 8;
-	private final IItemHandler bagInventory;
-
-	public GoldenRandomizerBagContainer(MenuType<?> type, int id){
-		super(type, id);
-		bagInventory = null;
-	}
-
-	//Client
-	public GoldenRandomizerBagContainer(int id, Inventory playerInventory, FriendlyByteBuf packetBuffer) {
-		this(id, playerInventory);
-	}
-
-	//Server?
-	public GoldenRandomizerBagContainer(int containerId, Inventory playerInventory) {
-		this(containerId, playerInventory, new ItemStackHandler(GoldenRandomizerBagItem.INV_SIZE));
-	}
-
-	public GoldenRandomizerBagContainer(int containerId, Inventory playerInventory, IItemHandler inventory) {
-		super(EffortlessBuilding.GOLDEN_RANDOMIZER_BAG_CONTAINER.get(), containerId);
-		bagInventory = inventory;
-
-		for (int i = 0; i < GoldenRandomizerBagItem.INV_SIZE; ++i) {
-			this.addSlot(new SlotItemHandler(bagInventory, i, 8 + (18 * i), 20));
-		}
-
-		// add player inventory slots
-		for (int i = 0; i < 3; ++i) {
-			for (int j = 0; j < 9; ++j) {
-				addSlot(new Slot(playerInventory, j + i * 9 + 9, 8 + j * 18, 51 + i * 18));
-			}
-		}
-
-		// add hotbar slots
-		for (int i = 0; i < 9; ++i) {
-			addSlot(new Slot(playerInventory, i, 8 + i * 18, 109));
-		}
-	}
-
-    @Override
-	public boolean stillValid(Player playerIn) {
-		return true;
-	}
-
-	@Override
-	public Slot getSlot(int parSlotIndex) {
-		if (parSlotIndex >= slots.size())
-			parSlotIndex = slots.size() - 1;
-		return super.getSlot(parSlotIndex);
-	}
-
-	@Override
-	public ItemStack quickMoveStack(Player playerIn, int slotIndex) {
-		ItemStack itemstack = ItemStack.EMPTY;
-		Slot slot = this.slots.get(slotIndex);
-
-		if (slot != null && slot.hasItem()) {
-			ItemStack itemstack1 = slot.getItem();
-			itemstack = itemstack1.copy();
-
-			// If item is in our custom inventory
-			if (slotIndex < INV_START) {
-				// try to place in player inventory / action bar
-				if (!this.moveItemStackTo(itemstack1, INV_START, HOTBAR_END + 1, true)) {
-					return ItemStack.EMPTY;
-				}
-
-				slot.onQuickCraft(itemstack1, itemstack);
-			}
-			// Item is in inventory / hotbar, try to place in custom inventory or armor slots
-			else {
-				/**
-				 * Implementation number 1: Shift-click into your custom inventory
-				 */
-				if (slotIndex >= INV_START) {
-					// place in custom inventory
-					if (!this.moveItemStackTo(itemstack1, 0, INV_START, false)) {
-						return ItemStack.EMPTY;
-					}
-				}
-			}
-
-			if (itemstack1.getCount() == 0) {
-				slot.set(ItemStack.EMPTY);
-			} else {
-				slot.setChanged();
-			}
-
-			if (itemstack1.getCount() == itemstack.getCount()) {
-				return ItemStack.EMPTY;
-			}
-
-			slot.onTake(playerIn, itemstack1);
-		}
-
-		return itemstack;
-	}
-
-	/**
-	 * You should override this method to prevent the player from moving the stack that
-	 * opened the inventory, otherwise if the player moves it, the inventory will not
-	 * be able to save properly
-	 */
-	@Override
-	public void clicked(int slot, int dragType, ClickType clickTypeIn, Player player) {
-		// this will prevent the player from interacting with the item that opened the inventory:
-		if (slot >= 0 && getSlot(slot) != null && getSlot(slot).getItem().equals(player.getItemInHand(InteractionHand.MAIN_HAND))) {
-			//Do nothing;
-			return;
-		}
-		super.clicked(slot, dragType, clickTypeIn, player);
-	}
-
-	/**
-	 * Callback for when the crafting gui is closed.
-	 */
-	@Override
-	public void removed(Player player) {
-		super.removed(player);
-		if (!player.level.isClientSide) {
-			broadcastChanges();
-		}
-	}
-}

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

@@ -1,49 +0,0 @@
-package nl.requios.effortlessbuilding.gui;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.entity.player.Inventory;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@OnlyIn(Dist.CLIENT)
-@ParametersAreNonnullByDefault
-public class GoldenRandomizerBagScreen extends AbstractContainerScreen<GoldenRandomizerBagContainer> {
-	private Inventory inventory;
-
-	private static final ResourceLocation guiTextures = new ResourceLocation(EffortlessBuilding.MODID, "textures/gui/container/goldenrandomizerbag.png");
-
-	public GoldenRandomizerBagScreen(GoldenRandomizerBagContainer randomizerBagContainer, Inventory playerInventory, Component title) {
-		super(randomizerBagContainer, playerInventory, title);
-		this.inventory = playerInventory;
-		imageHeight = 134;
-	}
-
-	@Override
-	public void render(PoseStack ms, int mouseX, int mouseY, float partialTicks) {
-		renderBackground(ms);
-		super.render(ms, mouseX, mouseY, partialTicks);
-		this.renderTooltip(ms, mouseX, mouseY);
-	}
-
-	@Override
-	protected void renderLabels(PoseStack ms, int mouseX, int mouseY) {
-		this.font.draw(ms, this.title, 8, 6, 0x404040);
-		this.font.draw(ms, this.playerInventoryTitle, 8, imageHeight - 96 + 2, 0x404040);
-	}
-
-	@Override
-	protected void renderBg(PoseStack ms, float partialTicks, int mouseX, int mouseY) {
-		RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1f);
-		RenderSystem.setShaderTexture(0, guiTextures);
-		int marginHorizontal = (width - imageWidth) / 2;
-		int marginVertical = (height - imageHeight) / 2;
-		blit(ms, marginHorizontal, marginVertical, 0, 0, imageWidth, imageHeight);
-	}
-}

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

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

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

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

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

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

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

@@ -1,49 +0,0 @@
-package nl.requios.effortlessbuilding.gui;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.systems.RenderSystem;
-import net.minecraft.client.gui.screens.inventory.AbstractContainerScreen;
-import net.minecraft.world.entity.player.Inventory;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.network.chat.Component;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@OnlyIn(Dist.CLIENT)
-@ParametersAreNonnullByDefault
-public class RandomizerBagScreen extends AbstractContainerScreen<RandomizerBagContainer> {
-	private Inventory inventory;
-
-	private static final ResourceLocation guiTextures = new ResourceLocation(EffortlessBuilding.MODID, "textures/gui/container/randomizerbag.png");
-
-	public RandomizerBagScreen(RandomizerBagContainer randomizerBagContainer, Inventory playerInventory, Component title) {
-		super(randomizerBagContainer, playerInventory, title);
-		this.inventory = playerInventory;
-		imageHeight = 134;
-	}
-
-	@Override
-	public void render(PoseStack ms, int mouseX, int mouseY, float partialTicks) {
-		renderBackground(ms);
-		super.render(ms, mouseX, mouseY, partialTicks);
-		this.renderTooltip(ms, mouseX, mouseY);
-	}
-
-	@Override
-	protected void renderLabels(PoseStack ms, int mouseX, int mouseY) {
-		this.font.draw(ms, this.title, 8, 6, 0x404040);
-		this.font.draw(ms, this.playerInventoryTitle, 8, imageHeight - 96 + 2, 0x404040);
-	}
-
-	@Override
-	protected void renderBg(PoseStack ms, float partialTicks, int mouseX, int mouseY) {
-		RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1f);
-		RenderSystem.setShaderTexture(0, guiTextures);
-		int marginHorizontal = (width - imageWidth) / 2;
-		int marginVertical = (height - imageHeight) / 2;
-		blit(ms, marginHorizontal, marginVertical, 0, 0, imageWidth, imageHeight);
-	}
-}

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

@@ -1,305 +0,0 @@
-package nl.requios.effortlessbuilding.gui.buildmode;
-
-import com.mojang.blaze3d.vertex.*;
-import com.mojang.blaze3d.platform.GlStateManager;
-import com.mojang.blaze3d.systems.RenderSystem;
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.resources.sounds.SimpleSoundInstance;
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.client.gui.components.Button;
-import net.minecraft.client.gui.components.ObjectSelectionList;
-import net.minecraft.sounds.SoundEvents;
-import net.minecraft.util.Mth;
-import net.minecraft.network.chat.Component;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import net.minecraftforge.client.gui.widget.ExtendedButton;
-import net.minecraftforge.client.gui.widget.ForgeSlider;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-public class PlayerSettingsGui extends Screen {
-
-	protected int left, right, top, bottom;
-	protected boolean showShaderList = false;
-	private Button shaderTypeButton;
-	private ShaderTypeList shaderTypeList;
-	private Button closeButton;
-
-	public PlayerSettingsGui() {
-		super(Component.translatable("effortlessbuilding.screen.player_settings"));
-	}
-
-	@Override
-	protected void init() {
-		left = this.width / 2 - 140;
-		right = this.width / 2 + 140;
-		top = this.height / 2 - 100;
-		bottom = this.height / 2 + 100;
-
-		int yy = top;
-		shaderTypeList = new ShaderTypeList(this.minecraft);
-		addWidget(shaderTypeList);
-		//TODO set selected name
-		Component currentShaderName = ShaderType.DISSOLVE_BLUE.name;
-		shaderTypeButton = new ExtendedButton(right - 180, yy, 180, 20, currentShaderName, (button) -> {
-			showShaderList = !showShaderList;
-		});
-		addRenderableOnly(shaderTypeButton);
-
-		yy += 50;
-		ForgeSlider slider = new ForgeSlider(right - 200, yy, 200, 20, Component.empty(), Component.empty(), 0.5, 2.0, 1.0, true);
-		addRenderableOnly(slider);
-
-		closeButton = new ExtendedButton(left + 50, bottom - 20, 180, 20, Component.literal("Done"), (button) -> this.minecraft.player.closeContainer());
-		addRenderableOnly(closeButton);
-	}
-
-	@Override
-	public void tick() {
-		super.tick();
-	}
-
-	@Override
-	public void render(PoseStack ms, int mouseX, int mouseY, float partialTicks) {
-		this.renderBackground(ms);
-
-		int yy = top;
-		font.draw(ms, "Shader type", left, yy + 5, 0xFFFFFF);
-
-		yy += 50;
-		font.draw(ms, "Shader speed", left, yy + 5, 0xFFFFFF);
-
-		super.render(ms, mouseX, mouseY, partialTicks);
-
-		if (showShaderList)
-			this.shaderTypeList.render(ms, mouseX, mouseY, partialTicks);
-	}
-
-	@Override
-	public boolean mouseClicked(double mouseX, double mouseY, int mouseButton) {
-		super.mouseClicked(mouseX, mouseY, mouseButton);
-		if (showShaderList) {
-			if (!shaderTypeList.isMouseOver(mouseX, mouseY) && !shaderTypeButton.isMouseOver(mouseX, mouseY))
-				showShaderList = false;
-		}
-		return true;
-	}
-
-	@Override
-	public void removed() {
-		ShaderTypeList.ShaderTypeEntry selectedShader = shaderTypeList.getSelected();
-		//TODO save and remove
-	}
-
-	public enum ShaderType {
-		DISSOLVE_BLUE("Dissolve Blue"),
-		DISSOLVE_ORANGE("Dissolve Orange");
-
-		public Component name;
-
-		ShaderType(Component name) {
-			this.name = name;
-		}
-
-		ShaderType(String name) {
-			this.name = Component.literal(name);
-		}
-	}
-
-	//Inspired by LanguageScreen
-	@OnlyIn(Dist.CLIENT)
-	class ShaderTypeList extends ObjectSelectionList<PlayerSettingsGui.ShaderTypeList.ShaderTypeEntry> {
-
-		public ShaderTypeList(Minecraft mcIn) {
-			super(mcIn, 180, 140, top + 20, top + 100, 18);
-			this.setLeftPos(right - width);
-
-			for (int i = 0; i < 40; i++) {
-
-				for (ShaderType shaderType : ShaderType.values()) {
-					ShaderTypeEntry shaderTypeEntry = new ShaderTypeEntry(shaderType);
-					addEntry(shaderTypeEntry);
-					//TODO setSelected to this if appropriate
-				}
-
-			}
-
-			if (this.getSelected() != null) {
-				this.centerScrollOn(this.getSelected());
-			}
-		}
-
-		@Override
-		public int getRowWidth() {
-			return width;
-		}
-
-		@Override
-		public void setSelected(PlayerSettingsGui.ShaderTypeList.ShaderTypeEntry selected) {
-			super.setSelected(selected);
-			Minecraft.getInstance().getSoundManager().play(SimpleSoundInstance.forUI(SoundEvents.UI_BUTTON_CLICK, 1.0F));
-			EffortlessBuilding.log("Selected shader " + selected.shaderType.name);
-			shaderTypeButton.setMessage(selected.shaderType.name);
-//            showShaderList = false;
-		}
-
-		@Override
-		public boolean mouseClicked(double p_mouseClicked_1_, double p_mouseClicked_3_, int p_mouseClicked_5_) {
-			if (!showShaderList) return false;
-			return super.mouseClicked(p_mouseClicked_1_, p_mouseClicked_3_, p_mouseClicked_5_);
-		}
-
-		@Override
-		public boolean mouseReleased(double p_mouseReleased_1_, double p_mouseReleased_3_, int p_mouseReleased_5_) {
-			if (!showShaderList) return false;
-			return super.mouseReleased(p_mouseReleased_1_, p_mouseReleased_3_, p_mouseReleased_5_);
-		}
-
-		@Override
-		public boolean mouseDragged(double p_mouseDragged_1_, double p_mouseDragged_3_, int p_mouseDragged_5_, double p_mouseDragged_6_, double p_mouseDragged_8_) {
-			if (!showShaderList) return false;
-			return super.mouseDragged(p_mouseDragged_1_, p_mouseDragged_3_, p_mouseDragged_5_, p_mouseDragged_6_, p_mouseDragged_8_);
-		}
-
-		@Override
-		public boolean mouseScrolled(double p_mouseScrolled_1_, double p_mouseScrolled_3_, double p_mouseScrolled_5_) {
-			if (!showShaderList) return false;
-			return super.mouseScrolled(p_mouseScrolled_1_, p_mouseScrolled_3_, p_mouseScrolled_5_);
-		}
-
-		@Override
-		public boolean isMouseOver(double p_isMouseOver_1_, double p_isMouseOver_3_) {
-			if (!showShaderList) return false;
-			return super.isMouseOver(p_isMouseOver_1_, p_isMouseOver_3_);
-		}
-
-		protected boolean isFocused() {
-			return PlayerSettingsGui.this.getFocused() == this;
-		}
-
-		@Override
-		protected int getScrollbarPosition() {
-			return right - 6;
-		}
-
-		//From AbstractSelectionList, disabled parts
-		@Override
-		public void render(PoseStack ms, int p_render_1_, int p_render_2_, float p_render_3_) {
-			this.renderBackground(ms);
-			int i = this.getScrollbarPosition();
-			int j = i + 6;
-			Tesselator tessellator = Tesselator.getInstance();
-			BufferBuilder bufferbuilder = tessellator.getBuilder();
-//            this.minecraft.getTextureManager().bindTexture(AbstractGui.BACKGROUND_LOCATION);
-			RenderSystem.enableBlend();
-			RenderSystem.blendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ZERO, GlStateManager.DestFactor.ONE);
-			RenderSystem.setShaderColor(1.0F, 1.0F, 1.0F, 1.0F);
-			float f = 32.0F;
-			bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
-			bufferbuilder.vertex(this.x0, this.y1, 0.0D).color(20, 20, 20, 180).endVertex();
-			bufferbuilder.vertex(this.x1, this.y1, 0.0D).color(20, 20, 20, 180).endVertex();
-			bufferbuilder.vertex(this.x1, this.y0, 0.0D).color(20, 20, 20, 180).endVertex();
-			bufferbuilder.vertex(this.x0, this.y0, 0.0D).color(20, 20, 20, 180).endVertex();
-			tessellator.end();
-			int k = this.getRowLeft();
-			int l = this.y0 + 4 - (int) this.getScrollAmount();
-			if (this.renderHeader) {
-				this.renderHeader(ms, k, l, tessellator);
-			}
-
-			this.renderList(ms, p_render_1_, p_render_2_, p_render_3_);
-			RenderSystem.disableDepthTest();
-//            this.renderHoleBackground(0, this.y0, 255, 255);
-//            this.renderHoleBackground(this.y1, this.height, 255, 255);
-			RenderSystem.enableBlend();
-			RenderSystem.blendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ZERO, GlStateManager.DestFactor.ONE);
-			RenderSystem.disableTexture();
-//            int i1 = 4;
-//            bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
-//            bufferbuilder.pos((double)this.x0, (double)(this.y0 + 4), 0.0D).tex(0.0F, 1.0F).color(0, 0, 0, 0).endVertex();
-//            bufferbuilder.pos((double)this.x1, (double)(this.y0 + 4), 0.0D).tex(1.0F, 1.0F).color(0, 0, 0, 0).endVertex();
-//            bufferbuilder.pos((double)this.x1, (double)this.y0, 0.0D).tex(1.0F, 0.0F).color(0, 0, 0, 255).endVertex();
-//            bufferbuilder.pos((double)this.x0, (double)this.y0, 0.0D).tex(0.0F, 0.0F).color(0, 0, 0, 255).endVertex();
-//            tessellator.draw();
-//            bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
-//            bufferbuilder.pos((double)this.x0, (double)this.y1, 0.0D).tex(0.0F, 1.0F).color(0, 0, 0, 255).endVertex();
-//            bufferbuilder.pos((double)this.x1, (double)this.y1, 0.0D).tex(1.0F, 1.0F).color(0, 0, 0, 255).endVertex();
-//            bufferbuilder.pos((double)this.x1, (double)(this.y1 - 4), 0.0D).tex(1.0F, 0.0F).color(0, 0, 0, 0).endVertex();
-//            bufferbuilder.pos((double)this.x0, (double)(this.y1 - 4), 0.0D).tex(0.0F, 0.0F).color(0, 0, 0, 0).endVertex();
-//            tessellator.draw();
-
-			//SCROLLBAR
-			int j1 = this.getMaxScroll();
-			if (j1 > 0) {
-				int k1 = (int) ((float) ((this.y1 - this.y0) * (this.y1 - this.y0)) / (float) this.getMaxPosition());
-				k1 = Mth.clamp(k1, 32, this.y1 - this.y0 - 8);
-				int l1 = (int) this.getScrollAmount() * (this.y1 - this.y0 - k1) / j1 + this.y0;
-				if (l1 < this.y0) {
-					l1 = this.y0;
-				}
-
-				bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
-				bufferbuilder.vertex(i, this.y1, 0.0D).uv(0.0F, 1.0F).color(0, 0, 0, 255).endVertex();
-				bufferbuilder.vertex(j, this.y1, 0.0D).uv(1.0F, 1.0F).color(0, 0, 0, 255).endVertex();
-				bufferbuilder.vertex(j, this.y0, 0.0D).uv(1.0F, 0.0F).color(0, 0, 0, 255).endVertex();
-				bufferbuilder.vertex(i, this.y0, 0.0D).uv(0.0F, 0.0F).color(0, 0, 0, 255).endVertex();
-				tessellator.end();
-				bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
-				bufferbuilder.vertex(i, l1 + k1, 0.0D).uv(0.0F, 1.0F).color(128, 128, 128, 255).endVertex();
-				bufferbuilder.vertex(j, l1 + k1, 0.0D).uv(1.0F, 1.0F).color(128, 128, 128, 255).endVertex();
-				bufferbuilder.vertex(j, l1, 0.0D).uv(1.0F, 0.0F).color(128, 128, 128, 255).endVertex();
-				bufferbuilder.vertex(i, l1, 0.0D).uv(0.0F, 0.0F).color(128, 128, 128, 255).endVertex();
-				tessellator.end();
-				bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
-				bufferbuilder.vertex(i, l1 + k1 - 1, 0.0D).uv(0.0F, 1.0F).color(192, 192, 192, 255).endVertex();
-				bufferbuilder.vertex(j - 1, l1 + k1 - 1, 0.0D).uv(1.0F, 1.0F).color(192, 192, 192, 255).endVertex();
-				bufferbuilder.vertex(j - 1, l1, 0.0D).uv(1.0F, 0.0F).color(192, 192, 192, 255).endVertex();
-				bufferbuilder.vertex(i, l1, 0.0D).uv(0.0F, 0.0F).color(192, 192, 192, 255).endVertex();
-				tessellator.end();
-			}
-
-//            this.renderDecorations(p_render_1_, p_render_2_);
-			RenderSystem.enableTexture();
-			RenderSystem.disableBlend();
-		}
-
-		public int getMaxScroll() {
-			return Math.max(0, this.getMaxPosition() - (this.y1 - this.y0 - 4));
-		}
-
-		@OnlyIn(Dist.CLIENT)
-		public class ShaderTypeEntry extends ObjectSelectionList.Entry<ShaderTypeEntry> {
-			private final ShaderType shaderType;
-
-			public ShaderTypeEntry(ShaderType shaderType) {
-				this.shaderType = shaderType;
-			}
-
-			@Override
-			public void render(PoseStack ms, int itemIndex, int rowTop, int rowLeft, int rowWidth, int rowHeight, int mouseX, int mouseY, boolean hovered, float partialTicks) {
-				if (rowTop + 10 > ShaderTypeList.this.y0 && rowTop + rowHeight - 5 < ShaderTypeList.this.y1)
-					drawString(ms, font, shaderType.name, ShaderTypeList.this.x0 + 8, rowTop + 4, 0xFFFFFF);
-			}
-
-			@Override
-			public boolean mouseClicked(double p_mouseClicked_1_, double p_mouseClicked_3_, int p_mouseClicked_5_) {
-				if (p_mouseClicked_5_ == 0) {
-					setSelected(this);
-					return true;
-				} else {
-					return false;
-				}
-			}
-
-			@Override
-			public Component getNarration() {
-				return null;
-			}
-		}
-	}
-}

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

@@ -1,524 +1,476 @@
 package nl.requios.effortlessbuilding.gui.buildmode;
 
-import com.mojang.blaze3d.vertex.*;
+import java.util.ArrayList;
-import com.mojang.blaze3d.systems.RenderSystem;
+import java.util.concurrent.TimeUnit;
-import com.mojang.math.Vector4f;
+
-import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.client.resources.I18n;
-import net.minecraft.client.Minecraft;
+import net.minecraft.client.settings.KeyBinding;
-import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.util.text.TextFormatting;
-import net.minecraft.client.player.LocalPlayer;
-import net.minecraft.client.renderer.GameRenderer;
-import net.minecraft.client.resources.language.I18n;
-import net.minecraft.client.KeyMapping;
-import net.minecraft.client.resources.sounds.SimpleSoundInstance;
-import net.minecraft.core.Direction;
-import net.minecraft.ChatFormatting;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.sounds.SoundEvents;
-import net.minecraft.sounds.SoundSource;
-import net.minecraft.util.RandomSource;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmode.ModeOptions;
 import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
-import nl.requios.effortlessbuilding.network.ModeActionMessage;
-import nl.requios.effortlessbuilding.network.ModeSettingsMessage;
-import nl.requios.effortlessbuilding.network.PacketHandler;
 import nl.requios.effortlessbuilding.proxy.ClientProxy;
 import org.apache.commons.lang3.text.WordUtils;
 import org.lwjgl.opengl.GL11;
 
-import javax.annotation.ParametersAreNonnullByDefault;
+import com.google.common.base.Stopwatch;
-import java.util.ArrayList;
 
+import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
+import net.minecraft.client.renderer.BufferBuilder;
+import net.minecraft.client.renderer.GlStateManager;
+import net.minecraft.client.renderer.Tessellator;
+import net.minecraft.client.renderer.texture.TextureAtlasSprite;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.util.EnumFacing;
+import net.minecraftforge.client.model.ModelLoader;
+
+import static nl.requios.effortlessbuilding.buildmode.BuildModes.*;
 import static nl.requios.effortlessbuilding.buildmode.ModeOptions.*;
 
-import nl.requios.effortlessbuilding.buildmode.BuildModes.BuildModeEnum;
-import nl.requios.effortlessbuilding.buildmode.ModeOptions.ActionEnum;
-import nl.requios.effortlessbuilding.buildmode.ModeOptions.OptionEnum;
-
 /**
- * Initially from Chisels and Bits by AlgorithmX2
+ * From Chisels and Bits by AlgorithmX2
  * https://github.com/AlgorithmX2/Chisels-and-Bits/blob/1.12/src/main/java/mod/chiselsandbits/client/gui/ChiselsAndBitsMenu.java
  */
+public class RadialMenu extends GuiScreen {
 
-@ParametersAreNonnullByDefault
+    private final float TIME_SCALE = 0.01f;
-@MethodsReturnNonnullByDefault
+    public static final RadialMenu instance = new RadialMenu();
-public class RadialMenu extends Screen {
 
-	public static final RadialMenu instance = new RadialMenu();
+    private float visibility = 0.0f;
+    private Stopwatch lastChange = Stopwatch.createStarted();
+    public BuildModeEnum switchTo = null;
+    public ActionEnum doAction = null;
+    public boolean actionUsed = false;
 
-	private final Vector4f radialButtonColor = new Vector4f(0f, 0f, 0f, .5f);
+    private float clampVis(final float f) {
-	private final Vector4f sideButtonColor = new Vector4f(.5f, .5f, .5f, .5f);
+        return Math.max( 0.0f, Math.min( 1.0f, f ) );
-	private final Vector4f highlightColor = new Vector4f(.6f, .8f, 1f, .6f);
+    }
-	private final Vector4f selectedColor = new Vector4f(0f, .5f, 1f, .5f);
-	private final Vector4f highlightSelectedColor = new Vector4f(0.2f, .7f, 1f, .7f);
 
-	private final int whiteTextColor = 0xffffffff;
+    public void raiseVisibility() {
-	private final int watermarkTextColor = 0x88888888;
+        visibility = clampVis( visibility + lastChange.elapsed( TimeUnit.MILLISECONDS ) * TIME_SCALE );
-	private final int descriptionTextColor = 0xdd888888;
+        lastChange = Stopwatch.createStarted();
-	private final int optionTextColor = 0xeeeeeeff;
+    }
-
-	private final double ringInnerEdge = 30;
-	private final double ringOuterEdge = 65;
-	private final double categoryLineWidth = 1;
-	private final double textDistance = 75;
-	private final double buttonDistance = 105;
-	private final float fadeSpeed = 0.3f;
-	private final int descriptionHeight = 100;
-
-	public BuildModeEnum switchTo = null;
-	public ActionEnum doAction = null;
-	public boolean performedActionUsingMouse;
-
-	private float visibility;
-
-	public RadialMenu() {
-		super(Component.translatable("effortlessbuilding.screen.radial_menu"));
-	}
-
-	public boolean isVisible() {
-		return Minecraft.getInstance().screen instanceof RadialMenu;
-	}
 
-	@Override
+    public void decreaseVisibility() {
-	protected void init() {
+        visibility = clampVis( visibility - lastChange.elapsed( TimeUnit.MILLISECONDS ) * TIME_SCALE );
-		super.init();
+        lastChange = Stopwatch.createStarted();
-		performedActionUsingMouse = false;
+    }
-		visibility = 0f;
-	}
-
-	@Override
-	public void tick() {
-		super.tick();
-
-		if (!ClientProxy.isKeybindDown(2)) {
-			onClose();
-		}
-	}
-
-	@Override
-	public void render(PoseStack ms, final int mouseX, final int mouseY, final float partialTicks) {
-		BuildModeEnum currentBuildMode = ModeSettingsManager.getModeSettings(minecraft.player).getBuildMode();
-
-		ms.pushPose();
-		ms.translate(0, 0, 200);
-
-		visibility += fadeSpeed * partialTicks;
-		if (visibility > 1f) visibility = 1f;
-
-		final int startColor = (int) (visibility * 98) << 24;
-		final int endColor = (int) (visibility * 128) << 24;
-
-		fillGradient(ms, 0, 0, width, height, startColor, endColor);
-
-		RenderSystem.disableTexture();
-		RenderSystem.enableBlend();
-		RenderSystem.blendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, 1, 0);
-		final Tesselator tessellator = Tesselator.getInstance();
-		final BufferBuilder buffer = tessellator.getBuilder();
-
-		buffer.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_COLOR);
-
-		final double middleX = width / 2.0;
-		final double middleY = height / 2.0;
-
-		//Fix for high def (retina) displays: use custom mouse coordinates
-		//Borrowed from GameRenderer::updateCameraAndRender
-		int mouseXX = (int) (minecraft.mouseHandler.xpos() * (double) minecraft.getWindow().getGuiScaledWidth() / (double) minecraft.getWindow().getScreenWidth());
-		int mouseYY = (int) (minecraft.mouseHandler.ypos() * (double) minecraft.getWindow().getGuiScaledHeight() / (double) minecraft.getWindow().getScreenHeight());
-
-		final double mouseXCenter = mouseXX - middleX;
-		final double mouseYCenter = mouseYY - middleY;
-		double mouseRadians = Math.atan2(mouseYCenter, mouseXCenter);
-
-		final double quarterCircle = Math.PI / 2.0;
-
-		if (mouseRadians < -quarterCircle) {
-			mouseRadians = mouseRadians + Math.PI * 2;
-		}
-
-		final ArrayList<MenuRegion> modes = new ArrayList<MenuRegion>();
-		final ArrayList<MenuButton> buttons = new ArrayList<MenuButton>();
-
-		//Add build modes
-		for (final BuildModeEnum mode : BuildModeEnum.values()) {
-			modes.add(new MenuRegion(mode));
-		}
-
-		//Add actions
-		buttons.add(new MenuButton(ActionEnum.UNDO.name, ActionEnum.UNDO, -buttonDistance - 26, -13, Direction.UP));
-		buttons.add(new MenuButton(ActionEnum.REDO.name, ActionEnum.REDO, -buttonDistance, -13, Direction.UP));
-//		buttons.add(new MenuButton(ActionEnum.OPEN_PLAYER_SETTINGS.name, ActionEnum.OPEN_PLAYER_SETTINGS, -buttonDistance - 26 - 13, 13, Direction.DOWN));
-		buttons.add(new MenuButton(ActionEnum.OPEN_MODIFIER_SETTINGS.name, ActionEnum.OPEN_MODIFIER_SETTINGS, -buttonDistance - 26, 13, Direction.DOWN));
-		buttons.add(new MenuButton(ActionEnum.REPLACE.name, ActionEnum.REPLACE, -buttonDistance, 13, Direction.DOWN));
-
-		//Add buildmode dependent options
-		OptionEnum[] options = currentBuildMode.options;
-		for (int i = 0; i < options.length; i++) {
-			for (int j = 0; j < options[i].actions.length; j++) {
-				ActionEnum action = options[i].actions[j];
-				buttons.add(new MenuButton(action.name, action, buttonDistance + j * 26, -13 + i * 39, Direction.DOWN));
-			}
-		}
-
-		switchTo = null;
-		doAction = null;
-
-		//Draw buildmode backgrounds
-		drawRadialButtonBackgrounds(currentBuildMode, buffer, middleX, middleY, mouseXCenter, mouseYCenter, mouseRadians,
-				quarterCircle, modes);
-
-		//Draw action backgrounds
-		drawSideButtonBackgrounds(buffer, middleX, middleY, mouseXCenter, mouseYCenter, buttons);
-
-		tessellator.end();
-		RenderSystem.disableBlend();
-		RenderSystem.enableTexture();
-
-		drawIcons(ms, middleX, middleY, modes, buttons);
-
-		drawTexts(ms, currentBuildMode, middleX, middleY, modes, buttons, options);
-
-		ms.popPose();
-	}
-
-	private void drawRadialButtonBackgrounds(BuildModeEnum currentBuildMode, BufferBuilder buffer, double middleX, double middleY,
-											 double mouseXCenter, double mouseYCenter, double mouseRadians, double quarterCircle, ArrayList<MenuRegion> modes) {
-		if (!modes.isEmpty()) {
-			final int totalModes = Math.max(3, modes.size());
-			final double fragment = Math.PI * 0.005; //gap between buttons in radians at inner edge
-			final double fragment2 = Math.PI * 0.0025; //gap between buttons in radians at outer edge
-			final double radiansPerObject = 2.0 * Math.PI / totalModes;
-
-			for (int i = 0; i < modes.size(); i++) {
-				MenuRegion menuRegion = modes.get(i);
-				final double beginRadians = i * radiansPerObject - quarterCircle;
-				final double endRadians = (i + 1) * radiansPerObject - quarterCircle;
-
-				menuRegion.x1 = Math.cos(beginRadians);
-				menuRegion.x2 = Math.cos(endRadians);
-				menuRegion.y1 = Math.sin(beginRadians);
-				menuRegion.y2 = Math.sin(endRadians);
-
-				final double x1m1 = Math.cos(beginRadians + fragment) * ringInnerEdge;
-				final double x2m1 = Math.cos(endRadians - fragment) * ringInnerEdge;
-				final double y1m1 = Math.sin(beginRadians + fragment) * ringInnerEdge;
-				final double y2m1 = Math.sin(endRadians - fragment) * ringInnerEdge;
-
-				final double x1m2 = Math.cos(beginRadians + fragment2) * ringOuterEdge;
-				final double x2m2 = Math.cos(endRadians - fragment2) * ringOuterEdge;
-				final double y1m2 = Math.sin(beginRadians + fragment2) * ringOuterEdge;
-				final double y2m2 = Math.sin(endRadians - fragment2) * ringOuterEdge;
-
-				final boolean isSelected = currentBuildMode.ordinal() == i;
-				final boolean isMouseInQuad = inTriangle(x1m1, y1m1, x2m2, y2m2, x2m1, y2m1, mouseXCenter, mouseYCenter)
-											  || inTriangle(x1m1, y1m1, x1m2, y1m2, x2m2, y2m2, mouseXCenter, mouseYCenter);
-				final boolean isHighlighted = beginRadians <= mouseRadians && mouseRadians <= endRadians && isMouseInQuad;
-
-				Vector4f color = radialButtonColor;
-				if (isSelected) color = selectedColor;
-				if (isHighlighted) color = highlightColor;
-				if (isSelected && isHighlighted) color = highlightSelectedColor;
-
-				if (isHighlighted) {
-					menuRegion.highlighted = true;
-					switchTo = menuRegion.mode;
-				}
-
-				buffer.vertex(middleX + x1m1, middleY + y1m1, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-				buffer.vertex(middleX + x2m1, middleY + y2m1, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-				buffer.vertex(middleX + x2m2, middleY + y2m2, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-				buffer.vertex(middleX + x1m2, middleY + y1m2, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-
-				//Category line
-				color = menuRegion.mode.category.color;
-				final double categoryLineOuterEdge = ringInnerEdge + categoryLineWidth;
-
-				final double x1m3 = Math.cos(beginRadians + fragment) * categoryLineOuterEdge;
-				final double x2m3 = Math.cos(endRadians - fragment) * categoryLineOuterEdge;
-				final double y1m3 = Math.sin(beginRadians + fragment) * categoryLineOuterEdge;
-				final double y2m3 = Math.sin(endRadians - fragment) * categoryLineOuterEdge;
-
-				buffer.vertex(middleX + x1m1, middleY + y1m1, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-				buffer.vertex(middleX + x2m1, middleY + y2m1, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-				buffer.vertex(middleX + x2m3, middleY + y2m3, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-				buffer.vertex(middleX + x1m3, middleY + y1m3, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-			}
-		}
-	}
-
-	private void drawSideButtonBackgrounds(BufferBuilder buffer, double middleX, double middleY, double mouseXCenter, double mouseYCenter, ArrayList<MenuButton> buttons) {
-		for (final MenuButton btn : buttons) {
-
-			final boolean isSelected =
-					btn.action == getBuildSpeed() ||
-					btn.action == getFill() ||
-					btn.action == getCubeFill() ||
-					btn.action == getRaisedEdge() ||
-					btn.action == getLineThickness() ||
-					btn.action == getCircleStart();
-
-			final boolean isHighlighted = btn.x1 <= mouseXCenter && btn.x2 >= mouseXCenter && btn.y1 <= mouseYCenter && btn.y2 >= mouseYCenter;
-
-			Vector4f color = sideButtonColor;
-			if (isSelected) color = selectedColor;
-			if (isHighlighted) color = highlightColor;
-			if (isSelected && isHighlighted) color = highlightSelectedColor;
-
-			if (isHighlighted) {
-				btn.highlighted = true;
-				doAction = btn.action;
-			}
-
-			buffer.vertex(middleX + btn.x1, middleY + btn.y1, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-			buffer.vertex(middleX + btn.x1, middleY + btn.y2, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-			buffer.vertex(middleX + btn.x2, middleY + btn.y2, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-			buffer.vertex(middleX + btn.x2, middleY + btn.y1, getBlitOffset()).color(color.x(), color.y(), color.z(), color.w()).endVertex();
-		}
-	}
-
-	private void drawIcons(PoseStack ms, double middleX, double middleY,
-						   ArrayList<MenuRegion> modes, ArrayList<MenuButton> buttons) {
-		ms.pushPose();
-		RenderSystem.enableTexture();
-		RenderSystem.setShader(GameRenderer::getPositionColorTexShader);
-		RenderSystem.setShaderColor(1f, 1f, 1f, 1f);
-
-		//Draw buildmode icons
-		for (final MenuRegion menuRegion : modes) {
-
-			final double x = (menuRegion.x1 + menuRegion.x2) * 0.5 * (ringOuterEdge * 0.55 + 0.45 * ringInnerEdge);
-			final double y = (menuRegion.y1 + menuRegion.y2) * 0.5 * (ringOuterEdge * 0.55 + 0.45 * ringInnerEdge);
-
-			RenderSystem.setShaderTexture(0, new ResourceLocation(EffortlessBuilding.MODID, "textures/icons/" + menuRegion.mode.getName() + ".png"));
-			blit(ms, (int) (middleX + x - 8), (int) (middleY + y - 8), 16, 16, 0, 0, 18, 18, 18, 18);
-		}
-
-		//Draw action icons
-		for (final MenuButton button : buttons) {
-
-			final double x = (button.x1 + button.x2) / 2 + 0.01;
-			final double y = (button.y1 + button.y2) / 2 + 0.01;
-
-			RenderSystem.setShaderTexture(0, new ResourceLocation(EffortlessBuilding.MODID, "textures/icons/" + button.action.name().toLowerCase() + ".png"));
-			blit(ms, (int) (middleX + x - 8), (int) (middleY + y - 8), 16, 16, 0, 0, 18, 18, 18, 18);
-		}
-
-		ms.popPose();
-	}
-
-	private void drawTexts(PoseStack ms, BuildModeEnum currentBuildMode, double middleX, double middleY, ArrayList<MenuRegion> modes, ArrayList<MenuButton> buttons, OptionEnum[] options) {
-		//font.drawStringWithShadow("Actions", (int) (middleX - buttonDistance - 13) - font.getStringWidth("Actions") * 0.5f, (int) middleY - 38, 0xffffffff);
-
-		//Draw option strings
-		for (int i = 0; i < currentBuildMode.options.length; i++) {
-			OptionEnum option = options[i];
-			font.drawShadow(ms, I18n.get(option.name), (int) (middleX + buttonDistance - 9), (int) middleY - 37 + i * 39, optionTextColor);
-		}
-
-		String credits = "Effortless Building";
-		font.drawShadow(ms, credits, width - font.width(credits) - 4, height - 10, watermarkTextColor);
-
-		//Draw buildmode text
-		for (final MenuRegion menuRegion : modes) {
-
-			if (menuRegion.highlighted) {
-				final double x = (menuRegion.x1 + menuRegion.x2) * 0.5;
-				final double y = (menuRegion.y1 + menuRegion.y2) * 0.5;
-
-				int fixed_x = (int) (x * textDistance);
-				int fixed_y = (int) (y * textDistance) - font.lineHeight / 2;
-				String text = I18n.get(menuRegion.mode.getNameKey());
-
-				if (x <= -0.2) {
-					fixed_x -= font.width(text);
-				} else if (-0.2 <= x && x <= 0.2) {
-					fixed_x -= font.width(text) / 2;
-				}
-
-				font.drawShadow(ms, text, (int) middleX + fixed_x, (int) middleY + fixed_y, whiteTextColor);
-
-				//Draw description
-				text = I18n.get(menuRegion.mode.getDescriptionKey());
-				font.drawShadow(ms, text, (int) middleX - font.width(text) / 2f, (int) middleY + descriptionHeight, descriptionTextColor);
-			}
-		}
-
-		//Draw action text
-		for (final MenuButton button : buttons) {
-			if (button.highlighted) {
-				String text = ChatFormatting.AQUA + button.name;
-
-				//Add keybind in brackets
-				String keybind = findKeybind(button, currentBuildMode);
-				String keybindFormatted = "";
-				if (!keybind.isEmpty())
-					keybindFormatted = ChatFormatting.GRAY + "(" + WordUtils.capitalizeFully(keybind) + ")";
-
-				if (button.textSide == Direction.WEST) {
-
-					font.draw(ms, text, (int) (middleX + button.x1 - 8) - font.width(text),
-							(int) (middleY + button.y1 + 6), whiteTextColor);
-
-				} else if (button.textSide == Direction.EAST) {
-
-					font.draw(ms, text, (int) (middleX + button.x2 + 8),
-							(int) (middleY + button.y1 + 6), whiteTextColor);
-
-				} else if (button.textSide == Direction.UP || button.textSide == Direction.NORTH) {
-
-					font.draw(ms, keybindFormatted, (int) (middleX + (button.x1 + button.x2) * 0.5 - font.width(keybindFormatted) * 0.5),
-							(int) (middleY + button.y1 - 26), whiteTextColor);
-
-					font.draw(ms, text, (int) (middleX + (button.x1 + button.x2) * 0.5 - font.width(text) * 0.5),
-							(int) (middleY + button.y1 - 14), whiteTextColor);
-
-				} else if (button.textSide == Direction.DOWN || button.textSide == Direction.SOUTH) {
-
-					font.draw(ms, text, (int) (middleX + (button.x1 + button.x2) * 0.5 - font.width(text) * 0.5),
-							(int) (middleY + button.y1 + 26), whiteTextColor);
-
-					font.draw(ms, keybindFormatted, (int) (middleX + (button.x1 + button.x2) * 0.5 - font.width(keybindFormatted) * 0.5),
-							(int) (middleY + button.y1 + 38), whiteTextColor);
-
-				}
-
-			}
-		}
-	}
-
-	private String findKeybind(MenuButton button, BuildModeEnum currentBuildMode){
-		String result = "";
-		int keybindingIndex = -1;
-		if (button.action == ActionEnum.UNDO) keybindingIndex = 3;
-		if (button.action == ActionEnum.REDO) keybindingIndex = 4;
-		if (button.action == ActionEnum.REPLACE) keybindingIndex = 1;
-		if (button.action == ActionEnum.OPEN_MODIFIER_SETTINGS) keybindingIndex = 0;
-
-		if (keybindingIndex != -1) {
-			KeyMapping keyMap = ClientProxy.keyBindings[keybindingIndex];
-
-			if (!keyMap.getKeyModifier().name().equals("none")) {
-				result = keyMap.getKeyModifier().name() + " ";
-			}
-			result += I18n.get(keyMap.getKey().getName());
-		}
-
-		if (currentBuildMode.options.length > 0) {
-			//Add (ctrl) to first two actions of first option
-			if (button.action == currentBuildMode.options[0].actions[0]
-				|| button.action == currentBuildMode.options[0].actions[1]) {
-				result = I18n.get(ClientProxy.keyBindings[5].getKey().getName());
-				if (result.equals("Left Control")) result = "Ctrl";
-			}
-		}
-		return result;
-	}
-
-	private boolean inTriangle(final double x1, final double y1, final double x2, final double y2,
-							   final double x3, final double y3, final double x, final double y) {
-		final double ab = (x1 - x) * (y2 - y) - (x2 - x) * (y1 - y);
-		final double bc = (x2 - x) * (y3 - y) - (x3 - x) * (y2 - y);
-		final double ca = (x3 - x) * (y1 - y) - (x1 - x) * (y3 - y);
-		return sign(ab) == sign(bc) && sign(bc) == sign(ca);
-	}
-
-	private int sign(final double n) {
-		return n > 0 ? 1 : -1;
-	}
-
-	@Override
-	public boolean isPauseScreen() {
-		return false;
-	}
-
-	@Override
-	public boolean mouseClicked(double mouseX, double mouseY, int mouseButton) {
-		performAction(true);
-
-		return super.mouseClicked(mouseX, mouseY, mouseButton);
-	}
-
-	@Override
-	public void onClose() {
-		super.onClose();
-		//After onClose so it can open another screen
-		if (!performedActionUsingMouse) performAction(false);
-	}
-
-	private void performAction(boolean fromMouseClick) {
-		LocalPlayer player = Minecraft.getInstance().player;
-
-		ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
-
-		if (switchTo != null) {
-			playRadialMenuSound();
-
-			modeSettings.setBuildMode(switchTo);
-			ModeSettingsManager.setModeSettings(player, modeSettings);
-			PacketHandler.INSTANCE.sendToServer(new ModeSettingsMessage(modeSettings));
-
-			EffortlessBuilding.log(player, I18n.get(modeSettings.getBuildMode().getNameKey()), true);
-
-			if (fromMouseClick) performedActionUsingMouse = true;
-		}
-
-		//Perform button action
-		ModeOptions.ActionEnum action = doAction;
-		if (action != null) {
-			playRadialMenuSound();
-
-			ModeOptions.performAction(player, action);
-			PacketHandler.INSTANCE.sendToServer(new ModeActionMessage(action));
-
-			if (fromMouseClick) performedActionUsingMouse = true;
-		}
-	}
-
-	public static void playRadialMenuSound() {
-		final float volume = 0.1f;
-		if (volume >= 0.0001f) {
-			SimpleSoundInstance sound = new SimpleSoundInstance(SoundEvents.UI_BUTTON_CLICK, SoundSource.MASTER, volume,
-					1.0f, RandomSource.create(), Minecraft.getInstance().player.blockPosition());
-			Minecraft.getInstance().getSoundManager().play(sound);
-		}
-	}
-
-	private static class MenuButton {
-
-		public final ActionEnum action;
-		public double x1, x2;
-		public double y1, y2;
-		public boolean highlighted;
-		public String name;
-		public Direction textSide;
-
-		public MenuButton(final String name, final ActionEnum action, final double x, final double y,
-						  final Direction textSide) {
-			this.name = I18n.get(name);
-			this.action = action;
-			x1 = x - 10;
-			x2 = x + 10;
-			y1 = y - 10;
-			y2 = y + 10;
-			this.textSide = textSide;
-		}
-
-	}
-
-	static class MenuRegion {
-
-		public final BuildModeEnum mode;
-		public double x1, x2;
-		public double y1, y2;
-		public boolean highlighted;
-
-		public MenuRegion(final BuildModeEnum mode) {
-			this.mode = mode;
-		}
-
-	}
 
+    public void setVisibility(float visibility) {
+        this.visibility = visibility;
+    }
+
+    public boolean isVisible() {
+        return visibility > 0.001;
+    }
+
+    public void configure(final int scaledWidth, final int scaledHeight ) {
+        mc = Minecraft.getMinecraft();
+        fontRenderer = mc.fontRenderer;
+        width = scaledWidth;
+        height = scaledHeight;
+    }
+
+    private static class MenuButton {
+
+        public double x1, x2;
+        public double y1, y2;
+        public boolean highlighted;
+
+        public final ActionEnum action;
+        public String name;
+        public EnumFacing textSide;
+
+        public MenuButton(final String name, final ActionEnum action, final double x, final double y,
+                final EnumFacing textSide) {
+            this.name = I18n.format(name);
+            this.action = action;
+            x1 = x - 10;
+            x2 = x + 10;
+            y1 = y - 10;
+            y2 = y + 10;
+            this.textSide = textSide;
+        }
+
+    }
+
+    static class MenuRegion {
+
+        public final BuildModeEnum mode;
+        public double x1, x2;
+        public double y1, y2;
+        public boolean highlighted;
+
+        public MenuRegion(final BuildModeEnum mode) {
+            this.mode = mode;
+        }
+
+    }
+
+    @Override
+    public void drawScreen(final int mouseX, final int mouseY, final float partialTicks) {
+        if (!isVisible()) return;
+
+        BuildModeEnum currentBuildMode = ModeSettingsManager.getModeSettings(Minecraft.getMinecraft().player).getBuildMode();
+
+        GlStateManager.pushMatrix();
+        GlStateManager.translate( 0.0F, 0.0F, 200.0F );
+
+        final int startColor = (int) ( visibility * 98 ) << 24;
+        final int endColor = (int) ( visibility * 128 ) << 24;
+
+        drawGradientRect(0, 0, width, height, startColor, endColor);
+
+        GlStateManager.disableTexture2D();
+        GlStateManager.enableBlend();
+        GlStateManager.disableAlpha();
+        GlStateManager.tryBlendFuncSeparate(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA, 1, 0);
+        GlStateManager.shadeModel(GL11.GL_SMOOTH);
+        final Tessellator tessellator = Tessellator.getInstance();
+        final BufferBuilder buffer = tessellator.getBuffer();
+
+        buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_COLOR);
+
+        final double middleX = width / 2.0;
+        final double middleY = height / 2.0;
+
+        final double mouseXCenter = mouseX - middleX;
+        final double mouseYCenter = mouseY - middleY;
+        double mouseRadians = Math.atan2(mouseYCenter, mouseXCenter);
+
+        final double ringInnerEdge = 30;
+        final double ringOuterEdge = 65;
+        final double textDistance = 75;
+        final double buttonDistance = 105;
+        final double quarterCircle = Math.PI / 2.0;
+
+        if ( mouseRadians < -quarterCircle ) {
+            mouseRadians = mouseRadians + Math.PI * 2;
+        }
+
+        final ArrayList<MenuRegion> modes = new ArrayList<MenuRegion>();
+        final ArrayList<MenuButton> buttons = new ArrayList<MenuButton>();
+
+        //Add build modes
+        for (final BuildModeEnum mode : BuildModeEnum.values()) {
+            modes.add(new MenuRegion(mode));
+        }
+
+        //Add actions
+        buttons.add(new MenuButton(ActionEnum.UNDO.name, ActionEnum.UNDO, -buttonDistance - 26, -13, EnumFacing.UP));
+        buttons.add(new MenuButton(ActionEnum.REDO.name, ActionEnum.REDO, -buttonDistance, -13, EnumFacing.UP));
+        buttons.add(new MenuButton(ActionEnum.OPEN_MODIFIER_SETTINGS.name, ActionEnum.OPEN_MODIFIER_SETTINGS, -buttonDistance - 26, 13, EnumFacing.DOWN));
+        buttons.add(new MenuButton(ActionEnum.REPLACE.name, ActionEnum.REPLACE, -buttonDistance, 13, EnumFacing.DOWN));
+
+        //Add buildmode dependent options
+        OptionEnum[] options = currentBuildMode.options;
+        for (int i = 0; i < options.length; i++) {
+            for (int j = 0; j < options[i].actions.length; j++) {
+                ActionEnum action = options[i].actions[j];
+                buttons.add(new MenuButton(action.name, action, buttonDistance + j * 26, -13 + i * 39, EnumFacing.DOWN));
+            }
+        }
+
+        switchTo = null;
+        doAction = null;
+
+        //Draw buildmode backgrounds
+        if (!modes.isEmpty()) {
+            final int totalModes = Math.max( 3, modes.size() );
+            int currentMode = 0;
+            final double fragment = Math.PI * 0.005;
+            final double fragment2 = Math.PI * 0.0025;
+            final double perObject = 2.0 * Math.PI / totalModes;
+
+            for (int i = 0; i < modes.size(); i++) {
+                MenuRegion menuRegion = modes.get(i);
+                final double beginRadians = currentMode * perObject - quarterCircle;
+                final double endRadians = (currentMode + 1) * perObject - quarterCircle;
+
+                menuRegion.x1 = Math.cos(beginRadians);
+                menuRegion.x2 = Math.cos(endRadians);
+                menuRegion.y1 = Math.sin(beginRadians);
+                menuRegion.y2 = Math.sin(endRadians);
+
+                final double x1m1 = Math.cos(beginRadians + fragment) * ringInnerEdge;
+                final double x2m1 = Math.cos(endRadians - fragment) * ringInnerEdge;
+                final double y1m1 = Math.sin(beginRadians + fragment) * ringInnerEdge;
+                final double y2m1 = Math.sin(endRadians - fragment) * ringInnerEdge;
+
+                final double x1m2 = Math.cos(beginRadians + fragment2) * ringOuterEdge;
+                final double x2m2 = Math.cos(endRadians - fragment2) * ringOuterEdge;
+                final double y1m2 = Math.sin(beginRadians + fragment2) * ringOuterEdge;
+                final double y2m2 = Math.sin(endRadians - fragment2) * ringOuterEdge;
+
+                float r = 0.0f;
+                float g = 0.0f;
+                float b = 0.0f;
+                float a = 0.5f;
+
+                //check if current mode
+                int buildMode = currentBuildMode.ordinal();
+                if (buildMode == i) {
+                    r = 0f;
+                    g = 0.5f;
+                    b = 1f;
+                    a = 0.5f;
+                    //menuRegion.highlighted = true; //draw text
+                }
+
+                //check if mouse is over this region
+                final boolean isMouseInQuad = inTriangle(x1m1, y1m1, x2m2, y2m2, x2m1, y2m1, mouseXCenter, mouseYCenter)
+                                              || inTriangle(x1m1, y1m1, x1m2, y1m2, x2m2, y2m2, mouseXCenter, mouseYCenter);
+
+                if (beginRadians <= mouseRadians && mouseRadians <= endRadians && isMouseInQuad) {
+                    r = 0.6f;
+                    g = 0.8f;
+                    b = 1f;
+                    a = 0.6f;
+                    menuRegion.highlighted = true;
+                    switchTo = menuRegion.mode;
+                }
+
+                buffer.pos(middleX + x1m1, middleY + y1m1, zLevel).color(r, g, b, a).endVertex();
+                buffer.pos(middleX + x2m1, middleY + y2m1, zLevel).color(r, g, b, a).endVertex();
+                buffer.pos(middleX + x2m2, middleY + y2m2, zLevel).color(r, g, b, a).endVertex();
+                buffer.pos(middleX + x1m2, middleY + y1m2, zLevel).color(r, g, b, a).endVertex();
+
+                currentMode++;
+            }
+        }
+
+        //Draw action backgrounds
+        for (final MenuButton btn : buttons) {
+            float r = 0.5f;
+            float g = 0.5f;
+            float b = 0.5f;
+            float a = 0.5f;
+
+            //highlight when active option
+            if (btn.action == getBuildSpeed() ||
+                btn.action == getFill() ||
+                btn.action == getCubeFill() ||
+                btn.action == getRaisedEdge() ||
+                btn.action == getLineThickness() ||
+                btn.action == getCircleStart()) {
+                r = 0.0f;
+                g = 0.5f;
+                b = 1f;
+                a = 0.6f;
+            }
+
+            //highlight when mouse over
+            if (btn.x1 <= mouseXCenter && btn.x2 >= mouseXCenter && btn.y1 <= mouseYCenter && btn.y2 >= mouseYCenter) {
+                r = 0.6f;
+                g = 0.8f;
+                b = 1f;
+                a = 0.6f;
+                btn.highlighted = true;
+                doAction = btn.action;
+            }
+
+            buffer.pos(middleX + btn.x1, middleY + btn.y1, zLevel).color(r, g, b, a).endVertex();
+            buffer.pos(middleX + btn.x1, middleY + btn.y2, zLevel).color(r, g, b, a).endVertex();
+            buffer.pos(middleX + btn.x2, middleY + btn.y2, zLevel).color(r, g, b, a).endVertex();
+            buffer.pos(middleX + btn.x2, middleY + btn.y1, zLevel).color(r, g, b, a).endVertex();
+        }
+
+        tessellator.draw();
+
+        GlStateManager.shadeModel(GL11.GL_FLAT);
+
+        GlStateManager.translate(0f, 0f, 5f);
+        GlStateManager.enableTexture2D();
+        GlStateManager.color(1f, 1f, 1f, 1f);
+        GlStateManager.disableBlend();
+        GlStateManager.enableAlpha();
+        GlStateManager.bindTexture(Minecraft.getMinecraft().getTextureMapBlocks().getGlTextureId());
+
+        buffer.begin(GL11.GL_QUADS, DefaultVertexFormats.POSITION_TEX_COLOR);
+
+        //Draw buildmode icons
+        for (final MenuRegion menuRegion : modes) {
+
+            final double x = (menuRegion.x1 + menuRegion.x2) * 0.5 * (ringOuterEdge * 0.6 + 0.4 * ringInnerEdge);
+            final double y = (menuRegion.y1 + menuRegion.y2) * 0.5 * (ringOuterEdge * 0.6 + 0.4 * ringInnerEdge);
+
+            final TextureAtlasSprite sprite = ClientProxy.getBuildModeIcon(menuRegion.mode);
+
+            final double x1 = x - 8;
+            final double x2 = x + 8;
+            final double y1 = y - 8;
+            final double y2 = y + 8;
+
+            final float f = 1f;
+            final float a = 1f;
+
+            final double u1 = 0;
+            final double u2 = 16;
+            final double v1 = 0;
+            final double v2 = 16;
+
+            buffer.pos(middleX + x1, middleY + y1, zLevel).tex(sprite.getInterpolatedU(u1), sprite.getInterpolatedV(v1)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + x1, middleY + y2, zLevel).tex(sprite.getInterpolatedU(u1), sprite.getInterpolatedV(v2)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + x2, middleY + y2, zLevel).tex(sprite.getInterpolatedU(u2), sprite.getInterpolatedV(v2)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + x2, middleY + y1, zLevel).tex(sprite.getInterpolatedU(u2), sprite.getInterpolatedV(v1)).color(f, f, f, a).endVertex();
+        }
+
+        //Draw action icons
+        for (final MenuButton button : buttons) {
+
+            final float f = 1f;
+            final float a = 1f;
+
+            final double u1 = 0;
+            final double u2 = 16;
+            final double v1 = 0;
+            final double v2 = 16;
+
+            final TextureAtlasSprite sprite = ClientProxy.getModeOptionIcon(button.action);
+
+            final double btnmiddleX = (button.x1 + button.x2) / 2 + 0.01;
+            final double btnmiddleY = (button.y1 + button.y2) / 2 + 0.01;
+            final double btnx1 = btnmiddleX - 8;
+            final double btnx2 = btnmiddleX + 8;
+            final double btny1 = btnmiddleY - 8;
+            final double btny2 = btnmiddleY + 8;
+
+            buffer.pos(middleX + btnx1, middleY + btny1, zLevel).tex(sprite.getInterpolatedU(u1), sprite.getInterpolatedV(v1)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + btnx1, middleY + btny2, zLevel).tex(sprite.getInterpolatedU(u1), sprite.getInterpolatedV(v2)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + btnx2, middleY + btny2, zLevel).tex(sprite.getInterpolatedU(u2), sprite.getInterpolatedV(v2)).color(f, f, f, a).endVertex();
+            buffer.pos(middleX + btnx2, middleY + btny1, zLevel).tex(sprite.getInterpolatedU(u2), sprite.getInterpolatedV(v1)).color(f, f, f, a).endVertex();
+        }
+
+        tessellator.draw();
+
+        //Draw strings
+        //fontRenderer.drawStringWithShadow("Actions", (int) (middleX - buttonDistance - 13) - fontRenderer.getStringWidth("Actions") * 0.5f, (int) middleY - 38, 0xffffffff);
+
+        //Draw option strings
+        for (int i = 0; i < currentBuildMode.options.length; i++) {
+            OptionEnum option = options[i];
+            fontRenderer.drawStringWithShadow(I18n.format(option.name), (int) (middleX + buttonDistance - 9), (int) middleY - 37 + i * 39, 0xeeeeeeff);
+        }
+
+        String credits = "Effortless Building";
+        fontRenderer.drawStringWithShadow(credits, width - fontRenderer.getStringWidth(credits) - 4, height - 10, 0x88888888);
+
+        //Draw buildmode text
+        for (final MenuRegion menuRegion : modes) {
+
+            if (menuRegion.highlighted) {
+                final double x = (menuRegion.x1 + menuRegion.x2) * 0.5;
+                final double y = (menuRegion.y1 + menuRegion.y2) * 0.5;
+
+                int fixed_x = (int) (x * textDistance);
+                final int fixed_y = (int) (y * textDistance) - fontRenderer.FONT_HEIGHT / 2;
+                final String text = I18n.format(menuRegion.mode.name);
+
+                if ( x <= -0.2 ) {
+                    fixed_x -= fontRenderer.getStringWidth(text);
+                } else if ( -0.2 <= x && x <= 0.2 ) {
+                    fixed_x -= fontRenderer.getStringWidth(text) / 2;
+                }
+
+                fontRenderer.drawStringWithShadow(text, (int) middleX + fixed_x, (int) middleY + fixed_y, 0xffffffff);
+            }
+        }
+
+        //Draw action text
+        for (final MenuButton button : buttons) {
+            if (button.highlighted) {
+                String text = TextFormatting.AQUA + button.name;
+                int wrap = 120;
+                String keybind = "";
+                String keybindFormatted = "";
+
+                //Add keybind in brackets
+                if (button.action == ActionEnum.UNDO) {
+                    keybind = ClientProxy.keyBindings[4].getDisplayName();
+                }
+                if (button.action == ActionEnum.REDO) {
+                    keybind = ClientProxy.keyBindings[5].getDisplayName();
+                }
+                if (button.action == ActionEnum.REPLACE) {
+                    keybind = ClientProxy.keyBindings[1].getDisplayName();
+                }
+                if (button.action == ActionEnum.OPEN_MODIFIER_SETTINGS) {
+                    keybind = ClientProxy.keyBindings[0].getDisplayName();
+                }
+                if (currentBuildMode.options.length > 0) {
+                    //Add (ctrl) to first two actions of first option
+                    if (button.action == currentBuildMode.options[0].actions[0]
+                        || button.action == currentBuildMode.options[0].actions[1]) {
+                        keybind = ClientProxy.keyBindings[6].getDisplayName();
+                        if (keybind.equals("LCONTROL")) keybind = "Ctrl";
+                    }
+                }
+                if (!keybind.isEmpty()) keybindFormatted = TextFormatting.GRAY + "(" + WordUtils.capitalizeFully(keybind) + ")";
+
+                if (button.textSide == EnumFacing.WEST) {
+
+                    fontRenderer.drawSplitString( text, (int) (middleX + button.x1 - 8 ) - fontRenderer.getStringWidth(text),
+                            (int) (middleY + button.y1 + 6), wrap, 0xffffffff);
+
+                } else if (button.textSide == EnumFacing.EAST) {
+
+                    fontRenderer.drawSplitString(text, (int) (middleX + button.x2 + 8),
+                            (int) (middleY + button.y1 + 6 ), wrap, 0xffffffff);
+
+                } else if (button.textSide == EnumFacing.UP || button.textSide == EnumFacing.NORTH) {
+
+                    fontRenderer.drawSplitString( keybindFormatted, (int) (middleX + (button.x1 + button.x2) * 0.5 - fontRenderer.getStringWidth(keybindFormatted) * 0.5),
+                            (int) (middleY + button.y1 - 26), wrap,0xffffffff);
+
+                    fontRenderer.drawSplitString( text, (int) (middleX + (button.x1 + button.x2) * 0.5 - fontRenderer.getStringWidth(text) * 0.5),
+                            (int) (middleY + button.y1 - 14), wrap,0xffffffff);
+
+                } else if (button.textSide == EnumFacing.DOWN || button.textSide == EnumFacing.SOUTH) {
+
+                    fontRenderer.drawSplitString(text, (int) (middleX + (button.x1 + button.x2) * 0.5 - fontRenderer.getStringWidth(text) * 0.5),
+                            (int) (middleY + button.y1 + 26), wrap, 0xffffffff);
+
+                    fontRenderer.drawSplitString(keybindFormatted, (int) (middleX + (button.x1 + button.x2) * 0.5 - fontRenderer.getStringWidth(keybindFormatted) * 0.5),
+                            (int) (middleY + button.y1 + 38), wrap, 0xffffffff);
+
+                }
+
+            }
+        }
+
+        GlStateManager.popMatrix();
+    }
+
+    private boolean inTriangle(final double x1, final double y1, final double x2, final double y2,
+                               final double x3, final double y3, final double x, final double y ) {
+        final double ab = (x1 - x) * (y2 - y) - (x2 - x) * (y1 - y);
+        final double bc = (x2 - x) * (y3 - y) - (x3 - x) * (y2 - y);
+        final double ca = (x3 - x) * (y1 - y) - (x1 - x) * (y3 - y);
+        return sign(ab) == sign(bc) && sign(bc) == sign(ca);
+    }
+
+    private int sign(final double n) {
+        return n > 0 ? 1 : -1;
+    }
+
+    /**
+     * Called when the mouse is clicked. Args : mouseX, mouseY, clickedButton
+     */
+    @Override
+    protected void mouseClicked(int mouseX, int mouseY, int mouseButton ) {
+        EffortlessBuilding.log("mouse clicked");
+
+//        KeyBinding.updateKeyBindState();
+//        KeyBinding.setKeyBindState(ClientProxy.keyBindings[3].getKeyCode(), true);
+
+//        if (mouseButton == 0) {
+//            this.mc.displayGuiScreen(null);
+//
+//            if (this.mc.currentScreen == null) {
+//                this.mc.setIngameFocus();
+//            }
+//        }
+    }
 }
 

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

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

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

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

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

@@ -1,12 +1,7 @@
 package nl.requios.effortlessbuilding.gui.buildmodifier;
 
-import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.Minecraft;
+import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.client.gui.components.Button;
-import net.minecraft.network.chat.Component;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmodifier.Array;
 import nl.requios.effortlessbuilding.buildmodifier.Mirror;
@@ -14,142 +9,129 @@ import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.buildmodifier.RadialMirror;
 import nl.requios.effortlessbuilding.gui.elements.GuiScrollPane;
 import nl.requios.effortlessbuilding.network.ModifierSettingsMessage;
-import nl.requios.effortlessbuilding.network.PacketHandler;
 import nl.requios.effortlessbuilding.proxy.ClientProxy;
 
-@OnlyIn(Dist.CLIENT)
+import java.io.IOException;
-public class ModifierSettingsGui extends Screen {
 
-	private GuiScrollPane scrollPane;
+public class ModifierSettingsGui extends GuiScreen {
-	private Button buttonClose;
 
-	private MirrorSettingsGui mirrorSettingsGui;
+    private GuiScrollPane scrollPane;
-	private ArraySettingsGui arraySettingsGui;
+    private GuiButton buttonClose;
-	private RadialMirrorSettingsGui radialMirrorSettingsGui;
 
-	public ModifierSettingsGui() {
+    private MirrorSettingsGui mirrorSettingsGui;
-		super(Component.translatable("effortlessbuilding.screen.modifier_settings"));
+    private ArraySettingsGui arraySettingsGui;
-	}
+    private RadialMirrorSettingsGui radialMirrorSettingsGui;
 
-	@Override
+    @Override
-	//Create buttons and labels and add them to buttonList/labelList
+    //Create buttons and labels and add them to buttonList/labelList
-	protected void init() {
+    public void initGui() {
+        int id = 0;
 
-		scrollPane = new GuiScrollPane(this, font, 8, height - 30);
+        scrollPane = new GuiScrollPane(this, fontRenderer, 8, height - 30);
 
-		mirrorSettingsGui = new MirrorSettingsGui(scrollPane);
+        mirrorSettingsGui = new MirrorSettingsGui(scrollPane);
-		scrollPane.AddListEntry(mirrorSettingsGui);
+        scrollPane.listEntries.add(mirrorSettingsGui);
 
-		arraySettingsGui = new ArraySettingsGui(scrollPane);
+        arraySettingsGui = new ArraySettingsGui(scrollPane);
-		scrollPane.AddListEntry(arraySettingsGui);
+        scrollPane.listEntries.add(arraySettingsGui);
 
-		radialMirrorSettingsGui = new RadialMirrorSettingsGui(scrollPane);
+        radialMirrorSettingsGui = new RadialMirrorSettingsGui(scrollPane);
-		scrollPane.AddListEntry(radialMirrorSettingsGui);
+        scrollPane.listEntries.add(radialMirrorSettingsGui);
 
-		scrollPane.init(renderables);
+        id = scrollPane.initGui(id, buttonList);
 
-		//Close button
+        //Close button
-		int y = height - 26;
+        int y = height - 26;
-		buttonClose = new Button(width / 2 - 100, y, 200, 20, Component.literal("Close"), (button) -> {
+        buttonClose = new GuiButton(id++, width / 2 - 100, y, "Close");
-			Minecraft.getInstance().player.closeContainer();
+        buttonList.add(buttonClose);
-		});
-		addRenderableOnly(buttonClose);
-	}
 
-	@Override
+    }
-	//Process general logic, i.e. hide buttons
-	public void tick() {
-		scrollPane.updateScreen();
 
-		handleMouseInput();
+    @Override
-	}
+    //Process general logic, i.e. hide buttons
+    public void updateScreen() {
+        scrollPane.updateScreen();
+    }
 
-	@Override
+    @Override
-	//Set colors using GL11, use the fontObj field to display text
+    //Set colors using GL11, use the fontRendererObj field to display text
-	//Use drawTexturedModalRect() to transfers areas of a texture resource to the screen
+    //Use drawTexturedModalRect() to transfers areas of a texture resource to the screen
-	public void render(PoseStack ms, int mouseX, int mouseY, float partialTicks) {
+    public void drawScreen(int mouseX, int mouseY, float partialTicks) {
-		this.renderBackground(ms);
+        this.drawDefaultBackground();
 
-		scrollPane.render(ms, mouseX, mouseY, partialTicks);
+        scrollPane.drawScreen(mouseX, mouseY, partialTicks);
 
-		buttonClose.render(ms, mouseX, mouseY, partialTicks);
+        buttonClose.drawButton(this.mc, mouseX, mouseY, partialTicks);
 
-		scrollPane.drawTooltip(ms, this, mouseX, mouseY);
+        scrollPane.drawTooltip(this, mouseX, mouseY);
-	}
+    }
 
+    @Override
+    protected void keyTyped(char typedChar, int keyCode) throws IOException {
+        super.keyTyped(typedChar, keyCode);
+        scrollPane.keyTyped(typedChar, keyCode);
+        if (keyCode == ClientProxy.keyBindings[0].getKeyCode()) {
+            mc.player.closeScreen();
+        }
+    }
 
-	@Override
+    @Override
-	public boolean charTyped(char typedChar, int keyCode) {
+    protected void mouseClicked(int mouseX, int mouseY, int mouseButton) throws IOException {
-		super.charTyped(typedChar, keyCode);
+        super.mouseClicked(mouseX, mouseY, mouseButton);
-		scrollPane.charTyped(typedChar, keyCode);
+        scrollPane.mouseClicked(mouseX, mouseY, mouseButton);
-		return false;
+    }
-	}
 
-	@Override
+    @Override
-	public boolean keyPressed(int keyCode, int p_96553_, int p_96554_) {
+    protected void mouseReleased(int mouseX, int mouseY, int state) {
-		if (keyCode == ClientProxy.keyBindings[0].getKey().getValue()) {
+        if (state != 0 || !scrollPane.mouseReleased(mouseX, mouseY, state))
-			minecraft.player.closeContainer();
+        {
-			return true;
+            super.mouseReleased(mouseX, mouseY, state);
-		}
+        }
+    }
 
-		return super.keyPressed(keyCode, p_96553_, p_96554_);
+    @Override
-	}
+    public void handleMouseInput() throws IOException {
+        super.handleMouseInput();
+        scrollPane.handleMouseInput();
 
-	@Override
+        //Scrolling numbers
-	public boolean mouseClicked(double mouseX, double mouseY, int mouseButton) {
-		super.mouseClicked(mouseX, mouseY, mouseButton);
-		renderables.forEach(renderable -> {
-			if (renderable instanceof Button) {
-				Button button = (Button) renderable;
-				button.mouseClicked(mouseX, mouseY, mouseButton);
-			}
-		});
-		return scrollPane.mouseClicked(mouseX, mouseY, mouseButton);
-	}
-
-	@Override
-	public boolean mouseReleased(double mouseX, double mouseY, int state) {
-		if (state != 0 || !scrollPane.mouseReleased(mouseX, mouseY, state)) {
-			return super.mouseReleased(mouseX, mouseY, state);
-		}
-		return false;
-	}
-
-	public void handleMouseInput() {
-		//super.handleMouseInput();
-		scrollPane.handleMouseInput();
-
-		//Scrolling numbers
 //        int mouseX = Mouse.getEventX() * this.width / this.mc.displayWidth;
 //        int mouseY = this.height - Mouse.getEventY() * this.height / this.mc.displayHeight - 1;
 //        numberFieldList.forEach(numberField -> numberField.handleMouseInput(mouseX, mouseY));
-	}
+    }
 
-	@Override
+    @Override
-	public void removed() {
+    protected void actionPerformed(GuiButton button) {
-		scrollPane.onGuiClosed();
+        //check what button and action type (left/right click)
+        if (button == buttonClose) {
+            mc.player.closeScreen();
+        }
+        scrollPane.actionPerformed(button);
+    }
 
-		//save everything
+    @Override
-		Mirror.MirrorSettings m = mirrorSettingsGui.getMirrorSettings();
+    public void onGuiClosed() {
-		Array.ArraySettings a = arraySettingsGui.getArraySettings();
+        scrollPane.onGuiClosed();
-		RadialMirror.RadialMirrorSettings r = radialMirrorSettingsGui.getRadialMirrorSettings();
 
-		ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(minecraft.player);
+        //save everything
-		if (modifierSettings == null) modifierSettings = new ModifierSettingsManager.ModifierSettings();
+        Mirror.MirrorSettings m = mirrorSettingsGui.getMirrorSettings();
-		modifierSettings.setMirrorSettings(m);
+        Array.ArraySettings a = arraySettingsGui.getArraySettings();
-		modifierSettings.setArraySettings(a);
+        RadialMirror.RadialMirrorSettings r = radialMirrorSettingsGui.getRadialMirrorSettings();
-		modifierSettings.setRadialMirrorSettings(r);
 
-		//Sanitize
+        ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(mc.player);
-		String error = ModifierSettingsManager.sanitize(modifierSettings, minecraft.player);
+        if (modifierSettings == null) modifierSettings = new ModifierSettingsManager.ModifierSettings();
-		if (!error.isEmpty()) EffortlessBuilding.log(minecraft.player, error);
+        modifierSettings.setMirrorSettings(m);
+        modifierSettings.setArraySettings(a);
+        modifierSettings.setRadialMirrorSettings(r);
 
-		ModifierSettingsManager.setModifierSettings(minecraft.player, modifierSettings);
+        //Sanitize
+        String error = ModifierSettingsManager.sanitize(modifierSettings, mc.player);
+        if (!error.isEmpty()) EffortlessBuilding.log(mc.player, error);
 
-		//Send to server
+        ModifierSettingsManager.setModifierSettings(mc.player, modifierSettings);
-		PacketHandler.INSTANCE.sendToServer(new ModifierSettingsMessage(modifierSettings));
 
-		Minecraft.getInstance().mouseHandler.grabMouse();
+        //Send to server
-	}
+        EffortlessBuilding.packetHandler.sendToServer(new ModifierSettingsMessage(modifierSettings));
+    }
 
 }

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

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

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

@@ -1,62 +0,0 @@
-package nl.requios.effortlessbuilding.gui.elements;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.components.Button;
-import net.minecraft.network.chat.Component;
-import net.minecraftforge.client.gui.ScreenUtils;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-
-/**
- * This class provides a checkbox style control.
- */
-@ParametersAreNonnullByDefault
-public class GuiCheckBoxFixed extends Button {
-	private final int boxWidth;
-	private boolean isChecked;
-
-	public GuiCheckBoxFixed(int xPos, int yPos, String displayString, boolean isChecked) {
-		super(xPos, yPos, Minecraft.getInstance().font.width(displayString) + 2 + 11, 11, Component.literal(displayString), b -> {
-		});
-		this.isChecked = isChecked;
-		this.boxWidth = 11;
-		this.height = 11;
-		this.width = this.boxWidth + 2 + Minecraft.getInstance().font.width(displayString);
-	}
-
-	@Override
-	public void renderButton(PoseStack ms, int mouseX, int mouseY, float partial) {
-		if (this.visible) {
-			Minecraft mc = Minecraft.getInstance();
-			this.isHovered = mouseX >= this.x && mouseY >= this.y && mouseX < this.x + this.boxWidth && mouseY < this.y + this.height;
-			ScreenUtils.blitWithBorder(ms, WIDGETS_LOCATION, this.x, this.y, 0, 46, this.boxWidth, this.height, 200, 20, 2, 3, 2, 2, this.getBlitOffset());
-			this.renderBg(ms, mc, mouseX, mouseY);
-			int color = 14737632;
-
-			if (packedFGColor != 0) {
-				color = packedFGColor;
-			} else if (!this.active) {
-				color = 10526880;
-			}
-
-			if (this.isChecked)
-				drawCenteredString(ms, mc.font, "x", this.x + this.boxWidth / 2 + 1, this.y + 1, 14737632);
-
-			drawString(ms, mc.font, getMessage(), this.x + this.boxWidth + 2, this.y + 2, color);
-		}
-	}
-
-	@Override
-	public void onPress() {
-		this.isChecked = !this.isChecked;
-	}
-
-	public boolean isChecked() {
-		return this.isChecked;
-	}
-
-	public void setIsChecked(boolean isChecked) {
-		this.isChecked = isChecked;
-	}
-}

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

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

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

@@ -1,79 +1,75 @@
 package nl.requios.effortlessbuilding.gui.elements;
 
-import com.mojang.blaze3d.systems.RenderSystem;
+import net.minecraft.client.Minecraft;
-import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.gui.components.Button;
+import net.minecraft.util.ResourceLocation;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.network.chat.Component;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
 
-import javax.annotation.ParametersAreNonnullByDefault;
 import java.util.ArrayList;
-import java.util.Collections;
+import java.util.Arrays;
 import java.util.List;
 
-@OnlyIn(Dist.CLIENT)
+public class GuiIconButton extends GuiButton {
-@ParametersAreNonnullByDefault
-public class GuiIconButton extends Button {
 
-	private final ResourceLocation resourceLocation;
+    private final ResourceLocation resourceLocation;
-	private final int iconX, iconY, iconWidth, iconHeight, iconAltX, iconAltY;
+    private final int iconX, iconY, iconWidth, iconHeight, iconAltX, iconAltY;
-	List<Component> tooltip = new ArrayList<>();
+    List<String> tooltip = new ArrayList<>();
-	private boolean useAltIcon = false;
+    private boolean useAltIcon = false;
 
-	public GuiIconButton(int x, int y, int iconX, int iconY, ResourceLocation resourceLocation, Button.OnPress onPress) {
+    public GuiIconButton(int buttonId, int x, int y, int iconX, int iconY, ResourceLocation resourceLocation) {
-		this(x, y, 20, 20, iconX, iconY, 20, 20, 20, 0, resourceLocation, onPress);
+        this(buttonId, x, y, 20, 20, iconX, iconY, 20, 20, 20, 0, resourceLocation);
-	}
+    }
 
-	public GuiIconButton(int x, int y, int width, int height, int iconX, int iconY, int iconWidth, int iconHeight, int iconAltX, int iconAltY, ResourceLocation resourceLocation, Button.OnPress onPress) {
+    public GuiIconButton(int buttonId, int x, int y, int width, int height, int iconX, int iconY, int iconWidth, int iconHeight, int iconAltX, int iconAltY, ResourceLocation resourceLocation) {
-		super(x, y, width, height, Component.empty(), onPress);
+        super(buttonId, x, y, width, height, "");
-		this.iconX = iconX;
+        this.iconX = iconX;
-		this.iconY = iconY;
+        this.iconY = iconY;
-		this.iconWidth = iconWidth;
+        this.iconWidth = iconWidth;
-		this.iconHeight = iconHeight;
+        this.iconHeight = iconHeight;
-		this.iconAltX = iconAltX;
+        this.iconAltX = iconAltX;
-		this.iconAltY = iconAltY;
+        this.iconAltY = iconAltY;
-		this.resourceLocation = resourceLocation;
+        this.resourceLocation = resourceLocation;
-	}
+    }
 
-	public void setTooltip(Component tooltip) {
+    public void setTooltip(String tooltip) {
-		setTooltip(Collections.singletonList(tooltip));
+        setTooltip(Arrays.asList(tooltip));
-	}
+    }
 
-	public void setTooltip(List<Component> tooltip) {
+    public void setTooltip(List<String> tooltip) {
-		this.tooltip = tooltip;
+        this.tooltip = tooltip;
-	}
+    }
 
-	public void setUseAlternateIcon(boolean useAlternateIcon) {
+    public void setUseAlternateIcon(boolean useAlternateIcon) {
-		this.useAltIcon = useAlternateIcon;
+        this.useAltIcon = useAlternateIcon;
-	}
+    }
 
-	@Override
+    @Override
-	public void render(PoseStack ms, int mouseX, int mouseY, float partialTicks) {
+    public void drawButton(Minecraft mc, int mouseX, int mouseY, float partialTicks) {
-		super.render(ms, mouseX, mouseY, partialTicks);
+        super.drawButton(mc, mouseX, mouseY, partialTicks);
-		if (this.visible) {
+        if (this.visible)
-			this.isHovered = mouseX >= this.x && mouseY >= this.y && mouseX < this.x + this.width && mouseY < this.y + this.height;
+        {
-			RenderSystem.setShaderTexture(0, this.resourceLocation);
+            this.hovered = mouseX >= this.x && mouseY >= this.y && mouseX < this.x + this.width && mouseY < this.y + this.height;
-			int currentIconX = this.iconX;
+            mc.getTextureManager().bindTexture(this.resourceLocation);
-			int currentIconY = this.iconY;
+            int currentIconX = this.iconX;
+            int currentIconY = this.iconY;
 
-			if (useAltIcon) {
+            if (useAltIcon)
-				currentIconX += iconAltX;
+            {
-				currentIconY += iconAltY;
+                currentIconX += iconAltX;
-			}
+                currentIconY += iconAltY;
+            }
 
-			//Draws a textured rectangle at the current z-value. Used to be drawTexturedModalRect in Gui.
+            this.drawTexturedModalRect(this.x, this.y, currentIconX, currentIconY, this.iconWidth, this.iconHeight);
-			this.blit(ms, this.x, this.y, currentIconX, currentIconY, this.iconWidth, this.iconHeight);
+        }
-		}
+    }
-	}
 
-	public void drawTooltip(PoseStack ms, Screen screen, int mouseX, int mouseY) {
+    public void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY) {
-		boolean flag = mouseX >= x && mouseX < x + width && mouseY >= y && mouseY < y + height;
+        boolean flag = mouseX >= x && mouseX < x + width && mouseY >= y && mouseY < y + height;
 
-		if (flag) {
+        if (flag) {
-			screen.renderComponentTooltip(ms, tooltip, mouseX - 10, mouseY + 25);
+            List<String> textLines = new ArrayList<>();
-		}
+            textLines.addAll(tooltip);
-	}
+            guiScreen.drawHoveringText(textLines, mouseX - 10, mouseY + 25);
+        }
+    }
 }

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

@@ -1,160 +1,138 @@
 package nl.requios.effortlessbuilding.gui.elements;
 
-import com.mojang.blaze3d.vertex.PoseStack;
+import net.minecraft.client.Minecraft;
-import net.minecraft.MethodsReturnNonnullByDefault;
+import net.minecraft.client.gui.*;
-import net.minecraft.client.gui.GuiComponent;
+import net.minecraft.util.text.TextFormatting;
-import net.minecraft.client.gui.Font;
-import net.minecraft.client.gui.components.Widget;
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.client.gui.components.EditBox;
-import net.minecraft.client.gui.components.Button;
-import net.minecraft.network.chat.Component;
-import net.minecraft.ChatFormatting;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
 
-import javax.annotation.ParametersAreNonnullByDefault;
+import java.io.IOException;
-import java.awt.*;
 import java.text.DecimalFormat;
-import java.text.ParseException;
 import java.util.ArrayList;
-import java.util.Collections;
+import java.util.Arrays;
 import java.util.List;
 
-@OnlyIn(Dist.CLIENT)
+public class GuiNumberField extends Gui {
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-public class GuiNumberField extends GuiComponent {
 
-	public int x, y, width, height;
+    public int x, y, width, height;
-	public int buttonWidth = 10;
+    public int buttonWidth = 10;
 
-	protected EditBox textField;
+    protected GuiTextField textField;
-	protected Button minusButton, plusButton;
+    protected GuiButton minusButton, plusButton;
 
-	List<Component> tooltip = new ArrayList<>();
+    List<String> tooltip = new ArrayList<>();
 
-	public GuiNumberField(Font font, List<Widget> renderables, int x, int y, int width, int height) {
+    public GuiNumberField(int id1, int id2, int id3, FontRenderer fontRenderer,
-		this.x = x;
+                          List<GuiButton> buttonList, int x, int y, int width, int height) {
-		this.y = y;
+        this.x = x;
-		this.width = width;
+        this.y = y;
-		this.height = height;
+        this.width = width;
+        this.height = height;
 
-		textField = new EditBox(font, x + buttonWidth + 1, y + 1, width - 2 * buttonWidth - 2, height - 2, Component.empty());
+        textField = new GuiTextField(id1, fontRenderer, x + buttonWidth + 1, y + 1, width - 2 * buttonWidth - 2, height - 2);
-		minusButton = new Button(x, y - 1, buttonWidth, height + 2, Component.literal("-"), button -> {
+        minusButton = new GuiButton(id2, x, y - 1, buttonWidth, height + 2, "-");
-			float valueChanged = 1f;
+        plusButton  = new GuiButton(id3, x + width - buttonWidth, y - 1, buttonWidth, height + 2, "+");
-			if (Screen.hasControlDown()) valueChanged = 5f;
-			if (Screen.hasShiftDown()) valueChanged = 10f;
 
-			setNumber(getNumber() - valueChanged);
+        buttonList.add(minusButton);
-		});
+        buttonList.add(plusButton);
-		plusButton = new Button(x + width - buttonWidth, y - 1, buttonWidth, height + 2, Component.literal("+"), button -> {
+    }
-			float valueChanged = 1f;
-			if (Screen.hasControlDown()) valueChanged = 5f;
-			if (Screen.hasShiftDown()) valueChanged = 10f;
 
-			setNumber(getNumber() + valueChanged);
+    public void setNumber(double number) {
-		});
+        DecimalFormat format = new DecimalFormat("0.#");
+        textField.setText(format.format(number));
+    }
 
-		renderables.add(minusButton);
+    public double getNumber() {
-		renderables.add(plusButton);
+        if (textField.getText().isEmpty()) return 0;
-	}
+        return Double.parseDouble(textField.getText());
+    }
 
-	public double getNumber() {
+    public void setTooltip(String tooltip) {
-		if (textField.getValue().isEmpty()) return 0;
+        setTooltip(Arrays.asList(tooltip));
-		try {
+    }
-			return DecimalFormat.getInstance().parse(textField.getValue()).doubleValue();
-		} catch (ParseException e) {
-			return 0;
-		}
-	}
 
-	public void setNumber(double number) {
+    public void setTooltip(List<String> tooltip) {
-		textField.setValue(DecimalFormat.getInstance().format(number));
+        this.tooltip = tooltip;
-	}
+    }
 
-	public void setTooltip(Component tooltip) {
+    public boolean mouseClicked(int mouseX, int mouseY, int mouseButton) {
-		setTooltip(Collections.singletonList(tooltip));
+        boolean result = textField.mouseClicked(mouseX, mouseY, mouseButton);
-	}
 
-	public void setTooltip(List<Component> tooltip) {
+        //Check if clicked inside textfield
-		this.tooltip = tooltip;
+        boolean flag = mouseX >= x + buttonWidth && mouseX < x + width - buttonWidth && mouseY >= y && mouseY < y + height;
-	}
 
-	public boolean mouseClicked(double mouseX, double mouseY, int mouseButton) {
+        //Rightclicked inside textfield
-		boolean result = textField.mouseClicked(mouseX, mouseY, mouseButton);
+        if (flag && mouseButton == 1) {
+            textField.setText("");
+            textField.setFocused(true);
+            result = true;
+        }
 
-		//Check if clicked inside textfield
+        return result;
-		boolean flag = mouseX >= x + buttonWidth && mouseX < x + width - buttonWidth && mouseY >= y && mouseY < y + height;
+    }
 
-		//Rightclicked inside textfield
+    public void drawNumberField(Minecraft mc, int mouseX, int mouseY, float partialTicks) {
-		if (flag && mouseButton == 1) {
+        textField.y = y + 1;
-			textField.setValue("");
+        minusButton.y = y - 1;
-			textField.setFocus(true);
+        plusButton.y = y - 1;
-			result = true;
-		}
 
-		return result;
+        textField.drawTextBox();
-	}
+        minusButton.drawButton(mc, mouseX, mouseY, partialTicks);
+        plusButton.drawButton(mc, mouseX, mouseY, partialTicks);
+    }
 
-	public void drawNumberField(PoseStack ms, int mouseX, int mouseY, float partialTicks) {
+    public void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY) {
-		textField.y = y + 1;
+        boolean insideTextField = mouseX >= x + buttonWidth && mouseX < x + width - buttonWidth && mouseY >= y && mouseY < y + height;
-		minusButton.y = y - 1;
+        boolean insideMinusButton = mouseX >= x && mouseX < x + buttonWidth && mouseY >= y && mouseY < y + height;
-		plusButton.y = y - 1;
+        boolean insidePlusButton = mouseX >= x + width - buttonWidth && mouseX < x + width && mouseY >= y && mouseY < y + height;
 
-		textField.render(ms, mouseX, mouseY, partialTicks);
+        List<String> textLines = new ArrayList<>();
-		minusButton.render(ms, mouseX, mouseY, partialTicks);
-		plusButton.render(ms, mouseX, mouseY, partialTicks);
-	}
 
-	public void drawTooltip(PoseStack ms, Screen screen, int mouseX, int mouseY) {
+        if (insideTextField) {
-		boolean insideTextField = mouseX >= x + buttonWidth && mouseX < x + width - buttonWidth && mouseY >= y && mouseY < y + height;
+            if (!tooltip.isEmpty())
-		boolean insideMinusButton = mouseX >= x && mouseX < x + buttonWidth && mouseY >= y && mouseY < y + height;
+                textLines.addAll(tooltip);
-		boolean insidePlusButton = mouseX >= x + width - buttonWidth && mouseX < x + width && mouseY >= y && mouseY < y + height;
-
-		// List<String> textLines = new ArrayList<>();
-
-		List<Component> textLines = new ArrayList<>();
-
-
-		if (insideTextField) {
-			textLines.addAll(tooltip);
 //            textLines.add(TextFormatting.GRAY + "Tip: try scrolling.");
-		}
+        }
 
-		if (insideMinusButton) {
+        if (insideMinusButton) {
-			textLines.add(Component.literal("Hold ").append(Component.literal("shift ").withStyle(ChatFormatting.AQUA)).append("for ")
+            textLines.add("Hold " + TextFormatting.AQUA + "shift " + TextFormatting.RESET + "for " + TextFormatting.RED + "10");
-				.append(Component.literal("10").withStyle(ChatFormatting.RED)));
+            textLines.add("Hold " + TextFormatting.AQUA + "ctrl " + TextFormatting.RESET + "for " + TextFormatting.RED + "5");
-			textLines.add(Component.literal("Hold ").append(Component.literal("ctrl ").withStyle(ChatFormatting.AQUA)).append("for ")
+        }
-				.append(Component.literal("5").withStyle(ChatFormatting.RED)));
-		}
 
-		if (insidePlusButton) {
+        if (insidePlusButton) {
-			textLines.add(Component.literal("Hold ").append(Component.literal("shift ").withStyle(ChatFormatting.DARK_GREEN)).append("for ")
+            textLines.add("Hold " + TextFormatting.AQUA + "shift " + TextFormatting.RESET + "for " + TextFormatting.DARK_GREEN + "10");
-				.append(Component.literal("10").withStyle(ChatFormatting.RED)));
+            textLines.add("Hold " + TextFormatting.AQUA + "ctrl " + TextFormatting.RESET + "for " + TextFormatting.DARK_GREEN + "5");
-			textLines.add(Component.literal("Hold ").append(Component.literal("ctrl ").withStyle(ChatFormatting.DARK_GREEN)).append("for ")
+        }
-				.append(Component.literal("5").withStyle(ChatFormatting.RED)));
-		}
 
-		screen.renderComponentTooltip(ms, textLines, mouseX - 10, mouseY + 25);
+        guiScreen.drawHoveringText(textLines, mouseX - 10, mouseY + 25);
 
-	}
+    }
 
-	public void update() {
+    public void actionPerformed(GuiButton button) {
-		textField.tick();
+        float valueChanged = 1f;
-	}
+        if (GuiScreen.isCtrlKeyDown()) valueChanged = 5f;
+        if (GuiScreen.isShiftKeyDown()) valueChanged = 10f;
 
-	public boolean charTyped(char typedChar, int keyCode) {
+        if (button == minusButton) {
-		if (!textField.isFocused()) return false;
+            setNumber(getNumber() - valueChanged);
+        }
+        if (button == plusButton) {
+            setNumber(getNumber() + valueChanged);
+        }
+    }
+
+    public void update() {
+        textField.updateCursorCounter();
+    }
+
+    public void keyTyped(char typedChar, int keyCode) throws IOException {
+        if (!textField.isFocused()) return;
 //        if (Character.isDigit(typedChar) || typedChar == '.' || typedChar == '-' || keyCode == Keyboard.KEY_BACK
 //            || keyCode == Keyboard.KEY_DELETE || keyCode == Keyboard.KEY_LEFT || keyCode == Keyboard.KEY_RIGHT
 //            || keyCode == Keyboard.KEY_UP || keyCode == Keyboard.KEY_DOWN) {
-		return textField.charTyped(typedChar, keyCode);
+            textField.textboxKeyTyped(typedChar, keyCode);
 //        }
-	}
+    }
 
-	//Scroll inside textfield to change number
+    //Scroll inside textfield to change number
-	//Disabled because entire screen can be scrolled
 //    public void handleMouseInput(int mouseX, int mouseY) {
 //        boolean insideTextField = mouseX >= x + buttonWidth && mouseX < x + width - buttonWidth && mouseY >= y && mouseY < y + height;
 //

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

@@ -1,223 +1,221 @@
 package nl.requios.effortlessbuilding.gui.elements;
 
-import com.mojang.blaze3d.vertex.*;
-import com.mojang.blaze3d.platform.GlStateManager;
-import com.mojang.blaze3d.systems.RenderSystem;
-import net.minecraft.MethodsReturnNonnullByDefault;
 import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.Font;
+import net.minecraft.client.gui.FontRenderer;
-import net.minecraft.client.gui.components.Widget;
+import net.minecraft.client.gui.GuiButton;
-import net.minecraft.client.gui.components.events.GuiEventListener;
+import net.minecraft.client.gui.GuiListExtended;
-import net.minecraft.client.gui.screens.Screen;
+import net.minecraft.client.gui.GuiScreen;
-import net.minecraft.client.gui.components.AbstractWidget;
+import net.minecraft.client.renderer.BufferBuilder;
-import net.minecraft.util.Mth;
+import net.minecraft.client.renderer.GlStateManager;
-import net.minecraftforge.api.distmarker.Dist;
+import net.minecraft.client.renderer.Tessellator;
-import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraft.client.renderer.vertex.DefaultVertexFormats;
+import net.minecraft.util.math.MathHelper;
 import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.fml.relauncher.Side;
+import net.minecraftforge.fml.relauncher.SideOnly;
+import org.lwjgl.input.Mouse;
 
-import javax.annotation.ParametersAreNonnullByDefault;
+import java.io.IOException;
 import java.util.ArrayList;
 import java.util.List;
 
-@OnlyIn(Dist.CLIENT)
+@SideOnly(Side.CLIENT)
-@MethodsReturnNonnullByDefault
+public class GuiScrollPane extends GuiListExtended {
-@ParametersAreNonnullByDefault
-public class GuiScrollPane extends SlotGui {
 
-	public Screen parent;
+    public GuiScreen parent;
-	public Font font;
+    public FontRenderer fontRenderer;
-	private final List<IScrollEntry> listEntries;
+    public List<IScrollEntry> listEntries;
-	private float scrollMultiplier = 1f;
 
-	private int mouseX;
+    public GuiScrollPane(GuiScreen parent, FontRenderer fontRenderer, int top, int bottom) {
-	private int mouseY;
+        super(parent.mc, parent.width, parent.height, top, bottom, 100);
+        this.parent = parent;
+        this.fontRenderer = fontRenderer;
+        this.setShowSelectionBox(false);
+        listEntries = new ArrayList<>();
+    }
 
-	public GuiScrollPane(Screen parent, Font font, int top, int bottom) {
+    @Override
-		super(Minecraft.getInstance(), parent.width, parent.height, top, bottom, 100);
+    public IGuiListEntry getListEntry(int index) {
-		this.parent = parent;
+        return listEntries.get(index);
-		this.font = font;
+    }
-		this.renderSelection = false;
-		listEntries = new ArrayList<>();
-		MinecraftForge.EVENT_BUS.register(this);
-	}
 
-	public IScrollEntry getListEntry(int index) {
+    @Override
-		return listEntries.get(index);
+    protected int getSize() {
-	}
+        return listEntries.size();
+    }
 
-	public void AddListEntry(IScrollEntry listEntry) {
+    @Override
-		listEntries.add(listEntry);
+    protected int getScrollBarX() {
-	}
+        //return width / 2 + 140 + 10;
+        return width - 15;
+    }
 
-	@Override
+    @Override
-	protected int getItemCount() {
+    public int getListWidth() {
-		return listEntries.size();
+        return 280;
-	}
+    }
 
-	@Override
+    //Removed background
-	protected boolean isSelectedItem(int slotIndex) {
+    @Override
-		return false;
+    public void drawScreen(int mouseXIn, int mouseYIn, float partialTicks)
-	}
+    {
+        if (this.visible)
+        {
+            this.mouseX = mouseXIn;
+            this.mouseY = mouseYIn;
+            int scrollBarLeft = this.getScrollBarX();
+            int scrollBarRight = scrollBarLeft + 6;
+            this.bindAmountScrolled();
+            GlStateManager.disableLighting();
+            GlStateManager.disableFog();
 
-	@Override
+            Tessellator tessellator = Tessellator.getInstance();
-	protected int getScrollbarPosition() {
+            BufferBuilder bufferbuilder = tessellator.getBuffer();
-		//return width / 2 + 140 + 10;
+            int insideLeft = this.left + this.width / 2 - this.getListWidth() / 2 + 2;
-		return width - 15;
+            int insideTop = this.top + 4 - (int)this.amountScrolled;
-	}
 
-	@Override
+            if (this.hasListHeader) {
-	public int getRowWidth() {
+                this.drawListHeader(insideLeft, insideTop, tessellator);
-		return 280;
+            }
-	}
 
-	//Removed background
+            //All entries
-	@Override
+            this.drawSelectionBox(insideLeft, insideTop, mouseXIn, mouseYIn, partialTicks);
-	public void render(PoseStack ms, int mouseXIn, int mouseYIn, float partialTicks) {
+            GlStateManager.disableDepth();
-		if (this.visible) {
-			this.mouseX = mouseXIn;
-			this.mouseY = mouseYIn;
-			this.renderBackground();
-			int scrollbarLeft = this.getScrollbarPosition();
-			int scrollbarRight = scrollbarLeft + 6;
-			this.capYPosition();
 
-			Tesselator tessellator = Tesselator.getInstance();
+            //Dirt overlays on top and bottom
-			BufferBuilder bufferbuilder = tessellator.getBuilder();
+//            this.overlayBackground(0, this.top, 255, 255);
+//            this.overlayBackground(this.bottom, this.height, 255, 255);
 
-			int insideLeft = this.x0 + this.width / 2 - this.getRowWidth() / 2 + 2;
+            GlStateManager.enableBlend();
-			int insideTop = this.y0 + 4 - (int) this.yo;
+            GlStateManager.tryBlendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ZERO, GlStateManager.DestFactor.ONE);
-			if (this.renderHeader) {
+            GlStateManager.disableAlpha();
-				this.renderHeader(insideLeft, insideTop, tessellator);
+            GlStateManager.shadeModel(7425);
-			}
+            GlStateManager.disableTexture2D();
 
-			//All entries
+//            //top fade
-			this.renderList(ms, insideLeft, insideTop, mouseXIn, mouseYIn, partialTicks);
-			RenderSystem.disableDepthTest();
-
-			//Dirt overlays on top and bottom
-//            this.renderHoleBackground(0, this.y0, 255, 255);
-//            this.renderHoleBackground(this.y1, this.height, 255, 255);
-
-			RenderSystem.enableBlend();
-			RenderSystem.blendFuncSeparate(GlStateManager.SourceFactor.SRC_ALPHA, GlStateManager.DestFactor.ONE_MINUS_SRC_ALPHA, GlStateManager.SourceFactor.ZERO, GlStateManager.DestFactor.ONE);
-			RenderSystem.disableTexture();
-
-			//top
 //            bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
-//            bufferbuilder.pos((double)this.x0, (double)(this.y0 + 4), 0.0D).tex(0.0D, 1.0D).color(0, 0, 0, 0).endVertex();
+//            bufferbuilder.pos((double)this.left, (double)(this.top + 5), 0.0D).tex(0.0D, 1.0D).color(100, 100, 100, 0).endVertex();
-//            bufferbuilder.pos((double)this.x1, (double)(this.y0 + 4), 0.0D).tex(1.0D, 1.0D).color(0, 0, 0, 0).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)(this.top + 5), 0.0D).tex(1.0D, 1.0D).color(100, 100, 100, 0).endVertex();
-//            bufferbuilder.pos((double)this.x1, (double)this.y0, 0.0D).tex(1.0D, 0.0D).color(0, 0, 0, 255).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)this.top, 0.0D).tex(1.0D, 0.0D).color(100, 100, 100, 100).endVertex();
-//            bufferbuilder.pos((double)this.x0, (double)this.y0, 0.0D).tex(0.0D, 0.0D).color(0, 0, 0, 255).endVertex();
+//            bufferbuilder.pos((double)this.left, (double)this.top, 0.0D).tex(0.0D, 0.0D).color(100, 100, 100, 100).endVertex();
 //            tessellator.draw();
 
-			//bottom
+//            //top line
 //            bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
-//            bufferbuilder.pos((double)this.x0, (double)this.y1, 0.0D).tex(0.0D, 1.0D).color(0, 0, 0, 255).endVertex();
+//            bufferbuilder.pos((double)this.left, (double)this.top, 0.0D).tex(0.0D, 1.0D).color(20, 20, 20, 255).endVertex();
-//            bufferbuilder.pos((double)this.x1, (double)this.y1, 0.0D).tex(1.0D, 1.0D).color(0, 0, 0, 255).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)this.top, 0.0D).tex(1.0D, 1.0D).color(20, 20, 20, 255).endVertex();
-//            bufferbuilder.pos((double)this.x1, (double)(this.y1 - 4), 0.0D).tex(1.0D, 0.0D).color(0, 0, 0, 0).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)(this.top - 1), 0.0D).tex(1.0D, 0.0D).color(20, 20, 20, 255).endVertex();
-//            bufferbuilder.pos((double)this.x0, (double)(this.y1 - 4), 0.0D).tex(0.0D, 0.0D).color(0, 0, 0, 0).endVertex();
+//            bufferbuilder.pos((double)this.left, (double)(this.top - 1), 0.0D).tex(0.0D, 0.0D).color(20, 20, 20, 255).endVertex();
 //            tessellator.draw();
 
-			//Draw scrollbar
+//            //bottom fade
-			int maxScroll = this.getMaxScroll();
+//            bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
-			if (maxScroll > 0) {
+//            bufferbuilder.pos((double)this.left, (double)this.bottom, 0.0D).tex(0.0D, 1.0D).color(10, 10, 10, 100).endVertex();
-				int k1 = (int) ((float) ((this.y1 - this.y0) * (this.y1 - this.y0)) / (float) this.getMaxPosition());
+//            bufferbuilder.pos((double)this.right, (double)this.bottom, 0.0D).tex(1.0D, 1.0D).color(10, 10, 10, 100).endVertex();
-				k1 = Mth.clamp(k1, 32, this.y1 - this.y0 - 8);
+//            bufferbuilder.pos((double)this.right, (double)(this.bottom - 5), 0.0D).tex(1.0D, 0.0D).color(10, 10, 10, 0).endVertex();
-				int l1 = (int) this.yo * (this.y1 - this.y0 - k1) / maxScroll + this.y0;
+//            bufferbuilder.pos((double)this.left, (double)(this.bottom - 5), 0.0D).tex(0.0D, 0.0D).color(10, 10, 10, 0).endVertex();
-				if (l1 < this.y0) {
+//            tessellator.draw();
-					l1 = this.y0;
-				}
 
-				bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
+//            //bottom line
-				bufferbuilder.vertex(scrollbarLeft, this.y1, 0.0F).uv(0.0F, 1.0F).color(0, 0, 0, 255).endVertex();
+//            bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
-				bufferbuilder.vertex(scrollbarRight, this.y1, 0.0F).uv(1.0F, 1.0F).color(0, 0, 0, 255).endVertex();
+//            bufferbuilder.pos((double)this.left, (double)(this.bottom + 1), 0.0D).tex(0.0D, 1.0D).color(20, 20, 20, 255).endVertex();
-				bufferbuilder.vertex(scrollbarRight, this.y0, 0.0F).uv(1.0F, 0.0F).color(0, 0, 0, 255).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)(this.bottom + 1), 0.0D).tex(1.0D, 1.0D).color(20, 20, 20, 255).endVertex();
-				bufferbuilder.vertex(scrollbarLeft, this.y0, 0.0F).uv(0.0F, 0.0F).color(0, 0, 0, 255).endVertex();
+//            bufferbuilder.pos((double)this.right, (double)this.bottom, 0.0D).tex(1.0D, 0.0D).color(20, 20, 20, 255).endVertex();
-				tessellator.end();
+//            bufferbuilder.pos((double)this.left, (double)this.bottom, 0.0D).tex(0.0D, 0.0D).color(20, 20, 20, 255).endVertex();
-				bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
+//            tessellator.draw();
-				bufferbuilder.vertex(scrollbarLeft, l1 + k1, 0.0F).uv(0.0F, 1.0F).color(128, 128, 128, 255).endVertex();
-				bufferbuilder.vertex(scrollbarRight, l1 + k1, 0.0F).uv(1.0F, 1.0F).color(128, 128, 128, 255).endVertex();
-				bufferbuilder.vertex(scrollbarRight, l1, 0.0F).uv(1.0F, 0.0F).color(128, 128, 128, 255).endVertex();
-				bufferbuilder.vertex(scrollbarLeft, l1, 0.0F).uv(0.0F, 0.0F).color(128, 128, 128, 255).endVertex();
-				tessellator.end();
-				bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION_TEX_COLOR);
-				bufferbuilder.vertex(scrollbarLeft, l1 + k1 - 1, 0.0F).uv(0.0F, 1.0F).color(192, 192, 192, 255).endVertex();
-				bufferbuilder.vertex(scrollbarRight - 1, l1 + k1 - 1, 0.0F).uv(1.0F, 1.0F).color(192, 192, 192, 255).endVertex();
-				bufferbuilder.vertex(scrollbarRight - 1, l1, 0.0F).uv(1.0F, 0.0F).color(192, 192, 192, 255).endVertex();
-				bufferbuilder.vertex(scrollbarLeft, l1, 0.0F).uv(0.0F, 0.0F).color(192, 192, 192, 255).endVertex();
-				tessellator.end();
-			}
 
-			//this.renderDecorations(mouseXIn, mouseYIn);
+            //Draw scrollbar
-			RenderSystem.enableTexture();
+            int maxScroll = this.getMaxScroll();
-			RenderSystem.disableBlend();
+            if (maxScroll > 0)
-		}
+            {
-	}
+                int k1 = (this.bottom - this.top) * (this.bottom - this.top) / this.getContentHeight();
+                k1 = MathHelper.clamp(k1, 32, this.bottom - this.top - 8);
+                int l1 = (int)this.amountScrolled * (this.bottom - this.top - k1) / maxScroll + this.top;
 
-	//SLOTHEIGHT MODIFICATIONS
+                if (l1 < this.top)
-	//SlotHeight is still relied on for determining how much to scroll
+                {
-	@Override
+                    l1 = this.top;
-	protected int getMaxPosition() {
+                }
-		//Add every entry height
-		int height = this.headerHeight;
-		for (IScrollEntry entry : listEntries) {
-			height += entry.getHeight();
-		}
-		return height;
-	}
 
-	@Override
+                bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
-	protected void renderBackground() {
+                bufferbuilder.pos((double)scrollBarLeft, (double)this.bottom, 0.0D).tex(0.0D, 1.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarRight, (double)this.bottom, 0.0D).tex(1.0D, 1.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarRight, (double)this.top, 0.0D).tex(1.0D, 0.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarLeft, (double)this.top, 0.0D).tex(0.0D, 0.0D).color(0, 0, 0, 255).endVertex();
+                tessellator.draw();
 
-	}
+                bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
+                bufferbuilder.pos((double)scrollBarLeft, (double)(l1 + k1), 0.0D).tex(0.0D, 1.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarRight, (double)(l1 + k1), 0.0D).tex(1.0D, 1.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarRight, (double)l1, 0.0D).tex(1.0D, 0.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)scrollBarLeft, (double)l1, 0.0D).tex(0.0D, 0.0D).color(128, 128, 128, 255).endVertex();
+                tessellator.draw();
 
-	@Override
+                bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
-	protected void renderItem(PoseStack ms, int slotIndex, int xPos, int yPos, int heightIn, int mouseXIn, int mouseYIn, float partialTicks) {
+                bufferbuilder.pos((double)scrollBarLeft, (double)(l1 + k1 - 1), 0.0D).tex(0.0D, 1.0D).color(192, 192, 192, 255).endVertex();
-		this.getListEntry(slotIndex).drawEntry(ms, slotIndex, xPos, yPos, this.getRowWidth(), heightIn, mouseXIn, mouseYIn,
+                bufferbuilder.pos((double)(scrollBarRight - 1), (double)(l1 + k1 - 1), 0.0D).tex(1.0D, 1.0D).color(192, 192, 192, 255).endVertex();
-			this.getSlotIndexFromScreenCoords(mouseXIn, mouseYIn) == slotIndex, partialTicks);
+                bufferbuilder.pos((double)(scrollBarRight - 1), (double)l1, 0.0D).tex(1.0D, 0.0D).color(192, 192, 192, 255).endVertex();
-	}
+                bufferbuilder.pos((double)scrollBarLeft, (double)l1, 0.0D).tex(0.0D, 0.0D).color(192, 192, 192, 255).endVertex();
+                tessellator.draw();
+            }
 
-	public int getMaxPosition(int count) {
+            GlStateManager.enableTexture2D();
-		//Add all count entry heights
+            GlStateManager.shadeModel(7424);
-		int height = this.headerHeight;
+            GlStateManager.enableAlpha();
-		for (int i = 0; i < count; i++) {
+            GlStateManager.disableBlend();
-			IScrollEntry entry = listEntries.get(i);
+        }
-			height += entry.getHeight();
+    }
-		}
-		return height;
-	}
 
-	public int getSlotIndexFromScreenCoords(double posX, double posY) {
+    //SLOTHEIGHT MODIFICATIONS
-		int left = this.x0 + (this.width - this.getRowWidth()) / 2;
+    //SlotHeight is still relied on for determining how much to scroll
-		int right = this.x0 + (this.width + this.getRowWidth()) / 2;
+    @Override
-		double relativeMouseY = getRelativeMouseY(mouseY, 0);
+    protected int getContentHeight() {
+        //Add every entry height
+        int height = this.headerPadding;
+        for (IScrollEntry entry : listEntries) {
+            height += entry.getHeight();
+        }
+        return height;
+    }
 
-		//Iterate over every entry until relativeMouseY falls within its height
+    public int getContentHeight(int count) {
-		for (int i = 0; i < listEntries.size(); i++) {
+        //Add all count entry heights
-			IScrollEntry entry = listEntries.get(i);
+        int height = this.headerPadding;
-			if (relativeMouseY <= entry.getHeight())
+        for (int i = 0; i < count; i++) {
-				return posX < this.getScrollbarPosition() && posX >= left && posX <= right && i >= 0 &&
+            IScrollEntry entry = listEntries.get(i);
-					relativeMouseY >= 0 && i < this.getItemCount() ? i : -1;
+            height += entry.getHeight();
-			relativeMouseY -= entry.getHeight();
+        }
-		}
+        return height;
-		return -1;
+    }
-	}
 
-	@Override
+    @Override
-	public List<? extends GuiEventListener> children() {
+    public int getSlotIndexFromScreenCoords(int posX, int posY) {
-		return null;
+        int left = this.left + (this.width - this.getListWidth()) / 2;
-	}
+        int right = this.left + (this.width + this.getListWidth()) / 2;
+        int relativeMouseY = getRelativeMouseY(mouseY, 0);
 
-	@Override
+        //Iterate over every entry until relativeMouseY falls within its height
-	public boolean mouseClicked(double mouseX, double mouseY, int button) {
+        for (int i = 0; i < listEntries.size(); i++) {
-		int selectedSlot = this.getSlotIndexFromScreenCoords(mouseX, mouseY);
+            IScrollEntry entry = listEntries.get(i);
-		double relativeX = getRelativeMouseX(mouseX);
+            if (relativeMouseY <= entry.getHeight())
+                return posX < this.getScrollBarX() && posX >= left && posX <= right && i >= 0 &&
+                       relativeMouseY >= 0 && i < this.getSize() ? i : -1;
+            relativeMouseY -= entry.getHeight();
+        }
+        return -1;
+    }
 
-		//Always pass through mouseclicked, to be able to unfocus textfields
+    @Override
-		for (int i = 0; i < this.listEntries.size(); i++) {
+    public boolean mouseClicked(int mouseX, int mouseY, int mouseEvent)
-			double relativeY = getRelativeMouseY(mouseY, i);
+    {
-			this.getListEntry(i).mousePressed(selectedSlot, (int) mouseX, (int) mouseY, button, (int) relativeX, (int) relativeY);
+        int selectedSlot = this.getSlotIndexFromScreenCoords(mouseX, mouseY);
-		}
+        int relativeX = getRelativeMouseX(mouseX);
+
+        //Always pass through mouseclicked, to be able to unfocus textfields
+        for (int i = 0; i < this.listEntries.size(); i++) {
+            int relativeY = getRelativeMouseY(mouseY, i);
+            this.getListEntry(i).mousePressed(selectedSlot, mouseX, mouseY, mouseEvent, relativeX, relativeY);
+        }
 
 
 //        if (this.isMouseYWithinSlotBounds(mouseY))
@@ -237,230 +235,232 @@ public class GuiScrollPane extends SlotGui {
 //            }
 //        }
 
-		return false;
+        return false;
-	}
+    }
 
-	@Override
+    @Override
-	public boolean mouseReleased(double mouseX, double mouseY, int button) {
+    public boolean mouseReleased(int x, int y, int mouseEvent)
-		for (int i = 0; i < this.getItemCount(); ++i) {
+    {
-			double relativeX = getRelativeMouseX(mouseX);
+        for (int i = 0; i < this.getSize(); ++i)
-			double relativeY = getRelativeMouseY(mouseY, i);
+        {
-			this.getListEntry(i).mouseReleased(i, (int) mouseX, (int) mouseY, button, (int) relativeX, (int) relativeY);
+            int relativeX = getRelativeMouseX(mouseX);
-		}
+            int relativeY = getRelativeMouseY(mouseY, i);
+            this.getListEntry(i).mouseReleased(i, x, y, mouseEvent, relativeX, relativeY);
+        }
 
-		this.visible = true;
+        this.setEnabled(true);
-		return false;
+        return false;
-	}
+    }
 
-	public void handleMouseInput() {
+    @Override
-		if (this.isMouseInList(this.mouseX, this.mouseY)) {
+    public void handleMouseInput() {
-			if (minecraft.mouseHandler.isLeftPressed() && this.mouseY >= this.y0 &&
+        if (this.isMouseYWithinSlotBounds(this.mouseY)) {
-				this.mouseY <= this.y1) {
+            if (Mouse.getEventButton() == 0 && Mouse.getEventButtonState() && this.mouseY >= this.top &&
-				int i = this.x0 + (this.width - this.getRowWidth()) / 2;
+                this.mouseY <= this.bottom) {
-				int j = this.x0 + (this.width + this.getRowWidth()) / 2;
+                int i = this.left + (this.width - this.getListWidth()) / 2;
-				int slotIndex = getSlotIndexFromScreenCoords(this.mouseX, this.mouseY);
+                int j = this.left + (this.width + this.getListWidth()) / 2;
-				double relativeMouseY = getRelativeMouseY(mouseY, slotIndex);
+                int slotIndex = getSlotIndexFromScreenCoords(this.mouseX, this.mouseY);
+                int relativeMouseY = getRelativeMouseY(mouseY, slotIndex);
 
-				if (slotIndex > -1) {
+                if (slotIndex > -1) {
-					this.mouseClicked(this.mouseX, this.mouseY, 0);
+                    this.elementClicked(slotIndex, false, this.mouseX, this.mouseY);
-				} else if (this.mouseX >= i && this.mouseX <= j && relativeMouseY < 0) {
+                    this.selectedElement = slotIndex;
-					this.clickedHeader(this.mouseX - i, this.mouseY - this.y0 + (int) this.yo - 4);
+                } else if (this.mouseX >= i && this.mouseX <= j && relativeMouseY < 0) {
-				}
+                    this.clickedHeader(this.mouseX - i, this.mouseY - this.top + (int) this.amountScrolled - 4);
-			}
+                }
+            }
 
-			if (minecraft.mouseHandler.isLeftPressed() && this.isVisible()) {
+            if (Mouse.isButtonDown(0) && this.getEnabled()) {
-				if (this.yDrag == -1) {
+                if (this.initialClickY == -1) {
-					boolean flag1 = true;
+                    boolean flag1 = true;
 
-					if (this.mouseY >= this.y0 && this.mouseY <= this.y1) {
+                    if (this.mouseY >= this.top && this.mouseY <= this.bottom) {
-						int i2 = this.x0 + (this.width - this.getRowWidth()) / 2;
+                        int i2 = this.left + (this.width - this.getListWidth()) / 2;
-						int j2 = this.x0 + (this.width + this.getRowWidth()) / 2;
+                        int j2 = this.left + (this.width + this.getListWidth()) / 2;
-						int slotIndex = getSlotIndexFromScreenCoords(this.mouseX, this.mouseY);
+                        int slotIndex = getSlotIndexFromScreenCoords(this.mouseX, this.mouseY);
-						double relativeMouseY = getRelativeMouseY(mouseY, slotIndex);
+                        int relativeMouseY = getRelativeMouseY(mouseY, slotIndex);
 
-						if (slotIndex > -1) {
+                        if (slotIndex > -1) {
-							this.mouseClicked(slotIndex, this.mouseX, this.mouseY);
+                            boolean flag = slotIndex == this.selectedElement &&
-						} else if (this.mouseX >= i2 && this.mouseX <= j2 && relativeMouseY < 0) {
+                                           Minecraft.getSystemTime() - this.lastClicked < 250L;
-							this.clickedHeader(this.mouseX - i2,
+                            this.elementClicked(slotIndex, flag, this.mouseX, this.mouseY);
-								this.mouseY - this.y0 + (int) this.yo - 4);
+                            this.selectedElement = slotIndex;
-							flag1 = false;
+                            this.lastClicked = Minecraft.getSystemTime();
-						}
+                        } else if (this.mouseX >= i2 && this.mouseX <= j2 && relativeMouseY < 0) {
+                            this.clickedHeader(this.mouseX - i2,
+                                    this.mouseY - this.top + (int) this.amountScrolled - 4);
+                            flag1 = false;
+                        }
 
-						int i3 = this.getScrollbarPosition();
+                        int i3 = this.getScrollBarX();
-						int j1 = i3 + 6;
+                        int j1 = i3 + 6;
 
-						if (this.mouseX >= i3 && this.mouseX <= j1) {
+                        if (this.mouseX >= i3 && this.mouseX <= j1) {
-							this.scrollMultiplier = -1.0F;
+                            this.scrollMultiplier = -1.0F;
-							int maxScroll = this.getMaxScroll();
+                            int maxScroll = this.getMaxScroll();
 
-							if (maxScroll < 1) {
+                            if (maxScroll < 1) {
-								maxScroll = 1;
+                                maxScroll = 1;
-							}
+                            }
 
-							int l1 = (int) ((float) ((this.y1 - this.y0) * (this.y1 - this.y0)) /
+                            int l1 = (int) ((float) ((this.bottom - this.top) * (this.bottom - this.top)) /
-								(float) this.getMaxPosition());
+                                            (float) this.getContentHeight());
-							l1 = Mth.clamp(l1, 32, this.y1 - this.y0 - 8);
+                            l1 = MathHelper.clamp(l1, 32, this.bottom - this.top - 8);
-							this.scrollMultiplier /= (float) (this.y1 - this.y0 - l1) / (float) maxScroll;
+                            this.scrollMultiplier /= (float) (this.bottom - this.top - l1) / (float) maxScroll;
-						} else {
+                        } else {
-							this.scrollMultiplier = 1.0F;
+                            this.scrollMultiplier = 1.0F;
-						}
+                        }
 
-						if (flag1) {
+                        if (flag1) {
-							this.yDrag = this.mouseY;
+                            this.initialClickY = this.mouseY;
-						} else {
+                        } else {
-							this.yDrag = -2;
+                            this.initialClickY = -2;
-						}
+                        }
-					} else {
+                    } else {
-						this.yDrag = -2;
+                        this.initialClickY = -2;
-					}
+                    }
-				} else if (this.yDrag >= 0) {
+                } else if (this.initialClickY >= 0) {
-					this.yo -= (float) (this.mouseY - this.yDrag) * this.scrollMultiplier;
+                    this.amountScrolled -= (float) (this.mouseY - this.initialClickY) * this.scrollMultiplier;
-					this.yDrag = this.mouseY;
+                    this.initialClickY = this.mouseY;
-				}
+                }
-			} else {
+            } else {
-				this.yDrag = -1;
+                this.initialClickY = -1;
-			}
+            }
 
-		}
+            int i2 = Mouse.getEventDWheel();
-	}
 
-	//Draw in center if it fits
+            if (i2 != 0) {
-	@Override
+                if (i2 > 0) {
-	protected void renderList(PoseStack ms, int insideLeft, int insideTop, int mouseXIn, int mouseYIn, float partialTicks) {
+                    i2 = -1;
-		int itemCount = this.getItemCount();
+                } else if (i2 < 0) {
-		Tesselator tessellator = Tesselator.getInstance();
+                    i2 = 1;
-		BufferBuilder bufferbuilder = tessellator.getBuilder();
+                }
 
-		//Find y to start with
+                this.amountScrolled += (float) (i2 * this.slotHeight / 2);
-		int y = this.headerHeight + insideTop;
+            }
-		int contentHeight = getMaxPosition();
+        }
-		int insideHeight = this.y1 - this.y0 - 4;
+    }
 
-		if (contentHeight < insideHeight) {
+    //Draw in center if it fits
-			//it fits, so we can center it vertically
+    @Override
-			y += (insideHeight - contentHeight) / 2;
+    protected void drawSelectionBox(int insideLeft, int insideTop, int mouseXIn, int mouseYIn, float partialTicks)
-		}
+    {
+        int size = this.getSize();
+        Tessellator tessellator = Tessellator.getInstance();
+        BufferBuilder bufferbuilder = tessellator.getBuffer();
 
-		//Draw all entries
+        //Find y to start with
-		for (int i = 0; i < itemCount; ++i) {
+        int y = this.headerPadding + insideTop;
-			int entryHeight = listEntries.get(i).getHeight();
+        int contentHeight = getContentHeight();
-			int entryHeight2 = entryHeight - 4;
+        int insideHeight = this.bottom - this.top - 4;
 
-			if (y > this.y1 || y + entryHeight2 < this.y0) {
+        if (contentHeight < insideHeight) {
-				this.updateItemPosition(i, insideLeft, y, partialTicks);
+            //it fits, so we can center it vertically
-			}
+            y += (insideHeight - contentHeight) / 2;
+        }
 
-			if (this.renderSelection && this.isSelectedItem(i)) {
+        //Draw all entries
-				int i1 = this.x0 + this.width / 2 - this.getRowWidth() / 2;
+        for (int i = 0; i < size; ++i)
-				int j1 = this.x0 + this.width / 2 + this.getRowWidth() / 2;
+        {
-				RenderSystem.disableTexture();
+            int entryHeight = listEntries.get(i).getHeight();
-				float f = this.isFocused() ? 1.0F : 0.5F;
+            int entryHeight2 = entryHeight - 4;
-				RenderSystem.setShaderColor(f, f, f, 1.0F);
-				bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION);
-				bufferbuilder.vertex(i1, y + entryHeight2 + 2, 0.0D).endVertex();
-				bufferbuilder.vertex(j1, y + entryHeight2 + 2, 0.0D).endVertex();
-				bufferbuilder.vertex(j1, y - 2, 0.0D).endVertex();
-				bufferbuilder.vertex(i1, y - 2, 0.0D).endVertex();
-				tessellator.end();
-				RenderSystem.setShaderColor(0.0F, 0.0F, 0.0F, 1.0F);
-				bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION);
-				bufferbuilder.vertex(i1 + 1, y + entryHeight2 + 1, 0.0D).endVertex();
-				bufferbuilder.vertex(j1 - 1, y + entryHeight2 + 1, 0.0D).endVertex();
-				bufferbuilder.vertex(j1 - 1, y - 1, 0.0D).endVertex();
-				bufferbuilder.vertex(i1 + 1, y - 1, 0.0D).endVertex();
-				tessellator.end();
-				RenderSystem.enableTexture();
-			}
 
-			this.renderItem(ms, i, insideLeft, y, entryHeight2, mouseXIn, mouseYIn, partialTicks);
+            if (y > this.bottom || y + entryHeight2 < this.top)
-			y += entryHeight;
+            {
-		}
+                this.updateItemPos(i, insideLeft, y, partialTicks);
-	}
+            }
 
-	private double getRelativeMouseX(double mouseX) {
+            if (this.showSelectionBox && this.isSelected(i))
-		int j = this.x0 + this.width / 2 - this.getRowWidth() / 2 + 2;
+            {
-		return mouseX - j;
+                int i1 = this.left + this.width / 2 - this.getListWidth() / 2;
-	}
+                int j1 = this.left + this.width / 2 + this.getListWidth() / 2;
+                GlStateManager.color(1.0F, 1.0F, 1.0F, 1.0F);
+                GlStateManager.disableTexture2D();
+                bufferbuilder.begin(7, DefaultVertexFormats.POSITION_TEX_COLOR);
+                bufferbuilder.pos((double)i1, (double)(y + entryHeight2 + 2), 0.0D).tex(0.0D, 1.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)j1, (double)(y + entryHeight2 + 2), 0.0D).tex(1.0D, 1.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)j1, (double)(y - 2), 0.0D).tex(1.0D, 0.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)i1, (double)(y - 2), 0.0D).tex(0.0D, 0.0D).color(128, 128, 128, 255).endVertex();
+                bufferbuilder.pos((double)(i1 + 1), (double)(y + entryHeight2 + 1), 0.0D).tex(0.0D, 1.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)(j1 - 1), (double)(y + entryHeight2 + 1), 0.0D).tex(1.0D, 1.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)(j1 - 1), (double)(y - 1), 0.0D).tex(1.0D, 0.0D).color(0, 0, 0, 255).endVertex();
+                bufferbuilder.pos((double)(i1 + 1), (double)(y - 1), 0.0D).tex(0.0D, 0.0D).color(0, 0, 0, 255).endVertex();
+                tessellator.draw();
+                GlStateManager.enableTexture2D();
+            }
 
-	private double getRelativeMouseY(double mouseY, int contentIndex) {
+            this.drawSlot(i, insideLeft, y, entryHeight2, mouseXIn, mouseYIn, partialTicks);
-		int k = this.y0 + 4 - this.getScroll() + getMaxPosition(contentIndex) + this.headerHeight;
+            y += entryHeight;
-		double relativeMouseY = mouseY - k;
+        }
+    }
 
-		//Content might be centered, adjust relative mouse y accordingly
+    private int getRelativeMouseX(int mouseX) {
-		int contentHeight = getMaxPosition();
+        int j = this.left + this.width / 2 - this.getListWidth() / 2 + 2;
-		int insideHeight = this.y1 - this.y0 - 4;
+        return mouseX - j;
+    }
 
-		if (contentHeight < insideHeight) {
+    private int getRelativeMouseY(int mouseY, int contentIndex) {
-			//it fits, so we can center it vertically
+        int k = this.top + 4 - this.getAmountScrolled() + getContentHeight(contentIndex) + this.headerPadding;
-			relativeMouseY -= (insideHeight - contentHeight) / 2f;
+        int relativeMouseY = mouseY - k;
-		}
-		return relativeMouseY;
-	}
 
-	//PASSTHROUGHS
+        //Content might be centered, adjust relative mouse y accordingly
-	public void init(List<Widget> renderables) {
+        int contentHeight = getContentHeight();
-		for (IScrollEntry entry : this.listEntries) {
+        int insideHeight = this.bottom - this.top - 4;
-			entry.init(renderables);
-		}
-	}
 
-	public void updateScreen() {
+        if (contentHeight < insideHeight) {
-		for (IScrollEntry entry : this.listEntries)
+            //it fits, so we can center it vertically
-			entry.updateScreen();
+            relativeMouseY -= (insideHeight - contentHeight) / 2;
-	}
+        }
+        return relativeMouseY;
+    }
 
-	public void drawTooltip(PoseStack ms, Screen guiScreen, int mouseX, int mouseY) {
+    //PASSTHROUGHS
-		for (IScrollEntry entry : this.listEntries)
+    public int initGui(int id, List<GuiButton> buttonList) {
-			entry.drawTooltip(ms, guiScreen, mouseX, mouseY);
+        for (IScrollEntry entry : this.listEntries) {
-	}
+            id = entry.initGui(id, buttonList);
+        }
+        registerScrollButtons(id++, id++);
+        return id;
+    }
 
-	@Override
+    public void updateScreen() {
-	public boolean charTyped(char eventChar, int eventKey) {
+        for (IScrollEntry entry : this.listEntries)
-		for (IScrollEntry entry : this.listEntries)
+            entry.updateScreen();
-			entry.charTyped(eventChar, eventKey);
+    }
-		return false;
-	}
 
-	public void onGuiClosed() {
+    public void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY) {
-		for (IScrollEntry entry : this.listEntries)
+        for (IScrollEntry entry : this.listEntries)
-			entry.onGuiClosed();
+            entry.drawTooltip(guiScreen, mouseX, mouseY);
-	}
+    }
 
-	//Make protected values available
+    public void keyTyped(char eventChar, int eventKey) throws IOException {
-	public int getWidth() {
+        for (IScrollEntry entry : this.listEntries)
-		return width;
+            entry.keyTyped(eventChar, eventKey);
-	}
+    }
 
-	public int getHeight() {
+    public void actionPerformed(GuiButton button) {
-		return height;
+        for (IScrollEntry entry : this.listEntries)
-	}
+            entry.actionPerformed(button);
+    }
 
-	public interface IScrollEntry {
+    public void onGuiClosed() {
-		void init(List<Widget> renderables);
+        for (IScrollEntry entry : this.listEntries)
+            entry.onGuiClosed();
+    }
 
-		void updateScreen();
+    public interface IScrollEntry extends GuiListExtended.IGuiListEntry {
+        int initGui(int id, List<GuiButton> buttonList);
 
-		void drawTooltip(PoseStack ms, Screen guiScreen, int mouseX, int mouseY);
+        void updateScreen();
 
-		boolean charTyped(char eventChar, int eventKey);
+        void drawTooltip(GuiScreen guiScreen, int mouseX, int mouseY);
 
-		void onGuiClosed();
+        void keyTyped(char eventChar, int eventKey) throws IOException;
 
-		int getHeight();
+        void actionPerformed(GuiButton button);
 
-		void updatePosition(int slotIndex, int x, int y, float partialTicks);
+        void onGuiClosed();
 
-		void drawEntry(PoseStack ms, int slotIndex, int x, int y, int listWidth, int slotHeight, int mouseX, int mouseY, boolean isSelected, float partialTicks);
+        int getHeight();
-
+    }
-		/**
-		 * Called when the mouse is clicked within this entry. Returning true means that something within this entry was
-		 * clicked and the list should not be dragged.
-		 */
-		boolean mousePressed(int slotIndex, int mouseX, int mouseY, int mouseEvent, int relativeX, int relativeY);
-
-		/**
-		 * Fired when the mouse button is released. Arguments: index, x, y, mouseEvent, relativeX, relativeY
-		 */
-		void mouseReleased(int slotIndex, int x, int y, int mouseEvent, int relativeX, int relativeY);
-	}
 }

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

@@ -1,260 +0,0 @@
-package nl.requios.effortlessbuilding.gui.elements;
-
-import com.mojang.blaze3d.vertex.*;
-import com.mojang.blaze3d.systems.RenderSystem;
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.components.events.AbstractContainerEventHandler;
-import net.minecraft.client.gui.components.events.GuiEventListener;
-import net.minecraft.client.gui.components.Widget;
-import net.minecraft.util.Mth;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-
-import javax.annotation.ParametersAreNonnullByDefault;
-import java.util.Collections;
-import java.util.List;
-
-@OnlyIn(Dist.CLIENT)
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-@SuppressWarnings("deprecation")
-public abstract class SlotGui extends AbstractContainerEventHandler implements Widget {
-	protected final Minecraft minecraft;
-	protected final int itemHeight;
-	protected int width;
-	protected int height;
-	protected int y0;
-	protected int y1;
-	protected int x1;
-	protected int x0;
-	protected int yDrag = -2;
-	protected double yo;
-	protected boolean visible = true;
-	protected boolean renderSelection = true;
-	protected boolean renderHeader;
-	protected int headerHeight;
-	private boolean scrolling;
-
-	public SlotGui(Minecraft mcIn, int width, int height, int topIn, int bottomIn, int slotHeightIn) {
-		this.minecraft = mcIn;
-		this.width = width;
-		this.height = height;
-		this.y0 = topIn;
-		this.y1 = bottomIn;
-		this.itemHeight = slotHeightIn;
-		this.x0 = 0;
-		this.x1 = width;
-	}
-
-	public boolean isVisible() {
-		return this.visible;
-	}
-
-	protected abstract int getItemCount();
-
-	public List<? extends GuiEventListener> children() {
-		return Collections.emptyList();
-	}
-
-	protected boolean selectItem(int p_selectItem_1_, int p_selectItem_2_, double p_selectItem_3_, double p_selectItem_5_) {
-		return true;
-	}
-
-	protected abstract boolean isSelectedItem(int p_isSelectedItem_1_);
-
-	protected int getMaxPosition() {
-		return this.getItemCount() * this.itemHeight + this.headerHeight;
-	}
-
-	protected abstract void renderBackground();
-
-	protected void updateItemPosition(int p_updateItemPosition_1_, int p_updateItemPosition_2_, int p_updateItemPosition_3_, float p_updateItemPosition_4_) {
-	}
-
-	protected abstract void renderItem(PoseStack ms, int p_renderItem_1_, int p_renderItem_2_, int p_renderItem_3_, int p_renderItem_4_, int p_renderItem_5_, int p_renderItem_6_, float p_renderItem_7_);
-
-	protected void renderHeader(int p_renderHeader_1_, int p_renderHeader_2_, Tesselator p_renderHeader_3_) {
-	}
-
-	protected void clickedHeader(int p_clickedHeader_1_, int p_clickedHeader_2_) {
-	}
-
-	public int getItemAtPosition(double p_getItemAtPosition_1_, double p_getItemAtPosition_3_) {
-		int i = this.x0 + this.width / 2 - this.getRowWidth() / 2;
-		int j = this.x0 + this.width / 2 + this.getRowWidth() / 2;
-		int k = Mth.floor(p_getItemAtPosition_3_ - (double) this.y0) - this.headerHeight + (int) this.yo - 4;
-		int l = k / this.itemHeight;
-		return p_getItemAtPosition_1_ < (double) this.getScrollbarPosition() && p_getItemAtPosition_1_ >= (double) i && p_getItemAtPosition_1_ <= (double) j && l >= 0 && k >= 0 && l < this.getItemCount() ? l : -1;
-	}
-
-	protected void capYPosition() {
-		this.yo = Mth.clamp(this.yo, 0.0D, this.getMaxScroll());
-	}
-
-	public int getMaxScroll() {
-		return Math.max(0, this.getMaxPosition() - (this.y1 - this.y0 - 4));
-	}
-
-	public int getScroll() {
-		return (int) this.yo;
-	}
-
-	public boolean isMouseInList(double p_isMouseInList_1_, double p_isMouseInList_3_) {
-		return p_isMouseInList_3_ >= (double) this.y0 && p_isMouseInList_3_ <= (double) this.y1 && p_isMouseInList_1_ >= (double) this.x0 && p_isMouseInList_1_ <= (double) this.x1;
-	}
-
-	public abstract void render(PoseStack ms, int p_render_1_, int p_render_2_, float p_render_3_);
-
-	protected void updateScrollingState(double p_updateScrollingState_1_, double p_updateScrollingState_3_, int p_updateScrollingState_5_) {
-		this.scrolling = p_updateScrollingState_5_ == 0 && p_updateScrollingState_1_ >= (double) this.getScrollbarPosition() && p_updateScrollingState_1_ < (double) (this.getScrollbarPosition() + 6);
-	}
-
-	public boolean mouseClicked(double p_mouseClicked_1_, double p_mouseClicked_3_, int p_mouseClicked_5_) {
-		this.updateScrollingState(p_mouseClicked_1_, p_mouseClicked_3_, p_mouseClicked_5_);
-		if (this.isVisible() && this.isMouseInList(p_mouseClicked_1_, p_mouseClicked_3_)) {
-			int i = this.getItemAtPosition(p_mouseClicked_1_, p_mouseClicked_3_);
-			if (i == -1 && p_mouseClicked_5_ == 0) {
-				this.clickedHeader((int) (p_mouseClicked_1_ - (double) (this.x0 + this.width / 2 - this.getRowWidth() / 2)), (int) (p_mouseClicked_3_ - (double) this.y0) + (int) this.yo - 4);
-				return true;
-			} else if (i != -1 && this.selectItem(i, p_mouseClicked_5_, p_mouseClicked_1_, p_mouseClicked_3_)) {
-				if (this.children().size() > i) {
-					this.setFocused(this.children().get(i));
-				}
-
-				this.setDragging(true);
-				return true;
-			} else {
-				return this.scrolling;
-			}
-		} else {
-			return false;
-		}
-	}
-
-	public boolean mouseReleased(double p_mouseReleased_1_, double p_mouseReleased_3_, int p_mouseReleased_5_) {
-		if (this.getFocused() != null) {
-			this.getFocused().mouseReleased(p_mouseReleased_1_, p_mouseReleased_3_, p_mouseReleased_5_);
-		}
-
-		return false;
-	}
-
-	public boolean mouseDragged(double p_mouseDragged_1_, double p_mouseDragged_3_, int p_mouseDragged_5_, double p_mouseDragged_6_, double p_mouseDragged_8_) {
-		if (super.mouseDragged(p_mouseDragged_1_, p_mouseDragged_3_, p_mouseDragged_5_, p_mouseDragged_6_, p_mouseDragged_8_)) {
-			return true;
-		} else if (this.isVisible() && p_mouseDragged_5_ == 0 && this.scrolling) {
-			if (p_mouseDragged_3_ < (double) this.y0) {
-				this.yo = 0.0D;
-			} else if (p_mouseDragged_3_ > (double) this.y1) {
-				this.yo = this.getMaxScroll();
-			} else {
-				double d0 = this.getMaxScroll();
-				if (d0 < 1.0D) {
-					d0 = 1.0D;
-				}
-
-				int i = (int) ((float) ((this.y1 - this.y0) * (this.y1 - this.y0)) / (float) this.getMaxPosition());
-				i = Mth.clamp(i, 32, this.y1 - this.y0 - 8);
-				double d1 = d0 / (double) (this.y1 - this.y0 - i);
-				if (d1 < 1.0D) {
-					d1 = 1.0D;
-				}
-
-				this.yo += p_mouseDragged_8_ * d1;
-				this.capYPosition();
-			}
-
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	public boolean mouseScrolled(double p_mouseScrolled_1_, double p_mouseScrolled_3_, double p_mouseScrolled_5_) {
-		if (!this.isVisible()) {
-			return false;
-		} else {
-			this.yo -= p_mouseScrolled_5_ * (double) this.itemHeight / 2.0D;
-			return true;
-		}
-	}
-
-	public boolean keyPressed(int p_keyPressed_1_, int p_keyPressed_2_, int p_keyPressed_3_) {
-		if (!this.isVisible()) {
-			return false;
-		} else if (super.keyPressed(p_keyPressed_1_, p_keyPressed_2_, p_keyPressed_3_)) {
-			return true;
-		} else if (p_keyPressed_1_ == 264) {
-			this.moveSelection(1);
-			return true;
-		} else if (p_keyPressed_1_ == 265) {
-			this.moveSelection(-1);
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	protected void moveSelection(int p_moveSelection_1_) {
-	}
-
-	public boolean charTyped(char p_charTyped_1_, int p_charTyped_2_) {
-		return this.isVisible() && super.charTyped(p_charTyped_1_, p_charTyped_2_);
-	}
-
-	public boolean isMouseOver(double p_isMouseOver_1_, double p_isMouseOver_3_) {
-		return this.isMouseInList(p_isMouseOver_1_, p_isMouseOver_3_);
-	}
-
-	public int getRowWidth() {
-		return 220;
-	}
-
-	protected void renderList(PoseStack ms, int p_renderList_1_, int p_renderList_2_, int p_renderList_3_, int p_renderList_4_, float p_renderList_5_) {
-		int i = this.getItemCount();
-		Tesselator tessellator = Tesselator.getInstance();
-		BufferBuilder bufferbuilder = tessellator.getBuilder();
-
-		for (int j = 0; j < i; ++j) {
-			int k = p_renderList_2_ + j * this.itemHeight + this.headerHeight;
-			int l = this.itemHeight - 4;
-			if (k > this.y1 || k + l < this.y0) {
-				this.updateItemPosition(j, p_renderList_1_, k, p_renderList_5_);
-			}
-
-			if (this.renderSelection && this.isSelectedItem(j)) {
-				int i1 = this.x0 + this.width / 2 - this.getRowWidth() / 2;
-				int j1 = this.x0 + this.width / 2 + this.getRowWidth() / 2;
-				RenderSystem.disableTexture();
-				float f = this.isFocused() ? 1.0F : 0.5F;
-				RenderSystem.setShaderColor(f, f, f, 1.0F);
-				bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION);
-				bufferbuilder.vertex(i1, k + l + 2, 0.0D).endVertex();
-				bufferbuilder.vertex(j1, k + l + 2, 0.0D).endVertex();
-				bufferbuilder.vertex(j1, k - 2, 0.0D).endVertex();
-				bufferbuilder.vertex(i1, k - 2, 0.0D).endVertex();
-				tessellator.end();
-				RenderSystem.setShaderColor(0.0F, 0.0F, 0.0F, 1.0F);
-				bufferbuilder.begin(VertexFormat.Mode.QUADS, DefaultVertexFormat.POSITION);
-				bufferbuilder.vertex(i1 + 1, k + l + 1, 0.0D).endVertex();
-				bufferbuilder.vertex(j1 - 1, k + l + 1, 0.0D).endVertex();
-				bufferbuilder.vertex(j1 - 1, k - 1, 0.0D).endVertex();
-				bufferbuilder.vertex(i1 + 1, k - 1, 0.0D).endVertex();
-				tessellator.end();
-				RenderSystem.enableTexture();
-			}
-
-			this.renderItem(ms, j, p_renderList_1_, k, l, p_renderList_3_, p_renderList_4_, p_renderList_5_);
-		}
-
-	}
-
-	protected boolean isFocused() {
-		return false;
-	}
-
-	protected int getScrollbarPosition() {
-		return this.width / 2 + 124;
-	}
-}

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

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

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

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

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

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

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

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

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

@@ -1,92 +1,84 @@
 package nl.requios.effortlessbuilding.helper;
 
-import net.minecraft.advancements.CriteriaTriggers;
+import net.minecraft.block.Block;
-import net.minecraft.core.BlockPos;
+import net.minecraft.block.BlockLiquid;
-import net.minecraft.core.Direction;
+import net.minecraft.block.BlockSlab;
-import net.minecraft.core.Registry;
+import net.minecraft.block.SoundType;
-import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.block.material.Material;
-import net.minecraft.sounds.SoundSource;
+import net.minecraft.block.properties.IProperty;
-import net.minecraft.tags.BlockTags;
+import net.minecraft.block.state.IBlockState;
-import net.minecraft.world.InteractionHand;
+import net.minecraft.entity.Entity;
-import net.minecraft.world.entity.Entity;
+import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.world.entity.player.Player;
+import net.minecraft.init.Blocks;
-import net.minecraft.world.item.BlockItem;
+import net.minecraft.item.ItemBlock;
-import net.minecraft.world.item.ItemStack;
+import net.minecraft.item.ItemSlab;
-import net.minecraft.world.level.Level;
+import net.minecraft.item.ItemStack;
-import net.minecraft.world.level.block.Block;
+import net.minecraft.util.EnumFacing;
-import net.minecraft.world.level.block.Blocks;
+import net.minecraft.util.EnumHand;
-import net.minecraft.world.level.block.SlabBlock;
+import net.minecraft.util.SoundCategory;
-import net.minecraft.world.level.block.SoundType;
+import net.minecraft.util.math.AxisAlignedBB;
-import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.level.block.state.pattern.BlockInWorld;
+import net.minecraft.util.math.Vec3d;
-import net.minecraft.world.level.material.Material;
+import net.minecraft.world.IBlockAccess;
-import net.minecraft.world.phys.Vec3;
+import net.minecraft.world.World;
-import net.minecraft.world.phys.shapes.VoxelShape;
-import net.minecraftforge.event.ForgeEventFactory;
 import nl.requios.effortlessbuilding.BuildConfig;
 import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.compatibility.CompatHelper;
 
+import javax.annotation.Nonnull;
 import javax.annotation.Nullable;
 
 public class SurvivalHelper {
 
-	//Used for all placing of blocks in this mod.
+    //Used for all placing of blocks in this mod.
-	//Checks if area is loaded, if player has the right permissions, if existing block can be replaced (drops it if so) and consumes an item from the stack.
+    //Checks if area is loaded, if player has the right permissions, if existing block can be replaced (drops it if so) and consumes an item from the stack.
-	//Based on ItemBlock#onItemUse
+    //Based on ItemBlock#onItemUse
-	public static boolean placeBlock(Level world, Player player, BlockPos pos, BlockState blockState,
+    public static boolean placeBlock(World world, EntityPlayer player, BlockPos pos, IBlockState blockState,
-									 ItemStack origstack, Direction facing, Vec3 hitVec, boolean skipPlaceCheck,
+                                     ItemStack origstack, EnumFacing facing, Vec3d hitVec, boolean skipPlaceCheck,
-									 boolean skipCollisionCheck, boolean playSound) {
+                                     boolean skipCollisionCheck, boolean playSound) {
-		if (!world.isLoaded(pos)) return false;
+        if (!world.isBlockLoaded(pos, true)) return false;
-		ItemStack itemstack = origstack;
+        ItemStack itemstack = origstack;
 
-		if (blockState.isAir() || itemstack.isEmpty()) {
+        if (blockState.getBlock().isAir(blockState, world, pos) || itemstack.isEmpty()) {
-			dropBlock(world, player, pos);
+            dropBlock(world, player, pos);
-			world.removeBlock(pos, false);
+            world.setBlockToAir(pos);
-			return true;
+            return true;
-		}
+        }
 
-		//Randomizer bag, other proxy item synergy
+        //Randomizer bag, other proxy item synergy
-		//Preliminary compatibility code for other items that hold blocks
+        //Preliminary compatibility code for other items that hold blocks
-		if (CompatHelper.isItemBlockProxy(itemstack))
+        if (CompatHelper.isItemBlockProxy(itemstack))
-			itemstack = CompatHelper.getItemBlockByState(itemstack, blockState);
+            itemstack = CompatHelper.getItemBlockByState(itemstack, blockState);
 
-		if (!(itemstack.getItem() instanceof BlockItem))
+        if (!(itemstack.getItem() instanceof ItemBlock))
-			return false;
+            return false;
-		Block block = ((BlockItem) itemstack.getItem()).getBlock();
+        Block block = ((ItemBlock) itemstack.getItem()).getBlock();
 
 
-		//More manual with ItemBlock#placeBlockAt
+        //More manual with ItemBlock#placeBlockAt
-		if (skipPlaceCheck || canPlace(world, player, pos, blockState, itemstack, skipCollisionCheck, facing.getOpposite())) {
+        if (skipPlaceCheck || canPlace(world, player, pos, blockState, itemstack, skipCollisionCheck, facing.getOpposite())) {
-			//Drop existing block
+            //Drop existing block
-			dropBlock(world, player, pos);
+            dropBlock(world, player, pos);
 
-			//TryPlace sets block with offset and reduces itemstack count in creative, so we copy only parts of it
+            boolean placed = ((ItemBlock) itemstack.getItem()).placeBlockAt(itemstack, player, world, pos, facing, (float) hitVec.x, (float) hitVec.y, (float) hitVec.z, blockState);
-//            BlockItemUseContext blockItemUseContext = new BlockItemUseContext(world, player, itemstack, pos, facing, (float) hitVec.x, (float) hitVec.y, (float) hitVec.z);
+            if (!placed) return false;
-//            EnumActionResult result = ((ItemBlock) itemstack.getItem()).tryPlace(blockItemUseContext);
-			if (!world.setBlock(pos, blockState, 3)) return false;
-			BlockItem.updateCustomBlockEntityTag(world, player, pos, itemstack); //Actually BlockItem::onBlockPlaced but that is protected
-			block.setPlacedBy(world, pos, blockState, player, itemstack);
-			if (player instanceof ServerPlayer) {
-				CriteriaTriggers.PLACED_BLOCK.trigger((ServerPlayer) player, pos, itemstack);
-			}
 
-			BlockState afterState = world.getBlockState(pos);
+            IBlockState afterState = world.getBlockState(pos);
 
-			if (playSound) {
+            if (playSound) {
-				SoundType soundtype = afterState.getBlock().getSoundType(afterState, world, pos, player);
+                SoundType soundtype = afterState.getBlock().getSoundType(afterState, world, pos, player);
-				world.playSound(null, pos, soundtype.getPlaceSound(), SoundSource.BLOCKS, (soundtype.getVolume() + 1.0F) / 2.0F, soundtype.getPitch() * 0.8F);
+                world.playSound(null, pos, soundtype.getPlaceSound(), SoundCategory.BLOCKS, (soundtype.getVolume() + 1.0F) / 2.0F, soundtype.getPitch() * 0.8F);
-			}
+            }
 
-			if (!player.isCreative() && Block.byItem(itemstack.getItem()) == block) {
+            if (!player.isCreative() && Block.getBlockFromItem(itemstack.getItem()) == block) {
-				itemstack.shrink(1);
+                CompatHelper.shrinkStack(origstack, itemstack, player);
-			}
+            }
 
-			return true;
+            return true;
-		}
+        }
-		return false;
+        return false;
 
-		//Using ItemBlock#onItemUse
+        //Using ItemBlock#onItemUse
 //        EnumActionResult result;
 //        PlayerInteractEvent.RightClickBlock event = ForgeHooks.onRightClickBlock(player, EnumHand.MAIN_HAND, pos, facing, net.minecraftforge.common.ForgeHooks.rayTraceEyeHitVec(player, ReachHelper.getPlacementReach(player)));
 //        if (player.isCreative())
@@ -109,40 +101,40 @@ public class SurvivalHelper {
 //            return false;
 //        }
 
-	}
+    }
 
-	//Used for all breaking of blocks in this mod.
+    //Used for all breaking of blocks in this mod.
-	//Checks if area is loaded, if appropriate tool is used in survival mode, and drops the block directly into the players inventory
+    //Checks if area is loaded, if appropriate tool is used in survival mode, and drops the block directly into the players inventory
-	public static boolean breakBlock(Level world, Player player, BlockPos pos, boolean skipChecks) {
+    public static boolean breakBlock(World world, EntityPlayer player, BlockPos pos, boolean skipChecks) {
-		if (!world.isLoaded(pos) && !world.isEmptyBlock(pos)) return false;
+        if (!world.isBlockLoaded(pos, false)) return false;
 
-		//Check if can break
+        //Check if can break
-		if (skipChecks || canBreak(world, player, pos)) {
+        if (skipChecks || canBreak(world, player, pos)) {
 //            player.addStat(StatList.getBlockStats(world.getNewBlockState(pos).getBlock()));
 //            player.addExhaustion(0.005F);
 
-			//Drop existing block
+            //Drop existing block
-			dropBlock(world, player, pos);
+            dropBlock(world, player, pos);
 
-			//Damage tool
+            //Damage tool
-			player.getMainHandItem().mineBlock(world, world.getBlockState(pos), pos, player);
+            player.getHeldItemMainhand().onBlockDestroyed(world, world.getBlockState(pos), pos, player);
 
-			world.removeBlock(pos, false);
+            world.setBlockToAir(pos);
-			return true;
+            return true;
-		}
+        }
-		return false;
+        return false;
-	}
+    }
 
-	//Gives items directly to player
+    //Gives items directly to player
-	public static void dropBlock(Level world, Player player, BlockPos pos) {
+    public static void dropBlock(World world, EntityPlayer player, BlockPos pos){
-		if (player.isCreative()) return;
+        if (player.isCreative()) return;
 
-		BlockState blockState = world.getBlockState(pos);
+        IBlockState blockState = world.getBlockState(pos);
-		Block block = blockState.getBlock();
+        Block block = blockState.getBlock();
 
-		block.playerDestroy(world, player, pos, blockState, world.getBlockEntity(pos), player.getMainHandItem());
+        block.harvestBlock(world, player, pos, blockState, world.getTileEntity(pos), player.getHeldItemMainhand());
 
-		//TODO drop items in inventory instead of world
+        //TODO drop items in inventory instead of world
 
 //        List<ItemStack> drops = new ArrayList<>();
 //
@@ -170,148 +162,174 @@ public class SurvivalHelper {
 //        {
 //            ItemHandlerHelper.giveItemToPlayer(player, drop);
 //        }
-	}
+    }
 
-	/**
+    /**
-	 * Check if player can place a block.
+     * Check if player can place a block.
-	 * Turn randomizer bag into itemstack inside before.
+     * Turn randomizer bag into itemstack inside before.
-	 *
+     * @param world
-	 * @param world
+     * @param player
-	 * @param player
+     * @param pos
-	 * @param pos
+     * @param newBlockState the blockstate that is going to be placed
-	 * @param newBlockState      the blockstate that is going to be placed
+     * @param itemStack the itemstack used for placing
-	 * @param itemStack          the itemstack used for placing
+     * @param skipCollisionCheck skips collision check with entities
-	 * @param skipCollisionCheck skips collision check with entities
+     * @param sidePlacedOn
-	 * @param sidePlacedOn
+     * @return Whether the player may place the block at pos with itemstack
-	 * @return Whether the player may place the block at pos with itemstack
+     */
-	 */
+    public static boolean canPlace(World world, EntityPlayer player, BlockPos pos, IBlockState newBlockState, ItemStack itemStack, boolean skipCollisionCheck, EnumFacing sidePlacedOn) {
-	public static boolean canPlace(Level world, Player player, BlockPos pos, BlockState newBlockState, ItemStack itemStack, boolean skipCollisionCheck, Direction sidePlacedOn) {
 
-		//Check if itemstack is correct
+        //Check if itemstack is correct
-		if (!(itemStack.getItem() instanceof BlockItem) || Block.byItem(itemStack.getItem()) != newBlockState.getBlock()) {
+        if (!(itemStack.getItem() instanceof ItemBlock) || Block.getBlockFromItem(itemStack.getItem()) != newBlockState.getBlock()) {
 //            EffortlessBuilding.log(player, "Cannot (re)place block", true);
 //            EffortlessBuilding.log("SurvivalHelper#canPlace: itemstack " + itemStack.toString() + " does not match blockstate " + newBlockState.toString());
-			//Happens when breaking blocks, no need to notify in that case
+            //Happens when breaking blocks, no need to notify in that case
-			return false;
+            return false;
-		}
+        }
 
-		Block block = ((BlockItem) itemStack.getItem()).getBlock();
+        Block block = ((ItemBlock) itemStack.getItem()).getBlock();
 
-		return !itemStack.isEmpty() && canPlayerEdit(player, world, pos, itemStack) &&
+        return !itemStack.isEmpty() && canPlayerEdit(player, world, pos, itemStack) &&
-			mayPlace(world, block, newBlockState, pos, skipCollisionCheck, sidePlacedOn, player) &&
+               mayPlace(world, block, newBlockState, pos, skipCollisionCheck, sidePlacedOn, player) &&
-			canReplace(world, player, pos);
+               canReplace(world, player, pos);
-	}
+    }
 
-	//Can be harvested with hand? (or in creative)
+    //Can be harvested with hand? (or in creative)
-	private static boolean canReplace(Level world, Player player, BlockPos pos) {
+    private static boolean canReplace(World world, EntityPlayer player, BlockPos pos){
-		if (player.isCreative()) return true;
+        if (player.isCreative()) return true;
 
-		BlockState state = world.getBlockState(pos);
+        IBlockState state = world.getBlockState(pos);
+        state = state.getBlock().getActualState(state, world, pos);
 
-		int miningLevel = BuildConfig.survivalBalancers.quickReplaceMiningLevel.get();
+        switch (BuildConfig.survivalBalancers.quickReplaceMiningLevel) {
-		switch (miningLevel) {
+            case -1: return state.getMaterial().isToolNotRequired();
-			case -1:
+            case 0: return state.getBlock().getHarvestLevel(state) <= 0;
-				return !state.requiresCorrectToolForDrops();
+            case 1: return state.getBlock().getHarvestLevel(state) <= 1;
-			case 0:
+            case 2: return state.getBlock().getHarvestLevel(state) <= 2;
-				return !state.is(BlockTags.NEEDS_STONE_TOOL) &&
+            case 3: return state.getBlock().getHarvestLevel(state) <= 3;
-					   !state.is(BlockTags.NEEDS_IRON_TOOL) &&
+        }
-					   !state.is(BlockTags.NEEDS_DIAMOND_TOOL);
-			case 1:
-				return !state.is(BlockTags.NEEDS_IRON_TOOL) &&
-					   !state.is(BlockTags.NEEDS_DIAMOND_TOOL);
-			case 2:
-				return !state.is(BlockTags.NEEDS_DIAMOND_TOOL);
-			case 3:
-			case 4:
-				return true;
-		}
 
-		return false;
+        return false;
-	}
+    }
 
-	//From Player#mayUseItemAt
+    //From EntityPlayer#canPlayerEdit
-	private static boolean canPlayerEdit(Player player, Level world, BlockPos pos, ItemStack stack) {
+    private static boolean canPlayerEdit(EntityPlayer player, World world, BlockPos pos, ItemStack stack)
-		if (!world.mayInteract(player, pos)) return false;
+    {
+        if (player.capabilities.allowEdit)
+        {
+            //True in creative and survival mode
+            return true;
+        }
+        else
+        {
+            //Adventure mode
+            Block block = world.getBlockState(pos).getBlock();
+            return stack.canPlaceOn(block) || stack.canEditBlocks();
+        }
+    }
 
-		if (player.getAbilities().mayBuild) {
+    //From World#mayPlace
-			//True in creative and survival mode
+    private static boolean mayPlace(World world, Block blockIn, IBlockState newBlockState, BlockPos pos, boolean skipCollisionCheck, EnumFacing sidePlacedOn, @Nullable Entity placer)
-			return true;
+    {
-		} else {
+        IBlockState iblockstate1 = world.getBlockState(pos);
-			//Adventure mode
+        AxisAlignedBB axisalignedbb = skipCollisionCheck ? Block.NULL_AABB : blockIn.getDefaultState().getCollisionBoundingBox(world, pos);
-			BlockInWorld blockinworld = new BlockInWorld(world, pos, false);
-			return stack.hasAdventureModePlaceTagForBlock(world.registryAccess().registryOrThrow(Registry.BLOCK_REGISTRY), blockinworld);
-		}
-	}
 
-	//From World#mayPlace
+        if (axisalignedbb != Block.NULL_AABB && !world.checkNoEntityCollision(axisalignedbb.offset(pos)))
-	private static boolean mayPlace(Level world, Block blockIn, BlockState newBlockState, BlockPos pos, boolean skipCollisionCheck, Direction sidePlacedOn, @Nullable Entity placer) {
+        {
-		BlockState iblockstate1 = world.getBlockState(pos);
+            return false;
-		VoxelShape voxelShape = skipCollisionCheck ? null : blockIn.defaultBlockState().getCollisionShape(world, pos);
+        }
 
-		if (voxelShape != null && !world.isUnobstructed(placer, voxelShape)) {
+        //Check if double slab
-			return false;
+        if (placer != null && doesBecomeDoubleSlab(((EntityPlayer) placer), pos, sidePlacedOn)) {
-		}
+            return true;
+        }
 
-		//Check if double slab
+        //Check if same block
-		if (placer != null && doesBecomeDoubleSlab(((Player) placer), pos, sidePlacedOn)) {
+        //Necessary otherwise extra items will be dropped
-			return true;
+        if (iblockstate1 == newBlockState) {
-		}
+            return false;
+        }
 
-		//Check if same block
+        if (iblockstate1.getMaterial() == Material.CIRCUITS && blockIn == Blocks.ANVIL)
-		//Necessary otherwise extra items will be dropped
+        {
-		if (iblockstate1 == newBlockState) {
+            return true;
-			return false;
+        }
-		}
 
-		//TODO 1.14 check what Material.CIRCUITS has become
+        //Check quickreplace
-		if (iblockstate1.getMaterial() == Material.BUILDABLE_GLASS && blockIn == Blocks.ANVIL) {
+        if (placer instanceof EntityPlayer && ModifierSettingsManager.getModifierSettings(((EntityPlayer) placer)).doQuickReplace()) {
-			return true;
+            return true;
-		}
+        }
 
-		//Check quickreplace
+        return iblockstate1.getBlock().isReplaceable(world, pos) && blockIn.canPlaceBlockOnSide(world, pos, sidePlacedOn);
-		if (placer instanceof Player && ModifierSettingsManager.getModifierSettings(((Player) placer)).doQuickReplace()) {
+    }
-			return true;
-		}
-
-		//TODO 1.13 replaceable
-		return iblockstate1.getMaterial().isReplaceable() /*&& canPlaceBlockOnSide(world, pos, sidePlacedOn)*/;
-	}
 
 
-	//Can break using held tool? (or in creative)
-	public static boolean canBreak(Level world, Player player, BlockPos pos) {
-		BlockState blockState = world.getBlockState(pos);
-		if (!world.getFluidState(pos).isEmpty()) return false;
 
-		if (player.isCreative()) return true;
+    //Can break using held tool? (or in creative)
+    public static boolean canBreak(World world, EntityPlayer player, BlockPos pos) {
+        IBlockState blockState = world.getBlockState(pos);
+        if (blockState.getBlock() instanceof BlockLiquid) return false;
 
-		return ForgeEventFactory.doPlayerHarvestCheck(player, blockState, true);
+        if (player.isCreative()) return true;
-	}
 
-	public static boolean doesBecomeDoubleSlab(Player player, BlockPos pos, Direction facing) {
+        return canHarvestBlock(blockState.getBlock(), player, world, pos);
-		BlockState placedBlockState = player.level.getBlockState(pos);
+    }
 
-		ItemStack itemstack = player.getItemInHand(InteractionHand.MAIN_HAND);
+    //From ForgeHooks#canHarvestBlock
-		if (CompatHelper.isItemBlockProxy(itemstack))
+    public static boolean canHarvestBlock(@Nonnull Block block, @Nonnull EntityPlayer player, @Nonnull IBlockAccess world, @Nonnull BlockPos pos)
-			itemstack = CompatHelper.getItemBlockFromStack(itemstack);
+    {
+        IBlockState state = world.getBlockState(pos);
+        state = state.getBlock().getActualState(state, world, pos);
 
-		if (itemstack.isEmpty() || !(itemstack.getItem() instanceof BlockItem) || !(((BlockItem) itemstack.getItem()).getBlock() instanceof SlabBlock))
+        //Dont break bedrock
-			return false;
+        if (state.getBlockHardness((World) world, pos) < 0) {
-		SlabBlock heldSlab = (SlabBlock) ((BlockItem) itemstack.getItem()).getBlock();
+            return false;
+        }
 
-		if (placedBlockState.getBlock() == heldSlab) {
+        if (state.getMaterial().isToolNotRequired())
-			//TODO 1.13
+        {
-//            IProperty<?> variantProperty = heldSlab.getVariantProperty();
+            return true;
-//            Comparable<?> placedVariant = placedBlockState.getValue(variantProperty);
+        }
-//            BlockSlab.EnumBlockHalf placedHalf = placedBlockState.getValue(BlockSlab.HALF);
+
-//
+        ItemStack stack = player.getHeldItemMainhand();
-//            Comparable<?> heldVariant = heldSlab.getTypeForItem(itemstack);
+        String tool = block.getHarvestTool(state);
-//
+        if (stack.isEmpty() || tool == null)
-//            if ((facing == EnumFacing.UP && placedHalf == BlockSlab.EnumBlockHalf.BOTTOM || facing == EnumFacing.DOWN && placedHalf == BlockSlab.EnumBlockHalf.TOP) && placedVariant == heldVariant)
+        {
-//            {
+            return player.canHarvestBlock(state);
-//                return true;
+        }
-//            }
+
-		}
+        if (stack.getItemDamage() >= stack.getMaxDamage()) return false;
-		return false;
+
-	}
+        int toolLevel = stack.getItem().getHarvestLevel(stack, tool, player, state);
+        if (toolLevel < 0)
+        {
+            return player.canHarvestBlock(state);
+        }
+
+        return toolLevel >= block.getHarvestLevel(state);
+    }
+
+    public static boolean doesBecomeDoubleSlab(EntityPlayer player, BlockPos pos, EnumFacing facing) {
+        IBlockState placedBlockState = player.world.getBlockState(pos);
+
+        ItemStack itemstack = player.getHeldItem(EnumHand.MAIN_HAND);
+        if (CompatHelper.isItemBlockProxy(itemstack))
+            itemstack = CompatHelper.getItemBlockFromStack(itemstack);
+
+        if (itemstack.isEmpty() || !(itemstack.getItem() instanceof ItemSlab)) return false;
+        BlockSlab heldSlab = (BlockSlab) ((ItemSlab) itemstack.getItem()).getBlock();
+
+        if (placedBlockState.getBlock() == heldSlab) {
+            IProperty<?> variantProperty = heldSlab.getVariantProperty();
+            Comparable<?> placedVariant = placedBlockState.getValue(variantProperty);
+            BlockSlab.EnumBlockHalf placedHalf = placedBlockState.getValue(BlockSlab.HALF);
+
+            Comparable<?> heldVariant = heldSlab.getTypeForItem(itemstack);
+
+            if ((facing == EnumFacing.UP && placedHalf == BlockSlab.EnumBlockHalf.BOTTOM || facing == EnumFacing.DOWN && placedHalf == BlockSlab.EnumBlockHalf.TOP) && placedVariant == heldVariant)
+            {
+                return true;
+            }
+        }
+        return false;
+    }
 }

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

@@ -1,220 +0,0 @@
-package nl.requios.effortlessbuilding.item;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.item.TooltipFlag;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.world.level.material.Fluids;
-import net.minecraft.world.MenuProvider;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.world.InteractionResultHolder;
-import net.minecraft.world.InteractionResult;
-import net.minecraft.core.Direction;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.phys.BlockHitResult;
-import net.minecraft.world.phys.Vec3;
-import net.minecraft.network.chat.Component;
-import net.minecraft.ChatFormatting;
-import net.minecraft.world.level.Level;
-import net.minecraftforge.common.capabilities.ICapabilityProvider;
-import net.minecraftforge.network.NetworkHooks;
-import net.minecraftforge.items.CapabilityItemHandler;
-import net.minecraftforge.items.IItemHandler;
-import nl.requios.effortlessbuilding.buildmode.BuildModes;
-import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
-import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
-import nl.requios.effortlessbuilding.capability.ItemHandlerCapabilityProvider;
-import nl.requios.effortlessbuilding.helper.SurvivalHelper;
-
-import javax.annotation.Nullable;
-import javax.annotation.ParametersAreNonnullByDefault;
-import java.util.ArrayList;
-import java.util.Calendar;
-import java.util.List;
-import java.util.Random;
-
-import net.minecraft.world.item.CreativeModeTab;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.context.BlockPlaceContext;
-import net.minecraft.world.item.context.UseOnContext;
-
-@MethodsReturnNonnullByDefault
-@ParametersAreNonnullByDefault
-public abstract class AbstractRandomizerBagItem extends Item {
-
-    private static long currentSeed = 1337;
-    private static final Random rand = new Random(currentSeed);
-
-    public AbstractRandomizerBagItem() {
-        super(new Item.Properties().tab(CreativeModeTab.TAB_TOOLS).stacksTo(1));
-    }
-
-    public abstract int getInventorySize();
-
-    public abstract MenuProvider getContainerProvider(ItemStack item);
-
-    /**
-     * Get the inventory of a randomizer bag by checking the capability.
-     */
-    public IItemHandler getBagInventory(ItemStack bag) {
-        return bag.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null).orElse(null);
-    }
-
-    /**
-     * Pick a random slot from the bag. Empty slots will never get chosen.
-     */
-    public ItemStack pickRandomStack(IItemHandler bagInventory) {
-        //Find how many stacks are non-empty, and save them in a list
-        int nonempty = 0;
-        List<ItemStack> nonEmptyStacks = new ArrayList<>();
-        List<Integer> originalSlots = new ArrayList<>(getInventorySize());
-        for (int i = 0; i < bagInventory.getSlots(); i++) {
-            ItemStack stack = bagInventory.getStackInSlot(i);
-            if (!stack.isEmpty()) {
-                nonempty++;
-                nonEmptyStacks.add(stack);
-                originalSlots.add(i);
-            }
-        }
-
-        if (nonEmptyStacks.size() != originalSlots.size())
-            throw new Error("NonEmptyStacks and OriginalSlots not same size");
-
-        if (nonempty == 0) return ItemStack.EMPTY;
-
-        //Pick random slot
-        int randomSlot = rand.nextInt(nonempty);
-        if (randomSlot < 0 || randomSlot > bagInventory.getSlots()) return ItemStack.EMPTY;
-
-        int originalSlot = originalSlots.get(randomSlot);
-        if (originalSlot < 0 || originalSlot > bagInventory.getSlots()) return ItemStack.EMPTY;
-
-        return bagInventory.getStackInSlot(originalSlot);
-    }
-
-    public ItemStack findStack(IItemHandler bagInventory, Item item) {
-        for (int i = 0; i < bagInventory.getSlots(); i++) {
-            ItemStack stack = bagInventory.getStackInSlot(i);
-            if (!stack.isEmpty() && stack.getItem() == item) {
-                return stack;
-            }
-        }
-        return ItemStack.EMPTY;
-    }
-
-    public static void resetRandomness() {
-        rand.setSeed(currentSeed);
-    }
-
-    public static void renewRandomness() {
-        currentSeed = Calendar.getInstance().getTimeInMillis();
-        rand.setSeed(currentSeed);
-    }
-
-    @Override
-    public InteractionResult useOn(UseOnContext ctx) {
-        Player player = ctx.getPlayer();
-        Level world = ctx.getLevel();
-        BlockPos pos = ctx.getClickedPos();
-        Direction facing = ctx.getClickedFace();
-        ItemStack item = ctx.getItemInHand();
-        Vec3 hitVec = ctx.getClickLocation();
-
-        if (player == null) return InteractionResult.FAIL;
-
-        if (ctx.getPlayer() != null && ctx.getPlayer().isShiftKeyDown()) { //ctx.isPlacerSneaking()
-            if (world.isClientSide) return InteractionResult.SUCCESS;
-            //Open inventory
-            NetworkHooks.openScreen((ServerPlayer) player, getContainerProvider(item));
-        } else {
-            if (world.isClientSide) return InteractionResult.SUCCESS;
-
-            //Only place manually if in normal vanilla mode
-            BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(player).getBuildMode();
-            ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-            if (buildMode != BuildModes.BuildModeEnum.NORMAL || modifierSettings.doQuickReplace()) {
-                return InteractionResult.FAIL;
-            }
-
-            //Use item
-            //Get bag inventory
-            //TODO offhand support
-            ItemStack bag = player.getItemInHand(InteractionHand.MAIN_HAND);
-            IItemHandler bagInventory = getBagInventory(bag);
-            if (bagInventory == null)
-                return InteractionResult.FAIL;
-
-            ItemStack toPlace = pickRandomStack(bagInventory);
-            if (toPlace.isEmpty()) return InteractionResult.FAIL;
-
-            //Previously: use onItemUse to place block (no synergy)
-            //bag.setItemDamage(toPlace.getMetadata());
-            //toPlace.onItemUse(player, world, pos, hand, facing, hitX, hitY, hitZ);
-
-            //TODO replaceable
-            if (!world.getBlockState(pos).getBlock().canBeReplaced(world.getBlockState(pos), Fluids.EMPTY)) {
-                pos = pos.relative(facing);
-            }
-
-            BlockPlaceContext blockItemUseContext = new BlockPlaceContext(new UseOnContext(player, InteractionHand.MAIN_HAND, new BlockHitResult(hitVec, facing, pos, false)));
-            BlockState blockState = Block.byItem(toPlace.getItem()).getStateForPlacement(blockItemUseContext);
-
-            SurvivalHelper.placeBlock(world, player, pos, blockState, toPlace, facing, hitVec, false, false, true);
-
-            //Synergy
-            //Works without calling
-//            BlockSnapshot blockSnapshot = new BlockSnapshot(player.world, pos, blockState);
-//            BlockEvent.PlaceEvent placeEvent = new BlockEvent.PlaceEvent(blockSnapshot, blockState, player, hand);
-//            Mirror.onBlockPlaced(placeEvent);
-//            Array.onBlockPlaced(placeEvent);
-        }
-        return InteractionResult.SUCCESS;
-    }
-
-    @Override
-    public InteractionResultHolder<ItemStack> use(Level world, Player player, InteractionHand hand) {
-        ItemStack bag = player.getItemInHand(hand);
-
-        if (player.isShiftKeyDown()) {
-            if (world.isClientSide) return new InteractionResultHolder<>(InteractionResult.SUCCESS, bag);
-            //Open inventory
-            NetworkHooks.openScreen((ServerPlayer) player, getContainerProvider(bag));
-        } else {
-            //Use item
-            //Get bag inventory
-            IItemHandler bagInventory = getBagInventory(bag);
-            if (bagInventory == null)
-                return new InteractionResultHolder<>(InteractionResult.FAIL, bag);
-
-            ItemStack toUse = pickRandomStack(bagInventory);
-            if (toUse.isEmpty()) return new InteractionResultHolder<>(InteractionResult.FAIL, bag);
-
-            return toUse.use(world, player, hand);
-        }
-        return new InteractionResultHolder<>(InteractionResult.PASS, bag);
-    }
-
-    @Override
-    public int getUseDuration(ItemStack p_77626_1_) {
-        return 1;
-    }
-
-    @Nullable
-    @Override
-    public ICapabilityProvider initCapabilities(ItemStack stack, @Nullable CompoundTag nbt) {
-        return new ItemHandlerCapabilityProvider(getInventorySize());
-    }
-
-    @Override
-    public void appendHoverText(ItemStack stack, @Nullable Level world, List<Component> tooltip, TooltipFlag flag) {
-        tooltip.add(Component.literal(ChatFormatting.BLUE + "Rightclick" + ChatFormatting.GRAY + " to place a random block"));
-        tooltip.add(Component.literal(ChatFormatting.BLUE + "Sneak + rightclick" + ChatFormatting.GRAY + " to open inventory"));
-        if (world != null && world.players().size() > 1) {
-            tooltip.add(Component.literal(ChatFormatting.YELLOW + "Experimental on servers: may lose inventory"));
-        }
-    }
-}

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

@@ -1,45 +0,0 @@
-package nl.requios.effortlessbuilding.item;
-
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.MenuProvider;
-import net.minecraft.world.entity.player.Inventory;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.inventory.AbstractContainerMenu;
-import net.minecraft.world.item.ItemStack;
-import nl.requios.effortlessbuilding.gui.DiamondRandomizerBagContainer;
-
-import javax.annotation.Nullable;
-
-public class DiamondRandomizerBagItem extends AbstractRandomizerBagItem{
-    public static final int INV_SIZE = 27;
-
-    @Override
-    public int getInventorySize() {
-        return 27;
-    }
-
-    @Override
-    public MenuProvider getContainerProvider(ItemStack bag) {
-        return new ContainerProvider(bag);
-    }
-
-    public static class ContainerProvider implements MenuProvider {
-
-        private final ItemStack bag;
-
-        public ContainerProvider(ItemStack bag) {
-            this.bag = bag;
-        }
-
-        @Override
-        public Component getDisplayName() {
-            return Component.translatable("effortlessbuilding:diamond_randomizer_bag");
-        }
-
-        @Nullable
-        @Override
-        public AbstractContainerMenu createMenu(int containerId, Inventory playerInventory, Player player) {
-            return new DiamondRandomizerBagContainer(containerId, playerInventory, ((AbstractRandomizerBagItem)bag.getItem()).getBagInventory(bag));
-        }
-    }
-}

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

@@ -1,45 +0,0 @@
-package nl.requios.effortlessbuilding.item;
-
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.MenuProvider;
-import net.minecraft.world.entity.player.Inventory;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.inventory.AbstractContainerMenu;
-import net.minecraft.world.item.ItemStack;
-import nl.requios.effortlessbuilding.gui.GoldenRandomizerBagContainer;
-
-import javax.annotation.Nullable;
-
-public class GoldenRandomizerBagItem extends AbstractRandomizerBagItem{
-    public static final int INV_SIZE = 9;
-
-    @Override
-    public int getInventorySize() {
-        return 9;
-    }
-
-    @Override
-    public MenuProvider getContainerProvider(ItemStack bag) {
-        return new ContainerProvider(bag);
-    }
-
-    public static class ContainerProvider implements MenuProvider {
-
-        private final ItemStack bag;
-
-        public ContainerProvider(ItemStack bag) {
-            this.bag = bag;
-        }
-
-        @Override
-        public Component getDisplayName() {
-            return Component.translatable("effortlessbuilding:golden_randomizer_bag");
-        }
-
-        @Nullable
-        @Override
-        public AbstractContainerMenu createMenu(int containerId, Inventory playerInventory, Player player) {
-            return new GoldenRandomizerBagContainer(containerId, playerInventory, ((AbstractRandomizerBagItem)bag.getItem()).getBagInventory(bag));
-        }
-    }
-}

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

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

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

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

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

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

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

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

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

@@ -1,45 +0,0 @@
-package nl.requios.effortlessbuilding.item;
-
-import net.minecraft.network.chat.Component;
-import net.minecraft.world.MenuProvider;
-import net.minecraft.world.entity.player.Inventory;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.inventory.AbstractContainerMenu;
-import net.minecraft.world.item.ItemStack;
-import nl.requios.effortlessbuilding.gui.RandomizerBagContainer;
-
-import javax.annotation.Nullable;
-
-public class RandomizerBagItem extends AbstractRandomizerBagItem {
-	public static final int INV_SIZE = 5;
-
-	@Override
-	public int getInventorySize() {
-		return 5;
-	}
-
-	@Override
-	public MenuProvider getContainerProvider(ItemStack bag) {
-		return new ContainerProvider(bag);
-	}
-
-	public static class ContainerProvider implements MenuProvider {
-
-		private final ItemStack bag;
-
-		public ContainerProvider(ItemStack bag) {
-			this.bag = bag;
-		}
-
-		@Override
-		public Component getDisplayName() {
-			return Component.translatable("effortlessbuilding:randomizer_bag");
-		}
-
-		@Nullable
-		@Override
-		public AbstractContainerMenu createMenu(int containerId, Inventory playerInventory, Player player) {
-			return new RandomizerBagContainer(containerId, playerInventory, ((AbstractRandomizerBagItem)bag.getItem()).getBagInventory(bag));
-		}
-	}
-}

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

@@ -1,69 +0,0 @@
-package nl.requios.effortlessbuilding.item;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.world.item.TooltipFlag;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.CreativeModeTab;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.network.chat.Component;
-import net.minecraft.ChatFormatting;
-import net.minecraft.world.level.Level;
-import nl.requios.effortlessbuilding.BuildConfig;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
-import nl.requios.effortlessbuilding.helper.ReachHelper;
-
-import javax.annotation.Nullable;
-import javax.annotation.ParametersAreNonnullByDefault;
-import java.util.List;
-
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.sounds.SoundEvent;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.InteractionResult;
-import net.minecraft.world.InteractionResultHolder;
-
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-public class ReachUpgrade1Item extends Item {
-
-	public ReachUpgrade1Item() {
-		super(new Item.Properties().tab(CreativeModeTab.TAB_TOOLS).stacksTo(1));
-	}
-
-	@Override
-	public InteractionResultHolder<ItemStack> use(Level world, Player player, InteractionHand hand) {
-		if (player.isCreative()) {
-			if (world.isClientSide) EffortlessBuilding.log(player, "Reach upgrades are not necessary in creative.");
-			if (world.isClientSide) EffortlessBuilding.log(player, "Still want increased reach? Use the config.");
-			return new InteractionResultHolder<>(InteractionResult.PASS, player.getItemInHand(hand));
-		}
-
-		ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-		int currentLevel = modifierSettings.getReachUpgrade();
-		if (currentLevel == 0) {
-			modifierSettings.setReachUpgrade(1);
-
-			if (world.isClientSide) EffortlessBuilding.log(player, "Upgraded reach to " + ReachHelper.getMaxReach(player));
-			player.setItemInHand(hand, ItemStack.EMPTY);
-
-			SoundEvent soundEvent = new SoundEvent(new ResourceLocation("entity.player.levelup"));
-			player.playSound(soundEvent, 1f, 1f);
-		} else if (currentLevel > 0) {
-			if (world.isClientSide)
-				EffortlessBuilding.log(player, "Already used this upgrade! Current reach is " + ReachHelper
-					.getMaxReach(player) + ".");
-
-			SoundEvent soundEvent = new SoundEvent(new ResourceLocation("item.armor.equip_leather"));
-			player.playSound(soundEvent, 1f, 1f);
-		}
-		return new InteractionResultHolder<>(InteractionResult.PASS, player.getItemInHand(hand));
-	}
-
-	@Override
-	public void appendHoverText(ItemStack stack, @Nullable Level world, List<Component> tooltip, TooltipFlag flag) {
-		tooltip.add(Component.literal(ChatFormatting.GRAY + "Consume to increase reach to " + ChatFormatting.BLUE + BuildConfig.reach.maxReachLevel1.get()));
-	}
-
-}

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

@@ -1,74 +0,0 @@
-package nl.requios.effortlessbuilding.item;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.world.item.TooltipFlag;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.CreativeModeTab;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.network.chat.Component;
-import net.minecraft.ChatFormatting;
-import net.minecraft.world.level.Level;
-import nl.requios.effortlessbuilding.BuildConfig;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
-import nl.requios.effortlessbuilding.helper.ReachHelper;
-
-import javax.annotation.Nullable;
-import javax.annotation.ParametersAreNonnullByDefault;
-import java.awt.*;
-import java.util.List;
-
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.sounds.SoundEvent;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.InteractionResult;
-import net.minecraft.world.InteractionResultHolder;
-
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-public class ReachUpgrade2Item extends Item {
-
-	public ReachUpgrade2Item() {
-		super(new Item.Properties().tab(CreativeModeTab.TAB_TOOLS).stacksTo(1));
-	}
-
-	@Override
-	public InteractionResultHolder<ItemStack> use(Level world, Player player, InteractionHand hand) {
-		if (player.isCreative()) {
-			if (world.isClientSide) EffortlessBuilding.log(player, "Reach upgrades are not necessary in creative.");
-			if (world.isClientSide) EffortlessBuilding.log(player, "Still want increased reach? Use the config.");
-			return new InteractionResultHolder<>(InteractionResult.PASS, player.getItemInHand(hand));
-		}
-
-		ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-		int currentLevel = modifierSettings.getReachUpgrade();
-		if (currentLevel == 1) {
-			modifierSettings.setReachUpgrade(2);
-			if (world.isClientSide) EffortlessBuilding.log(player, "Upgraded reach to " + ReachHelper.getMaxReach(player));
-			player.setItemInHand(hand, ItemStack.EMPTY);
-
-			SoundEvent soundEvent = new SoundEvent(new ResourceLocation("entity.player.levelup"));
-			player.playSound(soundEvent, 1f, 1f);
-		} else if (currentLevel < 1) {
-			if (world.isClientSide) EffortlessBuilding.log(player, "Use Reach Upgrade 1 first.");
-
-			SoundEvent soundEvent = new SoundEvent(new ResourceLocation("item.armor.equip_leather"));
-			player.playSound(soundEvent, 1f, 1f);
-		} else if (currentLevel > 1) {
-			if (world.isClientSide)
-				EffortlessBuilding.log(player, "Already used this upgrade! Current reach is " + ReachHelper
-					.getMaxReach(player) + ".");
-
-			SoundEvent soundEvent = new SoundEvent(new ResourceLocation("item.armor.equip_leather"));
-			player.playSound(soundEvent, 1f, 1f);
-		}
-		return new InteractionResultHolder<>(InteractionResult.PASS, player.getItemInHand(hand));
-	}
-
-	@Override
-	public void appendHoverText(ItemStack stack, @Nullable Level world, List<Component> tooltip, TooltipFlag flag) {
-		tooltip.add(Component.literal(ChatFormatting.GRAY + "Consume to increase reach to " + ChatFormatting.BLUE + BuildConfig.reach.maxReachLevel2.get()));
-		tooltip.add(Component.literal(ChatFormatting.GRAY + "Previous upgrades need to be consumed first"));
-	}
-}

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

@@ -1,77 +0,0 @@
-package nl.requios.effortlessbuilding.item;
-
-import net.minecraft.MethodsReturnNonnullByDefault;
-import net.minecraft.world.item.TooltipFlag;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.CreativeModeTab;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.network.chat.Component;
-import net.minecraft.ChatFormatting;
-import net.minecraft.world.level.Level;
-import nl.requios.effortlessbuilding.BuildConfig;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
-import nl.requios.effortlessbuilding.helper.ReachHelper;
-
-import javax.annotation.Nullable;
-import javax.annotation.ParametersAreNonnullByDefault;
-import java.util.List;
-
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.sounds.SoundEvent;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.InteractionResult;
-import net.minecraft.world.InteractionResultHolder;
-
-@ParametersAreNonnullByDefault
-@MethodsReturnNonnullByDefault
-public class ReachUpgrade3Item extends Item {
-
-	public ReachUpgrade3Item() {
-		super(new Item.Properties().tab(CreativeModeTab.TAB_TOOLS).stacksTo(1));
-	}
-
-	@Override
-	public InteractionResultHolder<ItemStack> use(Level world, Player player, InteractionHand hand) {
-		if (player.isCreative()) {
-			if (world.isClientSide) EffortlessBuilding.log(player, "Reach upgrades are not necessary in creative.");
-			if (world.isClientSide) EffortlessBuilding.log(player, "Still want increased reach? Use the config.");
-			return new InteractionResultHolder<>(InteractionResult.PASS, player.getItemInHand(hand));
-		}
-
-		ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-		int currentLevel = modifierSettings.getReachUpgrade();
-		if (currentLevel == 2) {
-			modifierSettings.setReachUpgrade(3);
-			if (world.isClientSide) EffortlessBuilding.log(player, "Upgraded reach to " + ReachHelper.getMaxReach(player));
-			player.setItemInHand(hand, ItemStack.EMPTY);
-
-			SoundEvent soundEvent = new SoundEvent(new ResourceLocation("entity.player.levelup"));
-			player.playSound(soundEvent, 1f, 1f);
-		} else if (currentLevel < 2) {
-			if (currentLevel == 0)
-				if (world.isClientSide) EffortlessBuilding.log(player, "Use Reach Upgrade 1 and 2 first.");
-			if (currentLevel == 1)
-				if (world.isClientSide) EffortlessBuilding.log(player, "Use Reach Upgrade 2 first.");
-
-			SoundEvent soundEvent = new SoundEvent(new ResourceLocation("item.armor.equip_leather"));
-			player.playSound(soundEvent, 1f, 1f);
-		} else if (currentLevel > 2) {
-			if (world.isClientSide)
-				EffortlessBuilding.log(player, "Already used this upgrade! Current reach is " + ReachHelper
-					.getMaxReach(player) + ".");
-
-			SoundEvent soundEvent = new SoundEvent(new ResourceLocation("item.armor.equip_leather"));
-			player.playSound(soundEvent, 1f, 1f);
-		}
-		return new InteractionResultHolder<>(InteractionResult.PASS, player.getItemInHand(hand));
-	}
-
-	@Override
-	public void appendHoverText(ItemStack stack, @Nullable Level world, List<Component> tooltip, TooltipFlag flag) {
-		tooltip.add(Component.literal(ChatFormatting.GRAY + "Consume to increase reach to " + ChatFormatting.BLUE + BuildConfig.reach.maxReachLevel3.get()));
-		tooltip.add(Component.literal(ChatFormatting.GRAY + "Previous upgrades need to be consumed first"));
-	}
-
-}

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

@@ -1,101 +1,94 @@
 package nl.requios.effortlessbuilding.network;
 
-import net.minecraft.world.level.block.Block;
+import io.netty.buffer.ByteBuf;
-import net.minecraft.world.level.block.state.BlockState;
+import net.minecraft.block.Block;
-import net.minecraft.world.entity.player.Player;
+import net.minecraft.block.state.IBlockState;
-import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.entity.player.EntityPlayer;
-import net.minecraft.core.BlockPos;
+import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.phys.Vec3;
+import net.minecraft.util.math.Vec3d;
-import net.minecraftforge.api.distmarker.Dist;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
-import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
-import net.minecraftforge.fml.DistExecutor;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
-import net.minecraftforge.fml.LogicalSide;
+import net.minecraftforge.fml.relauncher.Side;
-import net.minecraftforge.network.NetworkEvent;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmodifier.BlockSet;
 import nl.requios.effortlessbuilding.buildmodifier.UndoRedo;
-import nl.requios.effortlessbuilding.render.BlockPreviewRenderer;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
 
 import java.util.ArrayList;
-import java.util.function.Supplier;
 
 /***
  * Sends a message to the client asking to add a block to the undo stack.
  */
-public class AddUndoMessage {
+public class AddUndoMessage implements IMessage {
-	private final BlockPos coordinate;
+    private BlockPos coordinate;
-	private final BlockState previousBlockState;
+    private IBlockState previousBlockState;
-	private final BlockState newBlockState;
+    private IBlockState newBlockState;
 
-	public AddUndoMessage() {
+    public AddUndoMessage() {
-		coordinate = BlockPos.ZERO;
+        coordinate = BlockPos.ORIGIN;
-		previousBlockState = null;
+        previousBlockState = null;
-		newBlockState = null;
+        newBlockState = null;
-	}
+    }
 
-	public AddUndoMessage(BlockPos coordinate, BlockState previousBlockState, BlockState newBlockState) {
+    public AddUndoMessage(BlockPos coordinate, IBlockState previousBlockState, IBlockState newBlockState) {
-		this.coordinate = coordinate;
+        this.coordinate = coordinate;
-		this.previousBlockState = previousBlockState;
+        this.previousBlockState = previousBlockState;
-		this.newBlockState = newBlockState;
+        this.newBlockState = newBlockState;
-	}
+    }
 
-	public static void encode(AddUndoMessage message, FriendlyByteBuf buf) {
+    public BlockPos getCoordinate() {
-		buf.writeInt(message.coordinate.getX());
+        return coordinate;
-		buf.writeInt(message.coordinate.getY());
+    }
-		buf.writeInt(message.coordinate.getZ());
-		buf.writeInt(Block.getId(message.previousBlockState));
-		buf.writeInt(Block.getId(message.newBlockState));
-	}
 
-	public static AddUndoMessage decode(FriendlyByteBuf buf) {
+    public IBlockState getPreviousBlockState() {
-		BlockPos coordinate = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
+        return previousBlockState;
-		BlockState previousBlockState = Block.stateById(buf.readInt());
+    }
-		BlockState newBlockState = Block.stateById(buf.readInt());
-		return new AddUndoMessage(coordinate, previousBlockState, newBlockState);
-	}
 
-	public BlockPos getCoordinate() {
+    public IBlockState getNewBlockState() {
-		return coordinate;
+        return newBlockState;
-	}
+    }
 
-	public BlockState getPreviousBlockState() {
+    @Override
-		return previousBlockState;
+    public void toBytes(ByteBuf buf) {
-	}
+        buf.writeInt(this.coordinate.getX());
+        buf.writeInt(this.coordinate.getY());
+        buf.writeInt(this.coordinate.getZ());
+        buf.writeInt(Block.getStateId(this.previousBlockState));
+        buf.writeInt(Block.getStateId(this.newBlockState));
+    }
 
-	public BlockState getNewBlockState() {
+    @Override
-		return newBlockState;
+    public void fromBytes(ByteBuf buf) {
-	}
+        coordinate = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
+        previousBlockState = Block.getStateById(buf.readInt());
+        newBlockState = Block.getStateById(buf.readInt());
+    }
 
-	public static class Handler {
+    // The params of the IMessageHandler are <REQ, REPLY>
-		public static void handle(AddUndoMessage message, Supplier<NetworkEvent.Context> ctx) {
+    public static class MessageHandler implements IMessageHandler<AddUndoMessage, IMessage> {
-			ctx.get().enqueueWork(() -> {
+        // Do note that the default constructor is required, but implicitly defined in this case
-				if (ctx.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) {
-					//Received clientside
-					DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> ClientHandler.handle(message, ctx));
-				}
-			});
-			ctx.get().setPacketHandled(true);
-		}
-	}
 
-	@OnlyIn(Dist.CLIENT)
+        @Override
-	public static class ClientHandler {
+        public IMessage onMessage(AddUndoMessage message, MessageContext ctx) {
-		public static void handle(AddUndoMessage message, Supplier<NetworkEvent.Context> ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
-			Player player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
+
-			//Add to undo stack clientside
+            if (ctx.side == Side.CLIENT){
-			//Only the appropriate player that needs to add this to the undo stack gets this message
+                //Received clientside
-			UndoRedo.addUndo(player, new BlockSet(
+
-					new ArrayList<BlockPos>() {{
+                EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
-						add(message.getCoordinate());
+                    EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
-					}},
+
-					new ArrayList<BlockState>() {{
+                    //Add to undo stack clientside
-						add(message.getPreviousBlockState());
+                    UndoRedo.addUndo(player, new BlockSet(
-					}},
+                            new ArrayList<BlockPos>() {{add(message.getCoordinate());}},
-					new ArrayList<BlockState>() {{
+                            new ArrayList<IBlockState>() {{add(message.getPreviousBlockState());}},
-						add(message.getNewBlockState());
+                            new ArrayList<IBlockState>() {{add(message.getNewBlockState());}},
-					}},
+                            new Vec3d(0,0,0),
-					new Vec3(0, 0, 0),
+                            message.getCoordinate(), message.getCoordinate()));
-					message.getCoordinate(), message.getCoordinate()));
+                });
-		}
+            }
-	}
+            return null;
+        }
+    }
 }

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

@@ -1,92 +1,95 @@
 package nl.requios.effortlessbuilding.network;
 
-import net.minecraft.network.FriendlyByteBuf;
+import io.netty.buffer.ByteBuf;
-import net.minecraft.core.Direction;
+import net.minecraft.util.EnumFacing;
-import net.minecraft.core.BlockPos;
+import net.minecraft.util.math.BlockPos;
-import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.util.math.RayTraceResult;
-import net.minecraft.world.phys.HitResult;
+import net.minecraft.util.math.Vec3d;
-import net.minecraft.world.phys.Vec3;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
-import net.minecraftforge.fml.LogicalSide;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
-import net.minecraftforge.network.NetworkEvent;
+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 java.util.function.Supplier;
 
 /***
  * Sends a message to the server indicating that a player wants to break a block
  */
-public class BlockBrokenMessage {
+public class BlockBrokenMessage implements IMessage {
 
-	private final boolean blockHit;
+    private boolean blockHit;
-	private final BlockPos blockPos;
+    private BlockPos blockPos;
-	private final Direction sideHit;
+    private EnumFacing sideHit;
-	private final Vec3 hitVec;
+    private Vec3d hitVec;
 
-	public BlockBrokenMessage() {
+    public BlockBrokenMessage() {
-		this.blockHit = false;
+        this.blockHit = false;
-		this.blockPos = BlockPos.ZERO;
+        this.blockPos = BlockPos.ORIGIN;
-		this.sideHit = Direction.UP;
+        this.sideHit = EnumFacing.UP;
-		this.hitVec = new Vec3(0, 0, 0);
+        this.hitVec = new Vec3d(0, 0, 0);
-	}
+    }
 
-	public BlockBrokenMessage(BlockHitResult result) {
+    public BlockBrokenMessage(RayTraceResult result) {
-		this.blockHit = result.getType() == HitResult.Type.BLOCK;
+        this.blockHit = result.typeOfHit == RayTraceResult.Type.BLOCK;
-		this.blockPos = result.getBlockPos();
+        this.blockPos = result.getBlockPos();
-		this.sideHit = result.getDirection();
+        this.sideHit = result.sideHit;
-		this.hitVec = result.getLocation();
+        this.hitVec = result.hitVec;
-	}
+    }
 
-	public BlockBrokenMessage(boolean blockHit, BlockPos blockPos, Direction sideHit, Vec3 hitVec) {
+    public boolean isBlockHit() {
-		this.blockHit = blockHit;
+        return blockHit;
-		this.blockPos = blockPos;
+    }
-		this.sideHit = sideHit;
-		this.hitVec = hitVec;
-	}
 
-	public static void encode(BlockBrokenMessage message, FriendlyByteBuf buf) {
+    public BlockPos getBlockPos() {
-		buf.writeBoolean(message.blockHit);
+        return blockPos;
-		buf.writeInt(message.blockPos.getX());
+    }
-		buf.writeInt(message.blockPos.getY());
-		buf.writeInt(message.blockPos.getZ());
-		buf.writeInt(message.sideHit.get3DDataValue());
-		buf.writeDouble(message.hitVec.x);
-		buf.writeDouble(message.hitVec.y);
-		buf.writeDouble(message.hitVec.z);
-	}
 
-	public static BlockBrokenMessage decode(FriendlyByteBuf buf) {
+    public EnumFacing getSideHit() {
-		boolean blockHit = buf.readBoolean();
+        return sideHit;
-		BlockPos blockPos = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
+    }
-		Direction sideHit = Direction.from3DDataValue(buf.readInt());
-		Vec3 hitVec = new Vec3(buf.readDouble(), buf.readDouble(), buf.readDouble());
-		return new BlockBrokenMessage(blockHit, blockPos, sideHit, hitVec);
-	}
 
-	public boolean isBlockHit() {
+    public Vec3d getHitVec() {
-		return blockHit;
+        return hitVec;
-	}
+    }
 
-	public BlockPos getBlockPos() {
+    @Override
-		return blockPos;
+    public void toBytes(ByteBuf buf) {
-	}
+        buf.writeBoolean(blockHit);
+        buf.writeInt(blockPos.getX());
+        buf.writeInt(blockPos.getY());
+        buf.writeInt(blockPos.getZ());
+        buf.writeInt(sideHit.getIndex());
+        buf.writeDouble(hitVec.x);
+        buf.writeDouble(hitVec.y);
+        buf.writeDouble(hitVec.z);
+    }
 
-	public Direction getSideHit() {
+    @Override
-		return sideHit;
+    public void fromBytes(ByteBuf buf) {
-	}
+        blockHit = buf.readBoolean();
+        blockPos = new BlockPos(buf.readInt(), buf.readInt(), buf.readInt());
+        sideHit = EnumFacing.byIndex(buf.readInt());
+        hitVec = new Vec3d(buf.readDouble(), buf.readDouble(), buf.readDouble());
+    }
 
-	public Vec3 getHitVec() {
+    // The params of the IMessageHandler are <REQ, REPLY>
-		return hitVec;
+    public static class MessageHandler implements IMessageHandler<BlockBrokenMessage, IMessage> {
-	}
+        // Do note that the default constructor is required, but implicitly defined in this case
+
+        @Override
+        public IMessage onMessage(BlockBrokenMessage message, MessageContext ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
+
+            if (ctx.side == Side.SERVER) {
+                //Received serverside
+                EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
+                    BuildModes.onBlockBrokenMessage(ctx.getServerHandler().player, message);
+                });
+            }
+            // No response packet
+            return null;
+        }
+    }
 
-	public static class Handler {
-		public static void handle(BlockBrokenMessage message, Supplier<NetworkEvent.Context> ctx) {
-			ctx.get().enqueueWork(() -> {
-				if (ctx.get().getDirection().getReceptionSide() == LogicalSide.SERVER) {
-					//Received serverside
-					BuildModes.onBlockBrokenMessage(ctx.get().getSender(), message);
-				}
-			});
-			ctx.get().setPacketHandled(true);
-		}
-	}
 }

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

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

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

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

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

@@ -1,53 +1,57 @@
 package nl.requios.effortlessbuilding.network;
 
-import net.minecraft.world.entity.player.Player;
+import io.netty.buffer.ByteBuf;
-import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.block.Block;
-import net.minecraftforge.api.distmarker.Dist;
+import net.minecraft.block.state.IBlockState;
-import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraft.entity.player.EntityPlayer;
-import net.minecraftforge.fml.DistExecutor;
+import net.minecraft.util.math.BlockPos;
-import net.minecraftforge.fml.LogicalSide;
+import net.minecraft.util.math.Vec3d;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import net.minecraftforge.fml.relauncher.Side;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.BlockSet;
 import nl.requios.effortlessbuilding.buildmodifier.UndoRedo;
-import nl.requios.effortlessbuilding.render.BlockPreviewRenderer;
+import nl.requios.effortlessbuilding.proxy.ClientProxy;
 
-import java.util.function.Supplier;
+import java.util.ArrayList;
 
 /***
  * Sends a message to the client asking to clear the undo and redo stacks.
  */
-public class ClearUndoMessage {
+public class ClearUndoMessage implements IMessage {
 
-	public ClearUndoMessage() {
+    public ClearUndoMessage() {
-	}
+    }
 
-	public static void encode(ClearUndoMessage message, FriendlyByteBuf buf) {
+    @Override
+    public void toBytes(ByteBuf buf) {
+    }
 
-	}
+    @Override
+    public void fromBytes(ByteBuf buf) {
+    }
 
-	public static ClearUndoMessage decode(FriendlyByteBuf buf) {
+    // The params of the IMessageHandler are <REQ, REPLY>
-		return new ClearUndoMessage();
+    public static class MessageHandler implements IMessageHandler<ClearUndoMessage, IMessage> {
-	}
+        // Do note that the default constructor is required, but implicitly defined in this case
 
-	public static class Handler {
+        @Override
-		public static void handle(ClearUndoMessage message, Supplier<NetworkEvent.Context> ctx) {
+        public IMessage onMessage(ClearUndoMessage message, MessageContext ctx) {
-			ctx.get().enqueueWork(() -> {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
-				if (ctx.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) {
-					//Received clientside
-					DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> ClientHandler.handle(message, ctx));
-				}
-			});
-			ctx.get().setPacketHandled(true);
-		}
-	}
 
-	@OnlyIn(Dist.CLIENT)
+            if (ctx.side == Side.CLIENT){
-	public static class ClientHandler {
+                //Received clientside
-		public static void handle(ClearUndoMessage message, Supplier<NetworkEvent.Context> ctx) {
-			Player player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
 
-			//Add to undo stack clientside
+                EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
-			UndoRedo.clear(player);
+                    EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
-		}
+
-	}
+                    //Add to undo stack clientside
+                    UndoRedo.clear(player);
+                });
+            }
+            return null;
+        }
+    }
 }

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

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

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

@@ -1,50 +1,66 @@
 package nl.requios.effortlessbuilding.network;
 
-import net.minecraft.world.entity.player.Player;
+import io.netty.buffer.ByteBuf;
-import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.entity.player.EntityPlayer;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraft.util.IThreadListener;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmode.BuildModes;
 import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
-import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager.ModeSettings;
 
-import java.util.function.Supplier;
+import static nl.requios.effortlessbuilding.buildmode.ModeSettingsManager.*;
 
 /**
  * Shares mode settings (see ModeSettingsManager) between server and client
  */
-public class ModeSettingsMessage {
+public class ModeSettingsMessage implements IMessage {
 
-	private ModeSettings modeSettings;
+    private ModeSettings modeSettings;
 
-	public ModeSettingsMessage() {
+    public ModeSettingsMessage() {
-	}
+    }
 
-	public ModeSettingsMessage(ModeSettings modeSettings) {
+    public ModeSettingsMessage(ModeSettings modeSettings) {
-		this.modeSettings = modeSettings;
+        this.modeSettings = modeSettings;
-	}
+    }
 
-	public static void encode(ModeSettingsMessage message, FriendlyByteBuf buf) {
+    @Override
-		buf.writeInt(message.modeSettings.getBuildMode().ordinal());
+    public void toBytes(ByteBuf buf) {
-	}
+        buf.writeInt(modeSettings.getBuildMode().ordinal());
+    }
 
-	public static ModeSettingsMessage decode(FriendlyByteBuf buf) {
+    @Override
-		BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.values()[buf.readInt()];
+    public void fromBytes(ByteBuf buf) {
+        BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.values()[buf.readInt()];
 
-		return new ModeSettingsMessage(new ModeSettings(buildMode));
+        modeSettings = new ModeSettings(buildMode);
-	}
+    }
 
-	public static class Handler {
+    // The params of the IMessageHandler are <REQ, REPLY>
-		public static void handle(ModeSettingsMessage message, Supplier<NetworkEvent.Context> ctx) {
+    public static class MessageHandler implements IMessageHandler<ModeSettingsMessage, IMessage> {
-			ctx.get().enqueueWork(() -> {
+        // Do note that the default constructor is required, but implicitly defined in this case
-				Player player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
 
-				// Sanitize
+        @Override
-				ModeSettingsManager.sanitize(message.modeSettings, player);
+        public IMessage onMessage(ModeSettingsMessage message, MessageContext ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
 
-				ModeSettingsManager.setModeSettings(player, message.modeSettings);
+            // The value that was sent
-			});
+            ModeSettings modeSettings = message.modeSettings;
-			ctx.get().setPacketHandled(true);
+
-		}
+            // 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

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

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

@@ -1,32 +0,0 @@
-package nl.requios.effortlessbuilding.network;
-
-import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.network.NetworkRegistry;
-import net.minecraftforge.network.simple.SimpleChannel;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-
-public class PacketHandler {
-	private static final String PROTOCOL_VERSION = "1";
-	public static final SimpleChannel INSTANCE = NetworkRegistry.newSimpleChannel(
-			new ResourceLocation(EffortlessBuilding.MODID, "main"),
-			() -> PROTOCOL_VERSION,
-			PROTOCOL_VERSION::equals,
-			PROTOCOL_VERSION::equals
-			);
-
-	public static void register() {
-		int id = 0;
-
-		INSTANCE.registerMessage(id++, ModifierSettingsMessage.class, ModifierSettingsMessage::encode, ModifierSettingsMessage::decode, ModifierSettingsMessage.Handler::handle);
-		INSTANCE.registerMessage(id++, ModeSettingsMessage.class, ModeSettingsMessage::encode, ModeSettingsMessage::decode, ModeSettingsMessage.Handler::handle);
-		INSTANCE.registerMessage(id++, ModeActionMessage.class, ModeActionMessage::encode, ModeActionMessage::decode, ModeActionMessage.Handler::handle);
-		INSTANCE.registerMessage(id++, BlockPlacedMessage.class, BlockPlacedMessage::encode, BlockPlacedMessage::decode, BlockPlacedMessage.Handler::handle);
-		INSTANCE.registerMessage(id++, BlockBrokenMessage.class, BlockBrokenMessage::encode, BlockBrokenMessage::decode, BlockBrokenMessage.Handler::handle);
-		INSTANCE.registerMessage(id++, CancelModeMessage.class, CancelModeMessage::encode, CancelModeMessage::decode, CancelModeMessage.Handler::handle);
-		INSTANCE.registerMessage(id++, RequestLookAtMessage.class, RequestLookAtMessage::encode, RequestLookAtMessage::decode, RequestLookAtMessage.Handler::handle);
-		INSTANCE.registerMessage(id++, AddUndoMessage.class, AddUndoMessage::encode, AddUndoMessage::decode, AddUndoMessage.Handler::handle);
-		INSTANCE.registerMessage(id++, ClearUndoMessage.class, ClearUndoMessage::encode, ClearUndoMessage::decode, ClearUndoMessage.Handler::handle);
-
-	}
-
-}

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

@@ -1,73 +1,73 @@
 package nl.requios.effortlessbuilding.network;
 
-import net.minecraft.world.entity.player.Player;
+import io.netty.buffer.ByteBuf;
-import net.minecraft.network.FriendlyByteBuf;
+import net.minecraft.block.Block;
-import net.minecraft.world.phys.BlockHitResult;
+import net.minecraft.block.state.IBlockState;
-import net.minecraft.world.phys.HitResult;
+import net.minecraft.entity.player.EntityPlayer;
-import net.minecraftforge.api.distmarker.Dist;
+import net.minecraft.util.math.BlockPos;
-import net.minecraftforge.api.distmarker.OnlyIn;
+import net.minecraft.util.math.Vec3d;
-import net.minecraftforge.fml.DistExecutor;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessage;
-import net.minecraftforge.fml.LogicalSide;
+import net.minecraftforge.fml.common.network.simpleimpl.IMessageHandler;
-import net.minecraftforge.network.NetworkEvent;
+import net.minecraftforge.fml.common.network.simpleimpl.MessageContext;
+import net.minecraftforge.fml.relauncher.Side;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
+import nl.requios.effortlessbuilding.buildmodifier.BlockSet;
+import nl.requios.effortlessbuilding.buildmodifier.UndoRedo;
 import nl.requios.effortlessbuilding.proxy.ClientProxy;
-import nl.requios.effortlessbuilding.render.BlockPreviewRenderer;
 
-import java.util.function.Supplier;
+import java.util.ArrayList;
 
 /***
  * Sends a message to the client asking for its lookat (objectmouseover) data.
  * This is then sent back with a BlockPlacedMessage.
  */
-public class RequestLookAtMessage {
+public class RequestLookAtMessage implements IMessage {
-	private final boolean placeStartPos;
+    private boolean placeStartPos;
 
-	public RequestLookAtMessage() {
+    public RequestLookAtMessage() {
-		placeStartPos = false;
+        placeStartPos = false;
-	}
+    }
 
-	public RequestLookAtMessage(boolean placeStartPos) {
+    public RequestLookAtMessage(boolean placeStartPos) {
-		this.placeStartPos = placeStartPos;
+        this.placeStartPos = placeStartPos;
-	}
+    }
 
-	public static void encode(RequestLookAtMessage message, FriendlyByteBuf buf) {
+    public boolean getPlaceStartPos() {
-		buf.writeBoolean(message.placeStartPos);
+        return placeStartPos;
-	}
+    }
 
-	public static RequestLookAtMessage decode(FriendlyByteBuf buf) {
+    @Override
-		boolean placeStartPos = buf.readBoolean();
+    public void toBytes(ByteBuf buf) {
-		return new RequestLookAtMessage(placeStartPos);
+        buf.writeBoolean(this.placeStartPos);
-	}
+    }
 
-	public boolean getPlaceStartPos() {
+    @Override
-		return placeStartPos;
+    public void fromBytes(ByteBuf buf) {
-	}
+        placeStartPos = buf.readBoolean();
+    }
 
-	public static class Handler {
+    // The params of the IMessageHandler are <REQ, REPLY>
-		public static void handle(RequestLookAtMessage message, Supplier<NetworkEvent.Context> ctx) {
+    public static class MessageHandler implements IMessageHandler<RequestLookAtMessage, IMessage> {
-			ctx.get().enqueueWork(() -> {
+        // Do note that the default constructor is required, but implicitly defined in this case
-				if (ctx.get().getDirection().getReceptionSide() == LogicalSide.CLIENT) {
-					//Received clientside
-					DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> ClientHandler.handle(message, ctx));
-				}
-			});
-			ctx.get().setPacketHandled(true);
-		}
-	}
 
-	@OnlyIn(Dist.CLIENT)
+        @Override
-	public static class ClientHandler {
+        public IMessage onMessage(RequestLookAtMessage message, MessageContext ctx) {
-		public static void handle(RequestLookAtMessage message, Supplier<NetworkEvent.Context> ctx) {
+            //EffortlessBuilding.log("message received on " + ctx.side + " side");
-			//Send back your info
-			Player player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
 
-			//Prevent double placing in normal mode with placeStartPos false
+            if (ctx.side == Side.CLIENT){
-			//Unless QuickReplace is on, then we do need to place start pos.
+                //Received clientside
-			if (ClientProxy.previousLookAt.getType() == HitResult.Type.BLOCK) {
+                //Send back your info
-				PacketHandler.INSTANCE.sendToServer(new BlockPlacedMessage((BlockHitResult) ClientProxy.previousLookAt, message.getPlaceStartPos()));
+
-			} else {
+//                EffortlessBuilding.proxy.getThreadListenerFromContext(ctx).addScheduledTask(() -> {
-				PacketHandler.INSTANCE.sendToServer(new BlockPlacedMessage());
+//                    EntityPlayer player = EffortlessBuilding.proxy.getPlayerEntityFromContext(ctx);
-			}
+//
-		}
+//                });
-	}
+
+                //Prevent double placing in normal mode with placeStartPos false.
+                //Unless QuickReplace is on, then we do need to place start pos.
+                return new BlockPlacedMessage(ClientProxy.previousLookAt, message.getPlaceStartPos());
+            }
+            return null;
+        }
+    }
 }