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,187 +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 {
+        classpath 'net.minecraftforge.gradle:ForgeGradle:2.3-SNAPSHOT'
+    }
+}
+apply plugin: 'net.minecraftforge.gradle.forge'
+//Only edit below this line, the above code adds and enables the necessary things for Forge to be setup.
+
+
+version = "1.12.2-2.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'
 }
 
-version = '1.19-2.40'
-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.
+    version = "1.12.2-14.23.5.2825"
-    // snapshot_YYYYMMDD   Snapshot are built nightly.
+    runDir = "run"
-    // stable_#            Stables are built at the discretion of the MCP team.
+    
+    // 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.
+    // simply re-run your setup task after changing the mappings to update your workspace.
-    mappings channel: 'official', version: '1.19.2'
+    mappings = "stable_39"
-    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'
-
-            // Flywheel
-            property 'mixin.env.remapRefMap', 'true'
-            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
-
-            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'
-
-            // Flywheel
-            property 'mixin.env.remapRefMap', 'true'
-            property 'mixin.env.refMapRemappingFile', "${projectDir}/build/createSrgToMcp/output.srg"
-
-            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
-                }
-            }
-        }
-    }
 }
 
-// Include resources generated by data generators.
-sourceSets.main.resources { srcDir 'src/generated/resources' }
-
 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'
-    // }
-
-    //Flywheel
-    maven {
-        name "tterrag maven"
-        url "https://maven.tterrag.com/"
-    }
 }
 
 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
 
-    //Flywheel
-    //Versions: https://maven.tterrag.com/com/jozufozu/flywheel/flywheel-forge-1.19.2/
-    implementation fg.deobf("com.jozufozu.flywheel:flywheel-forge-1.19.2:0.6.8-13")
 }
 
-// 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
+        fi
-    case $MAX_FD in  #(
+        ulimit -n $MAX_FD
-      '' | soft) :;; #(
+        if [ $? -ne 0 ] ; then
-      *)
+            warn "Could not set maximum file descriptor limit: $MAX_FD"
-        ulimit -n "$MAX_FD" ||
+        fi
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    else
-    esac
+        warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT"
-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
-        # args, so each arg winds up back in the position where it started, but
-        # possibly modified.
-        #
-        # NB: a `for` loop captures its iteration list before it begins, so
-        # changing the positional parameters here affects neither the number of
-        # iterations, nor the values presented in `arg`.
-        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

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

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

@@ -1,36 +0,0 @@
-package nl.requios.effortlessbuilding;
-
-import net.minecraftforge.common.ForgeConfigSpec;
-
-public class ClientConfig {
-
-	private static final ForgeConfigSpec.Builder builder = new ForgeConfigSpec.Builder();
-	public static final Visuals visuals = new Visuals(builder);
-	public static final ForgeConfigSpec spec = builder.build();
-
-	public static class Visuals {
-		public final ForgeConfigSpec.ConfigValue<Boolean> showBlockPreviews;
-		public final ForgeConfigSpec.ConfigValue<Boolean> alwaysShowBlockPreview;
-		public final ForgeConfigSpec.ConfigValue<Integer> maxBlockPreviews;
-
-		public Visuals(ForgeConfigSpec.Builder builder) {
-			builder.push("Visuals");
-
-			showBlockPreviews = builder
-					.comment("Show previews of the blocks while placing them")
-					.define("useShaders", true);
-
-			alwaysShowBlockPreview = builder
-				.comment("Show a block preview if you have a block in hand even in the 'Disabled' build mode")
-				.define("alwaysShowBlockPreview", false);
-
-			maxBlockPreviews = builder
-				.comment("Don't show block previews when placing more than this many blocks. " +
-						 "The outline will always be rendered.")
-				.define("shaderTreshold", 500);
-
-
-			builder.pop();
-		}
-	}
-}

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

@@ -1,337 +0,0 @@
-package nl.requios.effortlessbuilding;
-
-import com.mojang.blaze3d.platform.InputConstants;
-import com.mojang.blaze3d.vertex.DefaultVertexFormat;
-import net.minecraft.ChatFormatting;
-import net.minecraft.client.KeyMapping;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.screens.Screen;
-import net.minecraft.client.player.LocalPlayer;
-import net.minecraft.client.renderer.ShaderInstance;
-import net.minecraft.core.BlockPos;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.sounds.SoundSource;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.BlockItem;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.ClipContext;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.block.SoundType;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.phys.BlockHitResult;
-import net.minecraft.world.phys.HitResult;
-import net.minecraft.world.phys.Vec3;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.InputEvent;
-import net.minecraftforge.client.event.RegisterKeyMappingsEvent;
-import net.minecraftforge.client.event.RegisterShadersEvent;
-import net.minecraftforge.client.event.ScreenEvent;
-import net.minecraftforge.client.settings.KeyConflictContext;
-import net.minecraftforge.client.settings.KeyModifier;
-import net.minecraftforge.event.TickEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import nl.requios.effortlessbuilding.buildmode.BuildModes;
-import nl.requios.effortlessbuilding.buildmode.ModeOptions;
-import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
-import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
-import nl.requios.effortlessbuilding.compatibility.CompatHelper;
-import nl.requios.effortlessbuilding.gui.buildmode.PlayerSettingsGui;
-import nl.requios.effortlessbuilding.gui.buildmode.RadialMenu;
-import nl.requios.effortlessbuilding.gui.buildmodifier.ModifierSettingsGui;
-import nl.requios.effortlessbuilding.helper.ReachHelper;
-import nl.requios.effortlessbuilding.network.*;
-import nl.requios.effortlessbuilding.render.BuildRenderTypes;
-import org.lwjgl.glfw.GLFW;
-
-import java.io.IOException;
-
-@EventBusSubscriber(Dist.CLIENT)
-public class ClientEvents {
-
-    public static KeyMapping[] keyBindings;
-    public static HitResult previousLookAt;
-    public static HitResult currentLookAt;
-    public static int ticksInGame = 0;
-    private static int placeCooldown = 0;
-    private static int breakCooldown = 0;
-
-    //Mod Bus Events
-    @EventBusSubscriber(value = Dist.CLIENT, bus = EventBusSubscriber.Bus.MOD)
-    public static class ModBusEvents {
-
-        @SubscribeEvent
-        public static void registerKeyMappings(RegisterKeyMappingsEvent event) {
-            EffortlessBuilding.log("Registering KeyMappings!");
-
-            // register key bindings
-            keyBindings = new KeyMapping[6];
-
-            // instantiate the key bindings
-            keyBindings[0] = new KeyMapping("key.effortlessbuilding.hud.desc", KeyConflictContext.IN_GAME, InputConstants.getKey(GLFW.GLFW_KEY_KP_ADD, 0), "key.effortlessbuilding.category");
-            keyBindings[1] = new KeyMapping("key.effortlessbuilding.replace.desc", KeyConflictContext.IN_GAME, InputConstants.getKey(GLFW.GLFW_KEY_KP_SUBTRACT, 0), "key.effortlessbuilding.category");
-            keyBindings[2] = new KeyMapping("key.effortlessbuilding.mode.desc", KeyConflictContext.IN_GAME, InputConstants.getKey(GLFW.GLFW_KEY_LEFT_ALT, 0), "key.effortlessbuilding.category");
-            keyBindings[3] = new KeyMapping("key.effortlessbuilding.undo.desc", KeyConflictContext.IN_GAME, KeyModifier.CONTROL, InputConstants.getKey(GLFW.GLFW_KEY_Z, 0), "key.effortlessbuilding.category");
-            keyBindings[4] = new KeyMapping("key.effortlessbuilding.redo.desc", KeyConflictContext.IN_GAME, KeyModifier.CONTROL, InputConstants.getKey(GLFW.GLFW_KEY_Y, 0), "key.effortlessbuilding.category");
-            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 : 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);
-        }
-    }
-
-    @SubscribeEvent
-    public static void onClientTick(TickEvent.ClientTickEvent event) {
-        if (event.phase == TickEvent.Phase.START) {
-            onMouseInput();
-
-            //Update previousLookAt
-            HitResult objectMouseOver = Minecraft.getInstance().hitResult;
-            //Checking for null is necessary! Even in vanilla when looking down ladders it is occasionally null (instead of Type MISS)
-            if (objectMouseOver == null) return;
-
-            if (currentLookAt == null) {
-                currentLookAt = objectMouseOver;
-                previousLookAt = objectMouseOver;
-                return;
-            }
-
-            if (objectMouseOver.getType() == HitResult.Type.BLOCK) {
-                if (currentLookAt.getType() != HitResult.Type.BLOCK) {
-                    currentLookAt = objectMouseOver;
-                    previousLookAt = objectMouseOver;
-                } else {
-                    if (((BlockHitResult) currentLookAt).getBlockPos() != ((BlockHitResult) objectMouseOver).getBlockPos()) {
-                        previousLookAt = currentLookAt;
-                        currentLookAt = objectMouseOver;
-                    }
-                }
-            }
-        } else if (event.phase == TickEvent.Phase.END) {
-            Screen gui = Minecraft.getInstance().screen;
-            if (gui == null || !gui.isPauseScreen()) {
-                ticksInGame++;
-            }
-        }
-
-    }
-
-    private static void onMouseInput() {
-        Minecraft mc = Minecraft.getInstance();
-        LocalPlayer player = mc.player;
-        if (player == null) return;
-        BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(player).getBuildMode();
-
-        if (mc.screen != null ||
-            buildMode == BuildModes.BuildModeEnum.DISABLED ||
-            RadialMenu.instance.isVisible()) {
-            return;
-        }
-
-        if (mc.options.keyUse.isDown()) {
-
-            //KeyBinding.setKeyBindState(mc.gameSettings.keyBindUseItem.getKeyCode(), false);
-
-            if (placeCooldown <= 0) {
-                placeCooldown = 4;
-
-                ItemStack currentItemStack = player.getItemInHand(InteractionHand.MAIN_HAND);
-                if (currentItemStack.getItem() instanceof BlockItem ||
-                    (CompatHelper.isItemBlockProxy(currentItemStack) && !player.isShiftKeyDown())) {
-
-                    ItemStack itemStack = CompatHelper.getItemBlockFromStack(currentItemStack);
-
-                    //find position in distance
-                    HitResult lookingAt = getLookingAt(player);
-                    if (lookingAt != null && lookingAt.getType() == HitResult.Type.BLOCK) {
-                        BlockHitResult blockLookingAt = (BlockHitResult) lookingAt;
-
-                        BuildModes.onBlockPlacedMessage(player, new BlockPlacedMessage(blockLookingAt, true));
-                        PacketHandler.INSTANCE.sendToServer(new BlockPlacedMessage(blockLookingAt, true));
-
-                        //play sound if further than normal
-                        if ((blockLookingAt.getLocation().subtract(player.getEyePosition(1f))).lengthSqr() > 25f &&
-                            itemStack.getItem() instanceof BlockItem) {
-
-                            BlockState state = ((BlockItem) itemStack.getItem()).getBlock().defaultBlockState();
-                            BlockPos blockPos = blockLookingAt.getBlockPos();
-                            SoundType soundType = state.getBlock().getSoundType(state, player.level, blockPos, player);
-                            player.level.playSound(player, player.blockPosition(), soundType.getPlaceSound(), SoundSource.BLOCKS,
-                                    0.4f, soundType.getPitch());
-                            player.swing(InteractionHand.MAIN_HAND);
-                        }
-                    } else {
-                        BuildModes.onBlockPlacedMessage(player, new BlockPlacedMessage());
-                        PacketHandler.INSTANCE.sendToServer(new BlockPlacedMessage());
-                    }
-                }
-            } else if (buildMode == BuildModes.BuildModeEnum.SINGLE) {
-                placeCooldown--;
-                if (ModeOptions.getBuildSpeed() == ModeOptions.ActionEnum.FAST_SPEED) placeCooldown = 0;
-            }
-        } else {
-            placeCooldown = 0;
-        }
-
-        if (mc.options.keyAttack.isDown()) {
-
-            //Break block in distance in creative (or survival if enabled in config)
-            if (breakCooldown <= 0) {
-                breakCooldown = 4;
-
-                HitResult lookingAt = getLookingAt(player);
-                if (lookingAt != null && lookingAt.getType() == HitResult.Type.BLOCK) {
-                    BlockHitResult blockLookingAt = (BlockHitResult) lookingAt;
-
-                    BuildModes.onBlockBrokenMessage(player, new BlockBrokenMessage(blockLookingAt));
-                    PacketHandler.INSTANCE.sendToServer(new BlockBrokenMessage(blockLookingAt));
-
-                    //play sound if further than normal
-                    if ((blockLookingAt.getLocation().subtract(player.getEyePosition(1f))).lengthSqr() > 25f) {
-
-                        BlockPos blockPos = blockLookingAt.getBlockPos();
-                        BlockState state = player.level.getBlockState(blockPos);
-                        SoundType soundtype = state.getBlock().getSoundType(state, player.level, blockPos, player);
-                        player.level.playSound(player, player.blockPosition(), soundtype.getBreakSound(), SoundSource.BLOCKS,
-                                0.4f, soundtype.getPitch());
-                        player.swing(InteractionHand.MAIN_HAND);
-                    }
-                } else {
-                    BuildModes.onBlockBrokenMessage(player, new BlockBrokenMessage());
-                    PacketHandler.INSTANCE.sendToServer(new BlockBrokenMessage());
-                }
-            } else if (buildMode == BuildModes.BuildModeEnum.SINGLE) {
-                breakCooldown--;
-                if (ModeOptions.getBuildSpeed() == ModeOptions.ActionEnum.FAST_SPEED) breakCooldown = 0;
-            }
-
-            //EffortlessBuilding.packetHandler.sendToServer(new CancelModeMessage());
-
-        } else {
-            breakCooldown = 0;
-        }
-    }
-
-    @SubscribeEvent(receiveCanceled = true)
-    public static void onKeyPress(InputEvent.Key event) {
-        LocalPlayer player = Minecraft.getInstance().player;
-        if (player == null)
-            return;
-
-        //Remember to send packet to server if necessary
-        //Show Modifier Settings GUI
-        if (keyBindings[0].consumeClick()) {
-            openModifierSettings();
-        }
-
-        //QuickReplace toggle
-        if (keyBindings[1].consumeClick()) {
-            ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-            modifierSettings.setQuickReplace(!modifierSettings.doQuickReplace());
-            EffortlessBuilding.log(player, "Set " + ChatFormatting.GOLD + "Quick Replace " + ChatFormatting.RESET + (
-                    modifierSettings.doQuickReplace() ? "on" : "off"));
-            PacketHandler.INSTANCE.sendToServer(new ModifierSettingsMessage(modifierSettings));
-        }
-
-        //Radial menu
-        if (keyBindings[2].isDown()) {
-            if (ReachHelper.getMaxReach(player) > 0) {
-                if (!RadialMenu.instance.isVisible()) {
-                    Minecraft.getInstance().setScreen(RadialMenu.instance);
-                }
-            } else {
-                EffortlessBuilding.log(player, "Build modes are disabled until your reach has increased. Increase your reach with craftable reach upgrades.");
-            }
-        }
-
-        //Undo (Ctrl+Z)
-        if (keyBindings[3].consumeClick()) {
-            ModeOptions.ActionEnum action = ModeOptions.ActionEnum.UNDO;
-            ModeOptions.performAction(player, action);
-            PacketHandler.INSTANCE.sendToServer(new ModeActionMessage(action));
-        }
-
-        //Redo (Ctrl+Y)
-        if (keyBindings[4].consumeClick()) {
-            ModeOptions.ActionEnum action = ModeOptions.ActionEnum.REDO;
-            ModeOptions.performAction(player, action);
-            PacketHandler.INSTANCE.sendToServer(new ModeActionMessage(action));
-        }
-
-        //Change placement mode
-        if (keyBindings[5].consumeClick()) {
-            //Toggle between first two actions of the first option of the current build mode
-            BuildModes.BuildModeEnum currentBuildMode = ModeSettingsManager.getModeSettings(player).getBuildMode();
-            if (currentBuildMode.options.length > 0) {
-                ModeOptions.OptionEnum option = currentBuildMode.options[0];
-                if (option.actions.length >= 2) {
-                    if (ModeOptions.getOptionSetting(option) == option.actions[0]) {
-                        ModeOptions.performAction(player, option.actions[1]);
-                        PacketHandler.INSTANCE.sendToServer(new ModeActionMessage(option.actions[1]));
-                    } else {
-                        ModeOptions.performAction(player, option.actions[0]);
-                        PacketHandler.INSTANCE.sendToServer(new ModeActionMessage(option.actions[0]));
-                    }
-                }
-            }
-        }
-
-    }
-
-    public static void openModifierSettings() {
-        Minecraft mc = Minecraft.getInstance();
-        LocalPlayer player = mc.player;
-        if (player == null) return;
-
-        //Disabled if max reach is 0, might be set in the config that way.
-        if (ReachHelper.getMaxReach(player) == 0) {
-            EffortlessBuilding.log(player, "Build modifiers are disabled until your reach has increased. Increase your reach with craftable reach upgrades.");
-        } else {
-            mc.setScreen(new ModifierSettingsGui());
-        }
-    }
-
-    public static void openPlayerSettings() {
-        Minecraft mc = Minecraft.getInstance();
-        mc.setScreen(new PlayerSettingsGui());
-    }
-
-    @SubscribeEvent
-    public static void onGuiOpen(ScreenEvent event) {
-        Player player = Minecraft.getInstance().player;
-        if (player != null) {
-            BuildModes.initializeMode(player);
-        }
-    }
-
-    public static boolean isKeybindDown(int keybindIndex) {
-        return InputConstants.isKeyDown(
-                Minecraft.getInstance().getWindow().getWindow(),
-                keyBindings[2].getKey().getValue());
-    }
-
-    public static HitResult getLookingAt(Player player) {
-        Level world = player.level;
-
-        //base distance off of player ability (config)
-        float raytraceRange = ReachHelper.getPlacementReach(player);
-
-        Vec3 look = player.getLookAngle();
-        Vec3 start = new Vec3(player.getX(), player.getY() + player.getEyeHeight(), player.getZ());
-        Vec3 end = new Vec3(player.getX() + look.x * raytraceRange, player.getY() + player.getEyeHeight() + look.y * raytraceRange, player.getZ() + look.z * raytraceRange);
-//        return player.rayTrace(raytraceRange, 1f, RayTraceFluidMode.NEVER);
-        //TODO 1.14 check if correct
-        return world.clip(new ClipContext(start, end, ClipContext.Block.COLLIDER, ClipContext.Fluid.NONE, player));
-    }
-
-}

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

@@ -1,103 +0,0 @@
-package nl.requios.effortlessbuilding;
-
-import net.minecraftforge.common.ForgeConfigSpec;
-import nl.requios.effortlessbuilding.create.foundation.render.SuperByteBufferCache;
-
-public class CommonConfig {
-
-	private static final ForgeConfigSpec.Builder builder = new ForgeConfigSpec.Builder();
-	public static final Reach reach = new Reach(builder);
-	public static final SurvivalBalancers survivalBalancers = new SurvivalBalancers(builder);
-	public static final Visuals visuals = new Visuals(builder);
-	public static final ForgeConfigSpec spec = builder.build();
-
-	public static class Reach {
-		public final ForgeConfigSpec.ConfigValue<Boolean> enableReachUpgrades;
-		public final ForgeConfigSpec.ConfigValue<Integer> maxReachCreative;
-		public final ForgeConfigSpec.ConfigValue<Integer> maxReachLevel0;
-		public final ForgeConfigSpec.ConfigValue<Integer> maxReachLevel1;
-		public final ForgeConfigSpec.ConfigValue<Integer> maxReachLevel2;
-		public final ForgeConfigSpec.ConfigValue<Integer> maxReachLevel3;
-
-		public Reach(ForgeConfigSpec.Builder builder) {
-			builder.push("Reach");
-			enableReachUpgrades = builder
-				.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 creative",
-					"Keep in mind that chunks need to be loaded to be able to place blocks inside.")
-				.define("maxReachCreative", 200);
-
-			maxReachLevel0 = builder
-				.comment("Maximum reach in survival without upgrades",
-					"Reach upgrades are craftable consumables that permanently increase reach.",
-					"Set to 0 to disable Effortless Building until the player has consumed a reach upgrade.")
-				.define("maxReachLevel0", 20);
-
-			maxReachLevel1 = builder
-				.comment("Maximum reach in survival with one upgrade")
-				.define("maxReachLevel1", 50);
-
-			maxReachLevel2 = builder
-				.comment("Maximum reach in survival with two upgrades")
-				.define("maxReachLevel2", 100);
-
-			maxReachLevel3 = builder
-				.comment("Maximum reach in survival with three upgrades")
-				.define("maxReachLevel3", 200);
-
-			builder.pop();
-		}
-	}
-
-	public static class SurvivalBalancers {
-		public final ForgeConfigSpec.ConfigValue<Integer> quickReplaceMiningLevel;
-		public final ForgeConfigSpec.ConfigValue<Integer> undoStackSize;
-
-		public SurvivalBalancers(ForgeConfigSpec.Builder builder) {
-			builder.push("SurvivalBalancers");
-
-			quickReplaceMiningLevel = builder
-				.comment("Determines what blocks can be replaced in survival.",
-					"-1: only blocks that can be harvested by hand (default)",
-					"0: blocks that can be harvested with wooden or gold tools",
-					"1: blocks that can be harvested with stone tools",
-					"2: blocks that can be harvested with iron tools",
-					"3: blocks that can be harvested with diamond tools",
-					"4: blocks that can be harvested with netherite tools")
-				.defineInRange("quickReplaceMiningLevel", -1, -1, 3);
-
-			undoStackSize = builder
-				.comment("How many placements are remembered for the undo functionality.")
-				.worldRestart()
-				.define("undoStackSize", 10);
-
-			builder.pop();
-		}
-	}
-
-	public static class Visuals {
-		public final ForgeConfigSpec.ConfigValue<Integer> appearAnimationLength;
-		public final ForgeConfigSpec.ConfigValue<Integer> breakAnimationLength;
-
-        public Visuals(ForgeConfigSpec.Builder builder) {
-			builder.push("Visuals");
-
-			appearAnimationLength = builder
-				.comment("How long it takes for a block to appear when placed in ticks.",
-					"Set to 0 to disable animation.")
-				.define("appearAnimationLength", 5);
-
-			breakAnimationLength = builder
-				.comment("How long the break animation is in ticks.",
-					"Set to 0 to disable animation.")
-				.define("breakAnimationLength", 10);
-
-			builder.pop();
-		}
-	}
-}

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

@@ -1,196 +0,0 @@
-package nl.requios.effortlessbuilding;
-
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.item.BlockItem;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.block.Blocks;
-import net.minecraft.world.entity.Entity;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.server.level.ServerPlayer;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.common.capabilities.RegisterCapabilitiesEvent;
-import net.minecraftforge.common.util.FakePlayer;
-import net.minecraftforge.event.AttachCapabilitiesEvent;
-import net.minecraftforge.event.TickEvent;
-import net.minecraftforge.event.entity.player.PlayerEvent;
-import net.minecraftforge.event.level.BlockEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import net.minecraftforge.network.PacketDistributor;
-import nl.requios.effortlessbuilding.buildmode.BuildModes;
-import nl.requios.effortlessbuilding.buildmode.ModeSettingsManager;
-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.network.AddUndoMessage;
-import nl.requios.effortlessbuilding.network.ClearUndoMessage;
-import nl.requios.effortlessbuilding.network.PacketHandler;
-import nl.requios.effortlessbuilding.network.RequestLookAtMessage;
-
-@EventBusSubscriber
-public class CommonEvents {
-
-	//Mod Bus Events
-	@EventBusSubscriber(bus = EventBusSubscriber.Bus.MOD)
-	public static class ModBusEvents {
-
-		@SubscribeEvent
-		public void registerCapabilities(RegisterCapabilitiesEvent event){
-			event.register(ModifierCapabilityManager.IModifierCapability.class);
-			event.register(ModeCapabilityManager.IModeCapability.class);
-		}
-	}
-
-	@SubscribeEvent
-	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
-	public static void onTick(TickEvent.LevelTickEvent event) {
-		if (event.phase != TickEvent.Phase.START) return;
-
-		EffortlessBuilding.DELAYED_BLOCK_PLACER.tick();
-	}
-
-	@SubscribeEvent
-	public static void onBlockPlaced(BlockEvent.EntityPlaceEvent event) {
-		if (event.getLevel().isClientSide()) return;
-
-		if (!(event.getEntity() instanceof Player)) return;
-
-		if (event.getEntity() instanceof FakePlayer) return;
-
-		//Cancel event if necessary
-		ServerPlayer player = ((ServerPlayer) event.getEntity());
-		BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(player).getBuildMode();
-		ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-
-		if (buildMode != BuildModes.BuildModeEnum.DISABLED) {
-
-			//Only cancel if itemblock in hand
-			//Fixed issue with e.g. Create Wrench shift-rightclick disassembling being cancelled.
-			ItemStack currentItemStack = player.getItemInHand(InteractionHand.MAIN_HAND);
-			if (currentItemStack.getItem() instanceof BlockItem ||
-				(CompatHelper.isItemBlockProxy(currentItemStack) && !player.isShiftKeyDown())) {
-				event.setCanceled(true);
-			}
-
-		} else if (modifierSettings.doQuickReplace()) {
-			//Cancel event and send message if QuickReplace
-			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
-	public static void onBlockBroken(BlockEvent.BreakEvent event) {
-		if (event.getLevel().isClientSide()) return;
-
-		if (event.getPlayer() instanceof FakePlayer) return;
-
-		//Cancel event if necessary
-		//If cant break far then dont cancel event ever
-		BuildModes.BuildModeEnum buildMode = ModeSettingsManager.getModeSettings(event.getPlayer()).getBuildMode();
-		if (buildMode != BuildModes.BuildModeEnum.DISABLED && ReachHelper.canBreakFar(event.getPlayer())) {
-			event.setCanceled(true);
-		} else {
-			//NORMAL mode, let vanilla handle block breaking
-			//But modifiers and QuickReplace should still work
-			//Dont break the original block yourself, otherwise Tinkers Hammer and Veinminer won't work
-			BuildModes.onBlockBroken(event.getPlayer(), event.getPos(), false);
-
-			//Add to undo stack in client
-			if (event.getPlayer() instanceof ServerPlayer && event.getState() != null && event.getPos() != null) {
-				PacketDistributor.PacketTarget packetTarget = PacketDistributor.PLAYER.with(() -> (ServerPlayer) event.getPlayer());
-				if (packetTarget != null)
-					PacketHandler.INSTANCE.send(packetTarget, new AddUndoMessage(event.getPos(), event.getState(), Blocks.AIR.defaultBlockState()));
-			}
-		}
-	}
-
-	@SubscribeEvent
-	public static void onPlayerLoggedIn(PlayerEvent.PlayerLoggedInEvent event) {
-		if (event.getEntity() instanceof FakePlayer) return;
-		Player player = event.getEntity();
-		ModifierSettingsManager.handleNewPlayer(player);
-		ModeSettingsManager.handleNewPlayer(player);
-	}
-
-	@SubscribeEvent
-	public static void onPlayerLoggedOut(PlayerEvent.PlayerLoggedOutEvent event) {
-		if (event.getEntity() instanceof FakePlayer) return;
-		Player player = event.getEntity();
-		if (player.getCommandSenderWorld().isClientSide) return;
-
-		UndoRedo.clear(player);
-		PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) player), new ClearUndoMessage());
-	}
-
-	@SubscribeEvent
-	public static void onPlayerRespawn(PlayerEvent.PlayerRespawnEvent event) {
-		if (event.getEntity() instanceof FakePlayer) return;
-		Player player = event.getEntity();
-		ModifierSettingsManager.handleNewPlayer(player);
-		ModeSettingsManager.handleNewPlayer(player);
-	}
-
-	@SubscribeEvent
-	public static void onPlayerChangedDimension(PlayerEvent.PlayerChangedDimensionEvent event) {
-		if (event.getEntity() instanceof FakePlayer) return;
-		Player player = event.getEntity();
-		if (player.getCommandSenderWorld().isClientSide) return;
-
-		//Set build mode to normal
-		ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
-		modeSettings.setBuildMode(BuildModes.BuildModeEnum.DISABLED);
-		ModeSettingsManager.setModeSettings(player, modeSettings);
-
-		//Disable modifiers
-		ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
-		modifierSettings.getMirrorSettings().enabled = false;
-		modifierSettings.getRadialMirrorSettings().enabled = false;
-		modifierSettings.getArraySettings().enabled = false;
-		ModifierSettingsManager.setModifierSettings(player, modifierSettings);
-
-		ModifierSettingsManager.handleNewPlayer(player);
-		ModeSettingsManager.handleNewPlayer(player);
-
-		UndoRedo.clear(player);
-		PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) player), new ClearUndoMessage());
-	}
-
-	@SubscribeEvent
-	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();
-		ModifierSettingsManager.setModifierSettings(newPlayer, ModifierSettingsManager.getModifierSettings(oldPlayer));
-		ModeSettingsManager.setModeSettings(newPlayer, ModeSettingsManager.getModeSettings(oldPlayer));
-	}
-
-
-}

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

@@ -1,107 +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.api.distmarker.Dist;
+import net.minecraft.util.text.TextComponentString;
-import net.minecraftforge.common.MinecraftForge;
+import net.minecraftforge.common.capabilities.CapabilityManager;
-import net.minecraftforge.eventbus.api.IEventBus;
+import net.minecraftforge.common.config.Config;
-import net.minecraftforge.fml.DistExecutor;
+import net.minecraftforge.common.config.ConfigManager;
-import net.minecraftforge.fml.ModLoadingContext;
 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.FMLCommonSetupEvent;
+import net.minecraftforge.fml.common.SidedProxy;
-import net.minecraftforge.fml.javafmlmod.FMLJavaModLoadingContext;
+import net.minecraftforge.fml.common.event.FMLInitializationEvent;
-import net.minecraftforge.network.IContainerFactory;
+import net.minecraftforge.fml.common.event.FMLPostInitializationEvent;
-import net.minecraftforge.registries.DeferredRegister;
+import net.minecraftforge.fml.common.event.FMLPreInitializationEvent;
-import net.minecraftforge.registries.ForgeRegistries;
+import net.minecraftforge.fml.common.event.FMLServerStartingEvent;
-import net.minecraftforge.registries.RegistryObject;
+import net.minecraftforge.fml.common.network.NetworkRegistry;
+import net.minecraftforge.fml.common.network.simpleimpl.SimpleNetworkWrapper;
+import net.minecraftforge.fml.relauncher.Side;
+import nl.requios.effortlessbuilding.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.helper.DelayedBlockPlacer;
+import nl.requios.effortlessbuilding.item.ItemReachUpgrade2;
-import nl.requios.effortlessbuilding.item.*;
+import nl.requios.effortlessbuilding.item.ItemReachUpgrade3;
-import nl.requios.effortlessbuilding.network.PacketHandler;
+import nl.requios.effortlessbuilding.network.*;
-import nl.requios.effortlessbuilding.proxy.ClientProxy;
 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 Logger logger = LogManager.getLogger();
+    public static final String NAME = "Effortless Building";
+    public static final String VERSION = "1.12.2-2.16";
 
+    @Mod.Instance(EffortlessBuilding.MODID)
     public static EffortlessBuilding instance;
-	public static IProxy proxy = DistExecutor.safeRunForDist(() -> ClientProxy::new, () -> ServerProxy::new);
 
-	public static final DelayedBlockPlacer DELAYED_BLOCK_PLACER = new DelayedBlockPlacer();
+    public static Logger logger;
 
-	//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;
+    };
 
-		ModLoadingContext modLoadingContext = ModLoadingContext.get();
+    public static final Item[] ITEMS = {
-		IEventBus modEventBus = FMLJavaModLoadingContext.get().getModEventBus();
+            ITEM_RANDOMIZER_BAG,
-		IEventBus forgeEventBus = MinecraftForge.EVENT_BUS;
+            ITEM_REACH_UPGRADE_1,
+            ITEM_REACH_UPGRADE_2,
+            ITEM_REACH_UPGRADE_3
+    };
 
-		modEventBus.addListener(EffortlessBuilding::setup);
+    public static final int RANDOMIZER_BAG_GUI = 0;
 
-		DistExecutor.unsafeRunWhenOn(Dist.CLIENT, () -> () -> EffortlessBuildingClient.onConstructorClient(modEventBus, forgeEventBus));
+    @EventHandler
+    // 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();
 
-		ITEMS.register(FMLJavaModLoadingContext.get().getModEventBus());
+        CapabilityManager.INSTANCE.register(ModifierCapabilityManager.IModifierCapability.class, new ModifierCapabilityManager.Storage(), ModifierCapabilityManager.ModifierCapability.class);
-		CONTAINERS.register(FMLJavaModLoadingContext.get().getModEventBus());
+        CapabilityManager.INSTANCE.register(ModeCapabilityManager.IModeCapability.class, new ModeCapabilityManager.Storage(), ModeCapabilityManager.ModeCapability.class);
 
-		//Register config
+        EffortlessBuilding.packetHandler.registerMessage(ModifierSettingsMessage.MessageHandler.class, ModifierSettingsMessage.class, 0, Side.SERVER);
-		ModLoadingContext.get().registerConfig(ModConfig.Type.COMMON, CommonConfig.spec);
+        EffortlessBuilding.packetHandler.registerMessage(ModifierSettingsMessage.MessageHandler.class, ModifierSettingsMessage.class, 0, Side.CLIENT);
-		ModLoadingContext.get().registerConfig(ModConfig.Type.CLIENT, ClientConfig.spec);
+
+        EffortlessBuilding.packetHandler.registerMessage(ModeSettingsMessage.MessageHandler.class, ModeSettingsMessage.class, 1, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ModeSettingsMessage.MessageHandler.class, ModeSettingsMessage.class, 1, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(ModeActionMessage.MessageHandler.class, ModeActionMessage.class, 2, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ModeActionMessage.MessageHandler.class, ModeActionMessage.class, 2, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 3, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(BlockPlacedMessage.MessageHandler.class, BlockPlacedMessage.class, 3, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(BlockBrokenMessage.MessageHandler.class, BlockBrokenMessage.class, 4, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(BlockBrokenMessage.MessageHandler.class, BlockBrokenMessage.class, 4, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(CancelModeMessage.MessageHandler.class, CancelModeMessage.class, 5, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(CancelModeMessage.MessageHandler.class, CancelModeMessage.class, 5, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(RequestLookAtMessage.MessageHandler.class, RequestLookAtMessage.class, 6, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(RequestLookAtMessage.MessageHandler.class, RequestLookAtMessage.class, 6, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(AddUndoMessage.MessageHandler.class, AddUndoMessage.class, 7, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(AddUndoMessage.MessageHandler.class, AddUndoMessage.class, 7, Side.CLIENT);
+
+        EffortlessBuilding.packetHandler.registerMessage(ClearUndoMessage.MessageHandler.class, ClearUndoMessage.class, 8, Side.SERVER);
+        EffortlessBuilding.packetHandler.registerMessage(ClearUndoMessage.MessageHandler.class, ClearUndoMessage.class, 8, Side.CLIENT);
+
+        proxy.preInit(event);
     }
 
-	public static void setup(final FMLCommonSetupEvent event) {
+    @EventHandler
-		PacketHandler.register();
+    // 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());
 
-		CompatHelper.setup();
+        proxy.init(event);
     }
 
-	public static <T extends AbstractContainerMenu> MenuType<T> registerContainer(IContainerFactory<T> fact){
+    @EventHandler
-		MenuType<T> type = new MenuType<T>(fact);
+    // postInit "Handle interaction with other mods, complete your setup based on this."
-		return type;
+    public void postInit(FMLPostInitializationEvent event)
+    {
+        proxy.postInit(event);
+        CompatHelper.postInit();
     }
 
-	public static void log(String msg) {
+    @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(Player player, String msg) {
+    public static void log(EntityPlayer player, String msg){
         log(player, msg, false);
     }
 
-	public static void log(Player player, String msg, boolean actionBar) {
+    public static void log(EntityPlayer player, String msg, boolean actionBar){
-		player.displayClientMessage(Component.literal(msg), actionBar);
+        player.sendStatusMessage(new TextComponentString(msg), actionBar);
     }
-
-	//Log with translation supported, call either on client or server (which then sends a message)
-	public static void logTranslate(Player player, String prefix, String translationKey, String suffix, boolean actionBar) {
-		proxy.logTranslate(player, prefix, translationKey, suffix, actionBar);
-	}
-
 }

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

@@ -1,21 +0,0 @@
-package nl.requios.effortlessbuilding;
-
-import net.minecraft.client.gui.screens.MenuScreens;
-import net.minecraftforge.eventbus.api.IEventBus;
-import net.minecraftforge.fml.event.lifecycle.FMLClientSetupEvent;
-import nl.requios.effortlessbuilding.gui.DiamondRandomizerBagScreen;
-import nl.requios.effortlessbuilding.gui.GoldenRandomizerBagScreen;
-import nl.requios.effortlessbuilding.gui.RandomizerBagScreen;
-
-public class EffortlessBuildingClient {
-
-    public static void onConstructorClient(IEventBus modEventBus, IEventBus forgeEventBus) {
-        modEventBus.addListener(EffortlessBuildingClient::clientSetup);
-    }
-
-    public static void clientSetup(final FMLClientSetupEvent event) {
-        MenuScreens.register(EffortlessBuilding.RANDOMIZER_BAG_CONTAINER.get(), RandomizerBagScreen::new);
-        MenuScreens.register(EffortlessBuilding.GOLDEN_RANDOMIZER_BAG_CONTAINER.get(), GoldenRandomizerBagScreen::new);
-        MenuScreens.register(EffortlessBuilding.DIAMOND_RANDOMIZER_BAG_CONTAINER.get(), DiamondRandomizerBagScreen::new);
-    }
-}

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

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

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

@@ -1,12 +1,13 @@
 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 {
@@ -15,25 +16,25 @@ public abstract class BaseBuildMode implements IBuildMode {
     protected Dictionary<UUID, Integer> rightClickClientTable = new Hashtable<>();
     protected Dictionary<UUID, Integer> rightClickServerTable = 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
-	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
-	public Direction getSideHit(Player player) {
+    public EnumFacing getSideHit(EntityPlayer player) {
-		return sideHitTable.get(player.getUUID());
+        return sideHitTable.get(player.getUniqueID());
     }
 
     @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,22 +22,47 @@ 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
     //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<>();
+
+    public enum BuildModeEnum {
+        NORMAL("effortlessbuilding.mode.normal", new Normal()),
+        NORMAL_PLUS("effortlessbuilding.mode.normal_plus", new NormalPlus(), OptionEnum.BUILD_SPEED),
+        LINE("effortlessbuilding.mode.line", new Line() /*, OptionEnum.THICKNESS*/),
+        WALL("effortlessbuilding.mode.wall", new Wall(), OptionEnum.FILL),
+        FLOOR("effortlessbuilding.mode.floor", new Floor(), OptionEnum.FILL),
+        DIAGONAL_LINE("effortlessbuilding.mode.diagonal_line", new DiagonalLine() /*, OptionEnum.THICKNESS*/),
+        DIAGONAL_WALL("effortlessbuilding.mode.diagonal_wall", new DiagonalWall() /*, OptionEnum.FILL*/),
+        SLOPE_FLOOR("effortlessbuilding.mode.slope_floor", new SlopeFloor(), OptionEnum.RAISED_EDGE),
+        CIRCLE("effortlessbuilding.mode.circle", new Circle(), OptionEnum.CIRCLE_START, OptionEnum.FILL),
+        CYLINDER("effortlessbuilding.mode.cylinder", new Cylinder(), OptionEnum.CIRCLE_START, OptionEnum.FILL),
+        SPHERE("effortlessbuilding.mode.sphere", new Sphere(), OptionEnum.CIRCLE_START, OptionEnum.FILL),
+        CUBE("effortlessbuilding.mode.cube", new Cube(), OptionEnum.CUBE_FILL);
+
+        public String name;
+        public IBuildMode instance;
+        public OptionEnum[] options;
+
+        BuildModeEnum(String name, IBuildMode instance, OptionEnum... options) {
+            this.name = name;
+            this.instance = instance;
+            this.options = options;
+        }
+    }
 
     //Uses a network message to get the previous raytraceresult from the player
     //The server could keep track of all raytraceresults but this might lag with many players
     //Raytraceresult is needed for sideHit and hitVec
-	public static void onBlockPlacedMessage(Player player, BlockPlacedMessage message) {
+    public static void onBlockPlacedMessage(EntityPlayer player, BlockPlacedMessage message) {
 
         //Check if not in the middle of breaking
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
         if (currentlyBreaking.get(player) != null && currentlyBreaking.get(player)) {
             //Cancel breaking
             initializeMode(player);
@@ -53,20 +79,20 @@ public class BuildModes {
             startPos = message.getBlockPos();
 
             //Offset in direction of sidehit if not quickreplace and not replaceable
-			boolean replaceable = player.level.getBlockState(startPos).getMaterial().isReplaceable();
+            boolean replaceable = player.world.getBlockState(startPos).getBlock().isReplaceable(player.world, startPos);
             boolean becomesDoubleSlab = SurvivalHelper.doesBecomeDoubleSlab(player, startPos, message.getSideHit());
             if (!modifierSettings.doQuickReplace() && !replaceable && !becomesDoubleSlab) {
-				startPos = startPos.relative(message.getSideHit());
+                startPos = startPos.offset(message.getSideHit());
             }
 
             //Get under tall grass and other replaceable blocks
             if (modifierSettings.doQuickReplace() && replaceable) {
-				startPos = startPos.below();
+                startPos = startPos.down();
             }
 
             //Check if player reach does not exceed startpos
             int maxReach = ReachHelper.getMaxReach(player);
-			if (buildMode != BuildModeEnum.DISABLED && player.blockPosition().distSqr(startPos) > maxReach * maxReach) {
+            if (buildMode != BuildModeEnum.NORMAL && player.getPosition().distanceSq(startPos) > maxReach * maxReach) {
                 EffortlessBuilding.log(player, "Placement exceeds your reach.");
                 return;
             }
@@ -87,10 +113,10 @@ public class BuildModes {
             coordinates = coordinates.subList(0, limit);
         }
 
-		Direction sideHit = buildMode.instance.getSideHit(player);
+        EnumFacing sideHit = buildMode.instance.getSideHit(player);
         if (sideHit == null) sideHit = message.getSideHit();
 
-		Vec3 hitVec = buildMode.instance.getHitVec(player);
+        Vec3d hitVec = buildMode.instance.getHitVec(player);
         if (hitVec == null) hitVec = message.getHitVec();
 
         BuildModifiers.onBlockPlaced(player, coordinates, sideHit, hitVec, message.getPlaceStartPos());
@@ -98,26 +124,25 @@ public class BuildModes {
         //Only works when finishing a buildmode is equal to placing some blocks
         //No intermediate blocks allowed
         currentlyBreaking.remove(player);
+
     }
 
     //Use a network message to break blocks in the distance using clientside mouse input
-	public static void onBlockBrokenMessage(Player player, BlockBrokenMessage message) {
+    public static void onBlockBrokenMessage(EntityPlayer player, BlockBrokenMessage message) {
         BlockPos startPos = message.isBlockHit() ? message.getBlockPos() : null;
         onBlockBroken(player, startPos, true);
     }
 
-	public static void onBlockBroken(Player player, BlockPos startPos, boolean breakStartPos) {
+    public static void onBlockBroken(EntityPlayer player, BlockPos startPos, boolean breakStartPos) {
 
         //Check if not in the middle of placing
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
         if (currentlyBreaking.get(player) != null && !currentlyBreaking.get(player)) {
             //Cancel placing
             initializeMode(player);
             return;
         }
 
-		if (!ReachHelper.canBreakFar(player)) return;
-
         //If first click
         if (currentlyBreaking.get(player) == null) {
             //If startpos is null, dont do anything
@@ -129,7 +154,7 @@ public class BuildModes {
 
         //Get coordinates
         BuildModeEnum buildMode = modeSettings.getBuildMode();
-		List<BlockPos> coordinates = buildMode.instance.onRightClick(player, startPos, Direction.UP, Vec3.ZERO, true);
+        List<BlockPos> coordinates = buildMode.instance.onRightClick(player, startPos, EnumFacing.UP, Vec3d.ZERO, true);
 
         if (coordinates.isEmpty()) {
             currentlyBreaking.put(player, true);
@@ -144,7 +169,7 @@ public class BuildModes {
         currentlyBreaking.remove(player);
     }
 
-	public static List<BlockPos> findCoordinates(Player player, BlockPos startPos, boolean skipRaytrace) {
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos, boolean skipRaytrace) {
         List<BlockPos> coordinates = new ArrayList<>();
 
         ModeSettingsManager.ModeSettings modeSettings = ModeSettingsManager.getModeSettings(player);
@@ -153,143 +178,68 @@ public class BuildModes {
         return coordinates;
     }
 
-	public static void initializeMode(Player player) {
+    public static void initializeMode(EntityPlayer player) {
         //Resetting mode, so not placing or breaking
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
         currentlyBreaking.remove(player);
 
         ModeSettingsManager.getModeSettings(player).getBuildMode().instance.initialize(player);
     }
 
-	public static boolean isCurrentlyPlacing(Player player) {
+    public static boolean isCurrentlyPlacing(EntityPlayer player) {
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
         return currentlyBreaking.get(player) != null && !currentlyBreaking.get(player);
     }
 
-	public static boolean isCurrentlyBreaking(Player player) {
+    public static boolean isCurrentlyBreaking(EntityPlayer player) {
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
+        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(Player player) {
+    public static boolean isActive(EntityPlayer player) {
-		Dictionary<Player, Boolean> currentlyBreaking = player.level.isClientSide ? currentlyBreakingClient : currentlyBreakingServer;
+        Dictionary<EntityPlayer, Boolean> currentlyBreaking = player.world.isRemote ? currentlyBreakingClient : currentlyBreakingServer;
         return currentlyBreaking.get(player) != null;
     }
 
+
     //Find coordinates on a line bound by a plane
-	public static Vec3 findXBound(double x, Vec3 start, Vec3 look) {
+    public static Vec3d findXBound(double x, Vec3d start, Vec3d look) {
         //then y and z are
         double y = (x - start.x) / look.x * look.y + start.y;
         double z = (x - start.x) / look.x * look.z + start.z;
 
-		return new Vec3(x, y, z);
+        return new Vec3d(x, y, z);
     }
 
-	public static Vec3 findYBound(double y, Vec3 start, Vec3 look) {
+    public static Vec3d findYBound(double y, Vec3d start, Vec3d look) {
         //then x and z are
         double x = (y - start.y) / look.y * look.x + start.x;
         double z = (y - start.y) / look.y * look.z + start.z;
 
-		return new Vec3(x, y, z);
+        return new Vec3d(x, y, z);
     }
 
-	public static Vec3 findZBound(double z, Vec3 start, Vec3 look) {
+    public static Vec3d findZBound(double z, Vec3d start, Vec3d look) {
         //then x and y are
         double x = (z - start.z) / look.z * look.x + start.x;
         double y = (z - start.z) / look.z * look.y + start.y;
 
-		return new Vec3(x, y, z);
+        return new Vec3d(x, y, z);
     }
 
-	//Use this instead of player.getLookVec() in any buildmodes code
+    public static boolean isCriteriaValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace, Vec3d lineBound, Vec3d planeBound, double distToPlayerSq) {
-	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)
-		//isCriteriaValid below will take up to 2 minutes to raytrace blocks towards infinity if that is the case
-		//So make sure they are close to but never exactly 0 or 1
-		if (Math.abs(x) < 0.0001) x = 0.0001;
-		if (Math.abs(x - 1.0) < 0.0001) x = 0.9999;
-		if (Math.abs(x + 1.0) < 0.0001) x = -0.9999;
-
-		if (Math.abs(y) < 0.0001) y = 0.0001;
-		if (Math.abs(y - 1.0) < 0.0001) y = 0.9999;
-		if (Math.abs(y + 1.0) < 0.0001) y = -0.9999;
-
-		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);
+            RayTraceResult rayTraceResult = player.world.rayTraceBlocks(start, lineBound, false, true, false);
-			HitResult rayTraceResult = player.level.clip(rayTraceContext);
+            intersects = rayTraceResult != null && rayTraceResult.typeOfHit == RayTraceResult.Type.BLOCK &&
-			intersects = rayTraceResult != null && rayTraceResult.getType() == HitResult.Type.BLOCK &&
+                         planeBound.subtract(rayTraceResult.hitVec).lengthSquared() > 4;
-				planeBound.subtract(rayTraceResult.getLocation()).lengthSqr() > 4;
         }
 
-		return planeBound.subtract(start).dot(look) > 0 &&
+        return planeBound.subtract(start).dotProduct(look) > 0 &&
                distToPlayerSq > 2 && distToPlayerSq < reach * reach &&
                !intersects;
     }
 
-	public enum BuildModeEnum {
-		DISABLED("normal", new Disabled(), BuildModeCategoryEnum.BASIC),
-		SINGLE("normal_plus", new Single(), 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 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
-	void initialize(Player player);
+    void initialize(EntityPlayer player);
 
     //Fired when a block would be placed
     //Return a list of coordinates where you want to place blocks
-	List<BlockPos> onRightClick(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
-	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,8 +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.ClientEvents;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.buildmodifier.ModifierSettingsManager;
 import nl.requios.effortlessbuilding.buildmodifier.UndoRedo;
@@ -10,6 +9,56 @@ import nl.requios.effortlessbuilding.proxy.ClientProxy;
 
 public class ModeOptions {
 
+    public enum ActionEnum {
+        UNDO("effortlessbuilding.action.undo"),
+        REDO("effortlessbuilding.action.redo"),
+        REPLACE("effortlessbuilding.action.replace"),
+        OPEN_MODIFIER_SETTINGS("effortlessbuilding.action.open_modifier_settings"),
+
+        NORMAL_SPEED("effortlessbuilding.action.normal_speed"),
+        FAST_SPEED("effortlessbuilding.action.fast_speed"),
+
+        FULL("effortlessbuilding.action.full"),
+        HOLLOW("effortlessbuilding.action.hollow"),
+
+        CUBE_FULL("effortlessbuilding.action.full"),
+        CUBE_HOLLOW("effortlessbuilding.action.hollow"),
+        CUBE_SKELETON("effortlessbuilding.action.skeleton"),
+
+        SHORT_EDGE("effortlessbuilding.action.short_edge"),
+        LONG_EDGE("effortlessbuilding.action.long_edge"),
+
+        THICKNESS_1("effortlessbuilding.action.thickness_1"),
+        THICKNESS_3("effortlessbuilding.action.thickness_3"),
+        THICKNESS_5("effortlessbuilding.action.thickness_5"),
+
+        CIRCLE_START_CORNER("effortlessbuilding.action.start_corner"),
+        CIRCLE_START_CENTER("effortlessbuilding.action.start_center");
+
+        public String name;
+
+        ActionEnum(String name) {
+            this.name = name;
+        }
+    }
+
+    public enum OptionEnum {
+        BUILD_SPEED("effortlessbuilding.action.build_speed", ActionEnum.NORMAL_SPEED, ActionEnum.FAST_SPEED),
+        FILL("effortlessbuilding.action.filling", ActionEnum.FULL, ActionEnum.HOLLOW),
+        CUBE_FILL("effortlessbuilding.action.filling", ActionEnum.CUBE_FULL, ActionEnum.CUBE_HOLLOW, ActionEnum.CUBE_SKELETON),
+        RAISED_EDGE("effortlessbuilding.action.raised_edge", ActionEnum.SHORT_EDGE, ActionEnum.LONG_EDGE),
+        LINE_THICKNESS("effortlessbuilding.action.thickness", ActionEnum.THICKNESS_1, ActionEnum.THICKNESS_3, ActionEnum.THICKNESS_5),
+        CIRCLE_START("effortlessbuilding.action.circle_start", ActionEnum.CIRCLE_START_CORNER, ActionEnum.CIRCLE_START_CENTER);
+
+        public String name;
+        public ActionEnum[] actions;
+
+        OptionEnum(String name, ActionEnum... actions){
+            this.name = name;
+            this.actions = actions;
+        }
+    }
+
     private static ActionEnum buildSpeed = ActionEnum.NORMAL_SPEED;
     private static ActionEnum fill = ActionEnum.FULL;
     private static ActionEnum cubeFill = ActionEnum.CUBE_FULL;
@@ -61,7 +110,7 @@ public class ModeOptions {
     }
 
     //Called on both client and server
-	public static void performAction(Player player, ActionEnum action) {
+    public static void performAction(EntityPlayer player, ActionEnum action) {
         if (action == null) return;
 
         switch (action) {
@@ -74,16 +123,12 @@ public class ModeOptions {
             case REPLACE:
                 ModifierSettingsManager.ModifierSettings modifierSettings = ModifierSettingsManager.getModifierSettings(player);
                 modifierSettings.setQuickReplace(!modifierSettings.doQuickReplace());
-				EffortlessBuilding.log(player, "Set " + ChatFormatting.GOLD + "Quick Replace " + ChatFormatting.RESET + (
+                EffortlessBuilding.log(player, "Set " + TextFormatting.GOLD + "Quick Replace " + TextFormatting.RESET + (
                         modifierSettings.doQuickReplace() ? "on" : "off"), true);
                 break;
             case OPEN_MODIFIER_SETTINGS:
-				if (player.level.isClientSide)
+                if (player.world.isRemote)
-					ClientEvents.openModifierSettings();
+                    ClientProxy.openModifierSettings();
-				break;
-			case OPEN_PLAYER_SETTINGS:
-				if (player.level.isClientSide)
-					ClientEvents.openPlayerSettings();
                 break;
 
             case NORMAL_SPEED:
@@ -130,63 +175,8 @@ public class ModeOptions {
                 break;
         }
 
-		if (player.level.isClientSide &&
+        if (player.world.isRemote && action != ActionEnum.REPLACE && action != ActionEnum.OPEN_MODIFIER_SETTINGS) {
-			action != ActionEnum.REPLACE &&
+            ClientProxy.logTranslate(action.name);
-			action != ActionEnum.OPEN_MODIFIER_SETTINGS &&
-			action != ActionEnum.OPEN_PLAYER_SETTINGS) {
-
-			EffortlessBuilding.logTranslate(player, "", action.name, "", true);
-		}
-	}
-
-	public enum ActionEnum {
-		UNDO("effortlessbuilding.action.undo"),
-		REDO("effortlessbuilding.action.redo"),
-		REPLACE("effortlessbuilding.action.replace"),
-		OPEN_MODIFIER_SETTINGS("effortlessbuilding.action.open_modifier_settings"),
-		OPEN_PLAYER_SETTINGS("effortlessbuilding.action.open_player_settings"),
-
-		NORMAL_SPEED("effortlessbuilding.action.normal_speed"),
-		FAST_SPEED("effortlessbuilding.action.fast_speed"),
-
-		FULL("effortlessbuilding.action.full"),
-		HOLLOW("effortlessbuilding.action.hollow"),
-
-		CUBE_FULL("effortlessbuilding.action.full"),
-		CUBE_HOLLOW("effortlessbuilding.action.hollow"),
-		CUBE_SKELETON("effortlessbuilding.action.skeleton"),
-
-		SHORT_EDGE("effortlessbuilding.action.short_edge"),
-		LONG_EDGE("effortlessbuilding.action.long_edge"),
-
-		THICKNESS_1("effortlessbuilding.action.thickness_1"),
-		THICKNESS_3("effortlessbuilding.action.thickness_3"),
-		THICKNESS_5("effortlessbuilding.action.thickness_5"),
-
-		CIRCLE_START_CORNER("effortlessbuilding.action.start_corner"),
-		CIRCLE_START_CENTER("effortlessbuilding.action.start_center");
-
-		public String name;
-
-		ActionEnum(String name) {
-			this.name = name;
-		}
-	}
-
-	public enum OptionEnum {
-		BUILD_SPEED("effortlessbuilding.action.build_speed", ActionEnum.NORMAL_SPEED, ActionEnum.FAST_SPEED),
-		FILL("effortlessbuilding.action.filling", ActionEnum.FULL, ActionEnum.HOLLOW),
-		CUBE_FILL("effortlessbuilding.action.filling", ActionEnum.CUBE_FULL, ActionEnum.CUBE_HOLLOW, ActionEnum.CUBE_SKELETON),
-		RAISED_EDGE("effortlessbuilding.action.raised_edge", ActionEnum.SHORT_EDGE, ActionEnum.LONG_EDGE),
-		LINE_THICKNESS("effortlessbuilding.action.thickness", ActionEnum.THICKNESS_1, ActionEnum.THICKNESS_3, ActionEnum.THICKNESS_5),
-		CIRCLE_START("effortlessbuilding.action.circle_start", ActionEnum.CIRCLE_START_CORNER, ActionEnum.CIRCLE_START_CENTER);
-
-		public String name;
-		public ActionEnum[] actions;
-
-		OptionEnum(String name, ActionEnum... actions) {
-			this.name = name;
-			this.actions = actions;
         }
     }
 }

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

@@ -1,61 +1,49 @@
 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
-	@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) {
-		if (modeCapability.isPresent()) {
-			ModeCapabilityManager.IModeCapability capability = modeCapability.orElse(null);
-			if (capability.getModeData() == null){
                 capability.setModeData(new ModeSettings());
             }
             return capability.getModeData();
         }
-
+        throw new IllegalArgumentException("Player does not have modeCapability capability");
-		EffortlessBuilding.logger.warn("Player does not have modeCapability: " + player);
-		//Return dummy settings
-		return new ModeSettings();
     }
 
-	public static void setModeSettings(Player player, ModeSettings modeSettings) {
+    public static void setModeSettings(EntityPlayer player, ModeSettings modeSettings) {
         if (player == null) {
-			EffortlessBuilding.log("Cannot set buildmode settings, player is null");
+            EffortlessBuilding.log("Cannot set buildsettings, player is null");
             return;
         }
-		LazyOptional<ModeCapabilityManager.IModeCapability> modeCapability =
+        if (player.hasCapability(ModeCapabilityManager.modeCapability, null)) {
-			player.getCapability(ModeCapabilityManager.MODE_CAPABILITY, null);
+            ModeCapabilityManager.IModeCapability capability = player.getCapability(
+                    ModeCapabilityManager.modeCapability, null);
 
-		modeCapability.ifPresent((capability) -> {
             capability.setModeData(modeSettings);
 
+            //Initialize new mode
             BuildModes.initializeMode(player);
-		});
+        } else {
-
+            EffortlessBuilding.log(player, "Saving buildsettings failed.");
-		if (!modeCapability.isPresent()) {
-			EffortlessBuilding.log(player, "Saving buildmode settings failed.");
         }
     }
 
-	public static String sanitize(ModeSettings modeSettings, Player player) {
+    public static String sanitize(ModeSettings modeSettings, EntityPlayer player) {
         int maxReach = ReachHelper.getMaxReach(player);
         String error = "";
 
@@ -64,20 +52,8 @@ public class ModeSettingsManager {
         return error;
     }
 
-	public static void handleNewPlayer(Player player) {
-		//Makes sure player has mode settings (if it doesnt it will create it)
-		getModeSettings(player);
-
-		//Only on server
-		if (!player.level.isClientSide) {
-			//Send to client
-			ModeSettingsMessage msg = new ModeSettingsMessage(getModeSettings(player));
-			PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) player), msg);
-		}
-	}
-
     public static class ModeSettings {
-		private BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.DISABLED;
+        private BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.NORMAL;
 
         public ModeSettings() {
         }
@@ -94,4 +70,17 @@ public class ModeSettingsManager {
             this.buildMode = buildMode;
         }
     }
+
+    public static void handleNewPlayer(EntityPlayer player){
+        if (getModeSettings(player) == null) {
+            setModeSettings(player, new ModeSettings());
+        }
+
+        //Only on server
+        if (!player.world.isRemote) {
+            //Send to client
+            ModeSettingsMessage msg = new ModeSettingsMessage(getModeSettings(player));
+            EffortlessBuilding.packetHandler.sendTo(msg, (EntityPlayerMP) player);
+        }
+    }
 }

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

@@ -1,9 +1,11 @@
 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.*;
@@ -11,109 +13,92 @@ import java.util.*;
 public abstract class ThreeClicksBuildMode extends BaseBuildMode {
     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;
-		//X
+            this.lineBound = toLongestLine(this.planeBound, secondPos);
-		Vec3 xBound = BuildModes.findXBound(secondPos.getX(), start, look);
+            this.distToLineSq = this.lineBound.subtract(this.planeBound).lengthSquared();
-		criteriaList.add(new HeightCriteria(xBound, secondPos, start));
+            this.distToPlayerSq = this.planeBound.subtract(start).lengthSquared();
-
-		//Z
-		Vec3 zBound = BuildModes.findZBound(secondPos.getZ(), start, look);
-		criteriaList.add(new HeightCriteria(zBound, secondPos, start));
-
-		//Remove invalid criteria
-		int reach = ReachHelper.getPlacementReach(player) * 4; //4 times as much as normal placement reach
-		criteriaList.removeIf(criteria -> !criteria.isValid(start, look, reach, player, skipRaytrace));
-
-		//If none are valid, return empty list of blocks
-		if (criteriaList.isEmpty()) return null;
-
-		//If only 1 is valid, choose that one
-		HeightCriteria selected = criteriaList.get(0);
-
-		//If multiple are valid, choose based on criteria
-		if (criteriaList.size() > 1) {
-			//Select the one that is closest (from wall position to its line counterpart)
-			for (int i = 1; i < criteriaList.size(); i++) {
-				HeightCriteria criteria = criteriaList.get(i);
-				if (criteria.distToLineSq < 2.0 && selected.distToLineSq < 2.0) {
-					//Both very close to line, choose closest to player
-					if (criteria.distToPlayerSq < selected.distToPlayerSq)
-						selected = criteria;
-				} else {
-					//Pick closest to line
-					if (criteria.distToLineSq < selected.distToLineSq)
-						selected = criteria;
         }
+
+        //Make it from a plane into a line, on y axis only
+        private Vec3d toLongestLine(Vec3d boundVec, BlockPos secondPos) {
+            BlockPos bound = new BlockPos(boundVec);
+            return new Vec3d(secondPos.getX(), bound.getY(), secondPos.getZ());
         }
+
+        //check if its not behind the player and its not too close and not too far
+        //also check if raytrace from player to block does not intersect blocks
+        public boolean isValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace) {
+
+            return BuildModes.isCriteriaValid(start, look, reach, player, skipRaytrace, lineBound, planeBound, distToPlayerSq);
         }
-		return new BlockPos(selected.lineBound);
     }
 
     @Override
-	public void initialize(Player player) {
+    public void initialize(EntityPlayer player) {
         super.initialize(player);
-		secondPosTable.put(player.getUUID(), BlockPos.ZERO);
+        secondPosTable.put(player.getUniqueID(), BlockPos.ORIGIN);
     }
 
     @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<>();
 
-		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++;
-		rightClickTable.put(player.getUUID(), rightClickNr);
+        rightClickTable.put(player.getUniqueID(), rightClickNr);
 
         if (rightClickNr == 1) {
             //If clicking in air, reset and try again
             if (blockPos == null) {
-				rightClickTable.put(player.getUUID(), 0);
+                rightClickTable.put(player.getUniqueID(), 0);
                 return list;
             }
 
             //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
         } else if (rightClickNr == 2) {
             //Second click, find other floor point
-			BlockPos firstPos = firstPosTable.get(player.getUUID());
+            BlockPos firstPos = firstPosTable.get(player.getUniqueID());
             BlockPos secondPos = findSecondPos(player, firstPos, true);
 
             if (secondPos == null) {
-				rightClickTable.put(player.getUUID(), 1);
+                rightClickTable.put(player.getUniqueID(), 1);
                 return list;
             }
 
-			secondPosTable.put(player.getUUID(), secondPos);
+            secondPosTable.put(player.getUniqueID(), secondPos);
 
         } else {
             //Third click, place diagonal wall with height
             list = findCoordinates(player, blockPos, skipRaytrace);
-			rightClickTable.put(player.getUUID(), 0);
+            rightClickTable.put(player.getUniqueID(), 0);
         }
 
         return list;
     }
 
     @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<>();
-		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());
 
         if (rightClickNr == 0) {
             if (blockPos != null)
                 list.add(blockPos);
         } else if (rightClickNr == 1) {
-			BlockPos firstPos = firstPosTable.get(player.getUUID());
+            BlockPos firstPos = firstPosTable.get(player.getUniqueID());
 
             BlockPos secondPos = findSecondPos(player, firstPos, true);
             if (secondPos == null) return list;
@@ -137,8 +122,8 @@ public abstract class ThreeClicksBuildMode extends BaseBuildMode {
             list.addAll(getIntermediateBlocks(player, x1, y1, z1, x2, y2, z2));
 
         } else {
-			BlockPos firstPos = firstPosTable.get(player.getUUID());
+            BlockPos firstPos = firstPosTable.get(player.getUniqueID());
-			BlockPos secondPos = secondPosTable.get(player.getUUID());
+            BlockPos secondPos = secondPosTable.get(player.getUniqueID());
 
             BlockPos thirdPos = findThirdPos(player, firstPos, secondPos, skipRaytrace);
             if (thirdPos == null) return list;
@@ -173,41 +158,58 @@ public abstract class ThreeClicksBuildMode extends BaseBuildMode {
     }
 
     //Finds the place of the second block pos
-	protected abstract BlockPos findSecondPos(Player player, BlockPos firstPos, boolean skipRaytrace);
+    protected abstract BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace);
 
     //Finds the place of the third block pos
-	protected abstract BlockPos findThirdPos(Player player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace);
+    protected abstract BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace);
 
     //After first and second pos are known, we want to visualize the blocks in a way (like floor for cube)
-	protected abstract List<BlockPos> getIntermediateBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2);
+    protected abstract List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2);
 
     //After first, second and third pos are known, we want all the blocks
-	protected abstract List<BlockPos> getFinalBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3);
+    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);
 
-	static class HeightCriteria {
+    //Finds height after floor has been chosen in buildmodes with 3 clicks
-		Vec3 planeBound;
+    public static BlockPos findHeight(EntityPlayer player, BlockPos secondPos, boolean skipRaytrace) {
-		Vec3 lineBound;
+        Vec3d look = player.getLookVec();
-		double distToLineSq;
+        Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
-		double distToPlayerSq;
 
-		HeightCriteria(Vec3 planeBound, BlockPos secondPos, Vec3 start) {
+        List<HeightCriteria> criteriaList = new ArrayList<>(3);
-			this.planeBound = planeBound;
+
-			this.lineBound = toLongestLine(this.planeBound, secondPos);
+        //X
-			this.distToLineSq = this.lineBound.subtract(this.planeBound).lengthSqr();
+        Vec3d xBound = BuildModes.findXBound(secondPos.getX(), start, look);
-			this.distToPlayerSq = this.planeBound.subtract(start).lengthSqr();
+        criteriaList.add(new HeightCriteria(xBound, secondPos, start));
+
+        //Z
+        Vec3d zBound = BuildModes.findZBound(secondPos.getZ(), start, look);
+        criteriaList.add(new HeightCriteria(zBound, secondPos, start));
+
+        //Remove invalid criteria
+        int reach = ReachHelper.getPlacementReach(player) * 4; //4 times as much as normal placement reach
+        criteriaList.removeIf(criteria -> !criteria.isValid(start, look, reach, player, skipRaytrace));
+
+        //If none are valid, return empty list of blocks
+        if (criteriaList.isEmpty()) return null;
+
+        //If only 1 is valid, choose that one
+        HeightCriteria selected = criteriaList.get(0);
+
+        //If multiple are valid, choose based on criteria
+        if (criteriaList.size() > 1) {
+            //Select the one that is closest (from wall position to its line counterpart)
+            for (int i = 1; i < criteriaList.size(); i++) {
+                HeightCriteria criteria = criteriaList.get(i);
+                if (criteria.distToLineSq < 2.0 && selected.distToLineSq < 2.0) {
+                    //Both very close to line, choose closest to player
+                    if (criteria.distToPlayerSq < selected.distToPlayerSq)
+                        selected = criteria;
+                } else {
+                    //Pick closest to line
+                    if (criteria.distToLineSq < selected.distToLineSq)
+                        selected = criteria;
                 }
-
-		//Make it from a plane into a line, on y axis only
-		private Vec3 toLongestLine(Vec3 boundVec, BlockPos secondPos) {
-			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
-		//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, lineBound, planeBound, distToPlayerSq);
         }
+        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;
@@ -14,41 +14,41 @@ import java.util.UUID;
 public abstract class TwoClicksBuildMode extends BaseBuildMode {
 
     @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<>();
 
-		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++;
-		rightClickTable.put(player.getUUID(), rightClickNr);
+        rightClickTable.put(player.getUniqueID(), rightClickNr);
 
         if (rightClickNr == 1) {
             //If clicking in air, reset and try again
             if (blockPos == null) {
-				rightClickTable.put(player.getUUID(), 0);
+                rightClickTable.put(player.getUniqueID(), 0);
                 return list;
             }
 
             //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
         } else {
             //Second click, place blocks
             list = findCoordinates(player, blockPos, skipRaytrace);
-			rightClickTable.put(player.getUUID(), 0);
+            rightClickTable.put(player.getUniqueID(), 0);
         }
 
         return list;
     }
 
     @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<>();
-		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 (blockPos != null)
@@ -79,8 +79,8 @@ public abstract class TwoClicksBuildMode extends BaseBuildMode {
     }
 
     //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
-	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,17 +1,26 @@
 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
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    protected List<BlockPos> getAllBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return getCircleBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    public static List<BlockPos> getCircleBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
         List<BlockPos> list = new ArrayList<>();
 
         float centerX = x1;
@@ -26,8 +35,8 @@ public class Circle extends TwoClicksBuildMode {
             z1 = (int) (centerZ - (z2 - centerZ));
         }
 
-		float radiusX = Mth.abs(x2 - centerX);
+        float radiusX = MathHelper.abs(x2 - centerX);
-		float radiusZ = Mth.abs(z2 - centerZ);
+        float radiusZ = MathHelper.abs(z2 - centerZ);
 
         if (ModeOptions.getFill() == ModeOptions.ActionEnum.FULL)
             addCircleBlocks(list, x1, y1, z1, x2, y2, z2, centerX, centerZ, radiusX, radiusZ);
@@ -66,24 +75,14 @@ public class Circle extends TwoClicksBuildMode {
     }
 
     private static float distance(float x1, float z1, float x2, float z2) {
-		return Mth.sqrt((x2 - x1) * (x2 - x1) + (z2 - z1) * (z2 - z1));
+        return MathHelper.sqrt((x2 - x1) * (x2 - x1) + (z2 - z1) * (z2 - z1));
     }
 
     public static float calculateEllipseRadius(float centerX, float centerZ, float radiusX, float radiusZ, int x, int z) {
         //https://math.stackexchange.com/questions/432902/how-to-get-the-radius-of-an-ellipse-at-a-specific-angle-by-knowing-its-semi-majo
-		float theta = (float) Mth.atan2(z - centerZ, x - centerX);
+        float theta = (float) MathHelper.atan2(z - centerZ, x - centerX);
-		float part1 = radiusX * radiusX * Mth.sin(theta) * Mth.sin(theta);
+        float part1 = radiusX * radiusX * MathHelper.sin(theta) * MathHelper.sin(theta);
-		float part2 = radiusZ * radiusZ * Mth.cos(theta) * Mth.cos(theta);
+        float part2 = radiusZ * radiusZ * MathHelper.cos(theta) * MathHelper.cos(theta);
-		return radiusX * radiusZ / Mth.sqrt(part1 + part2);
+        return radiusX * radiusZ / MathHelper.sqrt(part1 + part2);
-	}
-
-	@Override
-	protected BlockPos findSecondPos(Player player, BlockPos firstPos, boolean skipRaytrace) {
-		return Floor.findFloor(player, firstPos, skipRaytrace);
-	}
-
-	@Override
-	protected List<BlockPos> getAllBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2) {
-		return getCircleBlocks(player, x1, y1, z1, x2, y2, z2);
     }
 }

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,16 +1,39 @@
 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
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    protected BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    protected List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return getFloorBlocksUsingCubeFill(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    @Override
+    protected List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        return getCubeBlocks(player, x1, y1, z1, x3, y3, z3);
+    }
+
+    public static List<BlockPos> getFloorBlocksUsingCubeFill(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
         List<BlockPos> list = new ArrayList<>();
 
         if (ModeOptions.getCubeFill() == ModeOptions.ActionEnum.CUBE_SKELETON)
@@ -21,7 +44,7 @@ public class Cube extends ThreeClicksBuildMode {
         return list;
     }
 
-	public static List<BlockPos> getCubeBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2) {
+    public static List<BlockPos> getCubeBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
         List<BlockPos> list = new ArrayList<>();
 
         switch (ModeOptions.getCubeFill()) {
@@ -78,24 +101,4 @@ public class Cube extends ThreeClicksBuildMode {
         Line.addZLineBlocks(list, z1, z2, x2, y1);
         Line.addZLineBlocks(list, z1, z2, x2, y2);
     }
-
-	@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 getFloorBlocksUsingCubeFill(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) {
-		return getCubeBlocks(player, x1, y1, z1, x3, y3, z3);
-	}
 }

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,7 +9,27 @@ 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
+    public BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    public BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    public List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return Circle.getCircleBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    @Override
+    public List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        return getCylinderBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
+    }
+
+    public static List<BlockPos> getCylinderBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
         List<BlockPos> list = new ArrayList<>();
 
         //Get circle blocks (using CIRCLE_START and FILL options built-in)
@@ -27,24 +47,4 @@ public class Cylinder extends ThreeClicksBuildMode {
 
         return list;
     }
-
-	@Override
-	public BlockPos findSecondPos(Player player, BlockPos firstPos, boolean skipRaytrace) {
-		return Floor.findFloor(player, firstPos, skipRaytrace);
-	}
-
-	@Override
-	public BlockPos findThirdPos(Player player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
-		return findHeight(player, secondPos, skipRaytrace);
-	}
-
-	@Override
-	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
-	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,25 +1,48 @@
 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 {
 
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    protected BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    protected List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
         //Add diagonal line from first to second
-	public static List<BlockPos> getDiagonalLineBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2, float sampleMultiplier) {
+        return getDiagonalLineBlocks(player, x1, y1, z1, x2, y2, z2, 10);
+    }
+
+    @Override
+    protected List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        //Add diagonal line from first to third
+        return getDiagonalLineBlocks(player, x1, y1, z1, x3, y3, z3, 10);
+    }
+
+    //Add diagonal line from first to second
+    public static List<BlockPos> getDiagonalLineBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, float sampleMultiplier) {
         List<BlockPos> list = new ArrayList<>();
 
-		Vec3 first = new Vec3(x1, y1, z1).add(0.5, 0.5, 0.5);
+        Vec3d first = new Vec3d(x1, y1, z1).add(0.5, 0.5, 0.5);
-		Vec3 second = new Vec3(x2, y2, z2).add(0.5, 0.5, 0.5);
+        Vec3d second = new Vec3d(x2, y2, z2).add(0.5, 0.5, 0.5);
 
         int iterations = (int) Math.ceil(first.distanceTo(second) * sampleMultiplier);
-		for (double t = 0; t <= 1.0; t += 1.0 / iterations) {
+        for (double t = 0; t <= 1.0; t += 1.0/iterations) {
-			Vec3 lerp = first.add(second.subtract(first).scale(t));
+            Vec3d lerp = first.add(second.subtract(first).scale(t));
             BlockPos candidate = new BlockPos(lerp);
             //Only add if not equal to the last in the list
             if (list.isEmpty() || !list.get(list.size() - 1).equals(candidate))
@@ -28,26 +51,4 @@ public class DiagonalLine extends ThreeClicksBuildMode {
 
         return list;
     }
-
-	@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) {
-		//Add diagonal line from first to second
-		return getDiagonalLineBlocks(player, x1, y1, z1, x2, y2, z2, 10);
-	}
-
-	@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) {
-		//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,16 +1,37 @@
 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 {
 
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    protected BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    protected List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return DiagonalLine.getDiagonalLineBlocks(player, x1, y1, z1, x2, y2, z2, 1);
+    }
+
+    @Override
+    protected List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        return getDiagonalWallBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
+    }
+
     //Add diagonal wall from first to second
-	public static List<BlockPos> getDiagonalWallBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+    public static List<BlockPos> getDiagonalWallBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
         List<BlockPos> list = new ArrayList<>();
 
         //Get diagonal line blocks
@@ -28,24 +49,4 @@ public class DiagonalWall extends ThreeClicksBuildMode {
 
         return list;
     }
-
-	@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 DiagonalLine.getDiagonalLineBlocks(player, x1, y1, z1, x2, y2, z2, 1);
-	}
-
-	@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) {
-		return getDiagonalWallBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
-	}
 }

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

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

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,26 +1,47 @@
 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;
+
+        Criteria(Vec3d planeBound, Vec3d start) {
+            this.planeBound = planeBound;
+            this.distToPlayerSq = this.planeBound.subtract(start).lengthSquared();
+        }
+
+        //check if its not behind the player and its not too close and not too far
+        //also check if raytrace from player to block does not intersect blocks
+        public boolean isValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace) {
+
+            return BuildModes.isCriteriaValid(start, look, reach, player, skipRaytrace, planeBound, planeBound, distToPlayerSq);
+        }
+    }
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return findFloor(player, firstPos, skipRaytrace);
+    }
+
+    public static BlockPos findFloor(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        Vec3d look = player.getLookVec();
+        Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
 
         List<Criteria> criteriaList = new ArrayList<>(3);
 
         //Y
-		Vec3 yBound = BuildModes.findYBound(firstPos.getY(), start, look);
+        Vec3d yBound = BuildModes.findYBound(firstPos.getY(), start, look);
         criteriaList.add(new Criteria(yBound, start));
 
         //Remove invalid criteria
@@ -36,7 +57,12 @@ public class Floor extends TwoClicksBuildMode {
         return new BlockPos(selected.planeBound);
     }
 
-	public static List<BlockPos> getFloorBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2) {
+    @Override
+    protected List<BlockPos> getAllBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return getFloorBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    public static List<BlockPos> getFloorBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
         List<BlockPos> list = new ArrayList<>();
 
         if (ModeOptions.getFill() == ModeOptions.ActionEnum.FULL)
@@ -64,31 +90,4 @@ public class Floor extends TwoClicksBuildMode {
         Line.addZLineBlocks(list, z1, z2, x1, y);
         Line.addZLineBlocks(list, z1, z2, x2, y);
     }
-
-	@Override
-	protected BlockPos findSecondPos(Player player, BlockPos firstPos, boolean skipRaytrace) {
-		return findFloor(player, firstPos, skipRaytrace);
-	}
-
-	@Override
-	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 {
-		Vec3 planeBound;
-		double distToPlayerSq;
-
-		Criteria(Vec3 planeBound, Vec3 start) {
-			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
-		//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);
-		}
-	}
 }

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,22 +12,69 @@ 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;
+
+        Criteria(Vec3d planeBound, BlockPos firstPos, Vec3d start) {
+            this.planeBound = planeBound;
+            this.lineBound = toLongestLine(this.planeBound, firstPos);
+            this.distToLineSq = this.lineBound.subtract(this.planeBound).lengthSquared();
+            this.distToPlayerSq = this.planeBound.subtract(start).lengthSquared();
+        }
+
+        //Make it from a plane into a line
+        //Select the axis that is longest
+        private Vec3d toLongestLine(Vec3d boundVec, BlockPos firstPos) {
+            BlockPos bound = new BlockPos(boundVec);
+
+            BlockPos firstToSecond = bound.subtract(firstPos);
+            firstToSecond = new BlockPos(Math.abs(firstToSecond.getX()), Math.abs(firstToSecond.getY()), Math.abs(firstToSecond.getZ()));
+            int longest = Math.max(firstToSecond.getX(), Math.max(firstToSecond.getY(), firstToSecond.getZ()));
+            if (longest == firstToSecond.getX()) {
+                return new Vec3d(bound.getX(), firstPos.getY(), firstPos.getZ());
+            }
+            if (longest == firstToSecond.getY()) {
+                return new Vec3d(firstPos.getX(), bound.getY(), firstPos.getZ());
+            }
+            if (longest == firstToSecond.getZ()) {
+                return new Vec3d(firstPos.getX(), firstPos.getY(), bound.getZ());
+            }
+            return null;
+        }
+
+        //check if its not behind the player and its not too close and not too far
+        //also check if raytrace from player to block does not intersect blocks
+        public boolean isValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace) {
+
+            return BuildModes.isCriteriaValid(start, look, reach, player, skipRaytrace, lineBound, planeBound, distToPlayerSq);
+        }
+
+    }
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return findLine(player, firstPos, skipRaytrace);
+    }
+
+    public static BlockPos findLine(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        Vec3d look = player.getLookVec();
+        Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
 
         List<Criteria> criteriaList = new ArrayList<>(3);
 
         //X
-		Vec3 xBound = BuildModes.findXBound(firstPos.getX(), start, look);
+        Vec3d xBound = BuildModes.findXBound(firstPos.getX(), start, look);
         criteriaList.add(new Criteria(xBound, firstPos, start));
 
         //Y
-		Vec3 yBound = BuildModes.findYBound(firstPos.getY(), start, look);
+        Vec3d yBound = BuildModes.findYBound(firstPos.getY(), start, look);
         criteriaList.add(new Criteria(yBound, firstPos, start));
 
         //Z
-		Vec3 zBound = BuildModes.findZBound(firstPos.getZ(), start, look);
+        Vec3d zBound = BuildModes.findZBound(firstPos.getZ(), start, look);
         criteriaList.add(new Criteria(zBound, firstPos, start));
 
         //Remove invalid criteria
@@ -61,7 +108,12 @@ public class Line extends TwoClicksBuildMode {
         return new BlockPos(selected.lineBound);
     }
 
-	public static List<BlockPos> getLineBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2) {
+    @Override
+    protected List<BlockPos> getAllBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return getLineBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    public static List<BlockPos> getLineBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
         List<BlockPos> list = new ArrayList<>();
 
         if (x1 != x2) {
@@ -92,56 +144,4 @@ public class Line extends TwoClicksBuildMode {
             list.add(new BlockPos(x, y, z));
         }
     }
-
-	@Override
-	protected BlockPos findSecondPos(Player player, BlockPos firstPos, boolean skipRaytrace) {
-		return findLine(player, firstPos, skipRaytrace);
-	}
-
-	@Override
-	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 {
-		Vec3 planeBound;
-		Vec3 lineBound;
-		double distToLineSq;
-		double distToPlayerSq;
-
-		Criteria(Vec3 planeBound, BlockPos firstPos, Vec3 start) {
-			this.planeBound = planeBound;
-			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
-		//Select the axis that is longest
-		private Vec3 toLongestLine(Vec3 boundVec, BlockPos firstPos) {
-			BlockPos bound = new BlockPos(boundVec);
-
-			BlockPos firstToSecond = bound.subtract(firstPos);
-			firstToSecond = new BlockPos(Math.abs(firstToSecond.getX()), Math.abs(firstToSecond.getY()), Math.abs(firstToSecond.getZ()));
-			int longest = Math.max(firstToSecond.getX(), Math.max(firstToSecond.getY(), firstToSecond.getZ()));
-			if (longest == firstToSecond.getX()) {
-				return new 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
-		//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, lineBound, planeBound, distToPlayerSq);
-		}
-
-	}
 }

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

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

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

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

src/main/java/nl/requios/effortlessbuilding/buildmode/buildmodes/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/Single.java

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

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,8 +11,28 @@ import java.util.List;
 
 public class SlopeFloor extends ThreeClicksBuildMode {
 
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    protected BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    protected List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return Floor.getFloorBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    @Override
+    protected List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        return getSlopeFloorBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
+    }
+
     //Add slope floor from first to second
-	public static List<BlockPos> getSlopeFloorBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+    public static List<BlockPos> getSlopeFloorBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
         List<BlockPos> list = new ArrayList<>();
 
         int axisLimit = ReachHelper.getMaxBlocksPerAxis(player);
@@ -72,24 +92,4 @@ public class SlopeFloor extends ThreeClicksBuildMode {
 
         return list;
     }
-
-	@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) {
-		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,7 +11,27 @@ 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
+    public BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return Floor.findFloor(player, firstPos, skipRaytrace);
+    }
+
+    @Override
+    public BlockPos findThirdPos(EntityPlayer player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
+        return findHeight(player, secondPos, skipRaytrace);
+    }
+
+    @Override
+    public List<BlockPos> getIntermediateBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return Circle.getCircleBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    @Override
+    public List<BlockPos> getFinalBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
+        return getSphereBlocks(player, x1, y1, z1, x2, y2, z2, x3, y3, z3);
+    }
+
+    public static List<BlockPos> getSphereBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2, int x3, int y3, int z3) {
         List<BlockPos> list = new ArrayList<>();
 
         float centerX = x1;
@@ -29,9 +49,9 @@ public class Sphere extends ThreeClicksBuildMode {
             z1 = (int) (centerZ - (z2 - centerZ));
         }
 
-		float radiusX = Mth.abs(x2 - centerX);
+        float radiusX = MathHelper.abs(x2 - centerX);
-		float radiusY = Mth.abs(y3 - centerY);
+        float radiusY = MathHelper.abs(y3 - centerY);
-		float radiusZ = Mth.abs(z2 - centerZ);
+        float radiusZ = MathHelper.abs(z2 - centerZ);
 
         if (ModeOptions.getFill() == ModeOptions.ActionEnum.FULL)
             addSphereBlocks(list, x1, y1, z1, x3, y3, z3, centerX, centerY, centerZ, radiusX, radiusY, radiusZ);
@@ -76,7 +96,7 @@ public class Sphere extends ThreeClicksBuildMode {
     }
 
     private static float distance(float x1, float y1, float z1, float x2, float y2, float z2) {
-		return Mth.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) + (z2 - z1) * (z2 - z1));
+        return MathHelper.sqrt((x2 - x1) * (x2 - x1) + (y2 - y1) * (y2 - y1) + (z2 - z1) * (z2 - z1));
     }
 
     public static float calculateSpheroidRadius(float centerX, float centerY, float centerZ, float radiusX, float radiusY, float radiusZ, int x, int y, int z) {
@@ -87,24 +107,4 @@ public class Sphere extends ThreeClicksBuildMode {
 
         return Circle.calculateEllipseRadius(centerX, centerY, radiusXZ, radiusY, x, y);
     }
-
-	@Override
-	public BlockPos findSecondPos(Player player, BlockPos firstPos, boolean skipRaytrace) {
-		return Floor.findFloor(player, firstPos, skipRaytrace);
-	}
-
-	@Override
-	public BlockPos findThirdPos(Player player, BlockPos firstPos, BlockPos secondPos, boolean skipRaytrace) {
-		return findHeight(player, secondPos, skipRaytrace);
-	}
-
-	@Override
-	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
-	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,30 +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.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;
+
+        Criteria(Vec3d planeBound, BlockPos firstPos, Vec3d start, Vec3d look) {
+            this.planeBound = planeBound;
+            this.distToPlayerSq = this.planeBound.subtract(start).lengthSquared();
+            Vec3d wall = this.planeBound.subtract(new Vec3d(firstPos));
+            this.angle = wall.x * look.x + wall.z * look.z; //dot product ignoring y (looking up/down should not affect this angle)
+        }
+
+        //check if its not behind the player and its not too close and not too far
+        //also check if raytrace from player to block does not intersect blocks
+        public boolean isValid(Vec3d start, Vec3d look, int reach, EntityPlayer player, boolean skipRaytrace) {
+
+            return BuildModes.isCriteriaValid(start, look, reach, player, skipRaytrace, planeBound, planeBound, distToPlayerSq);
+        }
+    }
+
+    @Override
+    protected BlockPos findSecondPos(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        return findWall(player, firstPos, skipRaytrace);
+    }
+
+    public static BlockPos findWall(EntityPlayer player, BlockPos firstPos, boolean skipRaytrace) {
+        Vec3d look = player.getLookVec();
+        Vec3d start = new Vec3d(player.posX, player.posY + player.getEyeHeight(), player.posZ);
 
         List<Criteria> criteriaList = new ArrayList<>(3);
 
         //X
-		Vec3 xBound = BuildModes.findXBound(firstPos.getX(), start, look);
+        Vec3d xBound = BuildModes.findXBound(firstPos.getX(), start, look);
         criteriaList.add(new Criteria(xBound, firstPos, start, look));
 
         //Z
-		Vec3 zBound = BuildModes.findZBound(firstPos.getZ(), start, look);
+        Vec3d zBound = BuildModes.findZBound(firstPos.getZ(), start, look);
         criteriaList.add(new Criteria(zBound, firstPos, start, look));
 
         //Remove invalid criteria
@@ -51,7 +75,12 @@ public class Wall extends TwoClicksBuildMode {
         return new BlockPos(selected.planeBound);
     }
 
-	public static List<BlockPos> getWallBlocks(Player player, int x1, int y1, int z1, int x2, int y2, int z2) {
+    @Override
+    protected List<BlockPos> getAllBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
+        return getWallBlocks(player, x1, y1, z1, x2, y2, z2);
+    }
+
+    public static List<BlockPos> getWallBlocks(EntityPlayer player, int x1, int y1, int z1, int x2, int y2, int z2) {
         List<BlockPos> list = new ArrayList<>();
 
         if (x1 == x2) {
@@ -102,34 +131,4 @@ public class Wall extends TwoClicksBuildMode {
         Line.addYLineBlocks(list, y1, y2, x1, z);
         Line.addYLineBlocks(list, y1, y2, x2, z);
     }
-
-	@Override
-	protected BlockPos findSecondPos(Player player, BlockPos firstPos, boolean skipRaytrace) {
-		return findWall(player, firstPos, skipRaytrace);
-	}
-
-	@Override
-	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 {
-		Vec3 planeBound;
-		double distToPlayerSq;
-		double angle;
-
-		Criteria(Vec3 planeBound, BlockPos firstPos, Vec3 start, Vec3 look) {
-			this.planeBound = planeBound;
-			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
-		//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);
-		}
-	}
 }

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

@@ -1,84 +1,24 @@
 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<>();
-
-		//find arraysettings for the player
-		ArraySettings a = ModifierSettingsManager.getModifierSettings(player).getArraySettings();
-		if (!isEnabled(a)) return coordinates;
-
-		BlockPos pos = startPos;
-		Vec3i offset = new Vec3i(a.offset.getX(), a.offset.getY(), a.offset.getZ());
-
-		for (int i = 0; i < a.count; i++) {
-			pos = pos.offset(offset);
-			coordinates.add(pos);
-		}
-
-		return coordinates;
-	}
-
-	public static List<BlockState> findBlockStates(Player player, BlockPos startPos, BlockState blockState, ItemStack itemStack, List<ItemStack> itemStacks) {
-		List<BlockState> blockStates = new ArrayList<>();
-
-		//find arraysettings for the player that placed the block
-		ArraySettings a = ModifierSettingsManager.getModifierSettings(player).getArraySettings();
-		if (!isEnabled(a)) return blockStates;
-
-		BlockPos pos = startPos;
-		Vec3i offset = new Vec3i(a.offset.getX(), a.offset.getY(), a.offset.getZ());
-
-		//Randomizer bag synergy
-		AbstractRandomizerBagItem randomizerBagItem = null;
-		IItemHandler bagInventory = null;
-		if (!itemStack.isEmpty() && itemStack.getItem() instanceof AbstractRandomizerBagItem) {
-			randomizerBagItem = (AbstractRandomizerBagItem) itemStack.getItem() ;
-			bagInventory = randomizerBagItem.getBagInventory(itemStack);
-		}
-
-		for (int i = 0; i < a.count; i++) {
-			pos = pos.offset(offset);
-
-			//Randomizer bag synergy
-			if (randomizerBagItem != null) {
-				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, )
-			blockStates.add(blockState);
-			itemStacks.add(itemStack);
-		}
-
-		return blockStates;
-	}
-
-	public static boolean isEnabled(ArraySettings a) {
-		if (a == null || !a.enabled) return false;
-
-		return a.offset.getX() != 0 || a.offset.getY() != 0 || a.offset.getZ() != 0;
-	}
-
-	public static class ArraySettings {
         public boolean enabled = false;
-		public BlockPos offset = BlockPos.ZERO;
+        public BlockPos offset = BlockPos.ORIGIN;
         public int count = 5;
 
         public ArraySettings() {
@@ -101,4 +41,64 @@ public class Array {
         }
     }
 
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos startPos) {
+        List<BlockPos> coordinates = new ArrayList<>();
+
+        //find arraysettings for the player
+        ArraySettings a = ModifierSettingsManager.getModifierSettings(player).getArraySettings();
+        if (!isEnabled(a)) return coordinates;
+
+        BlockPos pos = startPos;
+        Vec3i offset = new Vec3i(a.offset.getX(), a.offset.getY(), a.offset.getZ());
+
+        for (int i = 0; i < a.count; i++) {
+            pos = pos.add(offset);
+            coordinates.add(pos);
+        }
+
+        return coordinates;
+    }
+
+    public static List<IBlockState> findBlockStates(EntityPlayer player, BlockPos startPos, IBlockState blockState, ItemStack itemStack, List<ItemStack> itemStacks) {
+        List<IBlockState> blockStates = new ArrayList<>();
+
+        //find arraysettings for the player that placed the block
+        ArraySettings a = ModifierSettingsManager.getModifierSettings(player).getArraySettings();
+        if (!isEnabled(a)) return blockStates;
+
+        BlockPos pos = startPos;
+        Vec3i offset = new Vec3i(a.offset.getX(), a.offset.getY(), a.offset.getZ());
+
+        //Randomizer bag synergy
+        IItemHandler bagInventory = null;
+        if (!itemStack.isEmpty() && itemStack.getItem() instanceof ItemRandomizerBag) {
+            bagInventory = ItemRandomizerBag.getBagInventory(itemStack);
+        }
+
+        for (int i = 0; i < a.count; i++) {
+            pos = pos.add(offset);
+
+            //Randomizer bag synergy
+            if (bagInventory != null) {
+                itemStack = ItemRandomizerBag.pickRandomStack(bagInventory);
+                blockState = BuildModifiers
+                        .getBlockStateFromItem(itemStack, player, startPos, EnumFacing.UP, new Vec3d(0, 0, 0), EnumHand.MAIN_HAND);
+            }
+
+            //blockState = blockState.getBlock().getStateForPlacement(player.world, pos, )
+            blockStates.add(blockState);
+            itemStacks.add(itemStack);
+        }
+
+        return blockStates;
+    }
+
+    public static boolean isEnabled(ArraySettings a) {
+        if (a == null || !a.enabled) return false;
+
+        if (a.offset.getX() == 0 && a.offset.getY() == 0 && a.offset.getZ() == 0) return false;
+
+        return true;
+    }
+
 }

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

@@ -1,20 +1,20 @@
 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) {
         this.coordinates = coordinates;
         this.previousBlockStates = previousBlockStates;
@@ -28,15 +28,15 @@ public class BlockSet {
         return coordinates;
     }
 
-	public List<BlockState> getPreviousBlockStates() {
+    public List<IBlockState> getPreviousBlockStates() {
         return previousBlockStates;
     }
 
-	public List<BlockState> getNewBlockStates() {
+    public List<IBlockState> getNewBlockStates() {
         return newBlockStates;
     }
 
-	public Vec3 getHitVec() {
+    public Vec3d getHitVec() {
         return hitVec;
     }
 

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

@@ -1,96 +1,128 @@
 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.CommonConfig;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.compatibility.CompatHelper;
-import nl.requios.effortlessbuilding.helper.DelayedBlockPlacer;
+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.BlockPreviews;
+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
-	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
-		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
         List<BlockPos> coordinates = findCoordinates(player, startCoordinates);
         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
         if (blockStates.size() == 0 || coordinates.size() != blockStates.size()) return;
 
-		if (world.isClientSide) {
+        //remember previous blockstates for undo
+        List<IBlockState> previousBlockStates = new ArrayList<>(coordinates.size());
+        List<IBlockState> newBlockStates = new ArrayList<>(coordinates.size());
+        for (BlockPos coordinate : coordinates) {
+            previousBlockStates.add(world.getBlockState(coordinate));
+        }
 
-			BlockPreviews.onBlocksPlaced();
+        if (world.isRemote) {
+
+            BlockPreviewRenderer.onBlocksPlaced();
+
+            newBlockStates = blockStates;
 
         } else {
 
-			int delay = CommonConfig.visuals.appearAnimationLength.get() * 3 - 3; //DelayedBlockPlacer is called 3 times per tick?
+            //place blocks
+            for (int i = placeStartPos ? 0 : 1; i < coordinates.size(); i++) {
+                BlockPos blockPos = coordinates.get(i);
+                IBlockState blockState = blockStates.get(i);
+                ItemStack itemStack = itemStacks.get(i);
 
-			//place blocks after delay
+                if (world.isBlockLoaded(blockPos, true)) {
-			EffortlessBuilding.DELAYED_BLOCK_PLACER.placeBlocksDelayed(new DelayedBlockPlacer.Entry(world, player, coordinates,
+                    //check itemstack empty
-					blockStates, itemStacks, hitVec, placeStartPos, delay));
+                    if (itemStack.isEmpty()) {
+                        //try to find new stack, otherwise continue
+                        itemStack = InventoryHelper.findItemStackInInventory(player, blockState.getBlock());
+                        if (itemStack.isEmpty()) continue;
+                    }
+                    SurvivalHelper.placeBlock(world, player, blockPos, blockState, itemStack, EnumFacing.UP, hitVec, false, false, false);
                 }
             }
 
-	public static void onBlockBroken(Player player, List<BlockPos> startCoordinates, boolean breakStartPos) {
+            //find actual new blockstates for undo
-		Level world = player.level;
+            for (BlockPos coordinate : coordinates) {
+                newBlockStates.add(world.getBlockState(coordinate));
+            }
+        }
+
+        //Set first previousBlockState to empty if in NORMAL mode, to make undo/redo work
+        //(Block is placed by the time it gets here, and unplaced after this)
+        if (!placeStartPos) previousBlockStates.set(0, Blocks.AIR.getDefaultState());
+
+        //If all new blockstates are air then no use in adding it, no block was actually placed
+        //Can happen when e.g. placing one block in yourself
+        if (Collections.frequency(newBlockStates, Blocks.AIR.getDefaultState()) != newBlockStates.size()) {
+            //add to undo stack
+            BlockPos firstPos = startCoordinates.get(0);
+            BlockPos secondPos = startCoordinates.get(startCoordinates.size() - 1);
+            UndoRedo.addUndo(player, new BlockSet(coordinates, previousBlockStates, newBlockStates, hitVec, firstPos, secondPos));
+        }
+
+    }
+
+    public static void onBlockBroken(EntityPlayer player, List<BlockPos> startCoordinates, boolean breakStartPos) {
+        World world = player.world;
 
         List<BlockPos> coordinates = findCoordinates(player, startCoordinates);
 
         if (coordinates.isEmpty()) return;
 
         //remember previous blockstates for undo
-		List<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) {
             previousBlockStates.add(world.getBlockState(coordinate));
         }
 
-		if (world.isClientSide) {
+        if (world.isRemote) {
-			BlockPreviews.onBlocksBroken();
+            BlockPreviewRenderer.onBlocksBroken();
 
             //list of air blockstates
-			for (int i = 0; i < coordinates.size(); i++) {
+            for (BlockPos coordinate : coordinates) {
-				newBlockStates.add(Blocks.AIR.defaultBlockState());
+                newBlockStates.add(Blocks.AIR.getDefaultState());
             }
 
         } else {
 
             //If the player is going to instabreak grass or a plant, only break other instabreaking things
             boolean onlyInstaBreaking = !player.isCreative() &&
-				world.getBlockState(startCoordinates.get(0)).getDestroySpeed(world, startCoordinates.get(0)) == 0f;
+                                        world.getBlockState(startCoordinates.get(0)).getBlockHardness(world, startCoordinates.get(0)) == 0f;
 
             //break all those blocks
             for (int i = breakStartPos ? 0 : 1; i < coordinates.size(); i++) {
                 BlockPos coordinate = coordinates.get(i);
-				if (world.isLoaded(coordinate) && !world.isEmptyBlock(coordinate)) {
+                if (world.isBlockLoaded(coordinate, false)) {
-					if (!onlyInstaBreaking || world.getBlockState(coordinate).getDestroySpeed(world, coordinate) == 0f) {
+                    if (!onlyInstaBreaking || world.getBlockState(coordinate).getBlockHardness(world, coordinate) == 0f) {
                         SurvivalHelper.breakBlock(world, player, coordinate, false);
                     }
                 }
@@ -104,17 +136,17 @@ public class BuildModifiers {
 
         //Set first newBlockState to empty if in NORMAL mode, to make undo/redo work
         //(Block isn't broken yet by the time it gets here, and broken after this)
-		if (!breakStartPos) newBlockStates.set(0, Blocks.AIR.defaultBlockState());
+        if (!breakStartPos) newBlockStates.set(0, Blocks.AIR.getDefaultState());
 
         //add to undo stack
         BlockPos firstPos = startCoordinates.get(0);
         BlockPos secondPos = startCoordinates.get(startCoordinates.size() - 1);
-		Vec3 hitVec = new Vec3(0.5, 0.5, 0.5);
+        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) {
+    public static List<BlockPos> findCoordinates(EntityPlayer player, List<BlockPos> posList) {
         List<BlockPos> coordinates = new ArrayList<>();
         //Add current blocks being placed too
         coordinates.addAll(posList);
@@ -135,18 +167,18 @@ public class BuildModifiers {
         return coordinates;
     }
 
-	public static List<BlockPos> findCoordinates(Player player, BlockPos blockPos) {
+    public static List<BlockPos> findCoordinates(EntityPlayer player, BlockPos blockPos) {
-		return findCoordinates(player, new ArrayList<>(Collections.singletonList(blockPos)));
+        return findCoordinates(player, new ArrayList<>(Arrays.asList(blockPos)));
     }
 
-	public static List<BlockState> findBlockStates(Player player, List<BlockPos> posList, Vec3 hitVec, Direction facing, List<ItemStack> itemStacks) {
+    public static List<IBlockState> findBlockStates(EntityPlayer player, List<BlockPos> posList, Vec3d hitVec, EnumFacing facing, List<ItemStack> itemStacks) {
-		List<BlockState> blockStates = new ArrayList<>();
+        List<IBlockState> blockStates = new ArrayList<>();
         itemStacks.clear();
 
         //Get itemstack
-		ItemStack itemStack = player.getItemInHand(InteractionHand.MAIN_HAND);
+        ItemStack itemStack = player.getHeldItem(EnumHand.MAIN_HAND);
         if (itemStack.isEmpty() || !CompatHelper.isItemBlockProxy(itemStack)) {
-			itemStack = player.getItemInHand(InteractionHand.OFF_HAND);
+            itemStack = player.getHeldItem(EnumHand.OFF_HAND);
         }
         if (itemStack.isEmpty() || !CompatHelper.isItemBlockProxy(itemStack)) {
             return blockStates;
@@ -154,25 +186,22 @@ public class BuildModifiers {
 
         //Get ItemBlock stack
         ItemStack itemBlock = ItemStack.EMPTY;
-		if (itemStack.getItem() instanceof BlockItem) itemBlock = itemStack;
+        if (itemStack.getItem() instanceof ItemBlock) itemBlock = itemStack;
         else itemBlock = CompatHelper.getItemBlockFromStack(itemStack);
-		AbstractRandomizerBagItem.resetRandomness();
+        ItemRandomizerBag.resetRandomness();
 
         //Add blocks in posList first
         for (BlockPos blockPos : posList) {
-			if (!(itemStack.getItem() instanceof BlockItem)) itemBlock = CompatHelper.getItemBlockFromStack(itemStack);
+            if (!(itemStack.getItem() instanceof ItemBlock)) itemBlock = CompatHelper.getItemBlockFromStack(itemStack);
-			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;
-
             blockStates.add(blockState);
             itemStacks.add(itemBlock);
         }
 
         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(Mirror.findBlockStates(player, blockPos, blockState, itemStack, itemStacks));
             blockStates.addAll(RadialMirror.findBlockStates(player, blockPos, blockState, itemStack, itemStacks));
@@ -180,9 +209,7 @@ public class BuildModifiers {
             List<BlockPos> arrayCoordinates = Array.findCoordinates(player, blockPos);
             for (int i = 0; i < arrayCoordinates.size(); 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));
             }
@@ -201,15 +228,15 @@ public class BuildModifiers {
     }
 
     public static boolean isEnabled(ModifierSettingsManager.ModifierSettings modifierSettings, BlockPos startPos) {
-		//startPos can be null
         return Mirror.isEnabled(modifierSettings.getMirrorSettings(), startPos) ||
                Array.isEnabled(modifierSettings.getArraySettings()) ||
                RadialMirror.isEnabled(modifierSettings.getRadialMirrorSettings(), startPos) ||
                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)
@@ -218,8 +245,8 @@ public class BuildModifiers {
         if (coordinates1 == null || coordinates2 == null) return false;
 
         //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 true;

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

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

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

@@ -1,62 +1,46 @@
 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.CommonConfig;
 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
     //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(
-		LazyOptional<ModifierCapabilityManager.IModifierCapability> modifierCapability =
+                    ModifierCapabilityManager.modifierCapability, null);
-			player.getCapability(ModifierCapabilityManager.MODIFIER_CAPABILITY, null);
+            if (capability.getModifierData() == null) {
-
-		if (modifierCapability.isPresent()) {
-			ModifierCapabilityManager.IModifierCapability capability = modifierCapability.orElse(null);
-			if (capability.getModifierData() == null){
                 capability.setModifierData(new ModifierSettings());
             }
             return capability.getModifierData();
         }
-
+        throw new IllegalArgumentException("Player does not have modifierCapability capability");
-		EffortlessBuilding.logger.warn("Player does not have modifierCapability: " + player);
-		//Return dummy settings
-		return new ModifierSettings();
     }
 
-	public static void setModifierSettings(Player player, ModifierSettings modifierSettings) {
+    public static void setModifierSettings(EntityPlayer player, ModifierSettings modifierSettings) {
         if (player == null) {
             EffortlessBuilding.log("Cannot set buildsettings, player is null");
             return;
         }
-
+        if (player.hasCapability(ModifierCapabilityManager.modifierCapability, null)) {
-		LazyOptional<ModifierCapabilityManager.IModifierCapability> modifierCapability =
+            ModifierCapabilityManager.IModifierCapability capability = player.getCapability(
-			player.getCapability(ModifierCapabilityManager.MODIFIER_CAPABILITY, null);
+                    ModifierCapabilityManager.modifierCapability, null);
-
-		modifierCapability.ifPresent((capability) -> {
             capability.setModifierData(modifierSettings);
-		});
+        } else {
-
-		if (!modifierCapability.isPresent()) {
             EffortlessBuilding.log(player, "Saving buildsettings failed.");
         }
     }
 
-	public static String sanitize(ModifierSettings modifierSettings, Player player) {
+    public static String sanitize(ModifierSettings modifierSettings, EntityPlayer player) {
         int maxReach = ReachHelper.getMaxReach(player);
         String error = "";
 
@@ -68,7 +52,7 @@ public class ModifierSettingsManager {
         }
         if (m.getReach() > maxReach) {
             m.radius = maxReach / 2;
-			error += "Mirror exceeds your maximum reach of " + (maxReach / 2) + ". Radius has been set to " + (maxReach / 2) + ". ";
+            error += "Mirror exceeds your maximum reach of " + (maxReach / 2) + ". Radius has been set to "+ (maxReach / 2) + ". ";
         }
 
         //Array settings
@@ -96,7 +80,7 @@ public class ModifierSettingsManager {
         }
         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) + ". ";
+            error += "Radial mirror exceeds your maximum reach of " + (maxReach / 2) + ". Radius has been set to "+ (maxReach / 2) + ". ";
         }
 
         //Other
@@ -110,18 +94,6 @@ public class ModifierSettingsManager {
         return error;
     }
 
-	public static void handleNewPlayer(Player player) {
-		//Makes sure player has modifier settings (if it doesnt it will create it)
-		getModifierSettings(player);
-
-		//Only on server
-		if (!player.level.isClientSide) {
-			//Send to client
-			ModifierSettingsMessage msg = new ModifierSettingsMessage(getModifierSettings(player));
-			PacketHandler.INSTANCE.send(PacketDistributor.PLAYER.with(() -> (ServerPlayer) player), msg);
-		}
-	}
-
     public static class ModifierSettings {
         private Mirror.MirrorSettings mirrorSettings;
         private Array.ArraySettings arraySettings;
@@ -191,24 +163,33 @@ public class ModifierSettingsManager {
             //Set mirror radius to max
             int reach = 10;
             switch (reachUpgrade) {
-				case 0:
+                case 0: reach = BuildConfig.reach.maxReachLevel0; break;
-					reach = CommonConfig.reach.maxReachLevel0.get();
+                case 1: reach =  BuildConfig.reach.maxReachLevel1; break;
-					break;
+                case 2: reach =  BuildConfig.reach.maxReachLevel2; break;
-				case 1:
+                case 3: reach =  BuildConfig.reach.maxReachLevel3; break;
-					reach = CommonConfig.reach.maxReachLevel1.get();
-					break;
-				case 2:
-					reach = CommonConfig.reach.maxReachLevel2.get();
-					break;
-				case 3:
-					reach = CommonConfig.reach.maxReachLevel3.get();
-					break;
             }
 
+            EffortlessBuilding.log("before "+this.mirrorSettings.radius);
+
             if (this.mirrorSettings != null)
                 this.mirrorSettings.radius = reach / 2;
             if (this.radialMirrorSettings != null)
                 this.radialMirrorSettings.radius = reach / 2;
+
+            EffortlessBuilding.log("after "+this.mirrorSettings.radius);
+        }
+    }
+
+    public static void handleNewPlayer(EntityPlayer player){
+        if (getModifierSettings(player) == null) {
+            setModifierSettings(player, new ModifierSettings());
+        }
+
+        //Only on server
+        if (!player.world.isRemote) {
+            //Send to client
+            ModifierSettingsMessage msg = new ModifierSettingsMessage(getModifierSettings(player));
+            EffortlessBuilding.packetHandler.sendTo(msg, (EntityPlayerMP) player);
         }
     }
 }

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

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

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

@@ -1,21 +1,21 @@
 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.CommonConfig;
+import nl.requios.effortlessbuilding.BuildConfig;
 import nl.requios.effortlessbuilding.EffortlessBuilding;
 import nl.requios.effortlessbuilding.helper.FixedStack;
 import nl.requios.effortlessbuilding.helper.InventoryHelper;
 import nl.requios.effortlessbuilding.helper.SurvivalHelper;
-import nl.requios.effortlessbuilding.render.BlockPreviews;
+import nl.requios.effortlessbuilding.render.BlockPreviewRenderer;
 
 import java.util.*;
 
@@ -23,14 +23,14 @@ public class UndoRedo {
 
     //Undo and redo stacks per player
     //Gets added to twice in singleplayer (server and client) if not careful. So separate stacks.
-	private static 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
-	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
         if (blockSet.getCoordinates().size() != blockSet.getPreviousBlockStates().size() ||
@@ -49,46 +49,47 @@ public class UndoRedo {
 //        }
 
         //If no stack exists, make one
-		if (!undoStacks.containsKey(player.getUUID())) {
+        if (!undoStacks.containsKey(player.getUniqueID())) {
-			undoStacks.put(player.getUUID(), new FixedStack<>(new BlockSet[CommonConfig.survivalBalancers.undoStackSize.get()]));
+            undoStacks.put(player.getUniqueID(), new FixedStack<>(new BlockSet[BuildConfig.survivalBalancers.undoStackSize]));
         }
 
-		undoStacks.get(player.getUUID()).push(blockSet);
+
+        undoStacks.get(player.getUniqueID()).push(blockSet);
     }
 
-	private static void addRedo(Player player, BlockSet blockSet) {
+    private static void addRedo(EntityPlayer player, BlockSet blockSet) {
-		Map<UUID, FixedStack<BlockSet>> redoStacks = player.level.isClientSide ? redoStacksClient : redoStacksServer;
+        Map<UUID, FixedStack<BlockSet>> redoStacks = player.world.isRemote ? redoStacksClient : redoStacksServer;
 
         //(No asserts necessary, it's private)
 
         //If no stack exists, make one
-		if (!redoStacks.containsKey(player.getUUID())) {
+        if (!redoStacks.containsKey(player.getUniqueID())) {
-			redoStacks.put(player.getUUID(), new FixedStack<>(new BlockSet[CommonConfig.survivalBalancers.undoStackSize.get()]));
+            redoStacks.put(player.getUniqueID(), new FixedStack<>(new BlockSet[BuildConfig.survivalBalancers.undoStackSize]));
         }
 
-		redoStacks.get(player.getUUID()).push(blockSet);
+        redoStacks.get(player.getUniqueID()).push(blockSet);
     }
 
-	public static boolean undo(Player player) {
+    public static boolean undo(EntityPlayer player) {
-		Map<UUID, FixedStack<BlockSet>> undoStacks = player.level.isClientSide ? undoStacksClient : undoStacksServer;
+        Map<UUID, FixedStack<BlockSet>> undoStacks = player.world.isRemote ? undoStacksClient : undoStacksServer;
 
-		if (!undoStacks.containsKey(player.getUUID())) return false;
+        if (!undoStacks.containsKey(player.getUniqueID())) return false;
 
-		FixedStack<BlockSet> undoStack = undoStacks.get(player.getUUID());
+        FixedStack<BlockSet> undoStack = undoStacks.get(player.getUniqueID());
 
         if (undoStack.isEmpty()) return false;
 
         BlockSet blockSet = undoStack.pop();
         List<BlockPos> coordinates = blockSet.getCoordinates();
-		List<BlockState> previousBlockStates = blockSet.getPreviousBlockStates();
+        List<IBlockState> previousBlockStates = blockSet.getPreviousBlockStates();
-		List<BlockState> newBlockStates = blockSet.getNewBlockStates();
+        List<IBlockState> newBlockStates = blockSet.getNewBlockStates();
-		Vec3 hitVec = blockSet.getHitVec();
+        Vec3d hitVec = blockSet.getHitVec();
 
         //Find up to date itemstacks in player inventory
         List<ItemStack> itemStacks = findItemStacksInInventory(player, previousBlockStates);
 
-		if (player.level.isClientSide) {
+        if (player.world.isRemote) {
-			BlockPreviews.onBlocksBroken(coordinates, itemStacks, newBlockStates, blockSet.getSecondPos(), blockSet.getFirstPos());
+            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++) {
@@ -98,27 +99,25 @@ public class UndoRedo {
                 if (previousBlockStates.get(i).equals(newBlockStates.get(i))) continue;
 
                 //get blockstate from itemstack
-				BlockState previousBlockState = previousBlockStates.get(i);
+                IBlockState previousBlockState = Blocks.AIR.getDefaultState();
-				if (itemStack.getItem() instanceof BlockItem) {
+                if (itemStack.getItem() instanceof ItemBlock) {
-					previousBlockState = ((BlockItem) itemStack.getItem()).getBlock().defaultBlockState();
+                    previousBlockState = previousBlockStates.get(i);//((ItemBlock) itemStack.getItem()).getBlock().getDefaultState();
                 }
 
-				if (player.level.isLoaded(coordinate)) {
+                if (player.world.isBlockLoaded(coordinate, true)) {
                     //check itemstack empty
-					if (itemStack.isEmpty() && !player.isCreative()) {
+                    if (itemStack.isEmpty()) {
                         itemStack = findItemStackInInventory(player, previousBlockStates.get(i));
                         //get blockstate from new itemstack
-						if (!itemStack.isEmpty() && itemStack.getItem() instanceof BlockItem) {
+                        if (!itemStack.isEmpty() && itemStack.getItem() instanceof ItemBlock) {
-							previousBlockState = ((BlockItem) itemStack.getItem()).getBlock().defaultBlockState();
+                            previousBlockState = previousBlockStates.get(i);//((ItemBlock) itemStack.getItem()).getBlock().getDefaultState();
                         } else {
-							if (previousBlockStates.get(i).getBlock() != Blocks.AIR)
+                            previousBlockState = Blocks.AIR.getDefaultState();
-								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 (itemStack.isEmpty()) SurvivalHelper.breakBlock(player.world, 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);
+                    SurvivalHelper.placeBlock(player.world, player, coordinate, previousBlockState, itemStack, EnumFacing.UP, hitVec, true, false, false);
                 }
             }
         }
@@ -129,26 +128,26 @@ public class UndoRedo {
         return true;
     }
 
-	public static boolean redo(Player player) {
+    public static boolean redo(EntityPlayer player) {
-		Map<UUID, FixedStack<BlockSet>> redoStacks = player.level.isClientSide ? redoStacksClient : redoStacksServer;
+        Map<UUID, FixedStack<BlockSet>> redoStacks = player.world.isRemote ? redoStacksClient : redoStacksServer;
 
-		if (!redoStacks.containsKey(player.getUUID())) return false;
+        if (!redoStacks.containsKey(player.getUniqueID())) return false;
 
-		FixedStack<BlockSet> redoStack = redoStacks.get(player.getUUID());
+        FixedStack<BlockSet> redoStack = redoStacks.get(player.getUniqueID());
 
         if (redoStack.isEmpty()) return false;
 
         BlockSet blockSet = redoStack.pop();
         List<BlockPos> coordinates = blockSet.getCoordinates();
-		List<BlockState> previousBlockStates = blockSet.getPreviousBlockStates();
+        List<IBlockState> previousBlockStates = blockSet.getPreviousBlockStates();
-		List<BlockState> newBlockStates = blockSet.getNewBlockStates();
+        List<IBlockState> newBlockStates = blockSet.getNewBlockStates();
-		Vec3 hitVec = blockSet.getHitVec();
+        Vec3d hitVec = blockSet.getHitVec();
 
         //Find up to date itemstacks in player inventory
         List<ItemStack> itemStacks = findItemStacksInInventory(player, newBlockStates);
 
-		if (player.level.isClientSide) {
+        if (player.world.isRemote) {
-			BlockPreviews.onBlocksPlaced(coordinates, itemStacks, newBlockStates, blockSet.getFirstPos(), blockSet.getSecondPos());
+            BlockPreviewRenderer.onBlocksPlaced(coordinates, itemStacks, newBlockStates, blockSet.getFirstPos(), blockSet.getSecondPos());
         } else {
             //place blocks
             for (int i = 0; i < coordinates.size(); i++) {
@@ -158,26 +157,24 @@ public class UndoRedo {
                 if (previousBlockStates.get(i).equals(newBlockStates.get(i))) continue;
 
                 //get blockstate from itemstack
-				BlockState newBlockState = newBlockStates.get(i);
+                IBlockState newBlockState = Blocks.AIR.getDefaultState();
-				if (itemStack.getItem() instanceof BlockItem) {
+                if (itemStack.getItem() instanceof ItemBlock) {
-					newBlockState = ((BlockItem) itemStack.getItem()).getBlock().defaultBlockState();
+                    newBlockState = newBlockStates.get(i);//((ItemBlock) itemStack.getItem()).getBlock().getDefaultState();
                 }
 
-				if (player.level.isLoaded(coordinate)) {
+                if (player.world.isBlockLoaded(coordinate, true)) {
                     //check itemstack empty
-					if (itemStack.isEmpty() && !player.isCreative()) {
+                    if (itemStack.isEmpty()) {
                         itemStack = findItemStackInInventory(player, newBlockStates.get(i));
                         //get blockstate from new itemstack
-						if (!itemStack.isEmpty() && itemStack.getItem() instanceof BlockItem) {
+                        if (!itemStack.isEmpty() && itemStack.getItem() instanceof ItemBlock) {
-							newBlockState = ((BlockItem) itemStack.getItem()).getBlock().defaultBlockState();
+                            newBlockState = newBlockStates.get(i);//((ItemBlock) itemStack.getItem()).getBlock().getDefaultState();
                         } else {
-							if (newBlockStates.get(i).getBlock() != Blocks.AIR)
+                            newBlockState = Blocks.AIR.getDefaultState();
-								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);
+                    if (itemStack.isEmpty()) SurvivalHelper.breakBlock(player.world, player, coordinate, true);
-					SurvivalHelper.placeBlock(player.level, player, coordinate, newBlockState, itemStack, Direction.UP, hitVec, true, false, false);
+                    SurvivalHelper.placeBlock(player.world, player, coordinate, newBlockState, itemStack, EnumFacing.UP, hitVec, true, false, false);
                 }
             }
         }
@@ -188,26 +185,26 @@ public class UndoRedo {
         return true;
     }
 
-	public static void clear(Player player) {
+    public static void clear(EntityPlayer player) {
-		Map<UUID, FixedStack<BlockSet>> undoStacks = player.level.isClientSide ? undoStacksClient : undoStacksServer;
+        Map<UUID, FixedStack<BlockSet>> undoStacks = player.world.isRemote ? undoStacksClient : undoStacksServer;
-		Map<UUID, FixedStack<BlockSet>> redoStacks = player.level.isClientSide ? redoStacksClient : redoStacksServer;
+        Map<UUID, FixedStack<BlockSet>> redoStacks = player.world.isRemote ? redoStacksClient : redoStacksServer;
-		if (undoStacks.containsKey(player.getUUID())) {
+        if (undoStacks.containsKey(player.getUniqueID())) {
-			undoStacks.get(player.getUUID()).clear();
+            undoStacks.get(player.getUniqueID()).clear();
         }
-		if (redoStacks.containsKey(player.getUUID())) {
+        if (redoStacks.containsKey(player.getUniqueID())) {
-			redoStacks.get(player.getUUID()).clear();
+            redoStacks.get(player.getUniqueID()).clear();
         }
     }
 
-	private static List<ItemStack> findItemStacksInInventory(Player player, List<BlockState> blockStates) {
+    private static List<ItemStack> findItemStacksInInventory(EntityPlayer player, List<IBlockState> blockStates) {
         List<ItemStack> itemStacks = new ArrayList<>(blockStates.size());
-		for (BlockState blockState : blockStates) {
+        for (IBlockState blockState : blockStates) {
             itemStacks.add(findItemStackInInventory(player, blockState));
         }
         return itemStacks;
     }
 
-	private static ItemStack findItemStackInInventory(Player player, BlockState blockState) {
+    private static ItemStack findItemStackInInventory(EntityPlayer player, IBlockState blockState) {
         ItemStack itemStack = ItemStack.EMPTY;
         if (blockState == null) return itemStack;
 
@@ -216,20 +213,14 @@ public class UndoRedo {
         // then change line 103 back (get state from item)
         itemStack = InventoryHelper.findItemStackInInventory(player, blockState.getBlock());
 
-
         //then anything it drops
         if (itemStack.isEmpty()) {
-			//Cannot check drops on clientside because loot tables are server only
+            Item itemDropped = blockState.getBlock().getItemDropped(blockState, player.world.rand, 10);
-			if (!player.level.isClientSide) {
+            if (itemDropped instanceof ItemBlock) {
-				List<ItemStack> itemsDropped = Block.getDrops(blockState, (ServerLevel) player.level, BlockPos.ZERO, null);
+                Block block = ((ItemBlock) itemDropped).getBlock();
-				for (ItemStack itemStackDropped : itemsDropped) {
-					if (itemStackDropped.getItem() instanceof BlockItem) {
-						Block block = ((BlockItem) itemStackDropped.getItem()).getBlock();
                 itemStack = InventoryHelper.findItemStackInInventory(player, block);
             }
         }
-			}
-		}
 
         //then air
         //(already empty)

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
-	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
-	public CompoundTag serializeNBT() {
+    public NBTTagCompound serializeNBT() {
         return ((ItemStackHandler) itemHandler).serializeNBT();
     }
 
     @Override
-	public void deserializeNBT(CompoundTag nbt) {
+    public void deserializeNBT(NBTTagCompound nbt) {
         ((ItemStackHandler) itemHandler).deserializeNBT(nbt);
     }
 }

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

@@ -1,34 +1,26 @@
 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.
-	@SubscribeEvent
-	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 {
         ModeSettings getModeData();
@@ -50,42 +42,14 @@ public class ModeCapabilityManager {
         }
     }
 
-	public static class Provider extends CapabilityProvider<Provider> implements ICapabilitySerializable<Tag> {
+    public static class Storage implements Capability.IStorage<IModeCapability> {
-
-		private IModeCapability instance = new ModeCapability();
-		private LazyOptional<IModeCapability> modeCapabilityOptional = LazyOptional.of(() -> instance);
-
-		public Provider() {
-			super(Provider.class);
-			gatherCapabilities();
-		}
-
-		@Nonnull
         @Override
-		public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
+        public NBTBase writeNBT(Capability<IModeCapability> capability, IModeCapability instance, EnumFacing side) {
-			if (cap == MODE_CAPABILITY) return modeCapabilityOptional.cast();
+            NBTTagCompound compound = new NBTTagCompound();
-			return LazyOptional.empty();
-		}
-
-		@Override
-		public void invalidateCaps() {
-			super.invalidateCaps();
-			modeCapabilityOptional.invalidate();
-		}
-
-		@Override
-		public void reviveCaps() {
-			super.reviveCaps();
-			modeCapabilityOptional = LazyOptional.of(() -> instance);
-		}
-
-		@Override
-		public Tag serializeNBT() {
-			CompoundTag compound = new CompoundTag();
             ModeSettings modeSettings = instance.getModeData();
             if (modeSettings == null) modeSettings = new ModeSettings();
 
-			//compound.putInteger("buildMode", modeSettings.getBuildMode().ordinal());
+            //compound.setInteger("buildMode", modeSettings.getBuildMode().ordinal());
 
             //TODO add mode settings
 
@@ -93,16 +57,48 @@ public class ModeCapabilityManager {
         }
 
         @Override
-		public void deserializeNBT(Tag nbt) {
+        public void readNBT(Capability<IModeCapability> capability, IModeCapability instance, EnumFacing side, NBTBase nbt) {
-			CompoundTag compound = (CompoundTag) nbt;
+            NBTTagCompound compound = (NBTTagCompound) nbt;
 
             //BuildModes.BuildModeEnum buildMode = BuildModes.BuildModeEnum.values()[compound.getInteger("buildMode")];
 
             //TODO add mode settings
 
-			ModeSettings modeSettings = new ModeSettings(BuildModes.BuildModeEnum.DISABLED);
+            ModeSettings modeSettings = new ModeSettings(BuildModes.BuildModeEnum.NORMAL);
             instance.setModeData(modeSettings);
         }
+    }
 
+    public static class Provider implements ICapabilitySerializable<NBTBase> {
+        IModeCapability inst = modeCapability.getDefaultInstance();
+
+        @Override
+        public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
+            return capability == modeCapability;
+        }
+
+        @Override
+        public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
+            if (capability == modeCapability) return modeCapability.<T>cast(inst);
+            return null;
+        }
+
+        @Override
+        public NBTBase serializeNBT() {
+            return modeCapability.getStorage().writeNBT(modeCapability, inst, null);
+        }
+
+        @Override
+        public void deserializeNBT(NBTBase nbt) {
+            modeCapability.getStorage().readNBT(modeCapability, inst, null, nbt);
+        }
+    }
+
+    // Allows for the capability to persist after death.
+    @SubscribeEvent
+    public static void clonePlayer(PlayerEvent.Clone event) {
+        IModeCapability original = event.getOriginal().getCapability(modeCapability, null);
+        IModeCapability clone = event.getEntity().getCapability(modeCapability, null);
+        clone.setModeData(original.getModeData());
     }
 }

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

@@ -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,22 +18,13 @@ 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.
-	@SubscribeEvent
-	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 {
         ModifierSettings getModifierData();
@@ -55,98 +46,70 @@ public class ModifierCapabilityManager {
         }
     }
 
-	public static class Provider extends CapabilityProvider<Provider> implements INBTSerializable<Tag> {
+    public static class Storage implements Capability.IStorage<IModifierCapability> {
-
-		private final IModifierCapability instance = new ModifierCapability();
-		private LazyOptional<IModifierCapability> modifierCapabilityOptional = LazyOptional.of(() -> instance);
-
-		public Provider() {
-			super(Provider.class);
-			gatherCapabilities();
-		}
-
-		@Nonnull
         @Override
-		public <T> LazyOptional<T> getCapability(@Nonnull Capability<T> cap, @Nullable Direction side) {
+        public NBTBase writeNBT(Capability<IModifierCapability> capability, IModifierCapability instance, EnumFacing side) {
-			if (cap == MODIFIER_CAPABILITY) return modifierCapabilityOptional.cast();
+            NBTTagCompound compound = new NBTTagCompound();
-			return LazyOptional.empty();
-		}
-
-		@Override
-		public void invalidateCaps() {
-			super.invalidateCaps();
-			modifierCapabilityOptional.invalidate();
-		}
-
-		@Override
-		public void reviveCaps() {
-			super.reviveCaps();
-			modifierCapabilityOptional = LazyOptional.of(() -> instance);
-		}
-
-		@Override
-		public Tag serializeNBT() {
-			CompoundTag compound = new CompoundTag();
             ModifierSettings modifierSettings = instance.getModifierData();
             if (modifierSettings == null) modifierSettings = new ModifierSettings();
 
             //MIRROR
             Mirror.MirrorSettings m = modifierSettings.getMirrorSettings();
             if (m == null) m = new Mirror.MirrorSettings();
-			compound.putBoolean("mirrorEnabled", m.enabled);
+            compound.setBoolean("mirrorEnabled", m.enabled);
-			compound.putDouble("mirrorPosX", m.position.x);
+            compound.setDouble("mirrorPosX", m.position.x);
-			compound.putDouble("mirrorPosY", m.position.y);
+            compound.setDouble("mirrorPosY", m.position.y);
-			compound.putDouble("mirrorPosZ", m.position.z);
+            compound.setDouble("mirrorPosZ", m.position.z);
-			compound.putBoolean("mirrorX", m.mirrorX);
+            compound.setBoolean("mirrorX", m.mirrorX);
-			compound.putBoolean("mirrorY", m.mirrorY);
+            compound.setBoolean("mirrorY", m.mirrorY);
-			compound.putBoolean("mirrorZ", m.mirrorZ);
+            compound.setBoolean("mirrorZ", m.mirrorZ);
-			compound.putInt("mirrorRadius", m.radius);
+            compound.setInteger("mirrorRadius", m.radius);
-			compound.putBoolean("mirrorDrawLines", m.drawLines);
+            compound.setBoolean("mirrorDrawLines", m.drawLines);
-			compound.putBoolean("mirrorDrawPlanes", m.drawPlanes);
+            compound.setBoolean("mirrorDrawPlanes", m.drawPlanes);
 
             //ARRAY
             Array.ArraySettings a = modifierSettings.getArraySettings();
             if (a == null) a = new Array.ArraySettings();
-			compound.putBoolean("arrayEnabled", a.enabled);
+            compound.setBoolean("arrayEnabled", a.enabled);
-			compound.putInt("arrayOffsetX", a.offset.getX());
+            compound.setInteger("arrayOffsetX", a.offset.getX());
-			compound.putInt("arrayOffsetY", a.offset.getY());
+            compound.setInteger("arrayOffsetY", a.offset.getY());
-			compound.putInt("arrayOffsetZ", a.offset.getZ());
+            compound.setInteger("arrayOffsetZ", a.offset.getZ());
-			compound.putInt("arrayCount", a.count);
+            compound.setInteger("arrayCount", a.count);
 
-			compound.putInt("reachUpgrade", modifierSettings.getReachUpgrade());
+            compound.setInteger("reachUpgrade", modifierSettings.getReachUpgrade());
 
-			//compound.putBoolean("quickReplace", buildSettings.doQuickReplace()); dont save quickreplace
+            //compound.setBoolean("quickReplace", buildSettings.doQuickReplace()); dont save quickreplace
 
             //RADIAL MIRROR
             RadialMirror.RadialMirrorSettings r = modifierSettings.getRadialMirrorSettings();
             if (r == null) r = new RadialMirror.RadialMirrorSettings();
-			compound.putBoolean("radialMirrorEnabled", r.enabled);
+            compound.setBoolean("radialMirrorEnabled", r.enabled);
-			compound.putDouble("radialMirrorPosX", r.position.x);
+            compound.setDouble("radialMirrorPosX", r.position.x);
-			compound.putDouble("radialMirrorPosY", r.position.y);
+            compound.setDouble("radialMirrorPosY", r.position.y);
-			compound.putDouble("radialMirrorPosZ", r.position.z);
+            compound.setDouble("radialMirrorPosZ", r.position.z);
-			compound.putInt("radialMirrorSlices", r.slices);
+            compound.setInteger("radialMirrorSlices", r.slices);
-			compound.putBoolean("radialMirrorAlternate", r.alternate);
+            compound.setBoolean("radialMirrorAlternate", r.alternate);
-			compound.putInt("radialMirrorRadius", r.radius);
+            compound.setInteger("radialMirrorRadius", r.radius);
-			compound.putBoolean("radialMirrorDrawLines", r.drawLines);
+            compound.setBoolean("radialMirrorDrawLines", r.drawLines);
-			compound.putBoolean("radialMirrorDrawPlanes", r.drawPlanes);
+            compound.setBoolean("radialMirrorDrawPlanes", r.drawPlanes);
 
             return compound;
         }
 
         @Override
-		public void deserializeNBT(Tag nbt) {
+        public void readNBT(Capability<IModifierCapability> capability, IModifierCapability instance, EnumFacing side, NBTBase nbt) {
-			CompoundTag compound = (CompoundTag) nbt;
+            NBTTagCompound compound = (NBTTagCompound) nbt;
 
             //MIRROR
             boolean mirrorEnabled = compound.getBoolean("mirrorEnabled");
-			Vec3 mirrorPosition = new Vec3(
+            Vec3d mirrorPosition = new Vec3d(
                     compound.getDouble("mirrorPosX"),
                     compound.getDouble("mirrorPosY"),
                     compound.getDouble("mirrorPosZ"));
             boolean mirrorX = compound.getBoolean("mirrorX");
             boolean mirrorY = compound.getBoolean("mirrorY");
             boolean mirrorZ = compound.getBoolean("mirrorZ");
-			int mirrorRadius = compound.getInt("mirrorRadius");
+            int mirrorRadius = compound.getInteger("mirrorRadius");
             boolean mirrorDrawLines = compound.getBoolean("mirrorDrawLines");
             boolean mirrorDrawPlanes = compound.getBoolean("mirrorDrawPlanes");
             Mirror.MirrorSettings mirrorSettings = new Mirror.MirrorSettings(mirrorEnabled, mirrorPosition, mirrorX, mirrorY, mirrorZ, mirrorRadius, mirrorDrawLines, mirrorDrawPlanes);
@@ -154,25 +117,25 @@ public class ModifierCapabilityManager {
             //ARRAY
             boolean arrayEnabled = compound.getBoolean("arrayEnabled");
             BlockPos arrayOffset = new BlockPos(
-					compound.getInt("arrayOffsetX"),
+                    compound.getInteger("arrayOffsetX"),
-					compound.getInt("arrayOffsetY"),
+                    compound.getInteger("arrayOffsetY"),
-					compound.getInt("arrayOffsetZ"));
+                    compound.getInteger("arrayOffsetZ"));
-			int arrayCount = compound.getInt("arrayCount");
+            int arrayCount = compound.getInteger("arrayCount");
             Array.ArraySettings arraySettings = new Array.ArraySettings(arrayEnabled, arrayOffset, arrayCount);
 
-			int reachUpgrade = compound.getInt("reachUpgrade");
+            int reachUpgrade = compound.getInteger("reachUpgrade");
 
             //boolean quickReplace = compound.getBoolean("quickReplace"); //dont load quickreplace
 
             //RADIAL MIRROR
             boolean radialMirrorEnabled = compound.getBoolean("radialMirrorEnabled");
-			Vec3 radialMirrorPosition = new Vec3(
+            Vec3d radialMirrorPosition = new Vec3d(
                     compound.getDouble("radialMirrorPosX"),
                     compound.getDouble("radialMirrorPosY"),
                     compound.getDouble("radialMirrorPosZ"));
-			int radialMirrorSlices = compound.getInt("radialMirrorSlices");
+            int radialMirrorSlices = compound.getInteger("radialMirrorSlices");
             boolean radialMirrorAlternate = compound.getBoolean("radialMirrorAlternate");
-			int radialMirrorRadius = compound.getInt("radialMirrorRadius");
+            int radialMirrorRadius = compound.getInteger("radialMirrorRadius");
             boolean radialMirrorDrawLines = compound.getBoolean("radialMirrorDrawLines");
             boolean radialMirrorDrawPlanes = compound.getBoolean("radialMirrorDrawPlanes");
             RadialMirror.RadialMirrorSettings radialMirrorSettings = new RadialMirror.RadialMirrorSettings(radialMirrorEnabled, radialMirrorPosition,
@@ -181,6 +144,38 @@ public class ModifierCapabilityManager {
             ModifierSettings modifierSettings = new ModifierSettings(mirrorSettings, arraySettings, radialMirrorSettings, false, reachUpgrade);
             instance.setModifierData(modifierSettings);
         }
+    }
 
+    public static class Provider implements ICapabilitySerializable<NBTBase> {
+        IModifierCapability inst = modifierCapability.getDefaultInstance();
+
+        @Override
+        public boolean hasCapability(@Nonnull Capability<?> capability, @Nullable EnumFacing facing) {
+            return capability == modifierCapability;
+        }
+
+        @Override
+        public <T> T getCapability(@Nonnull Capability<T> capability, @Nullable EnumFacing facing) {
+            if (capability == modifierCapability) return modifierCapability.<T>cast(inst);
+            return null;
+        }
+
+        @Override
+        public NBTBase serializeNBT() {
+            return modifierCapability.getStorage().writeNBT(modifierCapability, inst, null);
+        }
+
+        @Override
+        public void deserializeNBT(NBTBase nbt) {
+            modifierCapability.getStorage().readNBT(modifierCapability, inst, null, nbt);
+        }
+    }
+
+    // Allows for the capability to persist after death.
+    @SubscribeEvent
+    public static void clonePlayer(PlayerEvent.Clone event) {
+        IModifierCapability original = event.getOriginal().getCapability(modifierCapability, null);
+        IModifierCapability clone = event.getEntity().getCapability(modifierCapability, null);
+        clone.setModifierData(original.getModifierData());
     }
 }

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

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

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

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

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

@@ -1,25 +1,49 @@
 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,
     // /dank/null, or plain old blocks.
     public static boolean isItemBlockProxy(ItemStack stack) {
         Item item = stack.getItem();
-		if (item instanceof BlockItem)
+        if (item instanceof ItemBlock)
             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
@@ -27,37 +51,67 @@ public class CompatHelper {
     public static ItemStack getItemBlockFromStack(ItemStack proxy) {
         Item proxyItem = proxy.getItem();
 
-		if (proxyItem instanceof BlockItem)
+        if (proxyItem instanceof ItemBlock)
             return proxy;
 
         //Randomizer Bag
-		if (proxyItem instanceof AbstractRandomizerBagItem) {
+        if (proxyItem instanceof ItemRandomizerBag) {
             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;
         }
 
+        //Dank Null
+        if (proxyItem == dankNullItem) {
+            int index = 0;
+            if (proxy.hasTagCompound() && proxy.getTagCompound().hasKey("selectedIndex"))
+                index = proxy.getTagCompound().getInteger("selectedIndex");
+            return proxy.getCapability(CapabilityItemHandler.ITEM_HANDLER_CAPABILITY, null).getStackInSlot(index);
+        }
+
         return ItemStack.EMPTY;
     }
 
-	public static ItemStack getItemBlockByState(ItemStack stack, BlockState state) {
+    public static ItemStack getItemBlockByState(ItemStack stack, IBlockState state) {
-		if (state == null) return ItemStack.EMPTY;
+        Item blockItem = Item.getItemFromBlock(state.getBlock());
-
+        if (stack.getItem() instanceof ItemBlock)
-		Item blockItem = Item.byBlock(state.getBlock());
-		if (stack.getItem() instanceof BlockItem)
             return stack;
-		else if (stack.getItem() instanceof AbstractRandomizerBagItem) {
+        else if (stack.getItem() instanceof ItemRandomizerBag) {
-			AbstractRandomizerBagItem randomizerBagItem = (AbstractRandomizerBagItem) stack.getItem();
+            IItemHandler bagInventory = ItemRandomizerBag.getBagInventory(stack);
-			IItemHandler bagInventory = randomizerBagItem.getBagInventory(stack);
+            return ItemRandomizerBag.findStack(bagInventory, blockItem);
-			return randomizerBagItem.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/create/AllSpecialTextures.java

@@ -1,33 +0,0 @@
-package nl.requios.effortlessbuilding.create;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import net.minecraft.resources.ResourceLocation;
-
-public enum AllSpecialTextures {
-
-	BLANK("blank.png"),
-	CHECKERED("checkerboard.png"),
-	THIN_CHECKERED("thin_checkerboard.png"),
-	CUTOUT_CHECKERED("cutout_checkerboard.png"),
-	HIGHLIGHT_CHECKERED("highlighted_checkerboard.png"),
-	SELECTION("selection.png"),
-	GLUE("glue.png"),
-
-	;
-
-	public static final String ASSET_PATH = "textures/special/";
-	private ResourceLocation location;
-
-	private AllSpecialTextures(String filename) {
-		location = Create.asResource(ASSET_PATH + filename);
-	}
-
-	public void bind() {
-		RenderSystem.setShaderTexture(0, location);
-	}
-
-	public ResourceLocation getLocation() {
-		return location;
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/Create.java

@@ -1,16 +0,0 @@
-package nl.requios.effortlessbuilding.create;
-
-import com.mojang.logging.LogUtils;
-import net.minecraft.resources.ResourceLocation;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-import org.slf4j.Logger;
-
-public class Create {
-    public static final String ID = EffortlessBuilding.MODID;
-
-    public static final Logger LOGGER = LogUtils.getLogger();
-
-    public static ResourceLocation asResource(String path) {
-        return new ResourceLocation(EffortlessBuilding.MODID, path);
-    }
-}

src/main/java/nl/requios/effortlessbuilding/create/CreateClient.java

@@ -1,15 +0,0 @@
-package nl.requios.effortlessbuilding.create;
-
-import nl.requios.effortlessbuilding.create.foundation.render.SuperByteBufferCache;
-import nl.requios.effortlessbuilding.create.foundation.utility.ghost.GhostBlocks;
-import nl.requios.effortlessbuilding.create.foundation.utility.outliner.Outliner;
-
-public class CreateClient {
-    public static final SuperByteBufferCache BUFFER_CACHE = new SuperByteBufferCache();
-    public static final Outliner OUTLINER = new Outliner();
-    public static final GhostBlocks GHOST_BLOCKS = new GhostBlocks();
-
-    public static void invalidateRenderers() {
-        CreateClient.BUFFER_CACHE.invalidate();
-    }
-}

src/main/java/nl/requios/effortlessbuilding/create/CreateClientTest.java

@@ -1,31 +0,0 @@
-package nl.requios.effortlessbuilding.create;
-
-import net.minecraft.world.level.block.Blocks;
-import net.minecraft.world.phys.AABB;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.event.TickEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod;
-import nl.requios.effortlessbuilding.create.foundation.utility.Color;
-
-@Mod.EventBusSubscriber(Dist.CLIENT)
-public class CreateClientTest {
-
-//    @SubscribeEvent
-//    public static void onTick(TickEvent.ClientTickEvent event) {
-//        CreateClient.GHOST_BLOCKS.showGhostState(1, Blocks.SPRUCE_LOG.defaultBlockState())
-//                .at(0, 120, 0)
-//                .breathingAlpha();
-//        CreateClient.GHOST_BLOCKS.showGhostState(2, Blocks.SPRUCE_LOG.defaultBlockState())
-//                .at(1, 120, 0)
-//                .breathingAlpha();
-//
-//        CreateClient.OUTLINER.showAABB(1, new AABB(0, 0, 0, 10, 2, 6)
-//                        .move(10, 120, 0))
-//                .withFaceTexture(AllSpecialTextures.CHECKERED)
-//                .colored(new Color(0.11f, 0.49f, 0.7f, 1f))
-////                .colored(0xbfbfbf)
-//                .disableNormals()
-//                .lineWidth(1 / 32f);
-//    }
-}

src/main/java/nl/requios/effortlessbuilding/create/events/ClientEvents.java

@@ -1,96 +0,0 @@
-package nl.requios.effortlessbuilding.create.events;
-
-import com.mojang.blaze3d.systems.RenderSystem;
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.multiplayer.ClientLevel;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.LevelAccessor;
-import net.minecraft.world.phys.Vec3;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.RenderLevelLastEvent;
-import net.minecraftforge.client.event.ViewportEvent;
-import net.minecraftforge.event.TickEvent.ClientTickEvent;
-import net.minecraftforge.event.level.LevelEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import nl.requios.effortlessbuilding.create.Create;
-import nl.requios.effortlessbuilding.create.CreateClient;
-import nl.requios.effortlessbuilding.create.foundation.render.SuperRenderTypeBuffer;
-import nl.requios.effortlessbuilding.create.foundation.utility.AnimationTickHolder;
-import nl.requios.effortlessbuilding.create.foundation.utility.CameraAngleAnimationService;
-import nl.requios.effortlessbuilding.create.foundation.utility.worldWrappers.WrappedClientWorld;
-
-@EventBusSubscriber(Dist.CLIENT)
-public class ClientEvents {
-
-	private static final String ITEM_PREFIX = "item." + Create.ID;
-	private static final String BLOCK_PREFIX = "block." + Create.ID;
-
-	@SubscribeEvent
-	public static void onTick(ClientTickEvent event) {
-		if (!isGameActive())
-			return;
-
-		Level world = Minecraft.getInstance().level;
-		AnimationTickHolder.tick();
-
-		CreateClient.GHOST_BLOCKS.tickGhosts();
-		CreateClient.OUTLINER.tickOutlines();
-		CameraAngleAnimationService.tick();
-	}
-
-	@SubscribeEvent
-	public static void onLoadWorld(LevelEvent.Load event) {
-		LevelAccessor world = event.getLevel();
-		if (world.isClientSide() && world instanceof ClientLevel && !(world instanceof WrappedClientWorld)) {
-			CreateClient.invalidateRenderers();
-			AnimationTickHolder.reset();
-		}
-	}
-
-	@SubscribeEvent
-	public static void onUnloadWorld(LevelEvent.Unload event) {
-		if (!event.getLevel()
-			.isClientSide())
-			return;
-		CreateClient.invalidateRenderers();
-		AnimationTickHolder.reset();
-	}
-
-	@SubscribeEvent
-	public static void onRenderWorld(RenderLevelLastEvent event) {
-		Vec3 cameraPos = Minecraft.getInstance().gameRenderer.getMainCamera()
-			.getPosition();
-		float pt = AnimationTickHolder.getPartialTicks();
-
-		PoseStack ms = event.getPoseStack();
-		ms.pushPose();
-		ms.translate(-cameraPos.x(), -cameraPos.y(), -cameraPos.z());
-		SuperRenderTypeBuffer buffer = SuperRenderTypeBuffer.getInstance();
-
-		CreateClient.GHOST_BLOCKS.renderAll(ms, buffer);
-
-		CreateClient.OUTLINER.renderOutlines(ms, buffer, pt);
-		buffer.draw();
-		RenderSystem.enableCull();
-
-		ms.popPose();
-	}
-
-	@SubscribeEvent
-	public static void onCameraSetup(ViewportEvent.ComputeCameraAngles event) {
-		float partialTicks = AnimationTickHolder.getPartialTicks();
-
-		if (CameraAngleAnimationService.isYawAnimating())
-			event.setYaw(CameraAngleAnimationService.getYaw(partialTicks));
-
-		if (CameraAngleAnimationService.isPitchAnimating())
-			event.setPitch(CameraAngleAnimationService.getPitch(partialTicks));
-	}
-
-	public static boolean isGameActive() {
-		return !(Minecraft.getInstance().level == null || Minecraft.getInstance().player == null);
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/events/CommonEvents.java

@@ -1,39 +0,0 @@
-package nl.requios.effortlessbuilding.create.events;
-
-import net.minecraft.world.level.LevelAccessor;
-import net.minecraftforge.event.level.LevelEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-import nl.requios.effortlessbuilding.create.foundation.utility.WorldAttached;
-
-@EventBusSubscriber
-public class CommonEvents {
-
-	@SubscribeEvent
-	public static void onUnloadWorld(LevelEvent.Unload event) {
-		LevelAccessor world = event.getLevel();
-		WorldAttached.invalidateWorld(world);
-	}
-
-
-	@EventBusSubscriber(bus = EventBusSubscriber.Bus.MOD)
-	public static class ModBusEvents {
-
-//		@SubscribeEvent
-//		public static void addPackFinders(AddPackFindersEvent event) {
-//			if (event.getPackType() == PackType.CLIENT_RESOURCES) {
-//				IModFileInfo modFileInfo = ModList.get().getModFileById(Create.ID);
-//				if (modFileInfo == null) {
-//					Create.LOGGER.error("Could not find Create mod file info; built-in resource packs will be missing!");
-//					return;
-//				}
-//				IModFile modFile = modFileInfo.getFile();
-//				event.addRepositorySource((consumer, constructor) -> {
-//					consumer.accept(Pack.create(Create.asResource("legacy_copper").toString(), false, () -> new ModFilePackResources("Create Legacy Copper", modFile, "resourcepacks/legacy_copper"), constructor, Pack.Position.TOP, PackSource.DEFAULT));
-//				});
-//			}
-//		}
-
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/ClientResourceReloadListener.java

@@ -1,16 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation;
-
-import nl.requios.effortlessbuilding.create.foundation.utility.LangNumberFormat;
-import net.minecraft.server.packs.resources.ResourceManager;
-import net.minecraft.server.packs.resources.ResourceManagerReloadListener;
-
-public class ClientResourceReloadListener implements ResourceManagerReloadListener {
-
-	@Override
-	public void onResourceManagerReload(ResourceManager resourceManager) {
-//		CreateClient.invalidateRenderers();
-//		SoundScapes.invalidateAll();
-		LangNumberFormat.numberFormat.update();
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/ModFilePackResources.java

@@ -1,25 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation;
-
-import net.minecraftforge.forgespi.locating.IModFile;
-import net.minecraftforge.resource.PathPackResources;
-
-import java.nio.file.Path;
-
-public class ModFilePackResources extends PathPackResources {
-	protected final IModFile modFile;
-	protected final String sourcePath;
-
-	public ModFilePackResources(String name, IModFile modFile, String sourcePath) {
-		super(name, modFile.findResource(sourcePath));
-		this.modFile = modFile;
-		this.sourcePath = sourcePath;
-	}
-
-	@Override
-	protected Path resolve(String... paths) {
-		String[] allPaths = new String[paths.length + 1];
-		allPaths[0] = sourcePath;
-		System.arraycopy(paths, 0, allPaths, 1, paths.length);
-		return modFile.findResource(allPaths);
-	}
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/block/render/SpriteShiftEntry.java

@@ -1,49 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.block.render;
-
-import com.jozufozu.flywheel.core.StitchedSprite;
-import net.minecraft.client.renderer.texture.TextureAtlasSprite;
-import net.minecraft.resources.ResourceLocation;
-
-public class SpriteShiftEntry {
-	protected StitchedSprite original;
-	protected StitchedSprite target;
-
-	public void set(ResourceLocation originalTextureLocation, ResourceLocation targetTextureLocation) {
-		original = new StitchedSprite(originalTextureLocation);
-		target = new StitchedSprite(targetTextureLocation);
-	}
-
-	public ResourceLocation getOriginalResourceLocation() {
-		return original.getLocation();
-	}
-
-	public ResourceLocation getTargetResourceLocation() {
-		return target.getLocation();
-	}
-
-	public TextureAtlasSprite getOriginal() {
-		return original.get();
-	}
-
-	public TextureAtlasSprite getTarget() {
-		return target.get();
-	}
-
-	public float getTargetU(float localU) {
-		return getTarget().getU(getUnInterpolatedU(getOriginal(), localU));
-	}
-
-	public float getTargetV(float localV) {
-		return getTarget().getV(getUnInterpolatedV(getOriginal(), localV));
-	}
-
-	public static float getUnInterpolatedU(TextureAtlasSprite sprite, float u) {
-		float f = sprite.getU1() - sprite.getU0();
-		return (u - sprite.getU0()) / f * 16.0F;
-	}
-
-	public static float getUnInterpolatedV(TextureAtlasSprite sprite, float v) {
-		float f = sprite.getV1() - sprite.getV0();
-		return (v - sprite.getV0()) / f * 16.0F;
-	}
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/render/BakedModelRenderHelper.java

@@ -1,29 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.render;
-
-import com.jozufozu.flywheel.core.model.ModelUtil;
-import com.jozufozu.flywheel.util.Pair;
-import com.mojang.blaze3d.vertex.BufferBuilder.RenderedBuffer;
-import com.mojang.blaze3d.vertex.PoseStack;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.block.BlockRenderDispatcher;
-import net.minecraft.client.resources.model.BakedModel;
-import net.minecraft.world.level.block.state.BlockState;
-
-public class BakedModelRenderHelper {
-
-	public static SuperByteBuffer standardBlockRender(BlockState renderedState) {
-		BlockRenderDispatcher dispatcher = Minecraft.getInstance()
-			.getBlockRenderer();
-		return standardModelRender(dispatcher.getBlockModel(renderedState), renderedState);
-	}
-
-	public static SuperByteBuffer standardModelRender(BakedModel model, BlockState referenceState) {
-		return standardModelRender(model, referenceState, new PoseStack());
-	}
-
-	public static SuperByteBuffer standardModelRender(BakedModel model, BlockState referenceState, PoseStack ms) {
-		Pair<RenderedBuffer, Integer> pair = ModelUtil.getBufferBuilder(model, referenceState, ms);
-		return new SuperByteBuffer(pair.first(), pair.second());
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/render/CachedBufferer.java

@@ -1,88 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.render;
-
-import com.jozufozu.flywheel.core.PartialModel;
-import com.jozufozu.flywheel.util.transform.TransformStack;
-import com.mojang.blaze3d.vertex.PoseStack;
-import nl.requios.effortlessbuilding.EffortlessBuildingClient;
-import nl.requios.effortlessbuilding.create.CreateClient;
-import nl.requios.effortlessbuilding.create.foundation.render.SuperByteBufferCache.Compartment;
-import nl.requios.effortlessbuilding.create.foundation.utility.AngleHelper;
-import net.minecraft.core.Direction;
-import net.minecraft.world.level.block.state.BlockState;
-import org.apache.commons.lang3.tuple.Pair;
-
-import java.util.function.Supplier;
-
-import static net.minecraft.world.level.block.state.properties.BlockStateProperties.FACING;
-
-public class CachedBufferer {
-
-	public static final Compartment<BlockState> GENERIC_TILE = new Compartment<>();
-	public static final Compartment<PartialModel> PARTIAL = new Compartment<>();
-	public static final Compartment<Pair<Direction, PartialModel>> DIRECTIONAL_PARTIAL = new Compartment<>();
-
-	public static SuperByteBuffer block(BlockState toRender) {
-		return block(GENERIC_TILE, toRender);
-	}
-
-	public static SuperByteBuffer block(Compartment<BlockState> compartment, BlockState toRender) {
-		return CreateClient.BUFFER_CACHE.get(compartment, toRender, () -> BakedModelRenderHelper.standardBlockRender(toRender));
-	}
-
-	public static SuperByteBuffer partial(PartialModel partial, BlockState referenceState) {
-		return CreateClient.BUFFER_CACHE.get(PARTIAL, partial,
-				() -> BakedModelRenderHelper.standardModelRender(partial.get(), referenceState));
-	}
-
-	public static SuperByteBuffer partial(PartialModel partial, BlockState referenceState,
-			Supplier<PoseStack> modelTransform) {
-		return CreateClient.BUFFER_CACHE.get(PARTIAL, partial,
-				() -> BakedModelRenderHelper.standardModelRender(partial.get(), referenceState, modelTransform.get()));
-	}
-
-	public static SuperByteBuffer partialFacing(PartialModel partial, BlockState referenceState) {
-		Direction facing = referenceState.getValue(FACING);
-		return partialFacing(partial, referenceState, facing);
-	}
-
-	public static SuperByteBuffer partialFacing(PartialModel partial, BlockState referenceState, Direction facing) {
-		return partialDirectional(partial, referenceState, facing,
-			rotateToFace(facing));
-	}
-
-	public static SuperByteBuffer partialFacingVertical(PartialModel partial, BlockState referenceState, Direction facing) {
-		return partialDirectional(partial, referenceState, facing,
-			rotateToFaceVertical(facing));
-	}
-
-	public static SuperByteBuffer partialDirectional(PartialModel partial, BlockState referenceState, Direction dir,
-			Supplier<PoseStack> modelTransform) {
-		return CreateClient.BUFFER_CACHE.get(DIRECTIONAL_PARTIAL, Pair.of(dir, partial),
-			() -> BakedModelRenderHelper.standardModelRender(partial.get(), referenceState, modelTransform.get()));
-	}
-
-	public static Supplier<PoseStack> rotateToFace(Direction facing) {
-		return () -> {
-			PoseStack stack = new PoseStack();
-			TransformStack.cast(stack)
-				.centre()
-				.rotateY(AngleHelper.horizontalAngle(facing))
-				.rotateX(AngleHelper.verticalAngle(facing))
-				.unCentre();
-			return stack;
-		};
-	}
-
-	public static Supplier<PoseStack> rotateToFaceVertical(Direction facing) {
-		return () -> {
-			PoseStack stack = new PoseStack();
-			TransformStack.cast(stack)
-				.centre()
-				.rotateY(AngleHelper.horizontalAngle(facing))
-				.rotateX(AngleHelper.verticalAngle(facing) + 90)
-				.unCentre();
-			return stack;
-		};
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/render/ForcedDiffuseState.java

@@ -1,30 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.render;
-
-import com.jozufozu.flywheel.util.DiffuseLightCalculator;
-import it.unimi.dsi.fastutil.objects.ObjectArrayList;
-
-import javax.annotation.Nullable;
-
-public final class ForcedDiffuseState {
-	private static final ThreadLocal<ObjectArrayList<DiffuseLightCalculator>> FORCED_DIFFUSE = ThreadLocal.withInitial(ObjectArrayList::new);
-
-	private ForcedDiffuseState() {
-	}
-
-	public static void pushCalculator(DiffuseLightCalculator calculator) {
-		FORCED_DIFFUSE.get().push(calculator);
-	}
-
-	public static void popCalculator() {
-		FORCED_DIFFUSE.get().pop();
-	}
-
-	@Nullable
-	public static DiffuseLightCalculator getForcedCalculator() {
-		ObjectArrayList<DiffuseLightCalculator> stack = FORCED_DIFFUSE.get();
-		if (stack.isEmpty()) {
-			return null;
-		}
-		return stack.top();
-	}
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/render/RenderTypes.java

@@ -1,160 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.render;
-
-import com.mojang.blaze3d.vertex.DefaultVertexFormat;
-import com.mojang.blaze3d.vertex.VertexFormat;
-import nl.requios.effortlessbuilding.create.AllSpecialTextures;
-import nl.requios.effortlessbuilding.create.Create;
-import net.minecraft.client.renderer.RenderStateShard;
-import net.minecraft.client.renderer.RenderType;
-import net.minecraft.client.renderer.ShaderInstance;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.server.packs.resources.ResourceManager;
-import net.minecraft.world.inventory.InventoryMenu;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.client.event.RegisterShadersEvent;
-import net.minecraftforge.eventbus.api.SubscribeEvent;
-import net.minecraftforge.fml.common.Mod.EventBusSubscriber;
-
-import java.io.IOException;
-
-// TODO 1.17: use custom shaders instead of vanilla ones
-public class RenderTypes extends RenderStateShard {
-
-	public static final ShaderStateShard GLOWING_SHADER = new ShaderStateShard(() -> Shaders.glowingShader);
-
-	private static final RenderType OUTLINE_SOLID =
-		RenderType.create(createLayerName("outline_solid"), DefaultVertexFormat.NEW_ENTITY, VertexFormat.Mode.QUADS, 256, false,
-			false, RenderType.CompositeState.builder()
-				.setShaderState(RENDERTYPE_ENTITY_SOLID_SHADER)
-				.setTextureState(new TextureStateShard(AllSpecialTextures.BLANK.getLocation(), false, false))
-				.setCullState(CULL)
-				.setLightmapState(LIGHTMAP)
-				.setOverlayState(OVERLAY)
-				.createCompositeState(false));
-
-	public static RenderType getOutlineSolid() {
-		return OUTLINE_SOLID;
-	}
-
-	public static RenderType getOutlineTranslucent(ResourceLocation texture, boolean cull) {
-		return RenderType.create(createLayerName("outline_translucent" + (cull ? "_cull" : "")),
-			DefaultVertexFormat.NEW_ENTITY, VertexFormat.Mode.QUADS, 256, false, true, RenderType.CompositeState.builder()
-				.setShaderState(cull ? RENDERTYPE_ENTITY_TRANSLUCENT_CULL_SHADER : RENDERTYPE_ENTITY_TRANSLUCENT_SHADER)
-				.setTextureState(new TextureStateShard(texture, false, false))
-				.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-				.setCullState(cull ? CULL : NO_CULL)
-				.setLightmapState(LIGHTMAP)
-				.setOverlayState(OVERLAY)
-				.setWriteMaskState(COLOR_WRITE)
-				.createCompositeState(false));
-	}
-
-	public static RenderType getGlowingSolid(ResourceLocation texture) {
-		return RenderType.create(createLayerName("glowing_solid"), DefaultVertexFormat.NEW_ENTITY, VertexFormat.Mode.QUADS, 256,
-			true, false, RenderType.CompositeState.builder()
-				.setShaderState(GLOWING_SHADER)
-				.setTextureState(new TextureStateShard(texture, false, false))
-				.setCullState(CULL)
-				.setLightmapState(LIGHTMAP)
-				.setOverlayState(OVERLAY)
-				.createCompositeState(true));
-	}
-
-	private static final RenderType GLOWING_SOLID_DEFAULT = getGlowingSolid(InventoryMenu.BLOCK_ATLAS);
-
-	public static RenderType getGlowingSolid() {
-		return GLOWING_SOLID_DEFAULT;
-	}
-
-	public static RenderType getGlowingTranslucent(ResourceLocation texture) {
-		return RenderType.create(createLayerName("glowing_translucent"), DefaultVertexFormat.NEW_ENTITY, VertexFormat.Mode.QUADS,
-			256, true, true, RenderType.CompositeState.builder()
-				.setShaderState(GLOWING_SHADER)
-				.setTextureState(new TextureStateShard(texture, false, false))
-				.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-				.setLightmapState(LIGHTMAP)
-				.setOverlayState(OVERLAY)
-				.createCompositeState(true));
-	}
-
-	private static final RenderType ADDITIVE = RenderType.create(createLayerName("additive"), DefaultVertexFormat.BLOCK,
-		VertexFormat.Mode.QUADS, 256, true, true, RenderType.CompositeState.builder()
-			.setShaderState(BLOCK_SHADER)
-			.setTextureState(new TextureStateShard(InventoryMenu.BLOCK_ATLAS, false, false))
-			.setTransparencyState(ADDITIVE_TRANSPARENCY)
-			.setCullState(NO_CULL)
-			.setLightmapState(LIGHTMAP)
-			.setOverlayState(OVERLAY)
-			.createCompositeState(true));
-
-	public static RenderType getAdditive() {
-		return ADDITIVE;
-	}
-
-	private static final RenderType GLOWING_TRANSLUCENT_DEFAULT = getGlowingTranslucent(InventoryMenu.BLOCK_ATLAS);
-
-	public static RenderType getGlowingTranslucent() {
-		return GLOWING_TRANSLUCENT_DEFAULT;
-	}
-
-	private static final RenderType ITEM_PARTIAL_SOLID =
-		RenderType.create(createLayerName("item_partial_solid"), DefaultVertexFormat.NEW_ENTITY, VertexFormat.Mode.QUADS, 256, true,
-			false, RenderType.CompositeState.builder()
-				.setShaderState(RENDERTYPE_ENTITY_SOLID_SHADER)
-				.setTextureState(BLOCK_SHEET)
-				.setCullState(CULL)
-				.setLightmapState(LIGHTMAP)
-				.setOverlayState(OVERLAY)
-				.createCompositeState(true));
-
-	public static RenderType getItemPartialSolid() {
-		return ITEM_PARTIAL_SOLID;
-	}
-
-	private static final RenderType ITEM_PARTIAL_TRANSLUCENT = RenderType.create(createLayerName("item_partial_translucent"),
-		DefaultVertexFormat.NEW_ENTITY, VertexFormat.Mode.QUADS, 256, true, true, RenderType.CompositeState.builder()
-			.setShaderState(RENDERTYPE_ENTITY_TRANSLUCENT_CULL_SHADER)
-			.setTextureState(BLOCK_SHEET)
-			.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-			.setLightmapState(LIGHTMAP)
-			.setOverlayState(OVERLAY)
-			.createCompositeState(true));
-
-	public static RenderType getItemPartialTranslucent() {
-		return ITEM_PARTIAL_TRANSLUCENT;
-	}
-
-	private static final RenderType FLUID = RenderType.create(createLayerName("fluid"),
-		DefaultVertexFormat.NEW_ENTITY, VertexFormat.Mode.QUADS, 256, false, true, RenderType.CompositeState.builder()
-			.setShaderState(RENDERTYPE_ENTITY_TRANSLUCENT_CULL_SHADER)
-			.setTextureState(BLOCK_SHEET_MIPPED)
-			.setTransparencyState(TRANSLUCENT_TRANSPARENCY)
-			.setLightmapState(LIGHTMAP)
-			.setOverlayState(OVERLAY)
-			.createCompositeState(true));
-
-	public static RenderType getFluid() {
-		return FLUID;
-	}
-
-	private static String createLayerName(String name) {
-		return Create.ID + ":" + name;
-	}
-
-	// Mmm gimme those protected fields
-	private RenderTypes() {
-		super(null, null, null);
-	}
-
-	@EventBusSubscriber(value = Dist.CLIENT, bus = EventBusSubscriber.Bus.MOD)
-	private static class Shaders {
-		private static ShaderInstance glowingShader;
-
-		@SubscribeEvent
-		public static void onRegisterShaders(RegisterShadersEvent event) throws IOException {
-			ResourceManager resourceManager = event.getResourceManager();
-			event.registerShader(new ShaderInstance(resourceManager, Create.asResource("glowing_shader"), DefaultVertexFormat.NEW_ENTITY), shader -> glowingShader = shader);
-		}
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/render/ShadowRenderHelper.java

@@ -1,112 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.render;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.vertex.VertexConsumer;
-import net.minecraft.client.renderer.LightTexture;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.RenderType;
-import net.minecraft.client.renderer.texture.OverlayTexture;
-import net.minecraft.core.BlockPos;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.util.Mth;
-import net.minecraft.world.level.LevelReader;
-import net.minecraft.world.level.block.RenderShape;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.phys.AABB;
-import net.minecraft.world.phys.Vec3;
-import net.minecraft.world.phys.shapes.VoxelShape;
-
-/**
- * Taken from EntityRendererManager
- */
-public class ShadowRenderHelper {
-
-	private static final RenderType SHADOW_LAYER =
-		RenderType.entityNoOutline(new ResourceLocation("textures/misc/shadow.png"));
-
-	public static void renderShadow(PoseStack matrixStack, MultiBufferSource buffer, float opacity, float radius) {
-		PoseStack.Pose entry = matrixStack.last();
-		VertexConsumer builder = buffer.getBuffer(SHADOW_LAYER);
-
-		opacity /= 2;
-		shadowVertex(entry, builder, opacity, -1 * radius, 0, -1 * radius, 0, 0);
-		shadowVertex(entry, builder, opacity, -1 * radius, 0, 1 * radius, 0, 1);
-		shadowVertex(entry, builder, opacity, 1 * radius, 0, 1 * radius, 1, 1);
-		shadowVertex(entry, builder, opacity, 1 * radius, 0, -1 * radius, 1, 0);
-	}
-
-	public static void renderShadow(PoseStack matrixStack, MultiBufferSource buffer, LevelReader world,
-		Vec3 pos, float opacity, float radius) {
-		float f = radius;
-
-		double d2 = pos.x();
-		double d0 = pos.y();
-		double d1 = pos.z();
-		int i = Mth.floor(d2 - (double) f);
-		int j = Mth.floor(d2 + (double) f);
-		int k = Mth.floor(d0 - (double) f);
-		int l = Mth.floor(d0);
-		int i1 = Mth.floor(d1 - (double) f);
-		int j1 = Mth.floor(d1 + (double) f);
-		PoseStack.Pose entry = matrixStack.last();
-		VertexConsumer builder = buffer.getBuffer(SHADOW_LAYER);
-
-		for (BlockPos blockpos : BlockPos.betweenClosed(new BlockPos(i, k, i1), new BlockPos(j, l, j1))) {
-			renderBlockShadow(entry, builder, world, blockpos, d2, d0, d1, f,
-				opacity);
-		}
-	}
-
-	private static void renderBlockShadow(PoseStack.Pose entry, VertexConsumer builder,
-		LevelReader world, BlockPos pos, double x, double y, double z,
-		float radius, float opacity) {
-		BlockPos blockpos = pos.below();
-		BlockState blockstate = world.getBlockState(blockpos);
-		if (blockstate.getRenderShape() != RenderShape.INVISIBLE && world.getMaxLocalRawBrightness(pos) > 3) {
-			if (blockstate.isCollisionShapeFullBlock(world, blockpos)) {
-				VoxelShape voxelshape = blockstate.getShape(world, pos.below());
-				if (!voxelshape.isEmpty()) {
-					float brightness = LightTexture.getBrightness(world.dimensionType(), world.getMaxLocalRawBrightness(pos));
-					float f = (float) ((opacity - (y - pos.getY()) / 2.0D) * 0.5D * brightness);
-					if (f >= 0.0F) {
-						if (f > 1.0F) {
-							f = 1.0F;
-						}
-
-						AABB AABB = voxelshape.bounds();
-						double d0 = (double) pos.getX() + AABB.minX;
-						double d1 = (double) pos.getX() + AABB.maxX;
-						double d2 = (double) pos.getY() + AABB.minY;
-						double d3 = (double) pos.getZ() + AABB.minZ;
-						double d4 = (double) pos.getZ() + AABB.maxZ;
-						float f1 = (float) (d0 - x);
-						float f2 = (float) (d1 - x);
-						float f3 = (float) (d2 - y + 0.015625D);
-						float f4 = (float) (d3 - z);
-						float f5 = (float) (d4 - z);
-						float f6 = -f1 / 2.0F / radius + 0.5F;
-						float f7 = -f2 / 2.0F / radius + 0.5F;
-						float f8 = -f4 / 2.0F / radius + 0.5F;
-						float f9 = -f5 / 2.0F / radius + 0.5F;
-						shadowVertex(entry, builder, f, f1, f3, f4, f6, f8);
-						shadowVertex(entry, builder, f, f1, f3, f5, f6, f9);
-						shadowVertex(entry, builder, f, f2, f3, f5, f7, f9);
-						shadowVertex(entry, builder, f, f2, f3, f4, f7, f8);
-					}
-				}
-			}
-		}
-	}
-
-	private static void shadowVertex(PoseStack.Pose entry, VertexConsumer builder, float alpha,
-		float x, float y, float z, float u, float v) {
-		builder.vertex(entry.pose(), x, y, z)
-			.color(1.0F, 1.0F, 1.0F, alpha)
-			.uv(u, v)
-			.overlayCoords(OverlayTexture.NO_OVERLAY)
-			.uv2(LightTexture.FULL_BRIGHT)
-			.normal(entry.normal(), 0.0F, 1.0F, 0.0F)
-			.endVertex();
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/render/SuperByteBuffer.java

@@ -1,464 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.render;
-
-import com.jozufozu.flywheel.api.vertex.ShadedVertexList;
-import com.jozufozu.flywheel.backend.ShadersModHandler;
-import com.jozufozu.flywheel.core.vertex.BlockVertexList;
-import com.jozufozu.flywheel.util.DiffuseLightCalculator;
-import com.jozufozu.flywheel.util.transform.TStack;
-import com.jozufozu.flywheel.util.transform.Transform;
-import com.mojang.blaze3d.vertex.BufferBuilder.DrawState;
-import com.mojang.blaze3d.vertex.BufferBuilder.RenderedBuffer;
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.vertex.VertexConsumer;
-import com.mojang.math.*;
-import nl.requios.effortlessbuilding.create.foundation.block.render.SpriteShiftEntry;
-import nl.requios.effortlessbuilding.create.foundation.utility.Color;
-import it.unimi.dsi.fastutil.longs.Long2IntMap;
-import it.unimi.dsi.fastutil.longs.Long2IntOpenHashMap;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.LevelRenderer;
-import net.minecraft.client.renderer.LightTexture;
-import net.minecraft.client.renderer.texture.OverlayTexture;
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.util.Mth;
-import net.minecraft.world.level.Level;
-
-public class SuperByteBuffer implements Transform<SuperByteBuffer>, TStack<SuperByteBuffer> {
-
-	private final ShadedVertexList template;
-
-	// Vertex Position
-	private final PoseStack transforms;
-
-	// Vertex Coloring
-	private boolean shouldColor;
-	private int r, g, b, a;
-	private boolean disableDiffuseMult;
-	private DiffuseLightCalculator diffuseCalculator;
-
-	// Vertex Texture Coords
-	private SpriteShiftFunc spriteShiftFunc;
-
-	// Vertex Overlay Color
-	private boolean hasOverlay;
-	private int overlay = OverlayTexture.NO_OVERLAY;
-
-	// Vertex Lighting
-	private boolean useWorldLight;
-	private Matrix4f lightTransform;
-	private boolean hasCustomLight;
-	private int packedLightCoords;
-	private boolean hybridLight;
-
-	// Vertex Normals
-	private boolean fullNormalTransform;
-
-	// Temporary
-	private static final Long2IntMap WORLD_LIGHT_CACHE = new Long2IntOpenHashMap();
-
-	public SuperByteBuffer(RenderedBuffer buf, int unshadedStartVertex) {
-		DrawState drawState = buf.drawState();
-		template = new BlockVertexList.Shaded(buf.vertexBuffer(), drawState.vertexCount(), drawState.format().getVertexSize(), unshadedStartVertex);
-
-		transforms = new PoseStack();
-		transforms.pushPose();
-	}
-
-	public void renderInto(PoseStack input, VertexConsumer builder) {
-		if (isEmpty())
-			return;
-
-		Matrix4f modelMat = input.last()
-			.pose()
-			.copy();
-		Matrix4f localTransforms = transforms.last()
-			.pose();
-		modelMat.multiply(localTransforms);
-
-		Matrix3f normalMat;
-		if (fullNormalTransform) {
-			normalMat = input.last()
-				.normal()
-				.copy();
-			Matrix3f localNormalTransforms = transforms.last()
-				.normal();
-			normalMat.mul(localNormalTransforms);
-		} else {
-			normalMat = transforms.last()
-				.normal()
-				.copy();
-		}
-
-		if (useWorldLight) {
-			WORLD_LIGHT_CACHE.clear();
-		}
-
-		final Vector4f pos = new Vector4f();
-		final Vector3f normal = new Vector3f();
-		final Vector4f lightPos = new Vector4f();
-
-		DiffuseLightCalculator diffuseCalculator = ForcedDiffuseState.getForcedCalculator();
-		final boolean disableDiffuseMult =
-			this.disableDiffuseMult || (ShadersModHandler.isShaderPackInUse() && diffuseCalculator == null);
-		if (diffuseCalculator == null) {
-			diffuseCalculator = this.diffuseCalculator;
-			if (diffuseCalculator == null) {
-				diffuseCalculator = DiffuseLightCalculator.forCurrentLevel();
-			}
-		}
-
-		final int vertexCount = template.getVertexCount();
-		for (int i = 0; i < vertexCount; i++) {
-			float x = template.getX(i);
-			float y = template.getY(i);
-			float z = template.getZ(i);
-
-			pos.set(x, y, z, 1F);
-			pos.transform(modelMat);
-			builder.vertex(pos.x(), pos.y(), pos.z());
-
-			float normalX = template.getNX(i);
-			float normalY = template.getNY(i);
-			float normalZ = template.getNZ(i);
-
-			normal.set(normalX, normalY, normalZ);
-			normal.transform(normalMat);
-			float nx = normal.x();
-			float ny = normal.y();
-			float nz = normal.z();
-
-			byte r, g, b, a;
-			if (shouldColor) {
-				r = (byte) this.r;
-				g = (byte) this.g;
-				b = (byte) this.b;
-				a = (byte) this.a;
-			} else {
-				r = template.getR(i);
-				g = template.getG(i);
-				b = template.getB(i);
-				a = template.getA(i);
-			}
-			if (disableDiffuseMult) {
-				builder.color(r, g, b, a);
-			} else {
-				float instanceDiffuse = diffuseCalculator.getDiffuse(nx, ny, nz, template.isShaded(i));
-				int colorR = transformColor(r, instanceDiffuse);
-				int colorG = transformColor(g, instanceDiffuse);
-				int colorB = transformColor(b, instanceDiffuse);
-				builder.color(colorR, colorG, colorB, a);
-			}
-
-			float u = template.getU(i);
-			float v = template.getV(i);
-			if (spriteShiftFunc != null) {
-				spriteShiftFunc.shift(builder, u, v);
-			} else {
-				builder.uv(u, v);
-			}
-
-			if (hasOverlay) {
-				builder.overlayCoords(overlay);
-			}
-
-			int light;
-			if (useWorldLight) {
-				lightPos.set(((x - .5f) * 15 / 16f) + .5f, (y - .5f) * 15 / 16f + .5f, (z - .5f) * 15 / 16f + .5f, 1f);
-				lightPos.transform(localTransforms);
-				if (lightTransform != null) {
-					lightPos.transform(lightTransform);
-				}
-
-				light = getLight(Minecraft.getInstance().level, lightPos);
-				if (hasCustomLight) {
-					light = maxLight(light, packedLightCoords);
-				}
-			} else if (hasCustomLight) {
-				light = packedLightCoords;
-			} else {
-				light = template.getLight(i);
-			}
-
-			if (hybridLight) {
-				builder.uv2(maxLight(light, template.getLight(i)));
-			} else {
-				builder.uv2(light);
-			}
-
-			builder.normal(nx, ny, nz);
-
-			builder.endVertex();
-		}
-
-		reset();
-	}
-
-	public SuperByteBuffer reset() {
-		while (!transforms.clear())
-			transforms.popPose();
-		transforms.pushPose();
-
-		shouldColor = false;
-		r = 0;
-		g = 0;
-		b = 0;
-		a = 0;
-		disableDiffuseMult = false;
-		diffuseCalculator = null;
-		spriteShiftFunc = null;
-		hasOverlay = false;
-		overlay = OverlayTexture.NO_OVERLAY;
-		useWorldLight = false;
-		lightTransform = null;
-		hasCustomLight = false;
-		packedLightCoords = 0;
-		hybridLight = false;
-		fullNormalTransform = false;
-		return this;
-	}
-
-	public boolean isEmpty() {
-		return template.isEmpty();
-	}
-
-	public PoseStack getTransforms() {
-		return transforms;
-	}
-
-	@Override
-	public SuperByteBuffer translate(double x, double y, double z) {
-		transforms.translate(x, y, z);
-		return this;
-	}
-
-	@Override
-	public SuperByteBuffer multiply(Quaternion quaternion) {
-		transforms.mulPose(quaternion);
-		return this;
-	}
-
-	@Override
-	public SuperByteBuffer scale(float factorX, float factorY, float factorZ) {
-		transforms.scale(factorX, factorY, factorZ);
-		return this;
-	}
-
-	@Override
-	public SuperByteBuffer pushPose() {
-		transforms.pushPose();
-		return this;
-	}
-
-	@Override
-	public SuperByteBuffer popPose() {
-		transforms.popPose();
-		return this;
-	}
-
-	@Override
-	public SuperByteBuffer mulPose(Matrix4f pose) {
-		transforms.last()
-			.pose()
-			.multiply(pose);
-		return this;
-	}
-
-	@Override
-	public SuperByteBuffer mulNormal(Matrix3f normal) {
-		transforms.last()
-			.normal()
-			.mul(normal);
-		return this;
-	}
-
-	public SuperByteBuffer transform(PoseStack stack) {
-		transforms.last()
-			.pose()
-			.multiply(stack.last()
-				.pose());
-		transforms.last()
-			.normal()
-			.mul(stack.last()
-				.normal());
-		return this;
-	}
-
-	public SuperByteBuffer rotateCentered(Direction axis, float radians) {
-		translate(.5f, .5f, .5f).rotate(axis, radians)
-			.translate(-.5f, -.5f, -.5f);
-		return this;
-	}
-
-	public SuperByteBuffer rotateCentered(Quaternion q) {
-		translate(.5f, .5f, .5f).multiply(q)
-			.translate(-.5f, -.5f, -.5f);
-		return this;
-	}
-
-	public SuperByteBuffer color(int r, int g, int b, int a) {
-		shouldColor = true;
-		this.r = r;
-		this.g = g;
-		this.b = b;
-		this.a = a;
-		return this;
-	}
-
-	public SuperByteBuffer color(int color) {
-		shouldColor = true;
-		r = ((color >> 16) & 0xFF);
-		g = ((color >> 8) & 0xFF);
-		b = (color & 0xFF);
-		a = 255;
-		return this;
-	}
-
-	public SuperByteBuffer color(Color c) {
-		return color(c.getRGB());
-	}
-
-	/**
-	 * Prevents vertex colors from being multiplied by the diffuse value calculated
-	 * from the final transformed normal vector. Useful for entity rendering, when
-	 * diffuse is applied automatically later.
-	 */
-	public SuperByteBuffer disableDiffuse() {
-		disableDiffuseMult = true;
-		return this;
-	}
-
-	public SuperByteBuffer diffuseCalculator(DiffuseLightCalculator diffuseCalculator) {
-		this.diffuseCalculator = diffuseCalculator;
-		return this;
-	}
-
-	public SuperByteBuffer shiftUV(SpriteShiftEntry entry) {
-		this.spriteShiftFunc = (builder, u, v) -> {
-			builder.uv(entry.getTargetU(u), entry.getTargetV(v));
-		};
-		return this;
-	}
-
-	public SuperByteBuffer shiftUVScrolling(SpriteShiftEntry entry, float scrollV) {
-		return this.shiftUVScrolling(entry, 0, scrollV);
-	}
-
-	public SuperByteBuffer shiftUVScrolling(SpriteShiftEntry entry, float scrollU, float scrollV) {
-		this.spriteShiftFunc = (builder, u, v) -> {
-			float targetU = u - entry.getOriginal()
-				.getU0() + entry.getTarget()
-					.getU0()
-				+ scrollU;
-			float targetV = v - entry.getOriginal()
-				.getV0() + entry.getTarget()
-					.getV0()
-				+ scrollV;
-			builder.uv(targetU, targetV);
-		};
-		return this;
-	}
-
-	public SuperByteBuffer shiftUVtoSheet(SpriteShiftEntry entry, float uTarget, float vTarget, int sheetSize) {
-		this.spriteShiftFunc = (builder, u, v) -> {
-			float targetU = entry.getTarget()
-				.getU((SpriteShiftEntry.getUnInterpolatedU(entry.getOriginal(), u) / sheetSize) + uTarget * 16);
-			float targetV = entry.getTarget()
-				.getV((SpriteShiftEntry.getUnInterpolatedV(entry.getOriginal(), v) / sheetSize) + vTarget * 16);
-			builder.uv(targetU, targetV);
-		};
-		return this;
-	}
-
-	public SuperByteBuffer overlay() {
-		hasOverlay = true;
-		return this;
-	}
-
-	public SuperByteBuffer overlay(int overlay) {
-		hasOverlay = true;
-		this.overlay = overlay;
-		return this;
-	}
-
-	public SuperByteBuffer light() {
-		useWorldLight = true;
-		return this;
-	}
-
-	public SuperByteBuffer light(Matrix4f lightTransform) {
-		useWorldLight = true;
-		this.lightTransform = lightTransform;
-		return this;
-	}
-
-	public SuperByteBuffer light(int packedLightCoords) {
-		hasCustomLight = true;
-		this.packedLightCoords = packedLightCoords;
-		return this;
-	}
-
-	public SuperByteBuffer light(Matrix4f lightTransform, int packedLightCoords) {
-		light(lightTransform);
-		light(packedLightCoords);
-		return this;
-	}
-
-	/**
-	 * Uses max light from calculated light (world light or custom light) and vertex
-	 * light for the final light value. Ineffective if any other light method was
-	 * not called.
-	 */
-	public SuperByteBuffer hybridLight() {
-		hybridLight = true;
-		return this;
-	}
-
-	/**
-	 * Transforms normals not only by the local matrix stack, but also by the passed
-	 * matrix stack.
-	 */
-	public SuperByteBuffer fullNormalTransform() {
-		fullNormalTransform = true;
-		return this;
-	}
-
-	public SuperByteBuffer forEntityRender() {
-		disableDiffuse();
-		overlay();
-		fullNormalTransform();
-		return this;
-	}
-
-	public static int transformColor(byte component, float scale) {
-		return Mth.clamp((int) (Byte.toUnsignedInt(component) * scale), 0, 255);
-	}
-
-	public static int transformColor(int component, float scale) {
-		return Mth.clamp((int) (component * scale), 0, 255);
-	}
-
-	public static int maxLight(int packedLight1, int packedLight2) {
-		int blockLight1 = LightTexture.block(packedLight1);
-		int skyLight1 = LightTexture.sky(packedLight1);
-		int blockLight2 = LightTexture.block(packedLight2);
-		int skyLight2 = LightTexture.sky(packedLight2);
-		return LightTexture.pack(Math.max(blockLight1, blockLight2), Math.max(skyLight1, skyLight2));
-	}
-
-	private static int getLight(Level world, Vector4f lightPos) {
-		BlockPos pos = new BlockPos(lightPos.x(), lightPos.y(), lightPos.z());
-		return WORLD_LIGHT_CACHE.computeIfAbsent(pos.asLong(), $ -> LevelRenderer.getLightColor(world, pos));
-	}
-
-	@FunctionalInterface
-	public interface SpriteShiftFunc {
-		void shift(VertexConsumer builder, float u, float v);
-	}
-
-	@FunctionalInterface
-	public interface VertexLighter {
-		int getPackedLight(float x, float y, float z);
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/render/SuperByteBufferCache.java

@@ -1,54 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.render;
-
-import com.google.common.cache.Cache;
-import com.google.common.cache.CacheBuilder;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.concurrent.Callable;
-import java.util.concurrent.ExecutionException;
-import java.util.concurrent.TimeUnit;
-
-public class SuperByteBufferCache {
-
-	protected final Map<Compartment<?>, Cache<Object, SuperByteBuffer>> caches = new HashMap<>();
-
-	public synchronized void registerCompartment(Compartment<?> compartment) {
-		caches.put(compartment, CacheBuilder.newBuilder()
-			.build());
-	}
-
-	public synchronized void registerCompartment(Compartment<?> compartment, long ticksUntilExpired) {
-		caches.put(compartment, CacheBuilder.newBuilder()
-			.expireAfterAccess(ticksUntilExpired * 50, TimeUnit.MILLISECONDS)
-			.build());
-	}
-
-	public <T> SuperByteBuffer get(Compartment<T> compartment, T key, Callable<SuperByteBuffer> callable) {
-		Cache<Object, SuperByteBuffer> cache = caches.get(compartment);
-		if (cache != null) {
-			try {
-				return cache.get(key, callable);
-			} catch (ExecutionException e) {
-				e.printStackTrace();
-			}
-		}
-		return null;
-	}
-
-	public <T> void invalidate(Compartment<T> compartment, T key) {
-		caches.get(compartment).invalidate(key);
-	}
-
-	public <T> void invalidate(Compartment<?> compartment) {
-		caches.get(compartment).invalidateAll();
-	}
-
-	public void invalidate() {
-		caches.forEach((compartment, cache) -> cache.invalidateAll());
-	}
-
-	public static class Compartment<T> {
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/render/SuperRenderTypeBuffer.java

@@ -1,94 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.render;
-
-import com.mojang.blaze3d.vertex.BufferBuilder;
-import com.mojang.blaze3d.vertex.VertexConsumer;
-import it.unimi.dsi.fastutil.objects.Object2ObjectLinkedOpenHashMap;
-import net.minecraft.Util;
-import net.minecraft.client.renderer.ChunkBufferBuilderPack;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.RenderType;
-import net.minecraft.client.renderer.Sheets;
-import net.minecraft.client.resources.model.ModelBakery;
-
-import java.util.SortedMap;
-
-public class SuperRenderTypeBuffer implements MultiBufferSource {
-
-	private static final SuperRenderTypeBuffer INSTANCE = new SuperRenderTypeBuffer();
-
-	public static SuperRenderTypeBuffer getInstance() {
-		return INSTANCE;
-	}
-
-	private SuperRenderTypeBufferPhase earlyBuffer;
-	private SuperRenderTypeBufferPhase defaultBuffer;
-	private SuperRenderTypeBufferPhase lateBuffer;
-
-	public SuperRenderTypeBuffer() {
-		earlyBuffer = new SuperRenderTypeBufferPhase();
-		defaultBuffer = new SuperRenderTypeBufferPhase();
-		lateBuffer = new SuperRenderTypeBufferPhase();
-	}
-
-	public VertexConsumer getEarlyBuffer(RenderType type) {
-		return earlyBuffer.bufferSource.getBuffer(type);
-	}
-
-	@Override
-	public VertexConsumer getBuffer(RenderType type) {
-		return defaultBuffer.bufferSource.getBuffer(type);
-	}
-
-	public VertexConsumer getLateBuffer(RenderType type) {
-		return lateBuffer.bufferSource.getBuffer(type);
-	}
-
-	public void draw() {
-		earlyBuffer.bufferSource.endBatch();
-		defaultBuffer.bufferSource.endBatch();
-		lateBuffer.bufferSource.endBatch();
-	}
-
-	public void draw(RenderType type) {
-		earlyBuffer.bufferSource.endBatch(type);
-		defaultBuffer.bufferSource.endBatch(type);
-		lateBuffer.bufferSource.endBatch(type);
-	}
-
-	private static class SuperRenderTypeBufferPhase {
-
-		// Visible clones from RenderBuffers
-		private final ChunkBufferBuilderPack fixedBufferPack = new ChunkBufferBuilderPack();
-		private final SortedMap<RenderType, BufferBuilder> fixedBuffers = Util.make(new Object2ObjectLinkedOpenHashMap<>(), map -> {
-				map.put(Sheets.solidBlockSheet(), fixedBufferPack.builder(RenderType.solid()));
-				map.put(Sheets.cutoutBlockSheet(), fixedBufferPack.builder(RenderType.cutout()));
-				map.put(Sheets.bannerSheet(), fixedBufferPack.builder(RenderType.cutoutMipped()));
-				map.put(Sheets.translucentCullBlockSheet(), fixedBufferPack.builder(RenderType.translucent()));
-				put(map, Sheets.shieldSheet());
-				put(map, Sheets.bedSheet());
-				put(map, Sheets.shulkerBoxSheet());
-				put(map, Sheets.signSheet());
-				put(map, Sheets.chestSheet());
-				put(map, RenderType.translucentNoCrumbling());
-				put(map, RenderType.armorGlint());
-				put(map, RenderType.armorEntityGlint());
-				put(map, RenderType.glint());
-				put(map, RenderType.glintDirect());
-				put(map, RenderType.glintTranslucent());
-				put(map, RenderType.entityGlint());
-				put(map, RenderType.entityGlintDirect());
-				put(map, RenderType.waterMask());
-				put(map, RenderTypes.getOutlineSolid());
-				ModelBakery.DESTROY_TYPES.forEach((p_173062_) -> {
-					put(map, p_173062_);
-				});
-			});
-		private final BufferSource bufferSource = MultiBufferSource.immediateWithBuffers(fixedBuffers, new BufferBuilder(256));
-
-		private static void put(Object2ObjectLinkedOpenHashMap<RenderType, BufferBuilder> map, RenderType type) {
-			map.put(type, new BufferBuilder(type.bufferSize()));
-		}
-
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/render/TileEntityRenderHelper.java

@@ -1,113 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.render;
-
-import com.jozufozu.flywheel.backend.Backend;
-import com.jozufozu.flywheel.backend.instancing.InstancedRenderRegistry;
-import com.jozufozu.flywheel.config.BackendType;
-import com.jozufozu.flywheel.core.virtual.VirtualRenderWorld;
-import com.jozufozu.flywheel.util.transform.TransformStack;
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.math.Matrix4f;
-import com.mojang.math.Vector4f;
-import nl.requios.effortlessbuilding.create.Create;
-import nl.requios.effortlessbuilding.create.foundation.utility.AnimationTickHolder;
-import nl.requios.effortlessbuilding.create.foundation.utility.RegisteredObjects;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.renderer.LevelRenderer;
-import net.minecraft.client.renderer.MultiBufferSource;
-import net.minecraft.client.renderer.blockentity.BlockEntityRenderer;
-import net.minecraft.client.renderer.texture.OverlayTexture;
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.block.entity.BlockEntity;
-
-import javax.annotation.Nullable;
-import java.util.Iterator;
-
-public class TileEntityRenderHelper {
-
-	public static void renderTileEntities(Level world, Iterable<BlockEntity> customRenderTEs, PoseStack ms,
-			MultiBufferSource buffer) {
-		renderTileEntities(world, null, customRenderTEs, ms, null, buffer);
-	}
-
-	public static void renderTileEntities(Level world, Iterable<BlockEntity> customRenderTEs, PoseStack ms,
-			MultiBufferSource buffer, float pt) {
-		renderTileEntities(world, null, customRenderTEs, ms, null, buffer, pt);
-	}
-
-	public static void renderTileEntities(Level world, @Nullable VirtualRenderWorld renderWorld,
-			Iterable<BlockEntity> customRenderTEs, PoseStack ms, @Nullable Matrix4f lightTransform, MultiBufferSource buffer) {
-		renderTileEntities(world, renderWorld, customRenderTEs, ms, lightTransform, buffer,
-			AnimationTickHolder.getPartialTicks());
-	}
-
-	public static void renderTileEntities(Level world, @Nullable VirtualRenderWorld renderWorld,
-			Iterable<BlockEntity> customRenderTEs, PoseStack ms, @Nullable Matrix4f lightTransform, MultiBufferSource buffer,
-			float pt) {
-		Iterator<BlockEntity> iterator = customRenderTEs.iterator();
-		while (iterator.hasNext()) {
-			BlockEntity tileEntity = iterator.next();
-			if (Backend.getBackendType() == BackendType.INSTANCING && Backend.isFlywheelWorld(renderWorld) && InstancedRenderRegistry.shouldSkipRender(tileEntity))
-				continue;
-
-			BlockEntityRenderer<BlockEntity> renderer = Minecraft.getInstance().getBlockEntityRenderDispatcher().getRenderer(tileEntity);
-			if (renderer == null) {
-				iterator.remove();
-				continue;
-			}
-
-			BlockPos pos = tileEntity.getBlockPos();
-			ms.pushPose();
-			TransformStack.cast(ms)
-				.translate(pos);
-
-			try {
-				int worldLight = getCombinedLight(world, getLightPos(lightTransform, pos), renderWorld, pos);
-
-				if (renderWorld != null) {
-					// Swap the real world for the render world so that the renderer gets contraption-local information
-					tileEntity.setLevel(renderWorld);
-					renderer.render(tileEntity, pt, ms, buffer, worldLight, OverlayTexture.NO_OVERLAY);
-					tileEntity.setLevel(world);
-				} else {
-					renderer.render(tileEntity, pt, ms, buffer, worldLight, OverlayTexture.NO_OVERLAY);
-				}
-
-			} catch (Exception e) {
-				iterator.remove();
-
-				String message = "BlockEntity " + RegisteredObjects.getKeyOrThrow(tileEntity.getType())
-					.toString() + " could not be rendered virtually.";
-//				if (AllConfigs.CLIENT.explainRenderErrors.get())
-					Create.LOGGER.error(message, e);
-//				else
-//					Create.LOGGER.error(message);
-			}
-
-			ms.popPose();
-		}
-	}
-
-	private static BlockPos getLightPos(@Nullable Matrix4f lightTransform, BlockPos contraptionPos) {
-		if (lightTransform != null) {
-			Vector4f lightVec = new Vector4f(contraptionPos.getX() + .5f, contraptionPos.getY() + .5f, contraptionPos.getZ() + .5f, 1);
-			lightVec.transform(lightTransform);
-			return new BlockPos(lightVec.x(), lightVec.y(), lightVec.z());
-		} else {
-			return contraptionPos;
-		}
-	}
-
-	public static int getCombinedLight(Level world, BlockPos worldPos, @Nullable VirtualRenderWorld renderWorld,
-			BlockPos renderWorldPos) {
-		int worldLight = LevelRenderer.getLightColor(world, worldPos);
-
-		if (renderWorld != null) {
-			int renderWorldLight = LevelRenderer.getLightColor(renderWorld, renderWorldPos);
-			return SuperByteBuffer.maxLight(worldLight, renderWorldLight);
-		}
-
-		return worldLight;
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/AbstractBlockBreakQueue.java

@@ -1,36 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.InteractionHand;
-import net.minecraft.world.entity.LivingEntity;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.level.Level;
-import net.minecraftforge.event.ForgeEventFactory;
-
-import javax.annotation.Nullable;
-import java.util.function.BiConsumer;
-import java.util.function.Consumer;
-
-public abstract class AbstractBlockBreakQueue {
-	protected Consumer<BlockPos> makeCallbackFor(Level world, float effectChance, ItemStack toDamage,
-		@Nullable Player playerEntity, BiConsumer<BlockPos, ItemStack> drop) {
-		return pos -> {
-			ItemStack usedTool = toDamage.copy();
-			BlockHelper.destroyBlockAs(world, pos, playerEntity, toDamage, effectChance,
-				stack -> drop.accept(pos, stack));
-			if (toDamage.isEmpty() && !usedTool.isEmpty())
-				ForgeEventFactory.onPlayerDestroyItem(playerEntity, usedTool, InteractionHand.MAIN_HAND);
-		};
-	}
-
-	public void destroyBlocks(Level world, @Nullable LivingEntity entity, BiConsumer<BlockPos, ItemStack> drop) {
-		Player playerEntity = entity instanceof Player ? ((Player) entity) : null;
-		ItemStack toDamage =
-			playerEntity != null && !playerEntity.isCreative() ? playerEntity.getMainHandItem() : ItemStack.EMPTY;
-		destroyBlocks(world, toDamage, playerEntity, drop);
-	}
-
-	public abstract void destroyBlocks(Level world, ItemStack toDamage, @Nullable Player playerEntity,
-		BiConsumer<BlockPos, ItemStack> drop);
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/AngleHelper.java

@@ -1,52 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.core.Direction;
-import net.minecraft.core.Direction.Axis;
-import net.minecraft.util.Mth;
-
-public class AngleHelper {
-
-	public static float horizontalAngle(Direction facing) {
-		if (facing.getAxis().isVertical())
-			return 0;
-		float angle = facing.toYRot();
-		if (facing.getAxis() == Axis.X)
-			angle = -angle;
-		return angle;
-	}
-
-	public static float verticalAngle(Direction facing) {
-		return facing == Direction.UP ? -90 : facing == Direction.DOWN ? 90 : 0;
-	}
-
-	public static float rad(double angle) {
-		if (angle == 0)
-			return 0;
-		return (float) (angle / 180 * Math.PI);
-	}
-
-	public static float deg(double angle) {
-		if (angle == 0)
-			return 0;
-		return (float) (angle * 180 / Math.PI);
-	}
-
-	public static float angleLerp(double pct, double current, double target) {
-		return (float) (current + getShortestAngleDiff(current, target) * pct);
-	}
-
-	public static float getShortestAngleDiff(double current, double target) {
-		current = current % 360;
-		target = target % 360;
-		return (float) (((((target - current) % 360) + 540) % 360) - 180);
-	}
-
-	public static float getShortestAngleDiff(double current, double target, float hint) {
-		float diff = getShortestAngleDiff(current, target);
-		if (Mth.equal(Math.abs(diff), 180) && Math.signum(diff) != Math.signum(hint)) {
-			return diff + 360*Math.signum(hint);
-		}
-		return diff;
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/AnimationTickHolder.java

@@ -1,56 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import nl.requios.effortlessbuilding.create.foundation.utility.worldWrappers.WrappedClientWorld;
-import net.minecraft.client.Minecraft;
-import net.minecraft.world.level.LevelAccessor;
-
-public class AnimationTickHolder {
-
-	private static int ticks;
-	private static int pausedTicks;
-
-	public static void reset() {
-		ticks = 0;
-		pausedTicks = 0;
-	}
-
-	public static void tick() {
-		if (!Minecraft.getInstance()
-			.isPaused()) {
-			ticks = (ticks + 1) % 1_728_000; // wrap around every 24 hours so we maintain enough floating point precision
-		} else {
-			pausedTicks = (pausedTicks + 1) % 1_728_000;
-		}
-	}
-
-	public static int getTicks() {
-		return getTicks(false);
-	}
-
-	public static int getTicks(boolean includePaused) {
-		return includePaused ? ticks + pausedTicks : ticks;
-	}
-
-	public static float getRenderTime() {
-		return getTicks() + getPartialTicks();
-	}
-
-	public static float getPartialTicks() {
-		Minecraft mc = Minecraft.getInstance();
-		return (mc.isPaused() ? mc.pausePartialTick : mc.getFrameTime());
-	}
-
-	public static int getTicks(LevelAccessor world) {
-		if (world instanceof WrappedClientWorld)
-			return getTicks(((WrappedClientWorld) world).getWrappedWorld());
-		return getTicks();
-	}
-
-	public static float getRenderTime(LevelAccessor world) {
-		return getTicks(world) + getPartialTicks(world);
-	}
-
-	public static float getPartialTicks(LevelAccessor world) {
-		return getPartialTicks();
-	}
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/BBHelper.java

@@ -1,20 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.world.level.levelgen.structure.BoundingBox;
-
-public class BBHelper {
-
-	public static BoundingBox encapsulate(BoundingBox bb, BlockPos pos) {
-		return new BoundingBox(Math.min(bb.minX(), pos.getX()), Math.min(bb.minY(), pos.getY()),
-			Math.min(bb.minZ(), pos.getZ()), Math.max(bb.maxX(), pos.getX()), Math.max(bb.maxY(), pos.getY()),
-			Math.max(bb.maxZ(), pos.getZ()));
-	}
-
-	public static BoundingBox encapsulate(BoundingBox bb, BoundingBox bb2) {
-		return new BoundingBox(Math.min(bb.minX(), bb2.minX()), Math.min(bb.minY(), bb2.minY()),
-			Math.min(bb.minZ(), bb2.minZ()), Math.max(bb.maxX(), bb2.maxX()), Math.max(bb.maxY(), bb2.maxY()),
-			Math.max(bb.maxZ(), bb2.maxZ()));
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/BlockFace.java

@@ -1,52 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.NbtUtils;
-
-public class BlockFace extends Pair<BlockPos, Direction> {
-
-	public BlockFace(BlockPos first, Direction second) {
-		super(first, second);
-	}
-
-	public boolean isEquivalent(BlockFace other) {
-		if (equals(other))
-			return true;
-		return getConnectedPos().equals(other.getPos()) && getPos().equals(other.getConnectedPos());
-	}
-
-	public BlockPos getPos() {
-		return getFirst();
-	}
-
-	public Direction getFace() {
-		return getSecond();
-	}
-
-	public Direction getOppositeFace() {
-		return getSecond().getOpposite();
-	}
-
-	public BlockFace getOpposite() {
-		return new BlockFace(getConnectedPos(), getOppositeFace());
-	}
-
-	public BlockPos getConnectedPos() {
-		return getPos().relative(getFace());
-	}
-
-	public CompoundTag serializeNBT() {
-		CompoundTag compoundNBT = new CompoundTag();
-		compoundNBT.put("Pos", NbtUtils.writeBlockPos(getPos()));
-		NBTHelper.writeEnum(compoundNBT, "Face", getFace());
-		return compoundNBT;
-	}
-
-	public static BlockFace fromNBT(CompoundTag compound) {
-		return new BlockFace(NbtUtils.readBlockPos(compound.getCompound("Pos")),
-			NBTHelper.readEnum(compound, "Face", Direction.class));
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/BlockHelper.java

@@ -1,337 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.core.BlockPos;
-import net.minecraft.core.Direction;
-import net.minecraft.core.Registry;
-import net.minecraft.core.SectionPos;
-import net.minecraft.core.particles.ParticleTypes;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.sounds.SoundEvents;
-import net.minecraft.sounds.SoundSource;
-import net.minecraft.stats.Stats;
-import net.minecraft.tags.BlockTags;
-import net.minecraft.tags.FluidTags;
-import net.minecraft.world.entity.player.Player;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.ItemStack;
-import net.minecraft.world.item.Items;
-import net.minecraft.world.item.enchantment.Enchantments;
-import net.minecraft.world.level.BlockGetter;
-import net.minecraft.world.level.GameRules;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.level.block.*;
-import net.minecraft.world.level.block.entity.BlockEntity;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.level.block.state.properties.BlockStateProperties;
-import net.minecraft.world.level.block.state.properties.Property;
-import net.minecraft.world.level.block.state.properties.SlabType;
-import net.minecraft.world.level.chunk.LevelChunk;
-import net.minecraft.world.level.chunk.LevelChunkSection;
-import net.minecraft.world.level.material.FluidState;
-import net.minecraft.world.level.material.Material;
-import net.minecraftforge.common.IPlantable;
-import net.minecraftforge.common.MinecraftForge;
-import net.minecraftforge.event.level.BlockEvent;
-
-import javax.annotation.Nullable;
-import java.util.function.Consumer;
-
-public class BlockHelper {
-
-	public static BlockState setZeroAge(BlockState blockState) {
-		if (blockState.hasProperty(BlockStateProperties.AGE_1))
-			return blockState.setValue(BlockStateProperties.AGE_1, 0);
-		if (blockState.hasProperty(BlockStateProperties.AGE_2))
-			return blockState.setValue(BlockStateProperties.AGE_2, 0);
-		if (blockState.hasProperty(BlockStateProperties.AGE_3))
-			return blockState.setValue(BlockStateProperties.AGE_3, 0);
-		if (blockState.hasProperty(BlockStateProperties.AGE_5))
-			return blockState.setValue(BlockStateProperties.AGE_5, 0);
-		if (blockState.hasProperty(BlockStateProperties.AGE_7))
-			return blockState.setValue(BlockStateProperties.AGE_7, 0);
-		if (blockState.hasProperty(BlockStateProperties.AGE_15))
-			return blockState.setValue(BlockStateProperties.AGE_15, 0);
-		if (blockState.hasProperty(BlockStateProperties.AGE_25))
-			return blockState.setValue(BlockStateProperties.AGE_25, 0);
-		if (blockState.hasProperty(BlockStateProperties.LEVEL_HONEY))
-			return blockState.setValue(BlockStateProperties.LEVEL_HONEY, 0);
-		if (blockState.hasProperty(BlockStateProperties.HATCH))
-			return blockState.setValue(BlockStateProperties.HATCH, 0);
-		if (blockState.hasProperty(BlockStateProperties.STAGE))
-			return blockState.setValue(BlockStateProperties.STAGE, 0);
-		if (blockState.is(BlockTags.CAULDRONS))
-			return Blocks.CAULDRON.defaultBlockState();
-		if (blockState.hasProperty(BlockStateProperties.LEVEL_COMPOSTER))
-			return blockState.setValue(BlockStateProperties.LEVEL_COMPOSTER, 0);
-		if (blockState.hasProperty(BlockStateProperties.EXTENDED))
-			return blockState.setValue(BlockStateProperties.EXTENDED, false);
-		return blockState;
-	}
-
-	public static int findAndRemoveInInventory(BlockState block, Player player, int amount) {
-		int amountFound = 0;
-		Item required = getRequiredItem(block).getItem();
-
-		boolean needsTwo = block.hasProperty(BlockStateProperties.SLAB_TYPE)
-			&& block.getValue(BlockStateProperties.SLAB_TYPE) == SlabType.DOUBLE;
-
-		if (needsTwo)
-			amount *= 2;
-
-		if (block.hasProperty(BlockStateProperties.EGGS))
-			amount *= block.getValue(BlockStateProperties.EGGS);
-
-		if (block.hasProperty(BlockStateProperties.PICKLES))
-			amount *= block.getValue(BlockStateProperties.PICKLES);
-
-		{
-			// Try held Item first
-			int preferredSlot = player.getInventory().selected;
-			ItemStack itemstack = player.getInventory()
-				.getItem(preferredSlot);
-			int count = itemstack.getCount();
-			if (itemstack.getItem() == required && count > 0) {
-				int taken = Math.min(count, amount - amountFound);
-				player.getInventory()
-					.setItem(preferredSlot, new ItemStack(itemstack.getItem(), count - taken));
-				amountFound += taken;
-			}
-		}
-
-		// Search inventory
-		for (int i = 0; i < player.getInventory()
-			.getContainerSize(); ++i) {
-			if (amountFound == amount)
-				break;
-
-			ItemStack itemstack = player.getInventory()
-				.getItem(i);
-			int count = itemstack.getCount();
-			if (itemstack.getItem() == required && count > 0) {
-				int taken = Math.min(count, amount - amountFound);
-				player.getInventory()
-					.setItem(i, new ItemStack(itemstack.getItem(), count - taken));
-				amountFound += taken;
-			}
-		}
-
-		if (needsTwo) {
-			// Give back 1 if uneven amount was removed
-			if (amountFound % 2 != 0)
-				player.getInventory()
-					.add(new ItemStack(required));
-			amountFound /= 2;
-		}
-
-		return amountFound;
-	}
-
-	public static ItemStack getRequiredItem(BlockState state) {
-		ItemStack itemStack = new ItemStack(state.getBlock());
-		Item item = itemStack.getItem();
-		if (item == Items.FARMLAND || item == Items.DIRT_PATH)
-			itemStack = new ItemStack(Items.DIRT);
-		return itemStack;
-	}
-
-	public static void destroyBlock(Level world, BlockPos pos, float effectChance) {
-		destroyBlock(world, pos, effectChance, stack -> Block.popResource(world, pos, stack));
-	}
-
-	public static void destroyBlock(Level world, BlockPos pos, float effectChance,
-		Consumer<ItemStack> droppedItemCallback) {
-		destroyBlockAs(world, pos, null, ItemStack.EMPTY, effectChance, droppedItemCallback);
-	}
-
-	public static void destroyBlockAs(Level world, BlockPos pos, @Nullable Player player, ItemStack usedTool,
-		float effectChance, Consumer<ItemStack> droppedItemCallback) {
-		FluidState fluidState = world.getFluidState(pos);
-		BlockState state = world.getBlockState(pos);
-		
-		if (world.random.nextFloat() < effectChance)
-			world.levelEvent(2001, pos, Block.getId(state));
-		BlockEntity tileentity = state.hasBlockEntity() ? world.getBlockEntity(pos) : null;
-		
-		if (player != null) {
-			BlockEvent.BreakEvent event = new BlockEvent.BreakEvent(world, pos, state, player);
-			MinecraftForge.EVENT_BUS.post(event);
-			if (event.isCanceled())
-				return;
-
-			if (event.getExpToDrop() > 0 && world instanceof ServerLevel)
-				state.getBlock()
-					.popExperience((ServerLevel) world, pos, event.getExpToDrop());
-
-			usedTool.mineBlock(world, state, pos, player);
-			player.awardStat(Stats.BLOCK_MINED.get(state.getBlock()));
-		}
-
-		if (world instanceof ServerLevel && world.getGameRules()
-			.getBoolean(GameRules.RULE_DOBLOCKDROPS) && !world.restoringBlockSnapshots
-			&& (player == null || !player.isCreative())) {
-			for (ItemStack itemStack : Block.getDrops(state, (ServerLevel) world, pos, tileentity, player, usedTool))
-				droppedItemCallback.accept(itemStack);
-
-			// Simulating IceBlock#playerDestroy. Not calling method directly as it would drop item
-			// entities as a side-effect
-			if (state.getBlock() instanceof IceBlock && usedTool.getEnchantmentLevel(Enchantments.SILK_TOUCH) == 0) {
-				if (world.dimensionType()
-					.ultraWarm())
-					return;
-
-				Material material = world.getBlockState(pos.below())
-					.getMaterial();
-				if (material.blocksMotion() || material.isLiquid())
-					world.setBlockAndUpdate(pos, Blocks.WATER.defaultBlockState());
-				return;
-			}
-
-			state.spawnAfterBreak((ServerLevel) world, pos, ItemStack.EMPTY, true);
-		}
-		
-		world.setBlockAndUpdate(pos, fluidState.createLegacyBlock());
-	}
-
-	public static boolean isSolidWall(BlockGetter reader, BlockPos fromPos, Direction toDirection) {
-		return hasBlockSolidSide(reader.getBlockState(fromPos.relative(toDirection)), reader,
-			fromPos.relative(toDirection), toDirection.getOpposite());
-	}
-
-	public static boolean noCollisionInSpace(BlockGetter reader, BlockPos pos) {
-		return reader.getBlockState(pos)
-			.getCollisionShape(reader, pos)
-			.isEmpty();
-	}
-
-	private static void placeRailWithoutUpdate(Level world, BlockState state, BlockPos target) {
-		LevelChunk chunk = world.getChunkAt(target);
-		int idx = chunk.getSectionIndex(target.getY());
-		LevelChunkSection chunksection = chunk.getSection(idx);
-		if (chunksection == null) {
-			chunksection = new LevelChunkSection(chunk.getSectionYFromSectionIndex(idx), world.registryAccess()
-				.registryOrThrow(Registry.BIOME_REGISTRY));
-			chunk.getSections()[idx] = chunksection;
-		}
-		BlockState old = chunksection.setBlockState(SectionPos.sectionRelative(target.getX()),
-			SectionPos.sectionRelative(target.getY()), SectionPos.sectionRelative(target.getZ()), state);
-		chunk.setUnsaved(true);
-		world.markAndNotifyBlock(target, chunk, old, state, 82, 512);
-
-		world.setBlock(target, state, 82);
-		world.neighborChanged(target, world.getBlockState(target.below())
-			.getBlock(), target.below());
-	}
-
-	public static void placeSchematicBlock(Level world, BlockState state, BlockPos target, ItemStack stack,
-		@Nullable CompoundTag data) {
-		BlockEntity existingTile = world.getBlockEntity(target);
-
-		// Piston
-		if (state.hasProperty(BlockStateProperties.EXTENDED))
-			state = state.setValue(BlockStateProperties.EXTENDED, Boolean.FALSE);
-		if (state.hasProperty(BlockStateProperties.WATERLOGGED))
-			state = state.setValue(BlockStateProperties.WATERLOGGED, Boolean.FALSE);
-
-//		if (AllBlocks.BELT.has(state)) {
-//			world.setBlock(target, state, 2);
-//			return;
-//		} else if (state.getBlock() == Blocks.COMPOSTER)
-//			state = Blocks.COMPOSTER.defaultBlockState();
-//		else if (state.getBlock() != Blocks.SEA_PICKLE && state.getBlock() instanceof IPlantable)
-//			state = ((IPlantable) state.getBlock()).getPlant(world, target);
-//		else if (state.is(BlockTags.CAULDRONS))
-//			state = Blocks.CAULDRON.defaultBlockState();
-
-		if (world.dimensionType()
-			.ultraWarm() && state.getFluidState().is(FluidTags.WATER)) {
-			int i = target.getX();
-			int j = target.getY();
-			int k = target.getZ();
-			world.playSound(null, target, SoundEvents.FIRE_EXTINGUISH, SoundSource.BLOCKS, 0.5F,
-				2.6F + (world.random.nextFloat() - world.random.nextFloat()) * 0.8F);
-
-			for (int l = 0; l < 8; ++l) {
-				world.addParticle(ParticleTypes.LARGE_SMOKE, i + Math.random(), j + Math.random(), k + Math.random(),
-					0.0D, 0.0D, 0.0D);
-			}
-			Block.dropResources(state, world, target);
-			return;
-		}
-
-		if (state.getBlock() instanceof BaseRailBlock) {
-			placeRailWithoutUpdate(world, state, target);
-		} else {
-			world.setBlock(target, state, 18);
-		}
-
-		if (data != null) {
-//			if (existingTile instanceof IMergeableTE mergeable) {
-//				BlockEntity loaded = BlockEntity.loadStatic(target, state, data);
-//				if (existingTile.getType()
-//					.equals(loaded.getType())) {
-//					mergeable.accept(loaded);
-//					return;
-//				}
-//			}
-			BlockEntity tile = world.getBlockEntity(target);
-			if (tile != null) {
-				data.putInt("x", target.getX());
-				data.putInt("y", target.getY());
-				data.putInt("z", target.getZ());
-//				if (tile instanceof KineticTileEntity)
-//					((KineticTileEntity) tile).warnOfMovement();
-				tile.load(data);
-			}
-		}
-
-		try {
-			state.getBlock()
-				.setPlacedBy(world, target, state, null, stack);
-		} catch (Exception e) {
-		}
-	}
-
-	public static double getBounceMultiplier(Block block) {
-		if (block instanceof SlimeBlock)
-			return 0.8D;
-		if (block instanceof BedBlock)
-			return 0.66 * 0.8D;
-		return 0;
-	}
-
-	public static boolean hasBlockSolidSide(BlockState p_220056_0_, BlockGetter p_220056_1_, BlockPos p_220056_2_,
-		Direction p_220056_3_) {
-		return !p_220056_0_.is(BlockTags.LEAVES)
-			&& Block.isFaceFull(p_220056_0_.getCollisionShape(p_220056_1_, p_220056_2_), p_220056_3_);
-	}
-
-	public static boolean extinguishFire(Level world, @Nullable Player p_175719_1_, BlockPos p_175719_2_,
-		Direction p_175719_3_) {
-		p_175719_2_ = p_175719_2_.relative(p_175719_3_);
-		if (world.getBlockState(p_175719_2_)
-			.getBlock() == Blocks.FIRE) {
-			world.levelEvent(p_175719_1_, 1009, p_175719_2_, 0);
-			world.removeBlock(p_175719_2_, false);
-			return true;
-		} else {
-			return false;
-		}
-	}
-
-	public static BlockState copyProperties(BlockState fromState, BlockState toState) {
-		for (Property<?> property : fromState.getProperties()) {
-			toState = copyProperty(property, fromState, toState);
-		}
-		return toState;
-	}
-
-	public static <T extends Comparable<T>> BlockState copyProperty(Property<T> property, BlockState fromState,
-		BlockState toState) {
-		if (fromState.hasProperty(property) && toState.hasProperty(property)) {
-			return toState.setValue(property, fromState.getValue(property));
-		}
-		return toState;
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/CameraAngleAnimationService.java

@@ -1,90 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import nl.requios.effortlessbuilding.create.foundation.utility.animation.LerpedFloat;
-import net.minecraft.client.Minecraft;
-import net.minecraft.util.Mth;
-
-public class CameraAngleAnimationService {
-
-	private static final LerpedFloat yRotation = LerpedFloat.angular().startWithValue(0);
-	private static final LerpedFloat xRotation = LerpedFloat.angular().startWithValue(0);
-
-	private static Mode animationMode = Mode.LINEAR;
-	private static float animationSpeed = -1;
-
-	public static void tick() {
-
-		yRotation.tickChaser();
-		xRotation.tickChaser();
-
-		if (Minecraft.getInstance().player != null) {
-			if (!yRotation.settled())
-				Minecraft.getInstance().player.setYRot(yRotation.getValue(1));
-
-			if (!xRotation.settled())
-				Minecraft.getInstance().player.setXRot(xRotation.getValue(1));
-		}
-	}
-
-	public static boolean isYawAnimating() {
-		return !yRotation.settled();
-	}
-
-	public static boolean isPitchAnimating() {
-		return !xRotation.settled();
-	}
-
-	public static float getYaw(float partialTicks) {
-		return yRotation.getValue(partialTicks);
-	}
-
-	public static float getPitch(float partialTicks) {
-		return xRotation.getValue(partialTicks);
-	}
-
-	public static void setAnimationMode(Mode mode) {
-		animationMode = mode;
-	}
-
-	public static void setAnimationSpeed(float speed) {
-		animationSpeed = speed;
-	}
-
-	public static void setYawTarget(float yaw) {
-		float currentYaw = getCurrentYaw();
-		yRotation.startWithValue(currentYaw);
-		setupChaser(yRotation, currentYaw + AngleHelper.getShortestAngleDiff(currentYaw, Mth.wrapDegrees(yaw)));
-	}
-
-	public static void setPitchTarget(float pitch) {
-		float currentPitch = getCurrentPitch();
-		xRotation.startWithValue(currentPitch);
-		setupChaser(xRotation, currentPitch + AngleHelper.getShortestAngleDiff(currentPitch, Mth.wrapDegrees(pitch)));
-	}
-
-	private static float getCurrentYaw() {
-		if (Minecraft.getInstance().player == null)
-			return 0;
-		return Mth.wrapDegrees(Minecraft.getInstance().player.getYRot());
-	}
-
-	private static float getCurrentPitch() {
-		if (Minecraft.getInstance().player == null)
-			return 0;
-
-		return Mth.wrapDegrees(Minecraft.getInstance().player.getXRot());
-	}
-
-	private static void setupChaser(LerpedFloat rotation, float target) {
-		if (animationMode == Mode.LINEAR) {
-			rotation.chase(target, animationSpeed > 0 ? animationSpeed : 2, LerpedFloat.Chaser.LINEAR);
-		} else if (animationMode == Mode.EXPONENTIAL) {
-			rotation.chase(target, animationSpeed > 0 ? animationSpeed : 0.25, LerpedFloat.Chaser.EXP);
-		}
-	}
-
-	public enum Mode {
-		LINEAR,
-		EXPONENTIAL
-	}
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/Color.java

@@ -1,310 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import com.google.common.hash.Hashing;
-import com.mojang.math.Vector3f;
-import net.minecraft.util.Mth;
-import net.minecraft.world.phys.Vec3;
-
-import javax.annotation.Nonnull;
-import java.util.function.UnaryOperator;
-
-public class Color {
-	public final static Color TRANSPARENT_BLACK = new Color(0, 0, 0, 0).setImmutable();
-	public final static Color BLACK = new Color(0, 0, 0).setImmutable();
-	public final static Color WHITE = new Color(255, 255, 255).setImmutable();
-	public final static Color RED = new Color(255, 0, 0).setImmutable();
-	public final static Color GREEN = new Color(0, 255, 0).setImmutable();
-	public final static Color SPRING_GREEN = new Color(0, 255, 187).setImmutable();
-
-	protected boolean mutable = true;
-	protected int value;
-
-	public Color(int r, int g, int b) {
-		this(r, g, b, 0xff);
-	}
-
-	public Color(int r, int g, int b, int a) {
-		value = ((a & 0xff) << 24) |
-				((r & 0xff) << 16) |
-				((g & 0xff) << 8)  |
-				((b & 0xff) << 0);
-	}
-
-	public Color(float r, float g, float b, float a) {
-		this(
-				(int) (0.5 + 0xff * Mth.clamp(r, 0, 1)),
-				(int) (0.5 + 0xff * Mth.clamp(g, 0, 1)),
-				(int) (0.5 + 0xff * Mth.clamp(b, 0, 1)),
-				(int) (0.5 + 0xff * Mth.clamp(a, 0, 1))
-		);
-	}
-
-	public Color(int rgba) {
-		value = rgba;
-	}
-
-	public Color(int rgb, boolean hasAlpha) {
-		if (hasAlpha) {
-			value = rgb;
-		} else {
-			value = rgb | 0xff_000000;
-		}
-	}
-
-	public Color copy() {
-		return copy(true);
-	}
-
-	public Color copy(boolean mutable) {
-		if (mutable)
-			return new Color(value);
-		else
-			return new Color(value).setImmutable();
-	}
-
-	/**
-	 * Mark this color as immutable. Attempting to mutate this color in the future
-	 * will instead cause a copy to be created that can me modified.
-	 */
-	public Color setImmutable() {
-		this.mutable = false;
-		return this;
-	}
-
-	/**
-	 * @return the red component in the range 0-255.
-	 * @see #getRGB
-	 */
-	public int getRed() {
-		return (getRGB() >> 16) & 0xff;
-	}
-
-	/**
-	 * @return the green component in the range 0-255.
-	 * @see #getRGB
-	 */
-	public int getGreen() {
-		return (getRGB() >> 8) & 0xff;
-	}
-
-	/**
-	 * @return the blue component in the range 0-255.
-	 * @see #getRGB
-	 */
-	public int getBlue() {
-		return (getRGB() >> 0) & 0xff;
-	}
-
-	/**
-	 * @return the alpha component in the range 0-255.
-	 * @see #getRGB
-	 */
-	public int getAlpha() {
-		return (getRGB() >> 24) & 0xff;
-	}
-
-	/**
-	 * @return the red component in the range 0-1f.
-	 */
-	public float getRedAsFloat() {
-		return getRed() / 255f;
-	}
-
-	/**
-	 * @return the green component in the range 0-1f.
-	 */
-	public float getGreenAsFloat() {
-		return getGreen() / 255f;
-	}
-
-	/**
-	 * @return the blue component in the range 0-1f.
-	 */
-	public float getBlueAsFloat() {
-		return getBlue() / 255f;
-	}
-
-	/**
-	 * @return the alpha component in the range 0-1f.
-	 */
-	public float getAlphaAsFloat() {
-		return getAlpha() / 255f;
-	}
-
-	/**
-	 * Returns the RGB value representing this color
-	 * (Bits 24-31 are alpha, 16-23 are red, 8-15 are green, 0-7 are blue).
-	 * @return the RGB value of the color
-	 */
-	public int getRGB() {
-		return value;
-	}
-
-	public Vec3 asVector() {
-		return new Vec3(getRedAsFloat(), getGreenAsFloat(), getBlueAsFloat());
-	}
-
-	public Vector3f asVectorF() {
-		return new Vector3f(getRedAsFloat(), getGreenAsFloat(), getBlueAsFloat());
-	}
-
-	public Color setRed(int r) {
-		return ensureMutable().setRedUnchecked(r);
-	}
-
-	public Color setGreen(int g) {
-		return ensureMutable().setGreenUnchecked(g);
-	}
-
-	public Color setBlue(int b) {
-		return ensureMutable().setBlueUnchecked(b);
-	}
-
-	public Color setAlpha(int a) {
-		return ensureMutable().setAlphaUnchecked(a);
-	}
-
-	public Color setRed(float r) {
-		return ensureMutable().setRedUnchecked((int) (0xff * Mth.clamp(r, 0, 1)));
-	}
-
-	public Color setGreen(float g) {
-		return ensureMutable().setGreenUnchecked((int) (0xff * Mth.clamp(g, 0, 1)));
-	}
-
-	public Color setBlue(float b) {
-		return ensureMutable().setBlueUnchecked((int) (0xff * Mth.clamp(b, 0, 1)));
-	}
-
-	public Color setAlpha(float a) {
-		return ensureMutable().setAlphaUnchecked((int) (0xff * Mth.clamp(a, 0, 1)));
-	}
-
-	public Color scaleAlpha(float factor) {
-		return ensureMutable().setAlphaUnchecked((int) (getAlpha() * Mth.clamp(factor, 0, 1)));
-	}
-
-	public Color mixWith(Color other, float weight) {
-		return ensureMutable()
-				.setRedUnchecked((int) (getRed() + (other.getRed() - getRed()) * weight))
-				.setGreenUnchecked((int) (getGreen() + (other.getGreen() - getGreen()) * weight))
-				.setBlueUnchecked((int) (getBlue() + (other.getBlue() - getBlue()) * weight))
-				.setAlphaUnchecked((int) (getAlpha() + (other.getAlpha() - getAlpha()) * weight));
-	}
-
-	public Color darker() {
-		int a = getAlpha();
-		return ensureMutable().mixWith(BLACK, .25f).setAlphaUnchecked(a);
-	}
-
-	public Color brighter() {
-		int a = getAlpha();
-		return ensureMutable().mixWith(WHITE, .25f).setAlphaUnchecked(a);
-	}
-
-	public Color setValue(int value) {
-		return ensureMutable().setValueUnchecked(value);
-	}
-
-	public Color modifyValue(UnaryOperator<Integer> function) {
-		int newValue = function.apply(value);
-		if (newValue == value)
-			return this;
-
-		return ensureMutable().setValueUnchecked(newValue);
-	}
-
-	// ********* //
-
-	protected Color ensureMutable() {
-		if (this.mutable)
-			return this;
-
-		return new Color(this.value);
-	}
-
-	protected Color setRedUnchecked(int r) {
-		this.value = (this.value & 0xff_00ffff) | ((r & 0xff) << 16);
-		return this;
-	}
-
-	protected Color setGreenUnchecked(int g) {
-		this.value = (this.value & 0xff_ff00ff) | ((g & 0xff) << 8);
-		return this;
-	}
-
-	protected Color setBlueUnchecked(int b) {
-		this.value = (this.value & 0xff_ffff00) | ((b & 0xff) << 0);
-		return this;
-	}
-
-	protected Color setAlphaUnchecked(int a) {
-		this.value = (this.value & 0x00_ffffff) | ((a & 0xff) << 24);
-		return this;
-	}
-
-	protected Color setValueUnchecked(int value) {
-		this.value = value;
-		return this;
-	}
-
-	// ********* //
-
-	public static Color mixColors(@Nonnull Color c1, @Nonnull Color c2, float w) {
-		return new Color(
-				(int) (c1.getRed() + (c2.getRed() - c1.getRed()) * w),
-				(int) (c1.getGreen() + (c2.getGreen() - c1.getGreen()) * w),
-				(int) (c1.getBlue() + (c2.getBlue() - c1.getBlue()) * w),
-				(int) (c1.getAlpha() + (c2.getAlpha() - c1.getAlpha()) * w)
-		);
-	}
-
-	public static Color mixColors(@Nonnull Couple<Color> colors, float w) {
-		return mixColors(colors.getFirst(), colors.getSecond(), w);
-	}
-
-	public static int mixColors(int color1, int color2, float w) {
-		int a1 = (color1 >> 24);
-		int r1 = (color1 >> 16) & 0xFF;
-		int g1 = (color1 >> 8) & 0xFF;
-		int b1 = color1 & 0xFF;
-		int a2 = (color2 >> 24);
-		int r2 = (color2 >> 16) & 0xFF;
-		int g2 = (color2 >> 8) & 0xFF;
-		int b2 = color2 & 0xFF;
-
-		return
-				((int) (a1 + (a2 - a1) * w) << 24) +
-				((int) (r1 + (r2 - r1) * w) << 16) +
-				((int) (g1 + (g2 - g1) * w) << 8) +
-				((int) (b1 + (b2 - b1) * w) << 0);
-	}
-
-	public static Color rainbowColor(int timeStep) {
-		int localTimeStep = Math.abs(timeStep) % 1536;
-		int timeStepInPhase = localTimeStep % 256;
-		int phaseBlue = localTimeStep / 256;
-		int red = colorInPhase(phaseBlue + 4, timeStepInPhase);
-		int green = colorInPhase(phaseBlue + 2, timeStepInPhase);
-		int blue = colorInPhase(phaseBlue, timeStepInPhase);
-		return new Color(red, green, blue);
-	}
-
-	private static int colorInPhase(int phase, int progress) {
-		phase = phase % 6;
-		if (phase <= 1)
-			return 0;
-		if (phase == 2)
-			return progress;
-		if (phase <= 4)
-			return 255;
-		else
-			return 255 - progress;
-	}
-
-	public static Color generateFromLong(long l) {
-		return rainbowColor(Hashing.crc32().hashLong(l).asInt())
-				.mixWith(WHITE, 0.5f);
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/ColorHandlers.java

@@ -1,26 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.client.color.block.BlockColor;
-import net.minecraft.client.color.item.ItemColor;
-import net.minecraft.client.renderer.BiomeColors;
-import net.minecraft.world.level.GrassColor;
-import net.minecraft.world.level.block.RedStoneWireBlock;
-import net.minecraft.world.level.block.state.properties.BlockStateProperties;
-
-public class ColorHandlers {
-
-	public static BlockColor getGrassyBlock() {
-		return (state, world, pos, layer) -> pos != null && world != null ? BiomeColors.getAverageGrassColor(world, pos)
-				: GrassColor.get(0.5D, 1.0D);
-	}
-
-	public static ItemColor getGrassyItem() {
-		return (stack, layer) -> GrassColor.get(0.5D, 1.0D);
-	}
-
-	public static BlockColor getRedstonePower() {
-		return (state, world, pos, layer) -> RedStoneWireBlock
-				.getColorForPower(pos != null && world != null ? state.getValue(BlockStateProperties.POWER) : 0);
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/Components.java

@@ -1,33 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.MutableComponent;
-
-public final class Components {
-	private static final Component IMMUTABLE_EMPTY = Component.empty();
-
-	public static Component immutableEmpty() {
-		return IMMUTABLE_EMPTY;
-	}
-
-	/** Use {@link #immutableEmpty()} when possible to prevent creating an extra object. */
-	public static MutableComponent empty() {
-		return Component.empty();
-	}
-
-	public static MutableComponent literal(String str) {
-		return Component.literal(str);
-	}
-
-	public static MutableComponent translatable(String key) {
-		return Component.translatable(key);
-	}
-
-	public static MutableComponent translatable(String key, Object... args) {
-		return Component.translatable(key, args);
-	}
-
-	public static MutableComponent keybind(String name) {
-		return Component.keybind(name);
-	}
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/Couple.java

@@ -1,151 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import com.google.common.collect.ImmutableList;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.ListTag;
-
-import java.util.Iterator;
-import java.util.List;
-import java.util.function.*;
-import java.util.stream.Stream;
-
-public class Couple<T> extends Pair<T, T> implements Iterable<T> {
-
-	private static final Couple<Boolean> TRUE_AND_FALSE = Couple.create(true, false);
-
-	protected Couple(T first, T second) {
-		super(first, second);
-	}
-
-	public static <T> Couple<T> create(T first, T second) {
-		return new Couple<>(first, second);
-	}
-
-	public static <T> Couple<T> create(Supplier<T> factory) {
-		return new Couple<>(factory.get(), factory.get());
-	}
-
-	public static <T> Couple<T> createWithContext(Function<Boolean, T> factory) {
-		return new Couple<>(factory.apply(true), factory.apply(false));
-	}
-
-	public T get(boolean first) {
-		return first ? getFirst() : getSecond();
-	}
-
-	public void set(boolean first, T value) {
-		if (first)
-			setFirst(value);
-		else
-			setSecond(value);
-	}
-
-	@Override
-	public Couple<T> copy() {
-		return create(first, second);
-	}
-
-	public <S> Couple<S> map(Function<T, S> function) {
-		return Couple.create(function.apply(first), function.apply(second));
-	}
-
-	public <S> Couple<S> mapWithContext(BiFunction<T, Boolean, S> function) {
-		return Couple.create(function.apply(first, true), function.apply(second, false));
-	}
-
-	public <S, R> Couple<S> mapWithParams(BiFunction<T, R, S> function, Couple<R> values) {
-		return Couple.create(function.apply(first, values.first), function.apply(second, values.second));
-	}
-
-	public <S, R> Couple<S> mapNotNullWithParam(BiFunction<T, R, S> function, R value) {
-		return Couple.create(first != null ? function.apply(first, value) : null,
-				second != null ? function.apply(second, value) : null);
-	}
-
-	public boolean both(Predicate<T> test) {
-		return test.test(getFirst()) && test.test(getSecond());
-	}
-
-	public boolean either(Predicate<T> test) {
-		return test.test(getFirst()) || test.test(getSecond());
-	}
-
-	public void replace(Function<T, T> function) {
-		setFirst(function.apply(getFirst()));
-		setSecond(function.apply(getSecond()));
-	}
-
-	public void replaceWithContext(BiFunction<T, Boolean, T> function) {
-		replaceWithParams(function, TRUE_AND_FALSE);
-	}
-
-	public <S> void replaceWithParams(BiFunction<T, S, T> function, Couple<S> values) {
-		setFirst(function.apply(getFirst(), values.getFirst()));
-		setSecond(function.apply(getSecond(), values.getSecond()));
-	}
-
-	@Override
-	public void forEach(Consumer<? super T> consumer) {
-		consumer.accept(getFirst());
-		consumer.accept(getSecond());
-	}
-
-	public void forEachWithContext(BiConsumer<T, Boolean> consumer) {
-		forEachWithParams(consumer, TRUE_AND_FALSE);
-	}
-
-	public <S> void forEachWithParams(BiConsumer<T, S> function, Couple<S> values) {
-		function.accept(getFirst(), values.getFirst());
-		function.accept(getSecond(), values.getSecond());
-	}
-
-	public Couple<T> swap() {
-		return Couple.create(second, first);
-	}
-
-	public ListTag serializeEach(Function<T, CompoundTag> serializer) {
-		return NBTHelper.writeCompoundList(ImmutableList.of(first, second), serializer);
-	}
-
-	public static <S> Couple<S> deserializeEach(ListTag list, Function<CompoundTag, S> deserializer) {
-		List<S> readCompoundList = NBTHelper.readCompoundList(list, deserializer);
-		return new Couple<>(readCompoundList.get(0), readCompoundList.get(1));
-	}
-
-	@Override
-	public Iterator<T> iterator() {
-		return new Couplerator<>(this);
-	}
-
-	public Stream<T> stream() {
-		return Stream.of(first, second);
-	}
-
-	private static class Couplerator<T> implements Iterator<T> {
-
-		int state;
-		private final Couple<T> couple;
-
-		public Couplerator(Couple<T> couple) {
-			this.couple = couple;
-			state = 0;
-		}
-
-		@Override
-		public boolean hasNext() {
-			return state != 2;
-		}
-
-		@Override
-		public T next() {
-			state++;
-			if (state == 1)
-				return couple.first;
-			if (state == 2)
-				return couple.second;
-			return null;
-		}
-
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/CreateRegistry.java

@@ -1,102 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.resources.ResourceLocation;
-import net.minecraftforge.registries.IForgeRegistry;
-import nl.requios.effortlessbuilding.EffortlessBuilding;
-import nl.requios.effortlessbuilding.create.Create;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.*;
-
-public class CreateRegistry<K, V> {
-	private static final List<CreateRegistry<?, ?>> ALL = new ArrayList<>();
-
-	protected final IForgeRegistry<K> objectRegistry;
-	protected final Map<ResourceLocation, V> locationMap = new HashMap<>();
-	protected final Map<K, V> objectMap = new IdentityHashMap<>();
-	protected boolean unwrapped = false;
-
-	public CreateRegistry(IForgeRegistry<K> objectRegistry) {
-		this.objectRegistry = objectRegistry;
-		ALL.add(this);
-	}
-
-	public void register(ResourceLocation location, V value) {
-		if (!unwrapped) {
-			locationMap.put(location, value);
-		} else {
-			K object = objectRegistry.getValue(location);
-			if (object != null) {
-				objectMap.put(object, value);
-			} else {
-				Create.LOGGER.warn("Could not get object for location '" + location + "' in CreateRegistry after unwrapping!");
-			}
-		}
-	}
-
-	public void register(K object, V value) {
-		if (unwrapped) {
-			objectMap.put(object, value);
-		} else {
-			ResourceLocation location = objectRegistry.getKey(object);
-			if (location != null) {
-				locationMap.put(location, value);
-			} else {
-				Create.LOGGER.warn("Could not get location of object '" + object + "' in CreateRegistry before unwrapping!");
-			}
-		}
-	}
-
-	@Nullable
-	public V get(ResourceLocation location) {
-		if (!unwrapped) {
-			return locationMap.get(location);
-		} else {
-			K object = objectRegistry.getValue(location);
-			if (object != null) {
-				return objectMap.get(object);
-			} else {
-				Create.LOGGER.warn("Could not get object for location '" + location + "' in CreateRegistry after unwrapping!");
-				return null;
-			}
-		}
-	}
-
-	@Nullable
-	public V get(K object) {
-		if (unwrapped) {
-			return objectMap.get(object);
-		} else {
-			ResourceLocation location = objectRegistry.getKey(object);
-			if (location != null) {
-				return locationMap.get(location);
-			} else {
-				Create.LOGGER.warn("Could not get location of object '" + object + "' in CreateRegistry before unwrapping!");
-				return null;
-			}
-		}
-	}
-
-	public boolean isUnwrapped() {
-		return unwrapped;
-	}
-
-	protected void unwrap() {
-		for (Map.Entry<ResourceLocation, V> entry : locationMap.entrySet()) {
-			ResourceLocation location = entry.getKey();
-			K object = objectRegistry.getValue(location);
-			if (object != null) {
-				objectMap.put(object, entry.getValue());
-			} else {
-				Create.LOGGER.warn("Could not get object for location '" + location + "' in CreateRegistry during unwrapping!");
-			}
-		}
-		unwrapped = true;
-	}
-
-	public static void unwrapAll() {
-		for (CreateRegistry<?, ?> registry : ALL) {
-			registry.unwrap();
-		}
-	}
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/Debug.java

@@ -1,67 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import nl.requios.effortlessbuilding.create.Create;
-import net.minecraft.ChatFormatting;
-import net.minecraft.client.Minecraft;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.MutableComponent;
-import net.minecraftforge.api.distmarker.Dist;
-import net.minecraftforge.api.distmarker.OnlyIn;
-import net.minecraftforge.fml.util.thread.EffectiveSide;
-
-/** Deprecated so simi doensn't forget to remove debug calls **/
-@OnlyIn(value = Dist.CLIENT)
-public class Debug {
-
-	@Deprecated
-	public static void debugChat(String message) {
-		if (Minecraft.getInstance().player != null)
-			Minecraft.getInstance().player.displayClientMessage(Components.literal(message), false);
-	}
-
-	@Deprecated
-	public static void debugChatAndShowStack(String message, int depth) {
-		if (Minecraft.getInstance().player != null)
-			Minecraft.getInstance().player.displayClientMessage(Components.literal(message).append("@")
-				.append(debugStack(depth)), false);
-	}
-
-	@Deprecated
-	public static void debugMessage(String message) {
-		if (Minecraft.getInstance().player != null)
-			Minecraft.getInstance().player.displayClientMessage(Components.literal(message), true);
-	}
-	
-	@Deprecated
-	public static void log(String message) {
-		Create.LOGGER.info(message);
-	}
-
-	@Deprecated
-	public static String getLogicalSide() {
-		return EffectiveSide.get()
-			.isClient() ? "CL" : "SV";
-	}
-
-	@Deprecated
-	public static Component debugStack(int depth) {
-		StackTraceElement[] stackTraceElements = Thread.currentThread()
-			.getStackTrace();
-		MutableComponent text = Components.literal("[")
-			.append(Components.literal(getLogicalSide()).withStyle(ChatFormatting.GOLD))
-			.append("] ");
-		for (int i = 1; i < depth + 2 && i < stackTraceElements.length; i++) {
-			StackTraceElement e = stackTraceElements[i];
-			if (e.getClassName()
-				.equals(Debug.class.getName()))
-				continue;
-			text.append(Components.literal(e.getMethodName()).withStyle(ChatFormatting.YELLOW))
-				.append(", ");
-		}
-		return text.append(Components.literal(" ...").withStyle(ChatFormatting.GRAY));
-	}
-
-	@Deprecated
-	public static void markTemporary() {}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/DyeHelper.java

@@ -1,75 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import com.google.common.collect.ImmutableMap;
-import net.minecraft.world.item.DyeColor;
-import net.minecraft.world.level.ItemLike;
-import net.minecraft.world.level.block.Blocks;
-
-import java.util.Map;
-
-public class DyeHelper {
-
-	public static ItemLike getWoolOfDye(DyeColor color) {
-		switch (color) {
-		case BLACK:
-			return Blocks.BLACK_WOOL;
-		case BLUE:
-			return Blocks.BLUE_WOOL;
-		case BROWN:
-			return Blocks.BROWN_WOOL;
-		case CYAN:
-			return Blocks.CYAN_WOOL;
-		case GRAY:
-			return Blocks.GRAY_WOOL;
-		case GREEN:
-			return Blocks.GREEN_WOOL;
-		case LIGHT_BLUE:
-			return Blocks.LIGHT_BLUE_WOOL;
-		case LIGHT_GRAY:
-			return Blocks.LIGHT_GRAY_WOOL;
-		case LIME:
-			return Blocks.LIME_WOOL;
-		case MAGENTA:
-			return Blocks.MAGENTA_WOOL;
-		case ORANGE:
-			return Blocks.ORANGE_WOOL;
-		case PINK:
-			return Blocks.PINK_WOOL;
-		case PURPLE:
-			return Blocks.PURPLE_WOOL;
-		case RED:
-			return Blocks.RED_WOOL;
-		case YELLOW:
-			return Blocks.YELLOW_WOOL;
-		case WHITE:
-		default:
-			return Blocks.WHITE_WOOL;
-		}
-	}
-
-	public static final Map<DyeColor, Couple<Integer>> DYE_TABLE = new ImmutableMap.Builder<DyeColor, Couple<Integer>>()
-	
-	// DyeColor, ( Front RGB, Back RGB )
-	.put(DyeColor.BLACK, Couple.create(0x45403B, 0x21201F))
-	.put(DyeColor.RED, Couple.create(0xB13937, 0x632737))
-	.put(DyeColor.GREEN, Couple.create(0x208A46, 0x1D6045))
-	.put(DyeColor.BROWN, Couple.create(0xAC855C, 0x68533E))
-	
-	.put(DyeColor.BLUE, Couple.create(0x5391E1, 0x504B90))
-	.put(DyeColor.GRAY, Couple.create(0x5D666F, 0x313538))
-	.put(DyeColor.LIGHT_GRAY, Couple.create(0x95969B, 0x707070))
-	.put(DyeColor.PURPLE, Couple.create(0x9F54AE, 0x63366C))
-	
-	.put(DyeColor.CYAN, Couple.create(0x3EABB4, 0x3C7872))
-	.put(DyeColor.PINK, Couple.create(0xD5A8CB, 0xB86B95))
-	.put(DyeColor.LIME, Couple.create(0xA3DF55, 0x4FB16F))
-	.put(DyeColor.YELLOW, Couple.create(0xE6D756, 0xE9AC29))
-	
-	.put(DyeColor.LIGHT_BLUE, Couple.create(0x69CED2, 0x508AA5))
-	.put(DyeColor.ORANGE, Couple.create(0xEE9246, 0xD94927))
-	.put(DyeColor.MAGENTA, Couple.create(0xF062B0, 0xC04488))
-	.put(DyeColor.WHITE, Couple.create(0xEDEAE5, 0xBBB6B0))
-	
-	.build();
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/DynamicComponent.java

@@ -1,94 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import com.google.gson.JsonElement;
-import com.google.gson.JsonParseException;
-import com.google.gson.JsonParser;
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import nl.requios.effortlessbuilding.create.Create;
-import net.minecraft.commands.CommandSource;
-import net.minecraft.commands.CommandSourceStack;
-import net.minecraft.core.BlockPos;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.ComponentUtils;
-import net.minecraft.network.chat.MutableComponent;
-import net.minecraft.server.level.ServerLevel;
-import net.minecraft.world.level.Level;
-import net.minecraft.world.phys.Vec2;
-import net.minecraft.world.phys.Vec3;
-
-public class DynamicComponent {
-
-	private JsonElement rawCustomText;
-	private Component parsedCustomText;
-
-	public DynamicComponent() {}
-
-	public void displayCustomText(Level level, BlockPos pos, String tagElement) {
-		if (tagElement == null)
-			return;
-
-		rawCustomText = getJsonFromString(tagElement);
-		parsedCustomText = parseCustomText(level, pos, rawCustomText);
-	}
-
-	public boolean sameAs(String tagElement) {
-		return isValid() && rawCustomText.equals(getJsonFromString(tagElement));
-	}
-
-	public boolean isValid() {
-		return parsedCustomText != null && rawCustomText != null;
-	}
-
-	public String resolve() {
-		return parsedCustomText.getString();
-	}
-
-	public MutableComponent get() {
-		return parsedCustomText == null ? Components.empty() : parsedCustomText.copy();
-	}
-
-	public void read(Level level, BlockPos pos, CompoundTag nbt) {
-		rawCustomText = getJsonFromString(nbt.getString("RawCustomText"));
-		try {
-			parsedCustomText = Component.Serializer.fromJson(nbt.getString("CustomText"));
-		} catch (JsonParseException e) {
-			parsedCustomText = null;
-		}
-	}
-
-	public void write(CompoundTag nbt) {
-		if (!isValid())
-			return;
-
-		nbt.putString("RawCustomText", rawCustomText.toString());
-		nbt.putString("CustomText", Component.Serializer.toJson(parsedCustomText));
-	}
-
-	public static JsonElement getJsonFromString(String string) {
-		try {
-			return JsonParser.parseString(string);
-		} catch (JsonParseException e) {
-			return null;
-		}
-	}
-
-	public static Component parseCustomText(Level level, BlockPos pos, JsonElement customText) {
-		if (!(level instanceof ServerLevel serverLevel))
-			return null;
-		try {
-			return ComponentUtils.updateForEntity(getCommandSource(serverLevel, pos),
-				Component.Serializer.fromJson(customText), null, 0);
-		} catch (JsonParseException e) {
-			return null;
-		} catch (CommandSyntaxException e) {
-			return null;
-		}
-	}
-
-	public static CommandSourceStack getCommandSource(ServerLevel level, BlockPos pos) {
-		return new CommandSourceStack(CommandSource.NULL, Vec3.atCenterOf(pos), Vec2.ZERO, level, 2, Create.ID,
-			Components.literal(Create.ID), level.getServer(), null);
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/FilesHelper.java

@@ -1,101 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import com.google.gson.JsonElement;
-import com.google.gson.JsonParser;
-import com.google.gson.internal.Streams;
-import com.google.gson.stream.JsonReader;
-import com.google.gson.stream.JsonWriter;
-import nl.requios.effortlessbuilding.create.Create;
-import net.minecraft.nbt.CompoundTag;
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.nio.file.Files;
-import java.nio.file.Paths;
-import java.nio.file.StandardOpenOption;
-
-public class FilesHelper {
-
-	public static void createFolderIfMissing(String name) {
-		try {
-			Files.createDirectories(Paths.get(name));
-		} catch (IOException e) {
-			Create.LOGGER.warn("Could not create Folder: {}", name);
-		}
-	}
-
-	public static String findFirstValidFilename(String name, String folderPath, String extension) {
-		int index = 0;
-		String filename;
-		String filepath;
-		do {
-			filename = slug(name) + ((index == 0) ? "" : "_" + index) + "." + extension;
-			index++;
-			filepath = folderPath + "/" + filename;
-		} while (Files.exists(Paths.get(filepath)));
-		return filename;
-	}
-
-	public static String slug(String name) {
-		return Lang.asId(name)
-			.replaceAll("\\W+", "_");
-	}
-
-	public static boolean saveTagCompoundAsJson(CompoundTag compound, String path) {
-		try {
-			Files.deleteIfExists(Paths.get(path));
-			JsonWriter writer = new JsonWriter(Files.newBufferedWriter(Paths.get(path), StandardOpenOption.CREATE));
-			writer.setIndent("  ");
-			Streams.write(JsonParser.parseString(compound.toString()), writer);
-			writer.close();
-			return true;
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-		return false;
-	}
-
-	public static boolean saveTagCompoundAsJsonCompact(CompoundTag compound, String path) {
-		try {
-			Files.deleteIfExists(Paths.get(path));
-			JsonWriter writer = new JsonWriter(Files.newBufferedWriter(Paths.get(path), StandardOpenOption.CREATE));
-			Streams.write(JsonParser.parseString(compound.toString()), writer);
-			writer.close();
-			return true;
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-		return false;
-
-	}
-
-	private static JsonElement loadJson(InputStream inputStream) {
-		try {
-			JsonReader reader = new JsonReader(new BufferedReader(new InputStreamReader(inputStream)));
-			reader.setLenient(true);
-			JsonElement element = Streams.parse(reader);
-			reader.close();
-			inputStream.close();
-			return element;
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-		return null;
-	}
-
-	public static JsonElement loadJsonResource(String filepath) {
-		return loadJson(ClassLoader.getSystemResourceAsStream(filepath));
-	}
-
-	public static JsonElement loadJson(String filepath) {
-		try {
-			return loadJson(Files.newInputStream(Paths.get(filepath), StandardOpenOption.READ));
-		} catch (IOException e) {
-			e.printStackTrace();
-		}
-		return null;
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/FluidFormatter.java

@@ -1,26 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.network.chat.MutableComponent;
-
-public class FluidFormatter {
-
-	public static String asString(long amount, boolean shorten) {
-		Couple<MutableComponent> couple = asComponents(amount, shorten);
-		return couple.getFirst().getString() + " " + couple.getSecond().getString();
-	}
-
-	public static Couple<MutableComponent> asComponents(long amount, boolean shorten) {
-		if (shorten && amount >= 1000) {
-			return Couple.create(
-					Components.literal(String.format("%.1f" , amount / 1000d)),
-					Lang.translateDirect("generic.unit.buckets")
-			);
-		}
-
-		return Couple.create(
-				Components.literal(String.valueOf(amount)),
-				Lang.translateDirect("generic.unit.millibuckets")
-		);
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/FontHelper.java

@@ -1,87 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import com.mojang.blaze3d.vertex.PoseStack;
-import com.mojang.blaze3d.vertex.Tesselator;
-import com.mojang.math.Matrix4f;
-import net.minecraft.client.Minecraft;
-import net.minecraft.client.gui.Font;
-import net.minecraft.client.renderer.LightTexture;
-import net.minecraft.client.renderer.MultiBufferSource;
-
-import java.text.BreakIterator;
-import java.util.LinkedList;
-import java.util.List;
-
-public final class FontHelper {
-
-	private FontHelper() {}
-
-	public static List<String> cutString(Font font, String text, int maxWidthPerLine) {
-		// Split words
-		List<String> words = new LinkedList<>();
-		BreakIterator iterator = BreakIterator.getLineInstance(Minecraft.getInstance().getLocale());
-		iterator.setText(text);
-		int start = iterator.first();
-		for (int end = iterator.next(); end != BreakIterator.DONE; start = end, end = iterator.next()) {
-			String word = text.substring(start, end);
-			words.add(word);
-		}
-		// Apply hard wrap
-		List<String> lines = new LinkedList<>();
-		StringBuilder currentLine = new StringBuilder();
-		int width = 0;
-		for (String word : words) {
-			int newWidth = font.width(word);
-			if (width + newWidth > maxWidthPerLine) {
-				if (width > 0) {
-					String line = currentLine.toString();
-					lines.add(line);
-					currentLine = new StringBuilder();
-					width = 0;
-				} else {
-					lines.add(word);
-					continue;
-				}
-			}
-			currentLine.append(word);
-			width += newWidth;
-		}
-		if (width > 0) {
-			lines.add(currentLine.toString());
-		}
-		return lines;
-	}
-
-	public static void drawSplitString(PoseStack ms, Font font, String text, int x, int y, int width,
-		int color) {
-		List<String> list = cutString(font, text, width);
-		Matrix4f matrix4f = ms.last()
-			.pose();
-
-		for (String s : list) {
-			float f = (float) x;
-			if (font.isBidirectional()) {
-				int i = font.width(font.bidirectionalShaping(s));
-				f += (float) (width - i);
-			}
-
-			draw(font, s, f, (float) y, color, matrix4f, false);
-			y += 9;
-		}
-	}
-
-	private static int draw(Font font, String p_228078_1_, float p_228078_2_, float p_228078_3_,
-		int p_228078_4_, Matrix4f p_228078_5_, boolean p_228078_6_) {
-		if (p_228078_1_ == null) {
-			return 0;
-		} else {
-			MultiBufferSource.BufferSource irendertypebuffer$impl = MultiBufferSource.immediate(Tesselator.getInstance()
-				.getBuilder());
-			int i = font.drawInBatch(p_228078_1_, p_228078_2_, p_228078_3_, p_228078_4_, p_228078_6_, p_228078_5_,
-				irendertypebuffer$impl, false, 0, LightTexture.FULL_BRIGHT);
-			irendertypebuffer$impl.endBatch();
-			return i;
-		}
-	}
-
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/ICoordinate.java

@@ -1,8 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.core.BlockPos;
-
-@FunctionalInterface
-public interface ICoordinate {
-	float get(BlockPos from);
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/IInteractionChecker.java

@@ -1,7 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.world.entity.player.Player;
-
-public interface IInteractionChecker {
-	boolean canPlayerUse(Player player);
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/IPartialSafeNBT.java

@@ -1,8 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.nbt.CompoundTag;
-
-public interface IPartialSafeNBT {
-	/** This method always runs on the logical server. */
-	public void writeSafe(CompoundTag compound);
-}

src/main/java/nl/requios/effortlessbuilding/create/foundation/utility/IntAttached.java

@@ -1,61 +0,0 @@
-package nl.requios.effortlessbuilding.create.foundation.utility;
-
-import net.minecraft.nbt.CompoundTag;
-
-import java.util.Comparator;
-import java.util.function.Function;
-
-public class IntAttached<V> extends Pair<Integer, V> {
-
-	protected IntAttached(Integer first, V second) {
-		super(first, second);
-	}
-
-	public static <V> IntAttached<V> with(int number, V value) {
-		return new IntAttached<>(number, value);
-	}
-
-	public static <V> IntAttached<V> withZero(V value) {
-		return new IntAttached<>(0, value);
-	}
-
-	public boolean isZero() {
-		return first.intValue() == 0;
-	}
-
-	public boolean exceeds(int value) {
-		return first.intValue() > value;
-	}
-
-	public boolean isOrBelowZero() {
-		return first.intValue() <= 0;
-	}
-
-	public void increment() {
-		first++;
-	}
-
-	public void decrement() {
-		first--;
-	}
-
-	public V getValue() {
-		return getSecond();
-	}
-
-	public CompoundTag serializeNBT(Function<V, CompoundTag> serializer) {
-		CompoundTag nbt = new CompoundTag();
-		nbt.put("Item", serializer.apply(getValue()));
-		nbt.putInt("Location", getFirst());
-		return nbt;
-	}
-
-	public static Comparator<? super IntAttached<?>> comparator() {
-		return (i1, i2) -> Integer.compare(i2.getFirst(), i1.getFirst());
-	}
-
-	public static <T> IntAttached<T> read(CompoundTag nbt, Function<CompoundTag, T> deserializer) {
-		return IntAttached.with(nbt.getInt("Location"), deserializer.apply(nbt.getCompound("Item")));
-	}
-
-}