Publish WorldHandler jar from 548a0d5b9c

Avoid passing null narration text to GuiHintTextField, emit item components for custom item display/enchantment/attribute data, and update the player preview render call for the 1.21.1 InventoryScreen API.

Validated with ./gradlew.bat build --no-daemon.

.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

.gitea/workflows/build.yml

@@ -1,124 +0,0 @@
-name: Build
-
-on:
-  push:
-    branches-ignore:
-      - artifacts
-    tags:
-      - "v*"
-  pull_request:
-  workflow_dispatch:
-
-permissions:
-  contents: write
-
-jobs:
-  build:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-
-      - name: Set up Java 21
-        uses: actions/setup-java@v4
-        with:
-          distribution: temurin
-          java-version: "21"
-
-      - name: Make Gradle wrapper executable
-        run: chmod +x ./gradlew
-
-      - name: Build
-        run: ./gradlew build --no-daemon
-
-      - name: Create Gitea release
-        if: startsWith(github.ref, 'refs/tags/')
-        shell: bash
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-          GITEA_TOKEN: ${{ secrets.GITEA_TOKEN }}
-        run: |
-          set -euo pipefail
-
-          tag="${GITHUB_REF_NAME}"
-          api="${GITHUB_SERVER_URL}/api/v1"
-          release_name="WorldHandler ${tag}"
-          jar="$(find build/libs -maxdepth 1 -name '*neoforge*.jar' -print -quit)"
-          token="${GITEA_TOKEN:-${GITHUB_TOKEN:-}}"
-
-          if [ -z "${jar}" ]; then
-            echo "No NeoForge jar found in build/libs" >&2
-            exit 1
-          fi
-
-          if [ -z "${token}" ]; then
-            echo "No Gitea token available" >&2
-            exit 1
-          fi
-
-          release_json="$(mktemp)"
-          if ! curl -fsS \
-            -H "Authorization: token ${token}" \
-            -H "Accept: application/json" \
-            "${api}/repos/${GITHUB_REPOSITORY}/releases/tags/${tag}" \
-            -o "${release_json}"; then
-            export tag release_name GITHUB_SHA
-            python3 -c 'import json, os; print(json.dumps({"tag_name": os.environ["tag"], "target_commitish": os.environ["GITHUB_SHA"], "name": os.environ["release_name"], "body": "NeoForge 21.1.225 build for Minecraft 1.21.1.", "draft": False, "prerelease": False}))' > "${release_json}"
-            curl -fsS \
-              -X POST \
-              -H "Authorization: token ${token}" \
-              -H "Accept: application/json" \
-              -H "Content-Type: application/json" \
-              --data-binary @"${release_json}" \
-              "${api}/repos/${GITHUB_REPOSITORY}/releases" \
-              -o "${release_json}"
-          fi
-
-          release_id="$(python3 -c 'import json,sys; print(json.load(open(sys.argv[1]))["id"])' "${release_json}")"
-          asset_name="$(basename "${jar}")"
-
-          python3 -c 'import json, sys; release = json.load(open(sys.argv[1])); asset_name = sys.argv[2]; [print(asset["id"]) for asset in release.get("assets", []) if asset.get("name") == asset_name]' "${release_json}" "${asset_name}" > assets-to-delete.txt
-
-          while read -r asset_id; do
-            [ -z "${asset_id}" ] && continue
-            curl -fsS \
-              -X DELETE \
-              -H "Authorization: token ${token}" \
-              "${api}/repos/${GITHUB_REPOSITORY}/releases/${release_id}/assets/${asset_id}"
-          done < assets-to-delete.txt
-
-          curl -fsS \
-            -X POST \
-            -H "Authorization: token ${token}" \
-            -H "Accept: application/json" \
-            -F "attachment=@${jar};type=application/java-archive" \
-            "${api}/repos/${GITHUB_REPOSITORY}/releases/${release_id}/assets?name=${asset_name}"
-
-      - name: Publish jar to artifacts branch
-        if: github.event_name != 'pull_request'
-        shell: bash
-        run: |
-          set -euo pipefail
-
-          mkdir -p /tmp/worldhandler-artifacts
-          cp build/libs/*.jar /tmp/worldhandler-artifacts/
-
-          git config user.name "Gitea Actions"
-          git config user.email "actions@gitea.local"
-
-          git fetch origin artifacts || true
-          git switch --force-create artifacts
-          git rm -rf .
-
-          cp /tmp/worldhandler-artifacts/*.jar .
-          cat > README.md <<'EOF'
-          # WorldHandler build artifacts
-
-          This branch is maintained by the Gitea runner.
-          Download the jar file from this branch.
-          EOF
-
-          git add README.md *.jar
-          git commit --allow-empty -m "Publish WorldHandler jar from ${GITHUB_SHA}"
-          git push --force origin artifacts

.gitignore

@@ -1,137 +0,0 @@
-### Eclipse ###
-.metadata
-bin/
-tmp/
-*.tmp
-*.bak
-*.swp
-*~.nib
-local.properties
-.settings/
-.loadpath
-.recommenders
-
-# External tool builders
-.externalToolBuilders/
-
-# Locally stored "Eclipse launch configurations"
-*.launch
-
-# PyDev specific (Python IDE for Eclipse)
-*.pydevproject
-
-# CDT-specific (C/C++ Development Tooling)
-.cproject
-
-# CDT- autotools
-.autotools
-
-# Java annotation processor (APT)
-.factorypath
-
-# PDT-specific (PHP Development Tools)
-.buildpath
-
-# sbteclipse plugin
-.target
-
-# Tern plugin
-.tern-project
-
-# TeXlipse plugin
-.texlipse
-
-# STS (Spring Tool Suite)
-.springBeans
-
-# Code Recommenders
-.recommenders/
-
-# Annotation Processing
-.apt_generated/
-.apt_generated_test/
-
-# Scala IDE specific (Scala & Java development for Eclipse)
-.cache-main
-.scala_dependencies
-.worksheet
-
-# Uncomment this line if you wish to ignore the project description file.
-# Typically, this file would be tracked if it contains build/dependency configurations:
-#.project
-
-### Eclipse Patch ###
-# Spring Boot Tooling
-.sts4-cache/
-
-### ForgeGradle ###
-# Minecraft client/server files
-run/
-
-### Java ###
-# Compiled class file
-*.class
-
-# Log file
-*.log
-
-# BlueJ files
-*.ctxt
-
-# Mobile Tools for Java (J2ME)
-.mtj.tmp/
-
-# Package Files #
-*.jar
-*.war
-*.nar
-*.ear
-*.zip
-*.tar.gz
-*.rar
-
-# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
-hs_err_pid*
-
-### Gradle ###
-.gradle
-build/
-
-# Ignore Gradle GUI config
-gradle-app.setting
-
-# Avoid ignoring Gradle wrapper jar file (.jar files are usually ignored)
-!gradle-wrapper.jar
-
-# Cache of project
-.gradletasknamecache
-
-# # Work around https://youtrack.jetbrains.com/issue/IDEA-116898
-# gradle/wrapper/gradle-wrapper.properties
-
-### Gradle Patch ###
-**/build/
-
-# Eclipse Gradle plugin generated files
-# Eclipse Core
-.project
-# JDT-specific (Eclipse Java Development Tools)
-.classpath
-
-### Wiki ###
-wiki/
-
-### Test ###
-src/test/
-
-### ForgeGradle ###
-run/
-bin/
-
-### Changelog ###
-changelog.txt
-
-### Local Codex build runtime ###
-.codex-jdk/
-.gradle-home/
-temurin-jdk21.zip

LICENSE.txt

@@ -1,674 +0,0 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU General Public License is a free, copyleft license for
-software and other kinds of works.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-the GNU General Public License is intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.  We, the Free Software Foundation, use the
-GNU General Public License for most of our software; it applies also to
-any other work released this way by its authors.  You can apply it to
-your programs, too.
-
-  When we speak of free software, we are referring to freedom, 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
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  To protect your rights, we need to prevent others from denying you
-these rights or asking you to surrender the rights.  Therefore, you have
-certain responsibilities if you distribute copies of the software, or if
-you modify it: responsibilities to respect the freedom of others.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must pass on to the recipients the same
-freedoms that you received.  You must make sure that they, too, receive
-or can get the source code.  And you must show them these terms so they
-know their rights.
-
-  Developers that use the GNU GPL protect your rights with two steps:
-(1) assert copyright on the software, and (2) offer you this License
-giving you legal permission to copy, distribute and/or modify it.
-
-  For the developers' and authors' protection, the GPL clearly explains
-that there is no warranty for this free software.  For both users' and
-authors' sake, the GPL requires that modified versions be marked as
-changed, so that their problems will not be attributed erroneously to
-authors of previous versions.
-
-  Some devices are designed to deny users access to install or run
-modified versions of the software inside them, although the manufacturer
-can do so.  This is fundamentally incompatible with the aim of
-protecting users' freedom to change the software.  The systematic
-pattern of such abuse occurs in the area of products for individuals to
-use, which is precisely where it is most unacceptable.  Therefore, we
-have designed this version of the GPL to prohibit the practice for those
-products.  If such problems arise substantially in other domains, we
-stand ready to extend this provision to those domains in future versions
-of the GPL, as needed to protect the freedom of users.
-
-  Finally, every program is threatened constantly by software patents.
-States should not allow patents to restrict development and use of
-software on general-purpose computers, but in those that do, we wish to
-avoid the special danger that patents applied to a free program could
-make it effectively proprietary.  To prevent this, the GPL assures that
-patents cannot be used to render the program non-free.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If 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 convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Use with the GNU Affero General Public License.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU Affero General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the special requirements of the GNU Affero General Public License,
-section 13, concerning interaction through a network will apply to the
-combination as such.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU 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
-Program specifies that a certain numbered version of the GNU General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "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 PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM 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 PROGRAM (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 PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU General Public License as published by
-    the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If the program does terminal interaction, make it output a short
-notice like this when it starts in an interactive mode:
-
-    <program>  Copyright (C) <year>  <name of author>
-    This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
-    This is free software, and you are welcome to redistribute it
-    under certain conditions; type `show c' for details.
-
-The hypothetical commands `show w' and `show c' should show the appropriate
-parts of the General Public License.  Of course, your program's commands
-might be different; for a GUI interface, you would use an "about box".
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU GPL, see
-<https://www.gnu.org/licenses/>.
-
-  The GNU General Public License does not permit incorporating your program
-into proprietary programs.  If your program is a subroutine library, you
-may consider it more useful to permit linking proprietary applications with
-the library.  If this is what you want to do, use the GNU Lesser General
-Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,82 +1,4 @@
-# World Handler - Command GUI </br> [![badge](https://cf.way2muchnoise.eu/title/228970.svg)](https://www.curseforge.com/minecraft/mc-mods/world-handler-command-gui) [![badge](https://cf.way2muchnoise.eu/full_228970_downloads.svg)](https://www.curseforge.com/minecraft/mc-mods/world-handler-command-gui) #
+# WorldHandler build artifacts
 
-The World Handler provides a simple and easy to use graphical user interface for commands.
-It lets you create powerful and complex sub-commands alongside NBT-structures within seconds.
-
-# Features #
-
-* GUI for commands
-* Client Commands: advancement, blockdata, clear, clone, difficulty, effect, enchant, fill, gamemode, gamerule, give, kill, recipe, scoreboard, setworldspawn, spawnpoint, summon, tag, team, time, trigger, weather, xp
-* Server Commands: ban, deop, kick, op, pardon, save-all, save-off, save-on, whitelist
-* World and player information
-* /wh for a simplified /fill and /clone
-* Expandable GUI with json files and child mods
-* Client-side only
-
-# Download #
-
-Compiled binaries can be found on [Curseforge](https://www.curseforge.com/minecraft/mc-mods/world-handler-command-gui/files/)
-
-# Installation #
-
-Download World Handler or build from source
-
-## Prerequisites ##
-
-1. Make sure [Minecraft Forge](http://files.minecraftforge.net/) is installed
-
-## Installer ##
-
-1. Run `WorldHandler-[VERSION]-UNIVERSAL.jar`
-2. Select your Minecraft directory
-3. Click Install
-
-## Manual ##
-
-1. Navigate to `..\.minecraft\mods`
-2. Copy the `WorldHandler-[VERSION]-UNIVERSAL.jar`
-3. Follow the steps below
-
-## Launcher Settings ##
-
-1. Select Forge as your profile
-2. Launch Minecraft
-3. Join a world or server
-4. Press `V` to open the World Handler
-
-## Configuration ##
-
-≥ 1.14.4: Manual: `..\.minecraft\config\worldhandler\worldhandler.toml`  
-1.13-1.14.4: Manual: `..\.minecraft\config\worldhandler.toml`  
-1.9-1.12: Ingame: Mods -> World Handler -> Config (Manual: `..\.minecraft\config\worldhandler.cfg`)  
-≤ 1.8: Manual: `..\.minecraft\config\worldhandler\[CONFIG].cfg`
-
-## Installation with ModLoader (1.6.2) ##
-
-1. Navigate to `..\.minecraft\mods`
-2. Copy all files of the `World_Handler_GUI_[VERSION].zip` into the `1.6.2ML.jar`
-3. Run Minecraft
-
-# Expansion #
-
-The World Handler GUI can also be expanded with custom tabs configured with json and javascript files or as a separate child mod in java.  
-A description on how to implement a custom json and javascript file can be found [here](https://github.com/Exopandora/WorldHandler/wiki) and an example child mod can be found [here](https://github.com/Exopandora/WorldHandlerPlugin).
-
-# FAQ #
-
-**Q:** Is this client-side only ?  
-**A:** Yes
-
-**Q:** Can you port this to fabric, liteloader, rift, etc ?  
-**A:** No
-
-**Q:** Can i add this to my modpack ?  
-**A:** Yes, as long as you give credit
-
-# Support #
-
-This mod will no longer be updated.
-
-# License #
-
-GNU GENERAL PUBLIC LICENSE Version 3
+This branch is maintained by the Gitea runner.
+Download the jar file from this branch.

build.gradle

@@ -1,104 +0,0 @@
-plugins {
-	id 'java'
-	id 'eclipse'
-	id 'net.neoforged.moddev' version '2.0.141'
-	id 'me.hypherionmc.cursegradle' version '2.+'
-}
-
-archivesBaseName = "${mod_name}-${minecraft_version}-neoforge"
-version = mod_version
-
-java.toolchain.languageVersion = JavaLanguageVersion.of(21)
-javadoc.options.addStringOption('Xdoclint:none', '-quiet')
-println('Java: ' + System.getProperty('java.version') + ' JVM: ' + System.getProperty('java.vm.version') + ' (' + System.getProperty('java.vendor') + ') Arch: ' + System.getProperty('os.arch'))
-
-neoForge {
-	version = neo_version
-	accessTransformers = project.files('src/main/resources/META-INF/accesstransformer.cfg')
-	
-	runs {
-		client {
-			client()
-			gameDirectory = project.file('run')
-			systemProperty 'neoforge.enabledGameTestNamespaces', mod_id
-		}
-		
-		server {
-			server()
-			gameDirectory = project.file('run')
-			programArgument '--nogui'
-			systemProperty 'neoforge.enabledGameTestNamespaces', mod_id
-		}
-		
-		gameTestServer {
-			type = "gameTestServer"
-			gameDirectory = project.file('run')
-			systemProperty 'neoforge.enabledGameTestNamespaces', mod_id
-		}
-		
-		data {
-			data()
-			gameDirectory = project.file('run-data')
-			programArguments.addAll '--mod', mod_id, '--all', '--output', file('src/generated/resources/').getAbsolutePath(), '--existing', file('src/main/resources/').getAbsolutePath()
-		}
-	}
-	
-	mods {
-		"${mod_id}" {
-			sourceSet(sourceSets.main)
-		}
-	}
-}
-
-sourceSets.main.resources { srcDir 'src/generated/resources' }
-
-tasks.named('jar', Jar).configure {
-	manifest {
-		attributes([
-			"Specification-Title": "${mod_id}",
-			"Specification-Vendor": "${author}",
-			"Specification-Version": "1",
-			"Implementation-Title": "${mod_name}",
-			"Implementation-Version": "${minecraft_version}-${version}",
-			"Implementation-Vendor": "${author}",
-			"Implementation-Timestamp": new Date().format("yyyy-MM-dd'T'HH:mm:ssZ"),
-			"Main-Class": "${main_class}"
-		])
-	}
-}
-
-tasks.named('processResources', ProcessResources).configure {
-	outputs.upToDateWhen {
-		false
-	}
-	
-	from sourceSets.main.resources
-	
-	filesMatching(['META-INF/neoforge.mods.toml']) {
-		expand project.properties
-	}
-}
-
-tasks.withType(JavaCompile).configureEach {
-	options.encoding = 'UTF-8'
-}
-
-curseforge {
-	apiKey = project.hasProperty("curse_api_key") ? curse_api_key : ''
-	project {
-		id = curse_project_id
-		changelog = file('changelog.txt').canRead() ? file('changelog.txt').text : ''
-		changelogType = 'text'
-		releaseType = 'release'
-		addGameVersion 'NeoForge'
-		neoforge_compatible_minecraft_versions.split(",").each {
-			addGameVersion(it)
-		}
-		mainArtifact(jar) {
-			displayName = "${minecraft_version}-${mod_version} NeoForge"
-		}
-	}
-	options {
-		javaVersionAutoDetect = false
-	}
-}

curseforge.html

@@ -1,147 +0,0 @@
-<span style="font-family: Segoe UI;">
-	<h1><strong>World Handler - Command GUI</strong></h1>
-	<p>
-		The World Handler provides a simple and easy to use graphical user interface for commands.
-		It lets you create powerful and complex sub-commands alongside NBT-structures within seconds.
-	</p>
-	<h2><strong>Features</strong></h2>
-	<ul>
-		<li>
-			GUI for commands
-		</li>
-		<li>
-			Client Commands: advancement, blockdata, clear, clone, difficulty, effect, enchant, fill, gamemode, gamerule, give, kill, recipe, scoreboard, setworldspawn, spawnpoint, summon, tag, team, time, trigger, weather, xp
-		</li>
-		<li>
-			Server Commands: ban, deop, kick, op, pardon, save-all, save-off, save-on, whitelist
-		</li>
-		<li>
-			World and player information
-		</li>
-		<li>
-			/wh for a simplified /fill and /clone
-		</li>
-		<li>
-			Expandable GUI with json files and child mods
-		</li>
-		<li>
-			Client-side only
-		</li>
-	</ul>
-	<img src="https://media.forgecdn.net/attachments/300/564/2020-07-02.png" alt="World Handler Image" width="992" height="752" />
-	<h2><strong>Installation</strong></h2>
-	<p>
-		Download World Handler or build from source
-	</p>
-	<h3><strong>Prerequisites</strong></h3>
-	<ol>
-		<li>
-			1. Make sure <a href="http://files.minecraftforge.net/">Minecraft Forge</a> is installed
-		</li>
-	</ol>
-	<h3><strong>Installer</strong></h3>
-	<ol>
-		<li>
-			1. Run "WorldHandler-[VERSION]-UNIVERSAL.jar"
-		</li>
-		<li>
-			2. Select your Minecraft directory
-		</li>
-		<li>
-			3. Click Install
-		</li>
-	</ol>
-	<h3><strong>Manual</strong></h3>
-	<ol>
-		<li>
-			1. Navigate to "..\.minecraft\mods"
-		</li>
-		<li>
-			2. Copy the "WorldHandler-[VERSION]-UNIVERSAL.jar"
-		</li>
-		<li>
-			3. Follow the steps below
-		</li>
-	</ol>
-	<h3><strong>Launcher Settings</strong></h3>
-	<ol>
-		<li>
-			1. Select Forge as your profile
-		</li>
-		<li>
-			2. Launch Minecraft
-		</li>
-		<li>
-			3. Join a world or server
-		</li>
-		<li>
-			4. Press "V" to open the World Handler
-		</li>
-	</ol>
-	<h3><strong>Configuration</strong></h3>
-	<ol>
-		<li>
-			≥ 1.14.4: Manual: "..\.minecraft\config\worldhandler\worldhandler.toml"
-		</li>
-		<li>
-			1.13-1.14.4: Manual: "..\.minecraft\config\worldhandler.toml"
-		</li>
-		<li>
-			1.9-1.12: Ingame: Mods -> World Handler -> Config (Manual: "..\.minecraft\config\worldhandler.cfg")
-		</li>
-		<li>
-			≤ 1.8: Manual: "..\.minecraft\config\worldhandler\[CONFIG].cfg"
-		</li>
-	</ol>
-	<h3><strong>Installation with ModLoader (1.6.2)</strong></h3>
-	<ol>
-		<li>
-			1. Navigate to "..\.minecraft\mods"
-		</li>
-		<li>
-			2. Copy all files of the "World_Handler_GUI_[VERSION].zip" into the "1.6.2ML.jar"
-		</li>
-		<li>
-			3. Run Minecraft
-		</li>
-	</ol>
-	<h2><strong>Expansion</strong></h2>
-	<p>
-		The World Handler GUI can also be expanded with custom tabs configured with json and javascript files or as a separate child mod written in java.
-		A description on how to implement a custom json and javascript file can be found <a href="https://github.com/Exopandora/WorldHandler/wiki">here</a> and an example child mod can be found <a href="https://github.com/Exopandora/WorldHandlerPlugin">here</a>.
-	</p>
-	<h2><strong>FAQ</strong></h2>
-	<ol>
-		<li>
-			<strong>Q:</strong> Is this client-side only ?
-		</li>
-		<li>
-			<strong>A:</strong> Yes
-		</li>
-	</ol>
-	<ol>
-		<li>
-			<strong>Q: </strong> Can you port this to fabric, liteloader, rift, etc ?
-		</li>
-		<li>
-			<strong>A: </strong> No
-		</li>
-	</ol>
-	<ol>
-		<li>
-			<strong>Q: </strong> Can i add this to my modpack ?
-		</li>
-		<li>
-			<strong>A: </strong> Yes, as long as you give credit
-		</li>
-	</ol>
-	<h2><strong>Support</strong></h2>
-	<p>
-		Only the latest game version will be supported and updated with new features.
-		If you have any other suggestions, bug reports or questions feel free to open an issue on <a href="https://github.com/Exopandora/WorldHandler/issues">GitHub</a>.
-	</p>
-	<h2><strong>License</strong></h2>
-	<p>
-		GNU GENERAL PUBLIC LICENSE Version 3
-	</p>
-</span>

gradle.properties

@@ -1,21 +0,0 @@
-# WorldHandler
-mod_id = worldhandler
-mod_name = WorldHandler
-mod_version = 3.5.2-neoforge
-minecraft_version = 1.21.1
-group = exopandora.worldhandler
-main_class = exopandora.worldhandler.Main
-author = Exopandora
-
-# NeoForge
-neo_version = 21.1.225
-loader_version_range = [4,)
-neoforge_compatible_minecraft_versions = 1.21.1
-
-# Publishing
-curse_project_id = 228970
-
-# Gradle
-org.gradle.jvmargs = -Xmx3G
-org.gradle.daemon = false
-org.gradle.parallel = true

gradle/wrapper/gradle-wrapper.properties

@@ -1,6 +0,0 @@
-distributionBase=GRADLE_USER_HOME
-distributionPath=wrapper/dists
-distributionUrl=https\://services.gradle.org/distributions/gradle-8.12.1-bin.zip
-networkTimeout=10000
-zipStoreBase=GRADLE_USER_HOME
-zipStorePath=wrapper/dists

gradlew

@@ -1,245 +0,0 @@
-#!/bin/sh
-
-#
-# Copyright © 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.
-#
-#   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 «$var», «${var}», «${var:-default}», «${var+SET}»,
-#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
-#         * compound commands having a testable exit status, especially «case»;
-#         * various built-in commands including «command», «set», and «ulimit».
-#
-#   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/HEAD/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
-
-# Need this for daisy-chained symlinks.
-while
-    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
-    [ -h "$app_path" ]
-do
-    ls=$( ls -ld "$app_path" )
-    link=${ls#*' -> '}
-    case $link in             #(
-      /*)   app_path=$link ;; #(
-      *)    app_path=$APP_HOME$link ;;
-    esac
-done
-
-# This is normally unused
-# shellcheck disable=SC2034
-APP_BASE_NAME=${0##*/}
-APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
-
-# Use the maximum available, or set MAX_FD != -1 to use that value.
-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                #(
-  CYGWIN* )         cygwin=true  ;; #(
-  Darwin* )         darwin=true  ;; #(
-  MSYS* | 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
-    else
-        JAVACMD=$JAVA_HOME/bin/java
-    fi
-    if [ ! -x "$JAVACMD" ] ; then
-        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
-
-Please set the JAVA_HOME variable in your environment to match the
-location of your Java installation."
-    fi
-else
-    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
-location of your Java installation."
-fi
-
-# Increase the maximum file descriptors if we can.
-if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
-    case $MAX_FD in #(
-      max*)
-        # In POSIX sh, ulimit -H is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
-        MAX_FD=$( ulimit -H -n ) ||
-            warn "Could not query maximum file descriptor limit"
-    esac
-    case $MAX_FD in  #(
-      '' | soft) :;; #(
-      *)
-        # In POSIX sh, ulimit -n is undefined. That's why the result is checked to see if it worked.
-        # shellcheck disable=SC3045
-        ulimit -n "$MAX_FD" ||
-            warn "Could not set maximum file descriptor limit to $MAX_FD"
-    esac
-fi
-
-# Collect all arguments for the java command, stacking in reverse order:
-#   * args from the command line
-#   * the main class name
-#   * -classpath
-#   * -D...appname settings
-#   * --module-path (only if needed)
-#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
-
-# For Cygwin or MSYS, switch paths to Windows format before running java
-if "$cygwin" || "$msys" ; then
-    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
-    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
-
-    JAVACMD=$( cygpath --unix "$JAVACMD" )
-
-    # Now convert the arguments - kludge to limit ourselves to /bin/sh
-    for arg do
-        if
-            case $arg in                                #(
-              -*)   false ;;                            # don't mess with options #(
-              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
-                    [ -e "$t" ] ;;                      #(
-              *)    false ;;
-            esac
-        then
-            arg=$( cygpath --path --ignore --mixed "$arg" )
-        fi
-        # Roll the args list around exactly as many times as the number of
-        # 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
-
-
-# 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"'
-
-# Collect all arguments for the java command;
-#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
-#     shell script including quotes and variable substitutions, so put them in
-#     double quotes to make sure that they get re-expanded; and
-#   * put everything else in single quotes, so that it's not re-expanded.
-
-set -- \
-        "-Dorg.gradle.appname=$APP_BASE_NAME" \
-        -classpath "$CLASSPATH" \
-        org.gradle.wrapper.GradleWrapperMain \
-        "$@"
-
-# Stop when "xargs" is not available.
-if ! command -v xargs >/dev/null 2>&1
-then
-    die "xargs is not available"
-fi
-
-# Use "xargs" to parse quoted args.
-#
-# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
-#
-# In Bash we could simply go:
-#
-#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
-#   set -- "${ARGS[@]}" "$@"
-#
-# but POSIX shell has neither arrays nor command substitution, so instead we
-# post-process each arg (as a line of input to sed) to backslash-escape any
-# character that might be a shell metacharacter, then use eval to reverse
-# that process (while maintaining the separation between arguments), and wrap
-# the whole thing up as a single "set" statement.
-#
-# This will of course break if any of these variables contains a newline or
-# an unmatched quote.
-#
-
-eval "set -- $(
-        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
-        xargs -n1 |
-        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
-        tr '\n' ' '
-    )" '"$@"'
-
-exec "$JAVACMD" "$@"

gradlew.bat

@@ -1,92 +0,0 @@
-@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
-@rem  Gradle startup script for Windows
-@rem
-@rem ##########################################################################
-
-@rem Set local scope for the variables with windows NT shell
-if "%OS%"=="Windows_NT" setlocal
-
-set DIRNAME=%~dp0
-if "%DIRNAME%"=="" set DIRNAME=.
-@rem This is normally unused
-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"
-
-@rem Find java.exe
-if defined JAVA_HOME goto findJavaFromJavaHome
-
-set JAVA_EXE=java.exe
-%JAVA_EXE% -version >NUL 2>&1
-if %ERRORLEVEL% equ 0 goto execute
-
-echo.
-echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-:findJavaFromJavaHome
-set JAVA_HOME=%JAVA_HOME:"=%
-set JAVA_EXE=%JAVA_HOME%/bin/java.exe
-
-if exist "%JAVA_EXE%" goto execute
-
-echo.
-echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
-echo.
-echo Please set the JAVA_HOME variable in your environment to match the
-echo location of your Java installation.
-
-goto fail
-
-: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 %*
-
-:end
-@rem End local scope for the variables with windows NT shell
-if %ERRORLEVEL% equ 0 goto mainEnd
-
-:fail
-rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
-rem the _cmd.exe /c_ return code!
-set EXIT_CODE=%ERRORLEVEL%
-if %EXIT_CODE% equ 0 set EXIT_CODE=1
-if not ""=="%GRADLE_EXIT_CONSOLE%" exit %EXIT_CODE%
-exit /b %EXIT_CODE%
-
-:mainEnd
-if "%OS%"=="Windows_NT" endlocal
-
-:omega

run/config/worldhandler/usercontent/example/example.js

@@ -1,36 +0,0 @@
-var ActionHelper = Java.type('exopandora.worldhandler.util.ActionHelper');
-
-var visible = true;
-var enabled = true;
-
-function toggleVisibility() {
-	visible = !visible;
-}
-
-function toggleEnabled() {
-	enabled = !enabled;
-}
-
-function isVisible() {
-	return visible;
-}
-
-function isEnabled() {
-	return enabled;
-}
-
-function selected(arg) {
-	api.addChatMessage(arg);
-}
-
-function updateText(arg) {
-	api.setArgument("example1", "textfield", arg);
-}
-
-function openContent(arg) {
-	ActionHelper.open(arg);
-}
-
-function addChatMessage(arg) {
-	api.addChatMessage(arg);
-}

run/config/worldhandler/usercontent/example/example.json

@@ -1,389 +0,0 @@
-{
-	"commands": {
-		"example1": {
-			"label": "textfield",
-			"syntax": {
-				"name": "example",
-				"children": [
-					{
-						"name": "list_button",
-						"type": "resource_location",
-						"children": [
-							{
-								"name": "page_list",
-								"type": "resource_location",
-								"children": [
-									{
-										"name": "slider",
-										"type": "int",
-										"children": [
-											{
-												"name": "player",
-												"type": "player",
-												"children": [
-													{
-														"name": "textfield",
-														"label": "textfield",
-														"type": "string"
-													}
-												]
-											}
-										]
-									}
-								]
-							}
-						]
-					}
-				]
-			},
-			"visible": {
-				"type": "bool",
-				"bool": true
-			}
-		},
-		"example2": {
-			"label": "arg1",
-			"syntax": {
-				"name": "example2",
-				"children": [
-					{
-						"name": "arg1",
-						"label": "arg1",
-						"type": "float"
-					}
-				]
-			},
-			"visible": {
-				"type": "bool",
-				"bool": true
-			}
-		},
-		"example3": {
-			"label": "arg1",
-			"syntax": {
-				"name": "example3",
-				"children": [
-					{
-						"name": "arg1",
-						"label": "arg1",
-						"type": "int"
-					}
-				]
-			},
-			"visible": {
-				"type": "bool",
-				"bool": false
-			}
-		}
-	},
-	"gui": {
-		"title": "Example Title",
-		"tab": {
-			"title": "Example",
-			"category": "main",
-			"category_index": 3,
-			"active_content": "example"
-		},
-		"widgets": [
-			{
-				"text": "Button",
-				"type": "button",
-				"layout": {
-					"x": 0,
-					"y": 0,
-					"width": 56,
-					"height": 20
-				},
-				"action": {
-					"type": "js",
-					"attributes": {
-						"function": "addChatMessage",
-						"value": "Example message"
-					}
-				},
-				"attributes": {
-					"visible": {
-						"type": "bool",
-						"bool": true
-					},
-					"enabled": {
-						"type": "bool",
-						"bool": true
-					}
-				}
-			},
-			{
-				"text": "Send",
-				"type": "button",
-				"layout": {
-					"x": 58,
-					"y": 0,
-					"width": 56,
-					"height": 20
-				},
-				"action": {
-					"type": "run",
-					"attributes": {
-						"command": "example1",
-						"value": "textfield"
-					}
-				},
-				"attributes": {
-					"visible": {
-						"type": "bool",
-						"bool": true
-					},
-					"enabled": {
-						"type": "bool",
-						"bool": true
-					}
-				}
-			},
-			{
-				"text": "Textfield",
-				"type": "textfield",
-				"action": {
-					"type": "js",
-					"attributes": {
-						"function": "updateText"
-					}
-				},
-				"layout": {
-					"x": 0,
-					"y": 48,
-					"width": 114,
-					"height": 20
-				},
-				"attributes": {
-					"visible": {
-						"type": "js",
-						"function": "isVisible"
-					},
-					"enabled": {
-						"type": "js",
-						"function": "isEnabled"
-					},
-					"id": "textfield_id"
-				}
-			},
-			{
-				"type": "item_button",
-				"action": {
-					"type": "run_string",
-					"attributes": {
-						"value": "/give @p minecraft:diamond_sword 1"
-					}
-				},
-				"layout": {
-					"x": 0,
-					"y": 24,
-					"width": 20,
-					"height": 20
-				},
-				"attributes": {
-					"item": "minecraft:diamond_sword"
-				}
-			},
-			{
-				"type": "icon_button",
-				"action": {
-					"type": "open",
-					"attributes": {
-						"value": "main"
-					}
-				},
-				"layout": {
-					"x": 24,
-					"y": 24,
-					"width": 20,
-					"height": 20
-				},
-				"attributes": {
-					"icon": "home"
-				}
-			},
-			{
-				"text": "ActionHelper",
-				"type": "button",
-				"action": {
-					"type": "js",
-					"attributes": {
-						"function": "openContent",
-						"value": "settings"
-					}
-				},
-				"layout": {
-					"x": 48,
-					"y": 24,
-					"width": 66,
-					"height": 20
-				},
-				"attributes": {
-					"tooltip": "Opens Settings"
-				}
-			},
-			{
-				"type": "list_button",
-				"action": {
-					"type": "set",
-					"attributes": {
-						"command": "example1",
-						"argument": "list_button"
-					}
-				},
-				"layout": {
-					"x": 118,
-					"y": 72,
-					"width": 114,
-					"height": 20
-				},
-				"attributes": {
-					"items": [
-						{
-							"id": "minecraft:grass",
-							"translation": "block.minecraft.grass"
-						},
-						{
-							"id": "minecraft:stone",
-							"translation": "block.minecraft.stone"
-						},
-						{
-							"id": "minecraft:dirt",
-							"translation": "block.minecraft.dirt"
-						},
-						{
-							"id": "minecraft:cobblestone",
-							"translation": "block.minecraft.cobblestone"
-						}
-					]
-				}
-			},
-			{
-				"text": "Slider",
-				"type": "slider",
-				"action": {
-					"type": "set",
-					"attributes": {
-						"command": "example1",
-						"argument": "slider"
-					}
-				},
-				"layout": {
-					"x": 0,
-					"y": 96,
-					"width": 114,
-					"height": 20
-				},
-				"attributes": {
-					"id": "slider_id",
-					"min": 0.0,
-					"max": 100.0,
-					"start": 10.0
-				}
-			},
-			{
-				"text": "Visible",
-				"type": "button",
-				"action": {
-					"type": "js",
-					"attributes": {
-						"function": "toggleVisibility"
-					}
-				},
-				"layout": {
-					"x": 0,
-					"y": 72,
-					"width": 56,
-					"height": 20
-				},
-				"attributes": {
-					"tooltip": "Toggle Visibility State"
-				}
-			},
-			{
-				"text": "Enabled",
-				"type": "button",
-				"action": {
-					"type": "js",
-					"attributes": {
-						"function": "toggleEnabled"
-					}
-				},
-				"layout": {
-					"x": 58,
-					"y": 72,
-					"width": 56,
-					"height": 20
-				},
-				"attributes": {
-					"tooltip": "Toggle Enabled State"
-				}
-			},
-			{
-				"text": "gui.worldhandler.generic.backToGame",
-				"type": "button",
-				"action": {
-					"type": "back_to_game"
-				},
-				"layout": {
-					"x": 118,
-					"y": 96,
-					"width": 114,
-					"height": 20
-				}
-			}
-		],
-		"menus": [
-			{
-				"type": "page_list",
-				"layout": {
-					"x": 118,
-					"y": 0,
-					"width": 114,
-					"height": 20
-				},
-				"action": {
-					"type": "set",
-					"attributes": {
-						"command": "example1",
-						"argument": "page_list"
-					}
-				},
-				"attributes": {
-					"id": "page_list",
-					"length": 2,
-					"items": [
-						{
-							"id": "minecraft:grass",
-							"translation": "block.minecraft.grass"
-						},
-						{
-							"id": "minecraft:stone",
-							"translation": "block.minecraft.stone"
-						},
-						{
-							"id": "minecraft:dirt",
-							"translation": "block.minecraft.dirt"
-						},
-						{
-							"id": "minecraft:cobblestone",
-							"translation": "block.minecraft.cobblestone"
-						}
-					]
-				}
-			}
-		],
-		"labels": [
-			{
-				"text": "Text",
-				"x": 0,
-				"y": -11,
-				"color": 2039583,
-				"visible": {
-					"type": "js",
-					"function": "isVisible"
-				}
-			}
-		]
-	}
-}

settings.gradle

@@ -1,15 +0,0 @@
-pluginManagement {
-	repositories {
-		gradlePluginPortal()
-		maven {
-			name = 'NeoForge'
-			url = 'https://maven.neoforged.net/releases'
-		}
-	}
-}
-
-plugins {
-	id 'org.gradle.toolchains.foojay-resolver-convention' version '1.0.0'
-}
-
-rootProject.name = 'WorldHandler'

src/main/java/exopandora/worldhandler/Main.java

@@ -1,49 +0,0 @@
-package exopandora.worldhandler;
-
-import java.awt.EventQueue;
-import java.io.File;
-
-import javax.swing.UIManager;
-
-import exopandora.worldhandler.installer.Window;
-
-public class Main
-{
-	public static final String NAME = "World Handler";
-	public static final String MODID = "worldhandler";
-	public static final String MC_VERSION = "1.20.4";
-	public static final String MOD_VERSION = "3.5.1";
-	public static final String URL = "https://minecraft.curseforge.com/projects/world-handler-command-gui";
-	
-	public static void main(String[] args)
-	{
-		try
-		{
-			UIManager.setLookAndFeel(UIManager.getSystemLookAndFeelClassName());
-		}
-		catch(Exception e)
-		{
-			e.printStackTrace();
-		}
-		
-		EventQueue.invokeLater(new Window());
-	}
-	
-	public static File getInitialDirectory()
-	{
-		String home = System.getProperty("user.home", ".");
-		String os = String.valueOf(System.getProperty("os.name")).toLowerCase();
-		String minecraft = ".minecraft";
-		
-		if(os.contains("win") && System.getenv("APPDATA") != null)
-		{
-			return new File(System.getenv("APPDATA"), minecraft);
-		}
-		else if(os.contains("mac"))
-		{
-			return new File(new File(new File(home, "Library"), "Application Support"), "minecraft");
-		}
-		
-		return new File(home, minecraft);
-	}
-}

src/main/java/exopandora/worldhandler/WorldHandler.java

@@ -1,79 +0,0 @@
-package exopandora.worldhandler;
-
-import java.nio.file.Path;
-
-import org.apache.logging.log4j.LogManager;
-import org.apache.logging.log4j.Logger;
-
-import exopandora.worldhandler.config.Config;
-import exopandora.worldhandler.event.ClientEventHandler;
-import exopandora.worldhandler.event.KeyHandler;
-import exopandora.worldhandler.gui.category.Category;
-import exopandora.worldhandler.gui.content.Content;
-import exopandora.worldhandler.usercontent.UsercontentLoader;
-import exopandora.worldhandler.util.CommandHelper;
-import net.neoforged.api.distmarker.Dist;
-import net.neoforged.bus.api.IEventBus;
-import net.neoforged.bus.api.SubscribeEvent;
-import net.neoforged.fml.ModContainer;
-import net.neoforged.fml.common.Mod;
-import net.neoforged.fml.config.ModConfig.Type;
-import net.neoforged.neoforge.client.event.RegisterClientCommandsEvent;
-import net.neoforged.neoforge.client.event.RegisterKeyMappingsEvent;
-import net.neoforged.neoforge.common.NeoForge;
-import net.neoforged.fml.event.lifecycle.FMLClientSetupEvent;
-import net.neoforged.fml.event.lifecycle.FMLCommonSetupEvent;
-import net.neoforged.fml.loading.FMLEnvironment;
-import net.neoforged.fml.loading.FMLPaths;
-
-@Mod(Main.MODID)
-public class WorldHandler
-{
-	public static final Logger LOGGER = LogManager.getLogger();
-	public static final Path USERCONTENT_PATH = FMLPaths.CONFIGDIR.get().resolve(Main.MODID).resolve("usercontent");
-	
-	public WorldHandler(IEventBus modEventBus, ModContainer modContainer)
-	{
-		if(Dist.CLIENT.equals(FMLEnvironment.dist))
-		{
-			Config.setupDirectories(WorldHandler.USERCONTENT_PATH);
-			modContainer.registerConfig(Type.CLIENT, Config.CLIENT_SPEC, Main.MODID + "/" + Main.MODID + ".toml");
-			UsercontentLoader.load(WorldHandler.USERCONTENT_PATH);
-			modEventBus.addListener(WorldHandler.this::registerKeyMappingsEvent);
-			modEventBus.addListener(Content::createRegistry);
-			modEventBus.addListener(Category::createRegistry);
-			modEventBus.addListener(Content::register);
-			modEventBus.addListener(Category::register);
-		}
-		modEventBus.addListener(this::clientSetup);
-		modEventBus.addListener(this::commonSetup);
-	}
-	
-	@SubscribeEvent
-	public void clientSetup(FMLClientSetupEvent event)
-	{
-		NeoForge.EVENT_BUS.addListener(KeyHandler::keyInputEvent);
-		NeoForge.EVENT_BUS.addListener(ClientEventHandler::renderLevelStageEvent);
-		NeoForge.EVENT_BUS.addListener(ClientEventHandler::clientTickEvent);
-	}
-	
-	@SubscribeEvent
-	public void commonSetup(FMLCommonSetupEvent event)
-	{
-		NeoForge.EVENT_BUS.addListener(this::registerCommands);
-	}
-	
-	@SubscribeEvent
-	public void registerKeyMappingsEvent(RegisterKeyMappingsEvent event)
-	{
-		event.register(KeyHandler.KEY_WORLD_HANDLER);
-		event.register(KeyHandler.KEY_WORLD_HANDLER_POS1);
-		event.register(KeyHandler.KEY_WORLD_HANDLER_POS2);
-	}
-	
-	@SubscribeEvent
-	public void registerCommands(RegisterClientCommandsEvent event)
-	{
-		CommandHelper.registerCommands(event.getDispatcher(), event.getBuildContext());
-	}
-}

src/main/java/exopandora/worldhandler/builder/CommandBuilder.java

@@ -1,77 +0,0 @@
-package exopandora.worldhandler.builder;
-
-import java.util.List;
-import java.util.function.BiFunction;
-import java.util.stream.Collectors;
-
-import javax.annotation.Nullable;
-
-public abstract class CommandBuilder implements ICommandBuilder
-{
-	protected abstract CommandNodeLiteral root();
-	
-	public String toCommand(Object label, boolean preview)
-	{
-		CommandNode<?> node = this.root().find(label).orElse(this.root());
-		
-		if(preview)
-		{
-			return this.buildForward(node, label, CommandNode::toValue).toString();
-		}
-		
-		return this.buildReverse(node, label, CommandNode::toValue, false).toString();
-	}
-	
-	protected StringBuilder buildForward(CommandNode<?> node, Object label, BiFunction<CommandNode<?>, Object, String> valueMapper)
-	{
-		StringBuilder builder = this.buildReverse(node, label, valueMapper, true);
-		
-		if(builder.isEmpty())
-		{
-			return builder;
-		}
-		
-		if(node != null)
-		{
-			List<CommandNode<?>> children = node.getChildren();
-			
-			while(children != null && children.size() == 1)
-			{
-				node = children.get(0);
-				builder.append(" ");
-				builder.append(valueMapper.apply(children.get(0), label));
-				children = node.getChildren();
-			}
-			
-			if(children != null && children.size() > 0)
-			{
-				builder.append(children.stream().map(child -> valueMapper.apply(child, label)).collect(Collectors.joining("|", " [", "]")));
-			}
-		}
-		
-		return builder;
-	}
-	
-	protected StringBuilder buildReverse(@Nullable CommandNode<?> node, Object label, BiFunction<CommandNode<?>, Object, String> valueMapper, boolean includeOptionals)
-	{
-		StringBuilder builder = new StringBuilder();
-		
-		while(node != null)
-		{
-			CommandNode<?> parent = node.getParent();
-			
-			if(parent == null)
-			{
-				builder.insert(0, "/" + valueMapper.apply(node, label));
-			}
-			else if(includeOptionals || !builder.isEmpty() || !node.isOptional(label) || !node.isDefault(label))
-			{
-				builder.insert(0, " " + valueMapper.apply(node, label));
-			}
-			
-			node = parent;
-		}
-		
-		return builder;
-	}
-}

src/main/java/exopandora/worldhandler/builder/CommandNode.java

@@ -1,119 +0,0 @@
-package exopandora.worldhandler.builder;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Optional;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.builder.argument.IArgument;
-
-public abstract class CommandNode<T extends CommandNode<T>>
-{
-	private final String name;
-	private CommandNode<?> parent;
-	private List<CommandNode<?>> children;
-	private Object label;
-	
-	protected CommandNode(String name)
-	{
-		if(name == null || name.isBlank())
-		{
-			throw new IllegalArgumentException("Name cannot be null or blank");
-		}
-		
-		this.name = name;
-	}
-	
-	public T then(CommandNode<?> node)
-	{
-		if(this.children == null)
-		{
-			this.children = new ArrayList<CommandNode<?>>();
-		}
-		
-		node.parent = this.getThis();
-		this.children.add(node);
-		return this.getThis();
-	}
-	
-	public T label(Object label)
-	{
-		this.label = label;
-		return this.getThis();
-	}
-	
-	public Optional<CommandNode<?>> find(Object label)
-	{
-		if(label != null && label.equals(this.label))
-		{
-			return Optional.of(this.getThis());
-		}
-		
-		if(this.hasChildren())
-		{
-			for(CommandNode<?> child : this.children)
-			{
-				Optional<CommandNode<?>> result = child.find(label);
-				
-				if(result.isPresent())
-				{
-					return result;
-				}
-			}
-		}
-		
-		return Optional.empty();
-	}
-	
-	public String getName()
-	{
-		return this.name;
-	}
-	
-	@Nullable
-	public Object getLabel()
-	{
-		return this.label;
-	}
-	
-	public boolean isOptional(Object label)
-	{
-		return this.parent.label != null && (this.label != null && this.label.equals(label) || this.parent.label.equals(label));
-	}
-	
-	@Nullable
-	public CommandNode<?> getParent()
-	{
-		return this.parent;
-	}
-	
-	@Nullable
-	public List<CommandNode<?>> getChildren()
-	{
-		return this.children;
-	}
-	
-	public boolean hasChildren()
-	{
-		return this.children != null && !this.children.isEmpty();
-	}
-	
-	public abstract boolean isDefault(Object label);
-	
-	public abstract String toKey(Object label);
-	
-	public abstract String toValue(Object label);
-	
-	protected abstract T getThis();
-	
-	public static CommandNodeLiteral literal(String label)
-	{
-		return new CommandNodeLiteral(label);
-	}
-	
-	public static CommandNodeArgument argument(String label, IArgument argument)
-	{
-		return new CommandNodeArgument(label, argument);
-	}
-}

src/main/java/exopandora/worldhandler/builder/CommandNodeArgument.java

@@ -1,60 +0,0 @@
-package exopandora.worldhandler.builder;
-
-import exopandora.worldhandler.builder.argument.IArgument;
-
-public class CommandNodeArgument extends CommandNode<CommandNodeArgument>
-{
-	private final IArgument argument;
-	
-	protected CommandNodeArgument(String name, IArgument value)
-	{
-		super(name);
-		this.argument = value;
-	}
-	
-	@Override
-	public String toKey(Object label)
-	{
-		if(this.isOptional(label))
-		{
-			return "[" + this.getName() + "]";
-		}
-		
-		return "<" + this.getName() + ">";
-	}
-	
-	@Override
-	public String toValue(Object label)
-	{
-		if(this.argument == null || this.argument.isDefault())
-		{
-			return this.toKey(label);
-		}
-		
-		String argument = this.argument.serialize();
-		
-		if(argument != null)
-		{
-			return argument;
-		}
-		
-		return this.toKey(label);
-	}
-	
-	@Override
-	public boolean isDefault(Object label)
-	{
-		if(this.argument != null)
-		{
-			return this.argument.isDefault();
-		}
-		
-		return true;
-	}
-	
-	@Override
-	protected CommandNodeArgument getThis()
-	{
-		return this;
-	}
-}

src/main/java/exopandora/worldhandler/builder/CommandNodeLiteral.java

@@ -1,33 +0,0 @@
-package exopandora.worldhandler.builder;
-
-public class CommandNodeLiteral extends CommandNode<CommandNodeLiteral>
-{
-	protected CommandNodeLiteral(String literal)
-	{
-		super(literal);
-	}
-	
-	@Override
-	public boolean isDefault(Object label)
-	{
-		return false;
-	}
-	
-	@Override
-	public String toKey(Object label)
-	{
-		return this.getName();
-	}
-	
-	@Override
-	public String toValue(Object label)
-	{
-		return this.getName();
-	}
-	
-	@Override
-	protected CommandNodeLiteral getThis()
-	{
-		return this;
-	}
-}

src/main/java/exopandora/worldhandler/builder/ICommandBuilder.java

@@ -1,13 +0,0 @@
-package exopandora.worldhandler.builder;
-
-public interface ICommandBuilder
-{
-	static final int MAX_COMMAND_LENGTH = 256;
-	
-	String toCommand(Object label, boolean preview);
-	
-	default boolean needsCommandBlock(Object label, boolean preview)
-	{
-		return this.toCommand(label, preview).length() > MAX_COMMAND_LENGTH;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/AngleArgument.java

@@ -1,102 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import com.mojang.brigadier.StringReader;
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
-import net.minecraft.commands.arguments.coordinates.WorldCoordinate;
-
-public class AngleArgument implements IDeserializableArgument
-{
-	private Float angle;
-	private boolean relative;
-	
-	protected AngleArgument()
-	{
-		super();
-	}
-	
-	public void setAngle(@Nullable Float angle)
-	{
-		this.angle = angle;
-	}
-	
-	public void setRelative(boolean relative)
-	{
-		this.relative = relative;
-	}
-	
-	public void setAngle(@Nullable Float angle, boolean relative)
-	{
-		this.angle = angle;
-		this.relative = relative;
-	}
-	
-	@Nullable
-	public Float getAngle()
-	{
-		return this.angle;
-	}
-	
-	public boolean isRelative()
-	{
-		return this.relative;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		if(string == null)
-		{
-			this.reset();
-		}
-		else
-		{
-			try
-			{
-				StringReader reader = new StringReader(string);
-				boolean relative = WorldCoordinate.isRelative(reader);
-				float angle = reader.canRead() && reader.peek() != ' ' ? reader.readFloat() : 0.0F;
-				
-				if(!Float.isNaN(angle) && !Float.isInfinite(angle))
-				{
-					this.angle = angle;
-					this.relative = relative;
-				}
-				else
-				{
-					this.reset();
-				}
-			}
-			catch(CommandSyntaxException e)
-			{
-				this.reset();
-			}
-		}
-	}
-	
-	private void reset()
-	{
-		this.angle = null;
-		this.relative = false;
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.angle == null)
-		{
-			return null;
-		}
-		
-		return this.relative ? "~" : "" + Float.toString(this.angle);
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return this.angle == null;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/ArgumentListArgument.java

@@ -1,63 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.stream.Collectors;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-
-public class ArgumentListArgument implements IArgument
-{
-	private final List<OptionalCommandBuilder<?>> arguments = new ArrayList<OptionalCommandBuilder<?>>();
-	
-	public void add(OptionalCommandBuilder<?> argument)
-	{
-		this.arguments.add(argument);
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.arguments.isEmpty())
-		{
-			return null;
-		}
-		
-		return this.arguments.stream().map(builder -> builder.toCommand(builder.getLabel(), false)).collect(Collectors.joining(" "));
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return this.arguments.isEmpty();
-	}
-	
-	public abstract static class OptionalCommandBuilder<T> extends CommandBuilder
-	{
-		private T label;
-		
-		public OptionalCommandBuilder(T label)
-		{
-			this.label = label;
-		}
-		
-		public void setLabel(T label)
-		{
-			this.label = label;
-		}
-		
-		public T getLabel()
-		{
-			return this.label;
-		}
-		
-		@Override
-		public String toCommand(Object label, boolean preview)
-		{
-			return super.toCommand(label, preview).substring(1);
-		}
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/Arguments.java

@@ -1,369 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import java.util.function.Function;
-import java.util.Locale;
-
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import com.google.gson.JsonParseException;
-import com.mojang.brigadier.StringReader;
-import com.mojang.brigadier.arguments.StringArgumentType;
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-import com.mojang.serialization.JsonOps;
-
-import exopandora.worldhandler.builder.argument.PrimitiveArgument.Linkage;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument.Operation;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument.Relation;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument.Type;
-import exopandora.worldhandler.util.EnumHelper;
-import exopandora.worldhandler.util.RegistryHelper;
-import net.minecraft.advancements.critereon.MinMaxBounds;
-import net.minecraft.commands.ParserUtils;
-import net.minecraft.commands.arguments.EntityAnchorArgument.Anchor;
-import net.minecraft.core.Direction.Axis;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.Difficulty;
-import net.minecraft.world.scores.criteria.ObjectiveCriteria.RenderType;
-
-public class Arguments
-{
-    private static final Gson GSON = (new GsonBuilder()).disableHtmlEscaping().create();
-    
-	public static PrimitiveArgument<Short> shortArg()
-	{
-		return PrimitiveArgument.builder(string ->
-		{
-			try
-			{
-				return Short.parseShort(string);
-			}
-			catch(NumberFormatException e)
-			{
-				return null;
-			}
-		}).build();
-	}
-	
-	public static PrimitiveArgument<Byte> byteArg()
-	{
-		return PrimitiveArgument.builder(string ->
-		{
-			try
-			{
-				return Byte.parseByte(string);
-			}
-			catch(NumberFormatException e)
-			{
-				return null;
-			}
-		}).build();
-	}
-	
-	public static PrimitiveArgument<Integer> intArg()
-	{
-		return PrimitiveArgument.builder(string ->
-		{
-			try
-			{
-				return Integer.parseInt(string);
-			}
-			catch(NumberFormatException e)
-			{
-				return null;
-			}
-		}).build();
-	}
-	
-	public static PrimitiveArgument<Float> floatArg()
-	{
-		return PrimitiveArgument.builder(string ->
-		{
-			try
-			{
-				return Float.parseFloat(string);
-			}
-			catch(NumberFormatException e)
-			{
-				return null;
-			}
-		}).build();
-	}
-	
-	public static PrimitiveArgument<Double> doubleArg()
-	{
-		return PrimitiveArgument.builder(string ->
-		{
-			try
-			{
-				return Double.parseDouble(string);
-			}
-			catch(NumberFormatException e)
-			{
-				return null;
-			}
-		}).build();
-	}
-	
-	public static PrimitiveArgument<Long> longArg()
-	{
-		return PrimitiveArgument.builder(string ->
-		{
-			try
-			{
-				return Long.parseLong(string);
-			}
-			catch(NumberFormatException e)
-			{
-				return null;
-			}
-		}).build();
-	}
-	
-	public static PrimitiveArgument<Boolean> boolArg()
-	{
-		return PrimitiveArgument.builder(string ->
-		{
-			try
-			{
-				return Boolean.parseBoolean(string);
-			}
-			catch(NumberFormatException e)
-			{
-				return null;
-			}
-		}).build();
-	}
-	
-	public static PrimitiveArgument<String> string()
-	{
-		return PrimitiveArgument.builder(Function.identity())
-				.serializer(string -> string.isBlank() ? null : StringArgumentType.escapeIfRequired(string))
-				.build();
-	}
-	
-	public static PrimitiveArgument<String> greedyString()
-	{
-		return PrimitiveArgument.builder(string -> string == null || string.isBlank() ? null : string)
-				.serializer(string -> string.isBlank() ? null : string)
-				.defaultOverride(string -> string == null || string.isBlank())
-				.build();
-	}
-	
-	public static PrimitiveArgument<String> word()
-	{
-		return PrimitiveArgument.builder(string -> string == null || string.isBlank() ? null : string)
-				.serializer(string -> string.isBlank() ? null : string.replaceAll("[^0-9A-Za-z_\\-.+]", "_"))
-				.defaultOverride(string -> string == null || string.isBlank())
-				.build();
-	}
-	
-	public static PrimitiveArgument<ResourceLocation> resourceLocation()
-	{
-		return PrimitiveArgument.<ResourceLocation>builder(string -> string.isEmpty() ? null : ResourceLocation.parse(string)).build();
-	}
-	
-	public static ItemArgument item()
-	{
-		return new ItemArgument();
-	}
-	
-	public static BlockStateArgument blockState()
-	{
-		return new BlockStateArgument();
-	}
-	
-	public static BlockPredicateArgument blockPredicate()
-	{
-		return new BlockPredicateArgument();
-	}
-	
-	public static TagArgument tag()
-	{
-		return new TagArgument();
-	}
-	
-	public static PrimitiveArgument<Coordinate<Integer>> intCoordinate()
-	{
-		return PrimitiveArgument.<Coordinate<Integer>>builder(Coordinate.Ints::parse).build();
-	}
-	
-	public static PrimitiveArgument<Coordinate<Double>> doubleCoordinate()
-	{
-		return PrimitiveArgument.<Coordinate<Double>>builder(Coordinate.Doubles::parse).build();
-	}
-	
-	public static RangeArgument<Integer> intRange()
-	{
-		return new RangeArgument<Integer>(string ->
-		{
-			try
-			{
-				return MinMaxBounds.Ints.fromReader(new StringReader(string));
-			}
-			catch(CommandSyntaxException e)
-			{
-				return null;
-			}
-		});
-	}
-	
-	public static RangeArgument<Double> doubleRange()
-	{
-		return new RangeArgument<Double>(string ->
-		{
-			try
-			{
-				return MinMaxBounds.Doubles.fromReader(new StringReader(string));
-			}
-			catch(CommandSyntaxException e)
-			{
-				return null;
-			}
-		});
-	}
-	
-	public static AngleArgument angle()
-	{
-		return new AngleArgument();
-	}
-	
-	public static EnchantmentArgument enchantment()
-	{
-		return new EnchantmentArgument();
-	}
-	
-	public static EntitySummonArgument entitySummon()
-	{
-		return new EntitySummonArgument();
-	}
-	
-	public static PrimitiveArgument<Gamemode> gamemode()
-	{
-		return PrimitiveArgument.builder(string -> EnumHelper.find(string, Gamemode.values(), Gamemode::toString)).build();
-	}
-	
-	public static TimeArgument time()
-	{
-		return new TimeArgument();
-	}
-	
-	public static EffectArgument effect()
-	{
-		return new EffectArgument();
-	}
-	
-	public static PrimitiveArgument<Axis> axis()
-	{
-		return PrimitiveArgument.builder(string -> EnumHelper.find(string, Axis.values(), Axis::getName))
-				.serializer(Axis::getName)
-				.build();
-	}
-	
-	public static PrimitiveArgument<Anchor> anchor()
-	{
-		return PrimitiveArgument.builder(Anchor::getByName)
-				.serializer(anchor -> anchor.name().toLowerCase(Locale.ROOT))
-				.build();
-	}
-	
-	public static PrimitiveArgument<Difficulty> difficulty()
-	{
-		return PrimitiveArgument.builder(string -> EnumHelper.find(string, Difficulty.values(), Difficulty::getKey))
-				.serializer(Difficulty::getKey)
-				.build();
-	}
-	
-	public static PrimitiveArgument<RenderType> renderType()
-	{
-		return PrimitiveArgument.builder(string -> EnumHelper.find(string, RenderType.values(), RenderType::getId))
-				.serializer(RenderType::getId)
-				.build();
-	}
-	
-	public static PrimitiveArgument<PrimitiveArgument.Operation> operation()
-	{
-		return PrimitiveArgument.builder(string -> EnumHelper.find(string, Operation.values(), Operation::toString)).build();
-	}
-	
-	public static PrimitiveArgument<Component> textComponent()
-	{
-		return PrimitiveArgument.<Component>builder(string ->
-		{
-			try
-			{
-				return Component.Serializer.fromJson(string, RegistryHelper.registryAccess());
-			}
-			catch(Exception e)
-			{
-				return Component.literal(string);
-			}
-		}).serializer(component -> Component.Serializer.toJson(component, RegistryHelper.registryAccess())).build();
-	}
-	
-	public static PrimitiveArgument<PrimitiveArgument.Relation> relation()
-	{
-		return PrimitiveArgument.builder(string -> EnumHelper.find(string, Relation.values(), Relation::toString)).build();
-	}
-	
-	public static PrimitiveArgument<PrimitiveArgument.Type> type()
-	{
-		return PrimitiveArgument.builder(string -> EnumHelper.find(string, Type.values(), Type::toString)).build();
-	}
-	
-	public static PrimitiveArgument<PrimitiveArgument.Linkage> linkage()
-	{
-		return PrimitiveArgument.builder(string -> EnumHelper.find(string, Linkage.values(), Linkage::toString)).build();
-	}
-	
-	public static NbtPathArgument nbtPath()
-	{
-		return new NbtPathArgument();
-	}
-	
-	public static ItemPredicateArgument itemPredicate()
-	{
-		return new ItemPredicateArgument();
-	}
-	
-	public static PrimitiveArgument<String> criteria()
-	{
-		return PrimitiveArgument.builder(string -> string == null || string.isBlank() ? null : string)
-				.serializer(string -> string.isBlank() ? null : string.replaceAll(" ", "_"))
-				.defaultOverride(string -> string == null || string.isBlank())
-				.build();
-	}
-	
-	public static TargetArgument target()
-	{
-		return new TargetArgument();
-	}
-	
-	public static BlockPosArgument blockPos()
-	{
-		return new BlockPosArgument();
-	}
-	
-	public static DimensionArgument dimension()
-	{
-		return new DimensionArgument();
-	}
-	
-	public static PrimitiveArgument<Style> style()
-	{
-		return PrimitiveArgument.<Style>builder(string ->
-		{
-			try
-			{
-				return ParserUtils.parseJson(RegistryHelper.registryAccess(), new StringReader(string), Style.Serializer.CODEC);
-			}
-			catch(Exception e)
-			{
-				return null;
-			}
-		})
-		.serializer(style -> GSON.toJson(Style.Serializer.CODEC.encodeStart(JsonOps.INSTANCE, style).getOrThrow(JsonParseException::new)))
-		.build();
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/BlockPosArgument.java

@@ -1,95 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import net.minecraft.core.BlockPos;
-
-public class BlockPosArgument implements IArgument
-{
-	private Coordinate<?> x;
-	private Coordinate<?> y;
-	private Coordinate<?> z;
-	
-	protected BlockPosArgument()
-	{
-		super();
-	}
-	
-	public void setX(@Nullable Coordinate<?> x)
-	{
-		this.x = x;
-	}
-	
-	public void setY(@Nullable Coordinate<?> y)
-	{
-		this.y = y;
-	}
-	
-	public void setZ(@Nullable Coordinate<?> z)
-	{
-		this.z = z;
-	}
-	
-	public void set(@Nullable BlockPos pos)
-	{
-		if(pos != null)
-		{
-			this.x = new Coordinate.Ints(pos.getX());
-			this.y = new Coordinate.Ints(pos.getY());
-			this.z = new Coordinate.Ints(pos.getZ());
-		}
-		else
-		{
-			this.x = null;
-			this.y = null;
-			this.z = null;
-		}
-	}
-	
-	@Nullable
-	public Coordinate<?> getX()
-	{
-		return this.x;
-	}
-	
-	@Nullable
-	public Coordinate<?> getY()
-	{
-		return this.y;
-	}
-	
-	@Nullable
-	public Coordinate<?> getZ()
-	{
-		return this.z;
-	}
-	
-	@Nullable
-	public BlockPos getBlockPos()
-	{
-		if(this.x == null && this.y == null && this.z == null)
-		{
-			return null;
-		}
-		
-		return new BlockPos(this.x.getValue().intValue(), this.y.getValue().intValue(), this.z.getValue().intValue());
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.x == null || this.y == null || this.z == null)
-		{
-			return null;
-		}
-		
-		return this.x.serialize() + " " + this.y.serialize() + " " + this.z.serialize();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return this.x == null && this.y == null && this.z == null;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/BlockPredicateArgument.java

@@ -1,208 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import java.util.AbstractMap.SimpleEntry;
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.stream.Collectors;
-
-import javax.annotation.Nullable;
-
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
-import exopandora.worldhandler.util.BlockPredicateParser;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.world.level.block.state.properties.Property;
-import net.minecraft.core.registries.BuiltInRegistries;
-
-public class BlockPredicateArgument extends TagArgument
-{
-	private ResourceLocation resource;
-	private boolean isTag;
-	private Map<String, String> properties;
-	
-	protected BlockPredicateArgument()
-	{
-		super();
-	}
-	
-	public void set(@Nullable ResourceLocation resource)
-	{
-		this.resource = resource;
-	}
-	
-	public void set(@Nullable BlockState state)
-	{
-		if(state != null)
-		{
-			this.resource = BuiltInRegistries.BLOCK.getKey(state.getBlock());
-			this.properties = propertiesToString(state.getValues());
-		}
-		else
-		{
-			this.resource = null;
-			this.properties = null;
-		}
-		
-		this.isTag = false;
-	}
-	
-	public void set(@Nullable Map<Property<?>, Comparable<?>> properties)
-	{
-		if(properties != null)
-		{
-			this.properties = propertiesToString(properties);
-		}
-		else
-		{
-			this.properties = null;
-		}
-	}
-	
-	public void set(Property<?> key, @Nullable Comparable<?> value)
-	{
-		String name = key.getName();
-		
-		if(value == null)
-		{
-			if(this.properties != null && this.properties.containsKey(name))
-			{
-				this.properties.remove(name);
-			}
-		}
-		else
-		{
-			if(this.properties == null)
-			{
-				this.properties = new HashMap<String, String>();
-			}
-			
-			this.properties.put(name, getName(key, value));
-		}
-	}
-	
-	public void set(@Nullable BlockState state, CompoundTag tag)
-	{
-		this.set(state);
-		this.setTag(tag);
-		this.isTag = false;
-	}
-	
-	public void set(boolean isTag)
-	{
-		this.isTag = isTag;
-	}
-	
-	@Nullable
-	public ResourceLocation getResourceLocation()
-	{
-		return this.resource;
-	}
-	
-	public boolean isTag()
-	{
-		return this.isTag;
-	}
-	
-	public Map<String, String> getProperties()
-	{
-		if(this.properties == null)
-		{
-			return Collections.emptyMap();
-		}
-		
-		return Collections.unmodifiableMap(this.properties);
-	}
-	
-	@Override
-	public void deserialize(@Nullable String predicate)
-	{
-		if(predicate == null)
-		{
-			this.reset();
-		}
-		else
-		{
-			try
-			{
-				BlockPredicateParser parser = new BlockPredicateParser(predicate);
-				parser.parse(true);
-				this.resource = parser.getResourceLocation();
-				this.isTag = parser.isTag();
-				this.properties = parser.getVagueProperties();
-				this.setTag(parser.getNbt());
-			}
-			catch(CommandSyntaxException e)
-			{
-				this.reset();
-			}
-		}
-	}
-    
-	private void reset()
-	{
-		this.resource = null;
-		this.properties = null;
-		this.isTag = false;
-		this.setTag(null);
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.resource == null || this.resource.getPath().isEmpty())
-		{
-			return null;
-		}
-		
-		StringBuilder builder = new StringBuilder();
-		
-		if(this.isTag)
-		{
-			builder.append('#');
-		}
-		
-		builder.append(this.resource.toString());
-		
-		if(this.properties != null && !this.properties.isEmpty())
-		{
-			builder.append('[');
-			builder.append(this.properties.entrySet().stream().map(entry -> entry.getKey() + "=" + entry.getValue()).collect(Collectors.joining(",")));
-			builder.append(']');
-		}
-		
-		String nbt = super.serialize();
-		
-		if(nbt != null)
-		{
-			builder.append(nbt);
-		}
-		
-		return builder.toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return super.isDefault() && this.resource == null && (this.properties == null || this.properties.isEmpty());
-	}
-	
-	private static Map<String, String> propertiesToString(Map<Property<?>, Comparable<?>> properties)
-	{
-		return properties.entrySet().stream().map(entry ->
-		{
-			Property<?> property = entry.getKey();
-			return new SimpleEntry<String, String>(property.getName(), getName(property, entry.getValue()));
-		}).collect(Collectors.toMap(Entry::getKey, Entry::getValue));
-	}
-	
-	@SuppressWarnings("unchecked")
-	private static <T extends Comparable<T>> String getName(Property<T> key, Comparable<?> value)
-	{
-		return key.getName((T) value);
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/BlockStateArgument.java

@@ -1,123 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
-import exopandora.worldhandler.util.BlockPredicateParser;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.level.block.Block;
-import net.minecraft.world.level.block.state.BlockState;
-import net.minecraft.core.registries.BuiltInRegistries;
-
-public class BlockStateArgument extends TagArgument
-{
-	private BlockState state;
-	
-	protected BlockStateArgument()
-	{
-		super();
-	}
-	
-	public void set(@Nullable ResourceLocation block)
-	{
-		if(block != null)
-		{
-			this.set(BuiltInRegistries.BLOCK.get(block));
-		}
-		else
-		{
-			this.state = null;
-		}
-	}
-	
-	public void set(@Nullable Block block)
-	{
-		if(block != null)
-		{
-			this.state = block.defaultBlockState();
-		}
-		else
-		{
-			this.state = null;
-		}
-	}
-	
-	public void set(@Nullable BlockState state)
-	{
-		this.state = state;
-	}
-	
-	public void set(@Nullable BlockState state, CompoundTag tag)
-	{
-		this.set(state);
-		this.setTag(tag);
-	}
-	
-	@Nullable
-	public BlockState getBlockState()
-	{
-		return this.state;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		if(string == null)
-		{
-			this.reset();
-		}
-		else
-		{
-			try
-			{
-				BlockPredicateParser parser = new BlockPredicateParser(string);
-				parser.parse(false);
-				parser.getBlock().ifPresentOrElse(block ->
-				{
-					this.state = block.defaultBlockState();
-					this.setTag(parser.getNbt());
-				}, this::reset);
-			}
-			catch(CommandSyntaxException e)
-			{
-				this.reset();
-			}
-		}
-	}
-	
-	private void reset()
-	{
-		this.state = null;
-		this.setTag(null);
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.state == null)
-		{
-			return null;
-		}
-		
-		StringBuilder builder = new StringBuilder(this.state.toString());
-		String block = this.state.getBlock().toString();
-		builder.replace(0, block.length(), BuiltInRegistries.BLOCK.getKey(this.state.getBlock()).toString());
-		String nbt = super.serialize();
-		
-		if(nbt != null && this.state.hasBlockEntity())
-		{
-			builder.append(nbt);
-		}
-		
-		return builder.toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return super.isDefault() && this.state == null;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/CommandArgument.java

@@ -1,52 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.builder.ICommandBuilder;
-
-public class CommandArgument implements IArgument
-{
-	private ICommandBuilder command;
-	private Object label;
-	
-	public void set(ICommandBuilder command, Object label)
-	{
-		this.command = command;
-		this.label = label;
-	}
-	
-	public void set(Object label)
-	{
-		this.label = label;
-	}
-	
-	@Nullable
-	public ICommandBuilder getCommand()
-	{
-		return this.command;
-	}
-	
-	@Nullable
-	public Object getLabel()
-	{
-		return this.label;
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.command == null)
-		{
-			return null;
-		}
-		
-		return this.command.toCommand(this.label, false).substring(1);
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return false;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/Coordinate.java

@@ -1,191 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import com.mojang.brigadier.StringReader;
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
-import net.minecraft.commands.arguments.coordinates.LocalCoordinates;
-import net.minecraft.commands.arguments.coordinates.WorldCoordinate;
-
-public abstract class Coordinate<T extends Number>
-{
-	protected T value;
-	protected Type type;
-	
-	protected Coordinate(T value)
-	{
-		this(value, Type.ABSOLUTE);
-	}
-	
-	protected Coordinate(T value, Type type)
-	{
-		this.value = value;
-		this.type = type;
-	}
-	
-	public void setValue(T value)
-	{
-		this.value = value;
-	}
-	
-	public T getValue()
-	{
-		return this.value;
-	}
-	
-	public void setType(Type type)
-	{
-		this.type = type;
-	}
-	
-	public Type getType()
-	{
-		return this.type;
-	}
-	
-	@Nullable
-	public String serialize()
-	{
-		if(this.value == null)
-		{
-			return null;
-		}
-		
-		if(this.zero().equals(this.value) && !Type.ABSOLUTE.equals(this.type))
-		{
-			return this.type.getPrefix();
-		}
-		
-		return this.type.getPrefix() + this.value.toString();
-	}
-	
-	public abstract T zero();
-	
-	public static class Ints extends Coordinate<Integer>
-	{
-		public static final Ints ZERO = new Ints();
-		
-		public Ints()
-		{
-			super(0);
-		}
-		
-		public Ints(Integer value)
-		{
-			super(value);
-		}
-		
-		public Ints(Type type)
-		{
-			super(0, type);
-		}
-		
-		public Ints(Integer value, Type type)
-		{
-			super(value, type);
-		}
-		
-		@Override
-		public Integer zero()
-		{
-			return 0;
-		}
-		
-		@Nullable
-		public static Ints parse(String string)
-		{
-			try
-			{
-				StringReader reader = new StringReader(string);
-				
-				if(reader.canRead() && reader.peek() == '^')
-				{
-					return new Coordinate.Ints((int) LocalCoordinates.readDouble(reader, 0), Coordinate.Type.LOCAL);
-				}
-				else
-				{
-					WorldCoordinate wc = WorldCoordinate.parseInt(reader);
-					return new Coordinate.Ints((int) wc.get(0), wc.isRelative() ? Coordinate.Type.RELATIVE : Coordinate.Type.ABSOLUTE);
-				}
-			}
-			catch(CommandSyntaxException e)
-			{
-				return null;
-			}
-		}
-	}
-	
-	public static class Doubles extends Coordinate<Double>
-	{
-		public static final Doubles ZERO = new Doubles();
-		
-		public Doubles()
-		{
-			super(0.0D);
-		}
-		
-		public Doubles(Double value)
-		{
-			super(value);
-		}
-		
-		public Doubles(Type type)
-		{
-			super(0.0D, type);
-		}
-		
-		public Doubles(Double value, Type type)
-		{
-			super(value, type);
-		}
-		
-		@Override
-		public Double zero()
-		{
-			return 0.0D;
-		}
-		
-		@Nullable
-		public static Doubles parse(String string)
-		{
-			try
-			{
-				StringReader reader = new StringReader(string);
-				
-				if(reader.canRead() && reader.peek() == '^')
-				{
-					return new Coordinate.Doubles(LocalCoordinates.readDouble(reader, 0), Coordinate.Type.LOCAL);
-				}
-				else
-				{
-					WorldCoordinate wc = WorldCoordinate.parseInt(reader);
-					return new Coordinate.Doubles(wc.get(0), wc.isRelative() ? Coordinate.Type.RELATIVE : Coordinate.Type.ABSOLUTE);
-				}
-			}
-			catch(CommandSyntaxException e)
-			{
-				return null;
-			}
-		}
-	}
-	
-	public static enum Type
-	{
-		ABSOLUTE(""),
-		RELATIVE("~"),
-		LOCAL("^");
-		
-		private final String prefix;
-		
-		private Type(String prefix)
-		{
-			this.prefix = prefix;
-		}
-		
-		public String getPrefix()
-		{
-			return this.prefix;
-		}
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/DimensionArgument.java

@@ -1,66 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.util.ResourceHelper;
-import net.minecraft.core.registries.Registries;
-import net.minecraft.resources.ResourceKey;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.level.Level;
-
-public class DimensionArgument implements IDeserializableArgument
-{
-	private ResourceKey<Level> dimension;
-	
-	protected DimensionArgument()
-	{
-		super();
-	}
-	
-	public void set(@Nullable ResourceKey<Level> dimension)
-	{
-		this.dimension = dimension;
-	}
-	
-	public void set(@Nullable ResourceLocation dimension)
-	{
-		if(dimension != null)
-		{
-			this.set(ResourceKey.create(Registries.DIMENSION, dimension));
-		}
-		else
-		{
-			this.dimension = null;
-		}
-	}
-	
-	@Nullable
-	public ResourceKey<Level> getDimension()
-	{
-		return this.dimension;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		this.set(ResourceHelper.stringToResourceLocation(string));
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.dimension == null)
-		{
-			return null;
-		}
-		
-		return this.dimension.location().toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return false;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/EffectArgument.java

@@ -1,65 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.util.ResourceHelper;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.effect.MobEffect;
-import net.minecraft.core.registries.BuiltInRegistries;
-
-public class EffectArgument implements IDeserializableArgument
-{
-	private MobEffect effect;
-	
-	protected EffectArgument()
-	{
-		super();
-	}
-	
-	public void set(@Nullable MobEffect effect)
-	{
-		this.effect = effect;
-	}
-	
-	public void set(@Nullable ResourceLocation effect)
-	{
-		if(effect != null)
-		{
-			this.set(BuiltInRegistries.MOB_EFFECT.get(effect));
-		}
-		else
-		{
-			this.effect = null;
-		}
-	}
-	
-	@Nullable
-	public MobEffect getEffect()
-	{
-		return this.effect;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		this.set(ResourceHelper.stringToResourceLocation(string));
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.effect == null)
-		{
-			return null;
-		}
-		
-		return BuiltInRegistries.MOB_EFFECT.getKey(this.effect).toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return this.effect == null;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/EnchantmentArgument.java

@@ -1,65 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.util.RegistryHelper;
-import exopandora.worldhandler.util.ResourceHelper;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.enchantment.Enchantment;
-
-public class EnchantmentArgument implements IDeserializableArgument
-{
-	private Enchantment enchantment;
-	
-	protected EnchantmentArgument()
-	{
-		super();
-	}
-	
-	public void set(@Nullable Enchantment enchantment)
-	{
-		this.enchantment = enchantment;
-	}
-	
-	public void set(@Nullable ResourceLocation enchantment)
-	{
-		if(enchantment != null)
-		{
-			this.set(RegistryHelper.getEnchantment(enchantment));
-		}
-		else
-		{
-			this.enchantment = null;
-		}
-	}
-	
-	@Nullable
-	public Enchantment getEnchantment()
-	{
-		return this.enchantment;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		this.set(ResourceHelper.stringToResourceLocation(string));
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.enchantment == null)
-		{
-			return null;
-		}
-		
-		return RegistryHelper.getEnchantmentKey(this.enchantment).toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return false;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/EntitySummonArgument.java

@@ -1,135 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.util.ResourceHelper;
-import net.minecraft.Util;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.entity.EntityType;
-import net.minecraft.core.registries.BuiltInRegistries;
-
-public class EntitySummonArgument implements IDeserializableArgument
-{
-	private static final Map<String, ResourceLocation> ALIASES = Util.make(new HashMap<String, ResourceLocation>(), map ->
-	{
-		map.put("RedCow", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.MOOSHROOM));
-		map.put("ChickenJockey", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.CHICKEN));
-		map.put("Pigman", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.PIGLIN));
-		map.put("ZombiePig", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.PIGLIN));
-		map.put("ZombiePigman", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.PIGLIN));
-		map.put("Dog", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.WOLF));
-		map.put("Dragon", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.ENDER_DRAGON));
-		map.put("SnowMan", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.SNOW_GOLEM));
-		map.put("LavaCube", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.MAGMA_CUBE));
-		map.put("MagmaSlime", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.MAGMA_CUBE));
-		map.put("LavaSlime", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.MAGMA_CUBE));
-		map.put("SpiderJockey", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.SPIDER));
-		map.put("VillagerGolem", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.IRON_GOLEM));
-		map.put("Ozelot", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.OCELOT));
-		map.put("Kitty", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.CAT));
-		map.put("Kitten", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.CAT));
-		map.put("TESTIFICATE", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.VILLAGER));
-		map.put("Octopus", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.SQUID));
-		map.put("GlowingOctopus", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.SQUID));
-		map.put("Exwife", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.GHAST));
-		map.put("CommandMinecart", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.COMMAND_BLOCK_MINECART));
-		map.put("Wizard", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.EVOKER));
-		map.put("Johnny", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.VINDICATOR));
-		map.put("BabyZombie", BuiltInRegistries.ENTITY_TYPE.getKey(EntityType.ZOMBIE));
-		
-		BuiltInRegistries.VILLAGER_PROFESSION.entrySet().stream().forEach(profession -> map.put(profession.getKey().location().getPath(), profession.getKey().location()));
-	});
-	
-	private EntityType<?> entity;
-	
-	protected EntitySummonArgument()
-	{
-		super();
-	}
-	
-	public void set(@Nullable EntityType<?> entity)
-	{
-		if(entity != null && entity.canSummon())
-		{
-			this.entity = entity;
-		}
-		else
-		{
-			this.entity = null;
-		}
-	}
-	
-	public void set(@Nullable ResourceLocation entity)
-	{
-		if(entity != null)
-		{
-			EntityType<?> type = BuiltInRegistries.ENTITY_TYPE.get(entity);
-			ResourceLocation location = BuiltInRegistries.ENTITY_TYPE.getKey(type);
-			
-			if(!BuiltInRegistries.ENTITY_TYPE.getDefaultKey().equals(location) || location.equals(entity))
-			{
-				this.set(type);
-			}
-			else
-			{
-				this.entity = null;
-			}
-		}
-		else
-		{
-			this.entity = null;
-		}
-	}
-	
-	@Nullable
-	public EntityType<?> getEntity()
-	{
-		return this.entity;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String entity)
-	{
-		if(entity == null)
-		{
-			this.entity = null;
-		}
-		else
-		{
-			String stripped = entity.replace(" ", "");
-			
-			for(Entry<String, ResourceLocation> entry : ALIASES.entrySet())
-			{
-				if(entry.getKey().equalsIgnoreCase(stripped))
-				{
-					this.set(entry.getValue());
-					return;
-				}
-			}
-			
-			this.set(ResourceHelper.stringToResourceLocation(entity));
-		}
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.entity == null)
-		{
-			return null;
-		}
-		
-		return BuiltInRegistries.ENTITY_TYPE.getKey(this.entity).toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return this.entity == null;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/Gamemode.java

@@ -1,15 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-public enum Gamemode
-{
-	SURVIVAL,
-	CREATIVE,
-	ADVENTURE,
-	SPECTATOR;
-	
-	@Override
-	public String toString()
-	{
-		return this.name().toLowerCase();
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/IArgument.java

@@ -1,16 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-public interface IArgument
-{
-	@Nullable
-	String serialize();
-	
-	boolean isDefault();
-	
-	default boolean hasValue()
-	{
-		return this.serialize() != null;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/IDeserializableArgument.java

@@ -1,8 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-public interface IDeserializableArgument extends IArgument
-{
-	void deserialize(@Nullable String string);
-}

src/main/java/exopandora/worldhandler/builder/argument/ItemArgument.java

@@ -1,99 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
-import exopandora.worldhandler.util.ItemPredicateParser;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.Item;
-import net.minecraft.core.registries.BuiltInRegistries;
-
-public class ItemArgument extends TagArgument
-{
-	private Item item;
-	
-	protected ItemArgument()
-	{
-		super();
-	}
-	
-	public void set(@Nullable Item item)
-	{
-		this.item = item;
-	}
-	
-	public void set(@Nullable ResourceLocation item)
-	{
-		if(item != null)
-		{
-			this.set(BuiltInRegistries.ITEM.get(item));
-		}
-		else
-		{
-			this.item = null;
-		}
-	}
-	
-	public Item getItem()
-	{
-		return this.item;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		if(string != null)
-		{
-			try
-			{
-				ItemPredicateParser parser = new ItemPredicateParser(string);
-				parser.parse(false);
-				parser.getItem().ifPresentOrElse(item ->
-				{
-					this.item = item;
-					this.setTag(parser.getNbt());
-				}, () ->
-				{
-					this.item = null;
-					this.setTag(null);
-				});
-			}
-			catch(CommandSyntaxException e)
-			{
-				this.item = null;
-				this.setTag(null);
-			}
-		}
-		else
-		{
-			this.item = null;
-			this.setTag(null);
-		}
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.item == null)
-		{
-			return null;
-		}
-		
-		String tag = super.serialize();
-		
-		if(tag != null)
-		{
-			return BuiltInRegistries.ITEM.getKey(this.item).toString() + tag;
-		}
-		
-		return BuiltInRegistries.ITEM.getKey(this.item).toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return super.isDefault() && this.item == null;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/ItemPredicateArgument.java

@@ -1,116 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
-import exopandora.worldhandler.util.ItemPredicateParser;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.item.Item;
-import net.minecraft.core.registries.BuiltInRegistries;
-
-public class ItemPredicateArgument extends TagArgument
-{
-	private ResourceLocation resource;
-	private boolean isTag;
-	
-	protected ItemPredicateArgument()
-	{
-		super();
-	}
-	
-	public void set(@Nullable ResourceLocation resource)
-	{
-		this.resource = resource;
-	}
-	
-	public void set(@Nullable Item item)
-	{
-		if(item != null)
-		{
-			this.resource = BuiltInRegistries.ITEM.getKey(item);
-		}
-		else
-		{
-			this.resource = null;
-		}
-		
-		this.isTag = false;
-	}
-	
-	@Nullable
-	public ResourceLocation getResourceLocation()
-	{
-		return this.resource;
-	}
-	
-	public boolean isTag()
-	{
-		return this.isTag;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String predicate)
-	{
-		if(predicate == null)
-		{
-			this.reset();
-		}
-		else
-		{
-			try
-			{
-				ItemPredicateParser parser = new ItemPredicateParser(predicate);
-				parser.parse(true);
-				this.resource = parser.getResourceLocation();
-				this.setTag(parser.getNbt());
-				this.isTag = parser.isTag();
-			}
-			catch(CommandSyntaxException e)
-			{
-				this.reset();
-			}
-		}
-	}
-    
-	private void reset()
-	{
-		this.resource = null;
-		this.setTag(null);
-		this.isTag = false;
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.resource == null || this.resource.getPath().isEmpty())
-		{
-			return null;
-		}
-		
-		StringBuilder builder = new StringBuilder();
-		
-		if(this.isTag)
-		{
-			builder.append('#');
-		}
-		
-		builder.append(this.resource.toString());
-		
-		String nbt = super.serialize();
-		
-		if(nbt != null)
-		{
-			builder.append(nbt);
-		}
-		
-		return builder.toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return super.isDefault() && this.resource == null;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/NbtPathArgument.java

@@ -1,62 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import com.mojang.brigadier.StringReader;
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
-import net.minecraft.commands.arguments.NbtPathArgument.NbtPath;
-
-public class NbtPathArgument implements IDeserializableArgument
-{
-	private NbtPath path;
-	
-	protected NbtPathArgument()
-	{
-		super();
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		if(string != null)
-		{
-			try
-			{
-				this.path = net.minecraft.commands.arguments.NbtPathArgument.nbtPath().parse(new StringReader(string));
-			}
-			catch(CommandSyntaxException e)
-			{
-				this.path = null;
-			}
-		}
-		else
-		{
-			this.path = null;
-		}
-	}
-	
-	@Nullable
-	public NbtPath getPath()
-	{
-		return this.path;
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.path == null)
-		{
-			return null;
-		}
-		
-		return this.path.toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return this.path == null;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/PrimitiveArgument.java

@@ -1,183 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import java.util.function.Function;
-
-import javax.annotation.Nullable;
-
-public class PrimitiveArgument<T> implements IDeserializableArgument
-{
-	private T value;
-	private final Function<T, Boolean> defaultOverride;
-	private final Function<String, T> parser;
-	private final Function<T, String> serializer;
-	
-	protected PrimitiveArgument(Function<T, Boolean> defaultOverride, Function<String, T> parser, Function<T, String> serializer)
-	{
-		this.defaultOverride = defaultOverride;
-		this.parser = parser;
-		this.serializer = serializer;
-	}
-	
-	public void set(@Nullable T value)
-	{
-		this.value = value;
-	}
-	
-	@Nullable
-	public T get()
-	{
-		return this.value;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		if(string == null)
-		{
-			this.value = null;
-		}
-		else
-		{
-			this.value = this.parser.apply(string);
-		}
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.value == null)
-		{
-			return null;
-		}
-		else if(this.serializer != null)
-		{
-			return this.serializer.apply(this.value);
-		}
-		
-		return this.value.toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		if(this.defaultOverride != null)
-		{
-			return this.defaultOverride.apply(this.value);
-		}
-		
-		return this.value == null;
-	}
-	
-	public static <T> Builder<T> builder(Function<String, T> deserializer)
-	{
-		return new Builder<T>(deserializer);
-	}
-	
-	public static class Builder<T>
-	{
-		private Function<T, Boolean> defaultOverride;
-		private Function<String, T> deserializer;
-		private Function<T, String> serializer;
-		
-		private Builder(Function<String, T> deserializer)
-		{
-			this.deserializer = deserializer;
-		}
-		
-		public Builder<T> defaultOverride(Function<T, Boolean> defaultOverride)
-		{
-			this.defaultOverride = defaultOverride;
-			return this;
-		}
-		
-		public Builder<T> serializer(Function<T, String> serializer)
-		{
-			this.serializer = serializer;
-			return this;
-		}
-		
-		public PrimitiveArgument<T> build()
-		{
-			return new PrimitiveArgument<T>(this.defaultOverride, this.deserializer, this.serializer);
-		}
-	}
-	
-	public static enum Operation
-	{
-		SET("="),
-		ADD("+="),
-		SUB("-="),
-		MUL("*="),
-		DIV("/="),
-		MOD("%="),
-		LESS_THAN("<"),
-		GREATER_THAN(">");
-		
-		private final String operator;
-		
-		private Operation(String operator)
-		{
-			this.operator = operator;
-		}
-		
-		@Override
-		public String toString()
-		{
-			return this.operator;
-		}
-	}
-	
-	public static enum Relation
-	{
-		LT("<"),
-		LE("<="),
-		EQ("="),
-		GE(">="),
-		GT(">");
-		
-		private final String operator;
-		
-		private Relation(String operator)
-		{
-			this.operator = operator;
-		}
-		
-		@Override
-		public String toString()
-		{
-			return this.operator;
-		}
-	}
-	
-	public static enum Type
-	{
-		BYTE,
-		DOUBLE,
-		FLOAT,
-		INT,
-		LONG,
-		SHORT;
-		
-		@Override
-		public String toString()
-		{
-			return this.name().toLowerCase();
-		}
-	}
-	
-	public static enum Linkage
-	{
-		APPEND,
-		INSERT,
-		MERGE,
-		PREPEND,
-		SET;
-		
-		@Override
-		public String toString()
-		{
-			return this.name().toLowerCase();
-		}
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/RangeArgument.java

@@ -1,84 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import java.util.Optional;
-import java.util.function.Function;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.util.Util;
-import net.minecraft.advancements.critereon.MinMaxBounds;
-
-public class RangeArgument<T extends Number> implements IDeserializableArgument
-{
-	private final Function<String, MinMaxBounds<T>> parser;
-	private Optional<T> min;
-	private Optional<T> max;
-	
-	protected RangeArgument(Function<String, MinMaxBounds<T>> parser)
-	{
-		this.parser = parser;
-	}
-	
-	public void setExact(@Nullable T value)
-	{
-		this.min = Optional.ofNullable(value);
-		this.max = Optional.ofNullable(value);
-	}
-	
-	public void setRange(@Nullable T min, @Nullable T max)
-	{
-		this.min = Optional.ofNullable(min);
-		this.max = Optional.ofNullable(max);
-	}
-	
-	public void setMin(@Nullable T min)
-	{
-		this.min = Optional.ofNullable(min);
-	}
-	
-	public void setMax(@Nullable T max)
-	{
-		this.max = Optional.ofNullable(max);
-	}
-	
-	@Nullable
-	public T getMin()
-	{
-		return this.min.orElse(null);
-	}
-	
-	@Nullable
-	public T getMax()
-	{
-		return this.max.orElse(null);
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		if(string != null)
-		{
-			MinMaxBounds<T> bounds = this.parser.apply(string);
-			this.min = bounds.min();
-			this.max = bounds.max();
-		}
-		else
-		{
-			this.min = Optional.empty();
-			this.max = Optional.empty();
-		}
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		return Util.serializeBounds(this.getMin(), this.getMax());
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return this.min.isEmpty() && this.max.isEmpty();
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/TagArgument.java

@@ -1,112 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import java.util.ArrayList;
-import java.util.List;
-
-import javax.annotation.Nullable;
-
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
-import exopandora.worldhandler.builder.argument.tag.ITagProvider;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.Tag;
-import net.minecraft.nbt.TagParser;
-
-public class TagArgument implements IDeserializableArgument
-{
-	private List<ITagProvider> providers;
-	private CompoundTag tag;
-	
-	protected TagArgument()
-	{
-		super();
-	}
-	
-	public void addTagProvider(ITagProvider provider)
-	{
-		if(this.providers == null)
-		{
-			this.providers = new ArrayList<ITagProvider>();
-		}
-		
-		this.providers.add(provider);
-	}
-	
-	public void setTag(@Nullable CompoundTag tag)
-	{
-		this.tag = tag;
-	}
-	
-	@Nullable
-	public CompoundTag getTag()
-	{
-		return this.tag;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		if(string != null)
-		{
-			try
-	        {
-				this.tag = TagParser.parseTag(string);
-	        }
-	        catch(CommandSyntaxException e)
-	        {
-	    		this.tag = null;
-	        }
-		}
-		else
-		{
-    		this.tag = null;
-		}
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.tag == null && (this.providers == null || this.providers.isEmpty()))
-		{
-			return null;
-		}
-		
-		CompoundTag compound = this.tag == null ? new CompoundTag() : this.tag.copy();
-		
-		if(this.providers != null)
-		{
-			for(ITagProvider provider : this.providers)
-			{
-				Tag tag = provider.value();
-				
-				if(tag != null)
-				{
-					String key = provider.key();
-					
-					if(key != null)
-					{
-						compound.put(key, tag);
-					}
-					else if(tag instanceof CompoundTag)
-					{
-						compound.merge((CompoundTag) tag);
-					}
-				}
-			}
-		}
-		
-		if(compound.isEmpty())
-		{
-			return null;
-		}
-		
-		return compound.toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return this.tag == null && (this.providers == null || this.providers.isEmpty() || this.providers.stream().allMatch(provider -> provider.value() == null));
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/TargetArgument.java

@@ -1,729 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import java.util.AbstractMap.SimpleEntry;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Optional;
-import java.util.function.Function;
-import java.util.stream.Collectors;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.builder.argument.tag.ITagProvider;
-import exopandora.worldhandler.util.Util;
-import net.minecraft.advancements.critereon.MinMaxBounds;
-import net.minecraft.advancements.critereon.WrappedMinMaxBounds;
-import net.minecraft.resources.ResourceLocation;
-
-public class TargetArgument implements IArgument
-{
-	@Nullable
-	private String target; // player name or entity UUID
-	@Nullable
-	private String selectorType;
-	private NegatableCriterion<String> name = new NegatableCriterion<String>();
-	private DoubleMinMaxBounds distance = DoubleMinMaxBounds.ANY;
-	@Nullable
-	private Double x;
-	@Nullable
-	private Double y;
-	@Nullable
-	private Double z;
-	@Nullable
-	private Double deltaX;
-	@Nullable
-	private Double deltaY;
-	@Nullable
-	private Double deltaZ;
-	private WrappedMinMaxBounds rotX = WrappedMinMaxBounds.ANY;
-	private WrappedMinMaxBounds rotY = WrappedMinMaxBounds.ANY;
-	@Nullable
-	private Double level;
-	@Nullable
-	private Integer limit;
-	private NegatableCriterion<TagArgument> nbt = new NegatableCriterion<TagArgument>();
-	private NegatableCriterion<ResourceLocation> type = new NegatableCriterion<ResourceLocation>();
-	private Map<ResourceLocation, Boolean> advancements;
-	private List<NegatableCriterion<ResourceLocation>> predicates;
-	private NegatableCriterion<String> team = new NegatableCriterion<String>();
-	private Map<String, IntMinMaxBounds> scores;
-	@Nullable
-	private NegatableCriterion<Gamemode> gamemode = new NegatableCriterion<Gamemode>();
-	@Nullable
-	private Sort sort;
-	
-	protected TargetArgument()
-	{
-		super();
-	}
-	
-	public void setTarget(@Nullable String target)
-	{
-		this.target = target;
-	}
-	
-	public void setSelectorType(@Nullable String type)
-	{
-		this.selectorType = type;
-	}
-	
-	public void setName(@Nullable String name)
-	{
-		this.name.setCriterion(name);
-	}
-	
-	public void setNameNegated(boolean negated)
-	{
-		this.name.setNegated(negated);
-	}
-	
-	public void setName(@Nullable String name, boolean negated)
-	{
-		this.setName(name);
-		this.setNameNegated(negated);
-	}
-	
-	public void setDistance(@Nullable Double distance)
-	{
-		this.distance = new DoubleMinMaxBounds(distance, distance);
-	}
-	
-	public void setDistance(@Nullable Double min, @Nullable Double max)
-	{
-		this.distance = new DoubleMinMaxBounds(min, max);
-	}
-	
-	public void setDistanceMin(@Nullable Double min)
-	{
-		this.distance = new DoubleMinMaxBounds(min, this.distance.getMax());
-	}
-	
-	public void setDistanceMax(@Nullable Double max)
-	{
-		this.distance = new DoubleMinMaxBounds(this.distance.getMin(), max);
-	}
-	
-	public void setX(@Nullable Double x)
-	{
-		this.x = x;
-	}
-	
-	public void setY(@Nullable Double y)
-	{
-		this.y = y;
-	}
-	
-	public void setZ(@Nullable Double z)
-	{
-		this.z = z;
-	}
-	
-	public void setDeltaX(@Nullable Double deltaX)
-	{
-		this.deltaX = deltaX;
-	}
-	
-	public void setDeltaY(@Nullable Double deltaY)
-	{
-		this.deltaY = deltaY;
-	}
-	
-	public void setDeltaZ(@Nullable Double deltaZ)
-	{
-		this.deltaZ = deltaZ;
-	}
-	
-	public void setRotationX(@Nullable Float rotX)
-	{
-		this.rotX = WrappedMinMaxBounds.exactly(rotX);
-	}
-	
-	public void setRotationX(@Nullable Float min, @Nullable Float max)
-	{
-		this.rotX = WrappedMinMaxBounds.between(min, max);
-	}
-	
-	public void setRotationXMin(@Nullable Float min)
-	{
-		this.rotX = WrappedMinMaxBounds.between(min, this.rotX.max());
-	}
-	
-	public void setRotationXMax(@Nullable Float max)
-	{
-		this.rotX = WrappedMinMaxBounds.between(this.rotX.min(), max);
-	}
-	
-	public void setRotationY(@Nullable Float rotY)
-	{
-		this.rotY = WrappedMinMaxBounds.exactly(rotY);
-	}
-	
-	public void setRotationY(@Nullable Float min, @Nullable Float max)
-	{
-		this.rotY = WrappedMinMaxBounds.between(min, max);
-	}
-	
-	public void setRotationYMin(@Nullable Float min)
-	{
-		this.rotY = WrappedMinMaxBounds.between(min, this.rotY.max());
-	}
-	
-	public void setRotationYMax(@Nullable Float max)
-	{
-		this.rotY = WrappedMinMaxBounds.between(this.rotY.min(), max);
-	}
-	
-	public void setLevel(@Nullable Double level)
-	{
-		this.level = level;
-	}
-	
-	public void setLimit(@Nullable Integer limit)
-	{
-		this.limit = limit;
-	}
-	
-	public TargetArgument addTag(ITagProvider provider)
-	{
-		if(this.nbt.getCriterion() == null)
-		{
-			this.nbt.setCriterion(new TagArgument());
-		}
-		
-		this.nbt.getCriterion().addTagProvider(provider);
-		return this;
-	}
-	
-	public void setType(@Nullable ResourceLocation type)
-	{
-		this.type.setCriterion(type);
-	}
-	
-	public void setTypeNegated(boolean negated)
-	{
-		this.type.setNegated(negated);
-	}
-	
-	public void setType(@Nullable ResourceLocation type, boolean negated)
-	{
-		this.setType(type);
-		this.setTypeNegated(negated);
-	}
-	
-	public void setAdvancement(ResourceLocation advancement, boolean unlocked)
-	{
-		if(this.advancements == null)
-		{
-			this.advancements = new HashMap<ResourceLocation, Boolean>();
-		}
-		
-		this.advancements.put(advancement, unlocked);
-	}
-	
-	public void setPredicate(ResourceLocation predicate)
-	{
-		this.setPredicate(predicate, false);
-	}
-	
-	public void setPredicate(ResourceLocation predicate, boolean negated)
-	{
-		if(this.predicates == null)
-		{
-			this.predicates = new ArrayList<NegatableCriterion<ResourceLocation>>();
-		}
-		
-		NegatableCriterion<ResourceLocation> entry = this.findPredicate(predicate);
-		
-		if(entry == null)
-		{
-			this.predicates.add(new NegatableCriterion<ResourceLocation>(predicate, negated));
-		}
-		else if(entry.isNegated() != negated)
-		{
-			entry.setNegated(negated);
-		}
-	}
-	
-	private NegatableCriterion<ResourceLocation> findPredicate(ResourceLocation predicate)
-	{
-		for(NegatableCriterion<ResourceLocation> entry : this.predicates)
-		{
-			if(predicate.equals(entry.getCriterion()))
-			{
-				return entry;
-			}
-		}
-		
-		return null;
-	}
-	
-	public void setTeam(@Nullable String team)
-	{
-		this.team.setCriterion(team);
-	}
-	
-	public void setTeamNegated(boolean negated)
-	{
-		this.team.setNegated(negated);
-	}
-	
-	public void setTeam(@Nullable String team, boolean negated)
-	{
-		this.setTeam(team);
-		this.setTeamNegated(negated);
-	}
-	
-	public void setScore(String score, @Nullable Integer value)
-	{
-		if(this.scores == null)
-		{
-			this.scores = new HashMap<String, IntMinMaxBounds>();
-		}
-		
-		this.scores.put(score, IntMinMaxBounds.exactly(value));
-	}
-	
-	public void setScore(String score, @Nullable Integer min, @Nullable Integer max)
-	{
-		if(this.scores == null)
-		{
-			this.scores = new HashMap<String, IntMinMaxBounds>();
-		}
-		
-		this.scores.put(score, new IntMinMaxBounds(min, max));
-	}
-	
-	public void setScoreMin(String score, @Nullable Integer min)
-	{
-		if(this.scores == null)
-		{
-			this.scores = new HashMap<String, IntMinMaxBounds>();
-		}
-		
-		this.scores.put(score, new IntMinMaxBounds(min, this.scores.getOrDefault(score, IntMinMaxBounds.ANY).getMax()));
-	}
-	
-	public void setScoreMax(String score, @Nullable Integer max)
-	{
-		if(this.scores == null)
-		{
-			this.scores = new HashMap<String, IntMinMaxBounds>();
-		}
-		
-		this.scores.put(score, new IntMinMaxBounds(this.scores.getOrDefault(score, IntMinMaxBounds.ANY).getMin(), max));
-	}
-	
-	public void setGamemode(@Nullable Gamemode gamemode)
-	{
-		this.gamemode.setCriterion(gamemode);
-	}
-	
-	public void setGamemodeNegated(boolean negated)
-	{
-		this.gamemode.setNegated(negated);
-	}
-	
-	public void setGamemode(@Nullable Gamemode gamemode, boolean negated)
-	{
-		this.setGamemode(gamemode);
-		this.setGamemodeNegated(negated);
-	}
-	
-	public void setSort(@Nullable Sort sort)
-	{
-		this.sort = sort;
-	}
-	
-	@Nullable
-	public String getTarget()
-	{
-		return this.target;
-	}
-	
-	@Nullable
-	public String getSelectorType()
-	{
-		return this.selectorType;
-	}
-	
-	public NegatableCriterion<String> getName()
-	{
-		return this.name;
-	}
-	
-	public MinMaxBounds.Doubles getDistance()
-	{
-		return this.distance.toMinMaxBounds();
-	}
-	
-	@Nullable
-	public Double getX()
-	{
-		return this.x;
-	}
-	
-	@Nullable
-	public Double getY()
-	{
-		return this.y;
-	}
-	
-	@Nullable
-	public Double getZ()
-	{
-		return this.z;
-	}
-	
-	@Nullable
-	public Double getDeltaX()
-	{
-		return this.deltaX;
-	}
-	
-	@Nullable
-	public Double getDeltaY()
-	{
-		return this.deltaY;
-	}
-	
-	@Nullable
-	public Double getDeltaZ()
-	{
-		return this.deltaZ;
-	}
-	
-	public WrappedMinMaxBounds getRotX()
-	{
-		return this.rotX;
-	}
-	
-	public WrappedMinMaxBounds getRotY()
-	{
-		return this.rotY;
-	}
-	
-	@Nullable
-	public Double getLevel()
-	{
-		return this.level;
-	}
-	
-	@Nullable
-	public Integer getLimit()
-	{
-		return this.limit;
-	}
-	
-	public NegatableCriterion<TagArgument> getNbt()
-	{
-		return this.nbt;
-	}
-	
-	public NegatableCriterion<ResourceLocation> getType()
-	{
-		return this.type;
-	}
-	
-	@Nullable
-	public Map<ResourceLocation, Boolean> getAdvancements()
-	{
-		return this.advancements;
-	}
-	
-	@Nullable
-	public List<NegatableCriterion<ResourceLocation>> getPredicates()
-	{
-		return this.predicates;
-	}
-	
-	public NegatableCriterion<String> getTeam()
-	{
-		return this.team;
-	}
-	
-	@Nullable
-	public Map<String, MinMaxBounds.Ints> getScores()
-	{
-		return this.scores.entrySet().stream()
-			.map(entry -> new SimpleEntry<String, MinMaxBounds.Ints>(entry.getKey(), entry.getValue().toMinMaxBounds()))
-			.collect(Collectors.toMap(Entry::getKey, Entry::getValue));
-	}
-	
-	public NegatableCriterion<Gamemode> getGamemode()
-	{
-		return this.gamemode;
-	}
-	
-	@Nullable
-	public Sort getSort()
-	{
-		return this.sort;
-	}
-	
-	@Nullable
-	@Override
-	public String serialize()
-	{
-		if(this.selectorType == null)
-		{
-			if(this.target != null && !this.target.isBlank())
-			{
-				return this.target;
-			}
-			
-			return null;
-		}
-		
-		List<String> criteria = new ArrayList<String>();
-		
-		this.append("name", this.name, criteria, TargetArgument::serializeNegatableCriterion);
-		this.append("distance", this.distance, criteria, TargetArgument::serializeDoubleMinMaxBounds);
-		this.append("x", this.x, criteria);
-		this.append("y", this.y, criteria);
-		this.append("z", this.z, criteria);
-		this.append("dx", this.deltaX, criteria);
-		this.append("dy", this.deltaY, criteria);
-		this.append("dz", this.deltaZ, criteria);
-		this.append("x_rotation", this.rotX, criteria, TargetArgument::serializeWrappedMinMaxBounds);
-		this.append("y_rotation", this.rotY, criteria, TargetArgument::serializeWrappedMinMaxBounds);
-		this.append("level", this.level, criteria);
-		this.append("limit", this.limit, criteria);
-		this.append("nbt", this.nbt, criteria, nbt -> TargetArgument.serializeNegatableCriterion(nbt, TagArgument::serialize));
-		this.append("type", this.type, criteria, TargetArgument::serializeNegatableCriterion);
-		this.appendMap("advancements", this.advancements, criteria, ResourceLocation::toString, b -> b.toString());
-		this.appendList("predicate", this.predicates, criteria, TargetArgument::serializeNegatableCriterion);
-		this.append("team", this.team, criteria, TargetArgument::serializeNegatableCriterion);
-		this.appendMap("scores", this.scores, criteria, String::toString, TargetArgument::serializeIntMinMaxBounds);
-		this.append("gamemode", this.gamemode, criteria, TargetArgument::serializeNegatableCriterion);
-		this.append("sort", this.sort, criteria);
-		
-		if(criteria.isEmpty())
-		{
-			return "@" + this.selectorType;
-		}
-		
-		return criteria.stream().collect(Collectors.joining(",", "@" + this.selectorType + "[", "]"));
-	}
-	
-	private <T> void append(String name, T criterion, List<String> criteria)
-	{
-		this.append(name, criterion, criteria, null);
-	}
-	
-	private <T> void append(String name, T criterion, List<String> criteria, Function<T, String> serializer)
-	{
-		if(criterion != null)
-		{
-			String serialized = serializer == null ? criterion.toString() : serializer.apply(criterion);
-			
-			if(serialized != null)
-			{
-				criteria.add(name + "=" + serialized);
-			}
-		}
-	}
-	
-	private <T> void appendList(String name, List<T> criterion, List<String> criteria, Function<T, String> serializer)
-	{
-		if(criterion != null)
-		{
-			for(T entry : criterion)
-			{
-				criteria.add(name + "=" + serializer.apply(entry));
-			}
-		}
-	}
-	
-	private <T, K> void appendMap(String name, Map<T, K> criterion, List<String> criteria, Function<T, String> keySerializer, Function<K, String> valueSerializer)
-	{
-		if(criterion != null && !criterion.isEmpty())
-		{
-			List<String> entries = new ArrayList<String>();
-			
-			for(Entry<T, K> entry : criterion.entrySet())
-			{
-				entries.add(keySerializer.apply(entry.getKey()) + "=" + valueSerializer.apply(entry.getValue()));
-			}
-			
-			criteria.add(name + "=" + entries.stream().collect(Collectors.joining(",", "{", "}")));
-		}
-	}
-	
-	@Nullable
-	private static String serializeDoubleMinMaxBounds(DoubleMinMaxBounds bounds)
-	{
-		return Util.serializeBounds(bounds.getMin(), bounds.getMax());
-	}
-	
-	@Nullable
-	private static String serializeIntMinMaxBounds(IntMinMaxBounds bounds)
-	{
-		return Util.serializeBounds(bounds.getMin(), bounds.getMax());
-	}
-	
-	@Nullable
-	private static String serializeWrappedMinMaxBounds(WrappedMinMaxBounds bounds)
-	{
-		return Util.serializeBounds(bounds.min(), bounds.max());
-	}
-	
-	@Nullable
-	private static <T> String serializeNegatableCriterion(NegatableCriterion<T> criterion)
-	{
-		return serializeNegatableCriterion(criterion, null);
-	}
-	
-	@Nullable
-	private static <T> String serializeNegatableCriterion(NegatableCriterion<T> criterion, Function<T, String> serializer)
-	{
-		if(criterion.getCriterion() != null)
-		{
-			String serialized = serializer == null ? criterion.getCriterion().toString() : serializer.apply(criterion.getCriterion());
-			
-			if(criterion.isNegated())
-			{
-				serialized = '!' + serialized;
-			}
-			
-			return serialized;
-		}
-		
-		return null;
-	}
-	
-	private static class DoubleMinMaxBounds
-	{
-		public static final DoubleMinMaxBounds ANY = new DoubleMinMaxBounds(null, null);
-		
-		private final Double min;
-		private final Double max;
-		
-		public DoubleMinMaxBounds(Double min, Double max)
-		{
-			this.min = min;
-			this.max = max;
-		}
-		
-		public MinMaxBounds.Doubles toMinMaxBounds()
-		{
-			return new MinMaxBounds.Doubles(Optional.ofNullable(this.min), Optional.ofNullable(this.max));
-		}
-		
-		@Nullable
-		public Double getMin()
-		{
-			return this.min;
-		}
-		
-		@Nullable
-		public Double getMax()
-		{
-			return this.max;
-		}
-	}
-	
-	private static class IntMinMaxBounds
-	{
-		public static final IntMinMaxBounds ANY = new IntMinMaxBounds(null, null);
-		
-		private final Integer min;
-		private final Integer max;
-		
-		public IntMinMaxBounds(Integer min, Integer max)
-		{
-			this.min = min;
-			this.max = max;
-		}
-		
-		public MinMaxBounds.Ints toMinMaxBounds()
-		{
-			return new MinMaxBounds.Ints(Optional.ofNullable(this.min), Optional.ofNullable(this.max));
-		}
-		
-		@Nullable
-		public Integer getMin()
-		{
-			return this.min;
-		}
-		
-		@Nullable
-		public Integer getMax()
-		{
-			return this.max;
-		}
-		
-		private static IntMinMaxBounds exactly(@Nullable Integer value)
-		{
-			return new IntMinMaxBounds(value, value);
-		}
-	}
-	
-	public static class NegatableCriterion<T>
-	{
-		private T criterion;
-		private boolean negated;
-		
-		public NegatableCriterion()
-		{
-			super();
-		}
-		
-		public NegatableCriterion(T criterion, boolean negated)
-		{
-			this.criterion = criterion;
-			this.negated = negated;
-		}
-		
-		public T getCriterion()
-		{
-			return this.criterion;
-		}
-		
-		public void setCriterion(T criterion)
-		{
-			this.criterion = criterion;
-		}
-		
-		public boolean isNegated()
-		{
-			return this.negated;
-		}
-		
-		public void setNegated(boolean negated)
-		{
-			this.negated = negated;
-		}
-	}
-	
-	public static class SelectorTypes
-	{
-		public static final String NEAREST_PLAYER = "p";
-		public static final String RANDOM_PLAYER = "r";
-		public static final String ALL_PLAYERS = "a";
-		public static final String ALL_ENTITIES = "e";
-		public static final String SENDER = "s";
-	}
-	
-	public static enum Sort
-	{
-		NEAREST,
-		FURTHEST,
-		RANDOM,
-		ARBITRARY;
-		
-		@Override
-		public String toString()
-		{
-			return this.name().toLowerCase();
-		}
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return false;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/TimeArgument.java

@@ -1,124 +0,0 @@
-package exopandora.worldhandler.builder.argument;
-
-import javax.annotation.Nullable;
-
-import com.mojang.brigadier.StringReader;
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
-public class TimeArgument implements IDeserializableArgument
-{
-	private Float time;
-	private Unit unit;
-	
-	protected TimeArgument()
-	{
-		super();
-	}
-	
-	public void set(@Nullable Float time)
-	{
-		this.time = time;
-	}
-	
-	public void set(@Nullable Unit unit)
-	{
-		this.unit = unit;
-	}
-	
-	public void set(@Nullable Float time, @Nullable Unit unit)
-	{
-		this.time = time;
-		this.unit = unit;
-	}
-	
-	@Override
-	public void deserialize(@Nullable String string)
-	{
-		if(string == null)
-		{
-			this.reset();
-		}
-		else
-		{
-	        try
-			{
-				StringReader reader = new StringReader(string);
-				float time = reader.readFloat();
-				String unit = reader.readUnquotedString();
-				this.time = time;
-				
-				if(unit.isEmpty())
-				{
-					this.unit = null;
-				}
-			}
-			catch(CommandSyntaxException e)
-			{
-				this.reset();
-			}
-		}
-	}
-	
-	private void reset()
-	{
-		this.time = 0F;
-		this.unit = null;
-	}
-	
-	@Nullable
-	public Float getTime()
-	{
-		return this.time;
-	}
-	
-	@Nullable
-	public Unit getUnit()
-	{
-		return this.unit;
-	}
-	
-	@Override
-	@Nullable
-	public String serialize()
-	{
-		if(this.time == null)
-		{
-			return null;
-		}
-		
-		StringBuilder builder = new StringBuilder();
-		builder.append(this.time);
-		
-		if(this.unit != null)
-		{
-			builder.append(this.unit.getSuffix());
-		}
-		
-		return builder.toString();
-	}
-	
-	@Override
-	public boolean isDefault()
-	{
-		return this.time == null;
-	}
-	
-	public static enum Unit
-	{
-		TICKS("t"),
-		SECONDS("s"),
-		DAYS("d");
-		
-		private final String suffix;
-		
-		private Unit(String suffix)
-		{
-			this.suffix = suffix;
-		}
-		
-		public String getSuffix()
-		{
-			return this.suffix;
-		}
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/AbstractAttributeTag.java

@@ -1,45 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-import java.util.stream.Collectors;
-
-import net.minecraft.client.resources.language.I18n;
-import net.minecraft.world.entity.ai.attributes.Attribute;
-import net.minecraft.core.registries.BuiltInRegistries;
-
-public abstract class AbstractAttributeTag implements ITagProvider
-{	
-	public static final List<Attribute> ATTRIBUTES = BuiltInRegistries.ATTRIBUTE.stream().toList().stream()
-			.filter(attribute -> !attribute.getDescriptionId().equals(I18n.get(attribute.getDescriptionId())))
-			.collect(Collectors.toList());
-	
-	protected final Map<Attribute, Double> attributes = new HashMap<Attribute, Double>();
-	
-	public void set(Attribute attribute, double value)
-	{
-		this.attributes.put(attribute, value);
-	}
-	
-	public double get(Attribute value)
-	{
-		if(this.attributes.containsKey(value))
-		{
-			return this.attributes.get(value);
-		}
-		
-		return 0;
-	}
-	
-	public void remove(Attribute attribute)
-	{
-		this.attributes.remove(attribute);
-	}
-	
-	public Set<Attribute> getAttributes()
-	{
-		return this.attributes.keySet();
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/AbstractEffectTag.java

@@ -1,78 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-import java.util.Collections;
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import javax.annotation.Nullable;
-
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.ListTag;
-import net.minecraft.nbt.Tag;
-import net.minecraft.world.effect.MobEffect;
-import net.minecraft.core.registries.BuiltInRegistries;
-
-public abstract class AbstractEffectTag implements ITagProvider 
-{
-	private final Map<MobEffect, EffectInstance> effects = new HashMap<MobEffect, EffectInstance>();
-	
-	@Nullable
-	@Override
-	public Tag value()
-	{
-		ListTag list = new ListTag();
-		
-		for(Entry<MobEffect, EffectInstance> entry : this.effects.entrySet())
-		{
-			EffectInstance instance = entry.getValue();
-			
-			if(instance.getAmplifier() > 0)
-			{
-				CompoundTag compound = new CompoundTag();
-				int ticks = instance.toTicks();
-				
-				compound.putString("id", BuiltInRegistries.MOB_EFFECT.getKey(entry.getKey()).toString());
-				compound.putByte("amplifier", (byte) (instance.getAmplifier() - 1));
-				compound.putInt("duration", ticks > 0 ? ticks : 1000000);
-				compound.putBoolean("ambient", instance.isAmbient());
-				compound.putBoolean("show_particles", instance.doShowParticles());
-				
-				list.add(compound);
-			}
-		}
-		
-		if(list.isEmpty())
-		{
-			return null;
-		}
-		
-		return list;
-	}
-	
-	public EffectInstance getOrCreate(MobEffect effect)
-	{
-		return this.effects.computeIfAbsent(effect, key -> new EffectInstance());
-	}
-	
-	public Set<MobEffect> getMobEffects()
-	{
-		return this.effects.keySet();
-	}
-	
-	public void remove(MobEffect potion)
-	{
-		this.effects.remove(potion);
-	}
-	
-	public Map<MobEffect, EffectInstance> getEffects()
-	{
-		return Collections.unmodifiableMap(this.effects);
-	}
-	
-	public void clear()
-	{
-		this.effects.clear();
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/ActiveEffectsTag.java

@@ -1,10 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-public class ActiveEffectsTag extends AbstractEffectTag
-{
-	@Override
-	public String key()
-	{
-		return "active_effects";
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/AttributeModifiersTag.java

@@ -1,51 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-import java.util.Map.Entry;
-import java.util.UUID;
-
-import javax.annotation.Nullable;
-
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.ListTag;
-import net.minecraft.nbt.Tag;
-import net.minecraft.world.entity.ai.attributes.Attribute;
-import net.minecraft.core.registries.BuiltInRegistries;
-
-public class AttributeModifiersTag extends AbstractAttributeTag
-{
-	@Override
-	@Nullable
-	public Tag value()
-	{
-		ListTag attributes = new ListTag();
-		
-		for(Entry<Attribute, Double> entry : this.attributes.entrySet())
-		{
-			if(entry.getValue() != 0)
-			{
-				CompoundTag attribute = new CompoundTag();
-				String id = BuiltInRegistries.ATTRIBUTE.getKey(entry.getKey()).toString();
-				
-				attribute.putString("AttributeName", id);
-				attribute.putDouble("Amount", entry.getValue() / 100);
-				attribute.putInt("Operation", 1); // 0 = additive, 1 = percentage
-				attribute.putUUID("UUID", UUID.nameUUIDFromBytes(id.getBytes()));
-				
-				attributes.add(attribute);
-			}
-		}
-		
-		if(attributes.isEmpty())
-		{
-			return null;
-		}
-		
-		return attributes;
-	}
-	
-	@Override
-	public String key()
-	{
-		return "AttributeModifiers";
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/AttributesTag.java

@@ -1,48 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-import java.util.Map.Entry;
-
-import javax.annotation.Nullable;
-
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.ListTag;
-import net.minecraft.nbt.Tag;
-import net.minecraft.world.entity.ai.attributes.Attribute;
-import net.minecraft.core.registries.BuiltInRegistries;
-
-public class AttributesTag extends AbstractAttributeTag
-{
-	@Override
-	@Nullable
-	public Tag value()
-	{
-		ListTag attributes = new ListTag();
-		
-		for(Entry<Attribute, Double> entry : this.attributes.entrySet())
-		{
-			if(entry.getValue() != 0)
-			{
-				CompoundTag attribute = new CompoundTag();
-				String id = BuiltInRegistries.ATTRIBUTE.getKey(entry.getKey()).toString();
-				
-				attribute.putString("Name", id);
-				attribute.putDouble("Base", entry.getValue() / 100);
-				
-				attributes.add(attribute);
-			}
-		}
-		
-		if(attributes.isEmpty())
-		{
-			return null;
-		}
-		
-		return attributes;
-	}
-	
-	@Override
-	public String key()
-	{
-		return "Attributes";
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/CustomPotionEffectsTag.java

@@ -1,10 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-public class CustomPotionEffectsTag extends AbstractEffectTag
-{
-	@Override
-	public String key()
-	{
-		return "custom_potion_effects";
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/DisplayTag.java

@@ -1,94 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-import exopandora.worldhandler.util.TextUtils;
-import exopandora.worldhandler.util.UserStylableComponent;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.ListTag;
-import net.minecraft.nbt.StringTag;
-import net.minecraft.nbt.Tag;
-import net.minecraft.network.chat.Component;
-
-public class DisplayTag implements ITagProvider 
-{
-	private UserStylableComponent name = new UserStylableComponent();
-	private Component[] lore = new Component[2];
-	
-	@Override
-	public Tag value()
-	{
-		CompoundTag display = new CompoundTag();
-		
-		if(this.name.getText() != null && !this.name.getText().isEmpty())
-		{
-			display.putString("Name", TextUtils.toJson(this.name));
-		}
-		
-		ListTag lore = new ListTag();
-		
-		for(int x = 0; x < this.lore.length; x++)
-		{
-			if(this.lore[x] != null && !this.lore[x].getString().isEmpty())
-			{
-				lore.add(StringTag.valueOf(TextUtils.toJson(this.lore[x])));
-			}
-		}
-		
-		if(!lore.isEmpty())
-		{
-			display.put("Lore", lore);
-		}
-		
-		if(!display.isEmpty())
-		{
-			return display;
-		}
-		
-		return null;
-	}
-	
-	public void setName(String name)
-	{
-		this.name.setText(name);
-	}
-	
-	public UserStylableComponent getName()
-	{
-		return this.name;
-	}
-	
-	public void setLore(Component[] lore)
-	{
-		this.lore = lore;
-	}
-	
-	public Component[] getLore()
-	{
-		return this.lore;
-	}
-	
-	public void setLore1(Component lore)
-	{
-		this.lore[0] = lore;
-	}
-	
-	public Component getLore1()
-	{
-		return this.lore[0];
-	}
-	
-	public void setLore2(Component lore)
-	{
-		this.lore[1] = lore;
-	}
-	
-	public Component getLore2()
-	{
-		return this.lore[1];
-	}
-	
-	@Override
-	public String key()
-	{
-		return "display";
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/EffectInstance.java

@@ -1,117 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-public class EffectInstance
-{
-	private byte amplifier;
-	private int seconds;
-	private int minutes;
-	private int hours;
-	private boolean showParticles;
-	private boolean ambient;
-	
-	public EffectInstance()
-	{
-		this((byte) 0, 0, 0, 0, true, false);
-	}
-	
-	public EffectInstance(byte amplifier, int seconds, int minutes, int hours, boolean showParticles, boolean ambient)
-	{
-		this.amplifier = amplifier;
-		this.seconds = seconds;
-		this.minutes = minutes;
-		this.hours = hours;
-		this.showParticles = showParticles;
-		this.ambient = ambient;
-	}
-	
-	public byte getAmplifier()
-	{
-		return this.amplifier;
-	}
-	
-	public void setAmplifier(byte amplifier)
-	{
-		this.amplifier = amplifier;
-	}
-	
-	public int getSeconds()
-	{
-		return this.seconds;
-	}
-	
-	public void setSeconds(int seconds)
-	{
-		this.seconds = seconds;
-	}
-	
-	public int getMinutes()
-	{
-		return this.minutes;
-	}
-	
-	public void setMinutes(int minutes)
-	{
-		this.minutes = minutes;
-	}
-	
-	public int getHours()
-	{
-		return this.hours;
-	}
-	
-	public void setHours(int hours)
-	{
-		this.hours = hours;
-	}
-	
-	public boolean doShowParticles()
-	{
-		return this.showParticles;
-	}
-	
-	public void setShowParticles(boolean showParticles)
-	{
-		this.showParticles = showParticles;
-	}
-	
-	public boolean isAmbient()
-	{
-		return this.ambient;
-	}
-	
-	public void setAmbient(boolean ambient)
-	{
-		this.ambient = ambient;
-	}
-	
-	public int toTicks()
-	{
-		return EffectInstance.toTicks(this.seconds, this.minutes, this.hours);
-	}
-	
-	public int toSeconds()
-	{
-		return EffectInstance.toSeconds(this.seconds, this.minutes, this.hours);
-	}
-	
-	public static int toTicks(int seconds, int minutes, int hours)
-	{
-		return seconds * 20 + minutes * 1200 + hours * 72000;
-	}
-	
-	public static int toSeconds(int seconds, int minutes, int hours)
-	{
-		return seconds + minutes * 60 + hours * 3600;
-	}
-	
-	public EffectInstance copyTo(EffectInstance effectInstance, float modifier)
-	{
-		effectInstance.setAmbient(this.isAmbient());
-		effectInstance.setAmplifier(this.getAmplifier());
-		effectInstance.setHours((int) (this.getHours() / modifier));
-		effectInstance.setMinutes((int) (this.getMinutes() / modifier));
-		effectInstance.setSeconds((int) (this.getSeconds() / modifier));
-		effectInstance.setShowParticles(this.doShowParticles());
-		return effectInstance;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/EnchantmentsTag.java

@@ -1,74 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.Set;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.util.RegistryHelper;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.ListTag;
-import net.minecraft.nbt.Tag;
-import net.minecraft.world.item.enchantment.Enchantment;
-
-public class EnchantmentsTag implements ITagProvider
-{
-	private final Map<Enchantment, Short> enchantments = new HashMap<Enchantment, Short>();
-	
-	@Override
-	@Nullable
-	public Tag value()
-	{
-		ListTag enchantments = new ListTag();
-		
-		for(Entry<Enchantment, Short> entry : this.enchantments.entrySet())
-		{
-			if(entry.getValue() > 0)
-			{
-				CompoundTag enchantment = new CompoundTag();
-				
-				enchantment.putString("id", RegistryHelper.getEnchantmentKey(entry.getKey()).toString());
-				enchantment.putShort("lvl", entry.getValue());
-				
-				enchantments.add(enchantment);
-			}
-		}
-		
-		if(enchantments.isEmpty())
-		{
-			return null;
-		}
-		
-		return enchantments;
-	}
-	
-	public void set(Enchantment enchantment, short level)
-	{
-		if(level == 0)
-		{
-			this.enchantments.remove(enchantment);
-		}
-		else
-		{
-			this.enchantments.put(enchantment, level);
-		}
-	}
-	
-	public short get(Enchantment enchantment)
-	{
-		return this.enchantments.get(enchantment);
-	}
-	
-	public Set<Enchantment> getEnchantments()
-	{
-		return this.enchantments.keySet();
-	}
-	
-	@Override
-	public String key()
-	{
-		return "Enchantments";
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/EntityTag.java

@@ -1,437 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-import java.lang.reflect.Array;
-import java.util.ArrayList;
-import java.util.List;
-import java.util.Set;
-
-import javax.annotation.Nonnull;
-import javax.annotation.Nullable;
-
-import com.mojang.brigadier.exceptions.CommandSyntaxException;
-
-import exopandora.worldhandler.util.NBTHelper;
-import exopandora.worldhandler.util.TextUtils;
-import exopandora.worldhandler.util.UserStylableComponent;
-import net.minecraft.nbt.ByteTag;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.IntTag;
-import net.minecraft.nbt.StringTag;
-import net.minecraft.nbt.Tag;
-import net.minecraft.nbt.TagParser;
-import net.minecraft.network.chat.Component;
-import net.minecraft.resources.ResourceLocation;
-import net.minecraft.world.effect.MobEffect;
-import net.minecraft.world.entity.ai.attributes.Attribute;
-import net.minecraft.world.item.Item;
-import net.minecraft.world.item.Items;
-import net.minecraft.world.level.block.state.BlockState;
-
-public class EntityTag implements ITagProvider
-{
-	private ResourceLocation id;
-	private String command;
-	private Integer time;
-	private double[] motion = {0.0, 0.0, 0.0};
-	private boolean isBaby;
-	private BlockState blockState;
-	private AttributesTag attribute = new AttributesTag();
-	private UserStylableComponent customName = new UserStylableComponent();
-	private List<EntityTag> passengers = new ArrayList<EntityTag>();
-	private Item[] armorItems = {Items.AIR, Items.AIR, Items.AIR, Items.AIR};
-	private Item[] handItems = {Items.AIR, Items.AIR};
-	private ActiveEffectsTag potion = new ActiveEffectsTag();
-	private CompoundTag nbt;
-	
-	public EntityTag()
-	{
-		super();
-	}
-	
-	public EntityTag(ResourceLocation id)
-	{
-		this.id = id;
-	}
-	
-	public void setId(ResourceLocation id)
-	{
-		this.id = id;
-	}
-	
-	public ResourceLocation getId()
-	{
-		return this.id;
-	}
-	
-	public void setAttribute(Attribute attribute, double ammount)
-	{
-		this.attribute.set(attribute, ammount);
-	}
-	
-	public void removeAttribute(Attribute attribute)
-	{
-		this.attribute.remove(attribute);
-	}
-	
-	public double getAttribute(Attribute attribute)
-	{
-		return this.attribute.get(attribute);
-	}
-	
-	public Set<Attribute> getAttributes()
-	{
-		return this.attribute.getAttributes();
-	}
-	
-	public void setCustomName(String name)
-	{
-		this.customName.setText(name);
-	}
-	
-	public UserStylableComponent getCustomName()
-	{
-		return this.customName;
-	}
-	
-	public void setPassenger(int index, EntityTag entity)
-	{
-		if(index < 0 || index >= this.passengers.size())
-		{
-			this.passengers.add(entity);
-		}
-		else
-		{
-			this.passengers.set(index, entity);
-		}
-	}
-	
-	public void setPassenger(int index, ResourceLocation id)
-	{
-		this.setPassenger(index, new EntityTag(id));
-	}
-	
-	public void addPassenger(EntityTag entity)
-	{
-		this.passengers.add(entity);
-	}
-	
-	public void addPassenger(int index, EntityTag entity)
-	{
-		this.passengers.add(index, entity);
-	}
-	
-	public void removePassenger(int index)
-	{
-		this.passengers.remove(index);
-	}
-	
-	public int getPassengerCount()
-	{
-		return this.passengers.size();
-	}
-	
-	public List<EntityTag> getPassengers()
-	{
-		return this.passengers;
-	}
-	
-	@Nullable
-	public EntityTag getPassenger(int index)
-	{
-		if(index >= 0 && index <= this.passengers.size())
-		{
-			return this.passengers.get(index);
-		}
-		
-		return null;
-	}
-	
-	public boolean hasPassengers()
-	{
-		for(EntityTag entity : this.passengers)
-		{
-			if(entity.value() != null)
-			{
-				return true;
-			}
-		}
-		
-		return false;
-	}
-	
-	public void setArmorItem(int index, Item location)
-	{
-		if(EntityTag.isArrayIndexValid(this.armorItems, index) && location != null)
-		{
-			this.armorItems[index] = location;
-		}
-	}
-	
-	public void setArmorItems(Item[] armor)
-	{
-		this.armorItems = armor;
-	}
-	
-	@Nonnull
-	public Item getArmorItem(int slot)
-	{
-		if(EntityTag.isArrayIndexValid(this.armorItems, slot))
-		{
-			return this.armorItems[slot];
-		}
-		
-		return Items.AIR;
-	}
-	
-	public void setHandItem(int index, Item location)
-	{
-		if(EntityTag.isArrayIndexValid(this.handItems, index) && location != null)
-		{
-			this.handItems[index] = location;
-		}
-	}
-	
-	@Nonnull
-	public Item getHandItem(int slot)
-	{
-		if(EntityTag.isArrayIndexValid(this.handItems, slot))
-		{
-			return this.handItems[slot];
-		}
-		
-		return Items.AIR;
-	}
-	
-	public double[] getMotion()
-	{
-		return this.motion;
-	}
-	
-	public void setMotion(double x, double y, double z)
-	{
-		this.setMotionX(x);
-		this.setMotionY(y);
-		this.setMotionZ(z);
-	}
-	
-	public double getMotionX()
-	{
-		return this.motion[0];
-	}
-	
-	public double getMotionY()
-	{
-		return this.motion[1];
-	}
-	
-	public double getMotionZ()
-	{
-		return this.motion[2];
-	}
-	
-	public void setMotionX(double x)
-	{
-		this.motion[0] = x;
-	}
-	
-	public void setMotionY(double y)
-	{
-		this.motion[1] = y;
-	}
-	
-	public void setMotionZ(double z)
-	{
-		this.motion[2] = z;
-	}
-	
-	public void setAmplifier(MobEffect effect, byte amplifier)
-	{
-		this.potion.getOrCreate(effect).setAmplifier(amplifier);
-	}
-	
-	public void setSeconds(MobEffect effect, int seconds)
-	{
-		this.potion.getOrCreate(effect).setSeconds(seconds);
-	}
-	
-	public void setMinutes(MobEffect effect, int minutes)
-	{
-		this.potion.getOrCreate(effect).setMinutes(minutes);
-	}
-	
-	public void setHours(MobEffect effect, int hours)
-	{
-		this.potion.getOrCreate(effect).setHours(hours);
-	}
-	
-	public void setShowParticles(MobEffect effect, boolean showParticles)
-	{
-		this.potion.getOrCreate(effect).setShowParticles(showParticles);
-	}
-	
-	public void setAmbient(MobEffect effect, boolean ambient)
-	{
-		this.potion.getOrCreate(effect).setAmbient(ambient);
-	}
-	
-	public byte getAmplifier(MobEffect effect)
-	{
-		return this.potion.getOrCreate(effect).getAmplifier();
-	}
-	
-	public int getSeconds(MobEffect effect)
-	{
-		return this.potion.getOrCreate(effect).getSeconds();
-	}
-	
-	public int getMinutes(MobEffect effect)
-	{
-		return this.potion.getOrCreate(effect).getMinutes();
-	}
-	
-	public int getHours(MobEffect effect)
-	{
-		return this.potion.getOrCreate(effect).getHours();
-	}
-	
-	public boolean doShowParticles(MobEffect effect)
-	{
-		return this.potion.getOrCreate(effect).doShowParticles();
-	}
-	
-	public boolean isAmbient(MobEffect effect)
-	{
-		return this.potion.getOrCreate(effect).isAmbient();
-	}
-	
-	public Set<MobEffect> getEffects()
-	{
-		return this.potion.getMobEffects();
-	}
-	
-	public void setBlockState(BlockState blockState)
-	{
-		this.blockState = blockState;
-	}
-	
-	public BlockState getBlockState()
-	{
-		return this.blockState;
-	}
-	
-	public void setTime(int time)
-	{
-		this.time = time;
-	}
-	
-	public int getTime()
-	{
-		return this.time;
-	}
-	
-	public void setIsBaby(boolean baby)
-	{
-		this.isBaby = baby;
-	}
-	
-	public boolean isBaby()
-	{
-		return this.isBaby;
-	}
-	
-	public void setCommand(String command)
-	{
-		this.command = command;
-	}
-	
-	public String getCommand()
-	{
-		return this.command;
-	}
-	
-	public void setNBT(CompoundTag nbt)
-	{
-		this.nbt = nbt;
-	}
-	
-	public CompoundTag getNBT()
-	{
-		return this.nbt;
-	}
-	
-	public void setNBT(String nbt)
-	{
-		try
-		{
-			this.nbt = TagParser.parseTag("{" + nbt + "}");
-		}
-		catch(CommandSyntaxException e)
-		{
-			this.nbt = null;
-		}
-	}
-	
-	@Override
-	public String key()
-	{
-		return null;
-	}
-	
-	@Override
-	public Tag value()
-	{
-		CompoundTag nbt = new CompoundTag();
-		
-		if(this.time != null)
-		{
-			NBTHelper.append(nbt, "Time", IntTag.valueOf(this.time));
-		}
-		
-		if(this.command != null)
-		{
-			NBTHelper.append(nbt, "Command", StringTag.valueOf(this.command));
-		}
-		
-		if(this.isBaby)
-		{
-			NBTHelper.append(nbt, "IsBaby", ByteTag.valueOf(true));
-		}
-		
-		NBTHelper.append(nbt, "id", NBTHelper.serialize(this.id));
-		NBTHelper.append(nbt, "Motion", NBTHelper.serialize(this.motion));
-		NBTHelper.append(nbt, "Passengers", NBTHelper.serialize(this.passengers));
-		NBTHelper.append(nbt, "ArmorItems", NBTHelper.serialize(this.armorItems));
-		NBTHelper.append(nbt, "HandItems", NBTHelper.serialize(this.handItems));
-		NBTHelper.append(nbt, "BlockState", NBTHelper.serialize(this.blockState));
-		
-		if(this.customName.getText() != null && !this.customName.getText().isEmpty())
-		{
-			NBTHelper.append(nbt, "CustomName", StringTag.valueOf(TextUtils.toJson(this.customName)));
-		}
-		
-		NBTHelper.append(nbt, this.potion);
-		NBTHelper.append(nbt, this.attribute);
-		
-		if(this.nbt != null)
-		{
-			nbt.merge(this.nbt);
-		}
-		
-		if(nbt.isEmpty())
-		{
-			return null;
-		}
-		
-		return nbt;
-	}
-	
-	private static boolean isArrayIndexValid(Object[] array, int index)
-	{
-		if(array != null && (Array.getLength(array) == 0 || array.length <= index))
-		{
-            return false;
-		}
-		
-        return index >= 0;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/ITagProvider.java

@@ -1,14 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-import javax.annotation.Nullable;
-
-import net.minecraft.nbt.Tag;
-
-public interface ITagProvider
-{
-	@Nullable
-	String key();
-	
-	@Nullable
-	Tag value();
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/MutableTag.java

@@ -1,37 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-import net.minecraft.nbt.Tag;
-
-public class MutableTag implements ITagProvider
-{
-	private String key;
-	private Tag tag;
-	
-	public void setKey(String key)
-	{
-		this.key = key;
-	}
-	
-	public void setTag(Tag tag)
-	{
-		this.tag = tag;
-	}
-	
-	@Override
-	public String key()
-	{
-		return this.key;
-	}
-	
-	@Override
-	public Tag value()
-	{
-		return this.tag;
-	}
-	
-	public void reset()
-	{
-		this.key = null;
-		this.tag = null;
-	}
-}

src/main/java/exopandora/worldhandler/builder/argument/tag/SidedSignTextTag.java

@@ -1,62 +0,0 @@
-package exopandora.worldhandler.builder.argument.tag;
-
-import java.util.Arrays;
-
-import javax.annotation.Nonnull;
-
-import exopandora.worldhandler.util.TextUtils;
-import exopandora.worldhandler.util.UserStylableComponent;
-import net.minecraft.nbt.CompoundTag;
-import net.minecraft.nbt.ListTag;
-import net.minecraft.nbt.StringTag;
-import net.minecraft.nbt.Tag;
-import net.minecraft.network.chat.Component;
-
-public class SidedSignTextTag implements ITagProvider
-{
-	private boolean isFront;
-	private final UserStylableComponent[] lines = new UserStylableComponent[]
-	{
-		new UserStylableComponent(),
-		new UserStylableComponent(),
-		new UserStylableComponent(),
-		new UserStylableComponent()
-	};
-	
-	@Override
-	public String key()
-	{
-		return this.isFront ? "front_text" : "back_text";
-	}
-	
-	@Nonnull
-	@Override
-	public Tag value()
-	{
-		ListTag messages = new ListTag();
-		
-		for(UserStylableComponent text : this.lines)
-		{
-			messages.add(StringTag.valueOf(TextUtils.toJson(text)));
-		}
-		
-		CompoundTag tag = new CompoundTag();
-		tag.put("messages", messages);
-		return tag;
-	}
-	
-	public UserStylableComponent getLine(int index)
-	{
-		return this.lines[index];
-	}
-	
-	public boolean isStyled()
-	{
-		return Arrays.stream(this.lines).anyMatch(UserStylableComponent::isStyled);
-	}
-	
-	public void setIsFront(boolean isFront)
-	{
-		this.isFront = isFront;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/AdvancementCommandBuilder.java

@@ -1,91 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-import net.minecraft.resources.ResourceLocation;
-
-public class AdvancementCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	private final PrimitiveArgument<ResourceLocation> advancement = Arguments.resourceLocation();
-	private final PrimitiveArgument<String> criterion = Arguments.greedyString();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("advancement")
-			.then(CommandNode.literal("grant")
-					.then(CommandNode.argument("targets", this.targets)
-							.then(CommandNode.literal("only")
-									.then(CommandNode.argument("advancement", this.advancement)
-											.label(Label.GRANT_ONLY)
-											.then(CommandNode.argument("criterion", this.criterion)
-													.label(Label.GRANT_ONLY_CRITERION))))
-							.then(CommandNode.literal("from")
-									.then(CommandNode.argument("advancement", this.advancement)
-											.label(Label.GRANT_FROM)))
-							.then(CommandNode.literal("until")
-									.then(CommandNode.argument("advancement", this.advancement)
-											.label(Label.GRANT_UNTIL)))
-							.then(CommandNode.literal("through")
-									.then(CommandNode.argument("advancement", this.advancement)
-											.label(Label.GRANT_THROUGH)))
-							.then(CommandNode.literal("everything")
-									.label(Label.GRANT_EVERYTHING))))
-			.then(CommandNode.literal("revoke")
-					.then(CommandNode.argument("targets", this.targets)
-							.then(CommandNode.literal("only")
-									.then(CommandNode.argument("advancement", this.advancement)
-											.label(Label.REVOKE_ONLY)
-											.then(CommandNode.argument("criterion", this.criterion)
-													.label(Label.REVOKE_ONLY_CRITERION))))
-							.then(CommandNode.literal("from")
-									.then(CommandNode.argument("advancement", this.advancement)
-											.label(Label.REVOKE_FROM)))
-							.then(CommandNode.literal("until")
-									.then(CommandNode.argument("advancement", this.advancement)
-											.label(Label.REVOKE_UNTIL)))
-							.then(CommandNode.literal("through")
-									.then(CommandNode.argument("advancement", this.advancement)
-											.label(Label.REVOKE_THROUGH)))
-							.then(CommandNode.literal("everything")
-									.label(Label.REVOKE_EVERYTHING))));
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	public PrimitiveArgument<ResourceLocation> advancement()
-	{
-		return this.advancement;
-	}
-	
-	public PrimitiveArgument<String> criterion()
-	{
-		return this.criterion;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		GRANT_ONLY,
-		GRANT_ONLY_CRITERION,
-		GRANT_FROM,
-		GRANT_UNTIL,
-		GRANT_THROUGH,
-		GRANT_EVERYTHING,
-		REVOKE_ONLY,
-		REVOKE_ONLY_CRITERION,
-		REVOKE_FROM,
-		REVOKE_UNTIL,
-		REVOKE_THROUGH,
-		REVOKE_EVERYTHING;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/BanCommandBuilder.java

@@ -1,15 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-public class BanCommandBuilder extends TargetReasonCommandBuilder<BanCommandBuilder.Label>
-{
-	public BanCommandBuilder()
-	{
-		super("ban", Label.BAN, Label.BAN_REASON);
-	}
-	
-	public static enum Label
-	{
-		BAN,
-		BAN_REASON;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/ClearInventoryCommandBuilder.java

@@ -1,54 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.ItemPredicateArgument;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class ClearInventoryCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	private final ItemPredicateArgument item = Arguments.itemPredicate();
-	private final PrimitiveArgument<Integer> maxCount = Arguments.intArg();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("clear")
-			.label(Label.CLEAR)
-			.then(CommandNode.argument("targets", this.targets)
-					.label(Label.CLEAR_TARGETS)
-					.then(CommandNode.argument("item", this.item)
-							.label(Label.CLEAR_TARGETS_ITEM)
-							.then(CommandNode.argument("maxCount", this.maxCount)
-									.label(Label.CLEAR_TARGETS_IMTE_MAXCOUNT))));
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	public ItemPredicateArgument item()
-	{
-		return this.item;
-	}
-	
-	public PrimitiveArgument<Integer> maxCount()
-	{
-		return this.maxCount;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		CLEAR,
-		CLEAR_TARGETS,
-		CLEAR_TARGETS_ITEM,
-		CLEAR_TARGETS_IMTE_MAXCOUNT;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/CloneCommandBuilder.java

@@ -1,90 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.BlockPosArgument;
-import exopandora.worldhandler.builder.argument.BlockPredicateArgument;
-
-public class CloneCommandBuilder extends CommandBuilder
-{
-	private final BlockPosArgument begin = Arguments.blockPos();
-	private final BlockPosArgument end = Arguments.blockPos();
-	private final BlockPosArgument destination = Arguments.blockPos();
-	private final BlockPredicateArgument filter = Arguments.blockPredicate();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("clone")
-			.then(CommandNode.argument("begin", this.begin)
-					.then(CommandNode.argument("end", this.end)
-							.then(CommandNode.argument("destination", this.destination)
-									.label(Label.CLONE)
-									.then(CommandNode.literal("replace")
-											.label(Label.REPLACE)
-											.then(CommandNode.literal("force")
-													.label(Label.REPLACE_FORCE))
-											.then(CommandNode.literal("move")
-													.label(Label.REPLACE_MOVE))
-											.then(CommandNode.literal("normal")
-													.label(Label.REPLACE_NORMAL)))
-									.then(CommandNode.literal("masked")
-											.label(Label.MASKED)
-											.then(CommandNode.literal("force")
-													.label(Label.MASKED_FORCE))
-											.then(CommandNode.literal("move")
-													.label(Label.MASKED_MOVE))
-											.then(CommandNode.literal("normal")
-													.label(Label.MASKED_NORMAL)))
-									.then(CommandNode.literal("filtered")
-											.then(CommandNode.argument("filter", this.filter)
-													.label(Label.FILTERED)
-													.then(CommandNode.literal("force")
-															.label(Label.FILTERED_FORCE))
-													.then(CommandNode.literal("move")
-															.label(Label.FILTERED_MOVE))
-													.then(CommandNode.literal("normal")
-															.label(Label.FILTERED_NORMAL)))))));
-	
-	public BlockPosArgument begin()
-	{
-		return this.begin;
-	}
-	
-	public BlockPosArgument end()
-	{
-		return this.end;
-	}
-	
-	public BlockPosArgument destination()
-	{
-		return this.destination;
-	}
-	
-	public BlockPredicateArgument filter()
-	{
-		return this.filter;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public enum Label
-	{
-		CLONE,
-		REPLACE,
-		REPLACE_FORCE,
-		REPLACE_MOVE,
-		REPLACE_NORMAL,
-		MASKED,
-		MASKED_FORCE,
-		MASKED_MOVE,
-		MASKED_NORMAL,
-		FILTERED,
-		FILTERED_FORCE,
-		FILTERED_MOVE,
-		FILTERED_NORMAL;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/DataCommandBuilder.java

@@ -1,314 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.BlockPosArgument;
-import exopandora.worldhandler.builder.argument.NbtPathArgument;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TagArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument.Linkage;
-
-public class DataCommandBuilder extends CommandBuilder
-{
-	private final BlockPosArgument targetPos = Arguments.blockPos();
-	private final NbtPathArgument path = Arguments.nbtPath();
-	private final PrimitiveArgument<Linkage> linkage = Arguments.linkage();
-	private final PrimitiveArgument<Double> scale = Arguments.doubleArg();
-	private final TargetArgument target = Arguments.target();
-	private final TagArgument nbt = Arguments.tag();
-	private final TargetArgument sourceTarget = Arguments.target();
-	private final BlockPosArgument sourcePos = Arguments.blockPos();
-	private final PrimitiveArgument<String> sourcePath = Arguments.word();
-	private final PrimitiveArgument<String> value = Arguments.greedyString();
-	private final PrimitiveArgument<Integer> index = Arguments.intArg();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("data")
-			.then(CommandNode.literal("get")
-					.then(CommandNode.literal("block")
-							.then(CommandNode.argument("targetPos", this.targetPos)
-									.label(Label.GET_BLOCK)
-									.then(CommandNode.argument("path", this.path)
-											.label(Label.GET_BLOCK_PATH)
-											.then(CommandNode.argument("scale", this.scale)
-													.label(Label.GET_BLOCK_PATH_SCALE)))))
-					.then(CommandNode.literal("entity")
-							.then(CommandNode.argument("target", this.target)
-									.label(Label.GET_ENTITY)
-									.then(CommandNode.argument("path", this.path)
-											.label(Label.GET_ENTITY_PATH)
-											.then(CommandNode.argument("scale", this.scale)
-													.label(Label.GET_ENTITY_PATH_SCALE)))))
-					.then(CommandNode.literal("storage")
-							.then(CommandNode.argument("target", this.target)
-									.label(Label.GET_STORAGE)
-									.then(CommandNode.argument("path", this.path)
-											.label(Label.GET_STORAGE_PATH)
-											.then(CommandNode.argument("scale", this.scale)
-													.label(Label.GET_STORAGE_PATH_SCALE))))))
-			.then(CommandNode.literal("merge")
-					.then(CommandNode.literal("block")
-							.then(CommandNode.argument("targetPos", this.targetPos)
-									.then(CommandNode.argument("nbt", this.nbt)
-											.label(Label.MERGE_BLOCK))))
-					.then(CommandNode.literal("entity")
-							.then(CommandNode.argument("target", this.target)
-									.then(CommandNode.argument("nbt", this.nbt)
-											.label(Label.MERGE_ENTITY))))
-					.then(CommandNode.literal("storage")
-							.then(CommandNode.argument("target", this.target)
-									.then(CommandNode.argument("nbt", this.nbt)
-											.label(Label.MERGE_STORAGE)))))
-			.then(CommandNode.literal("modify")
-					.then(CommandNode.literal("block")
-							.then(CommandNode.argument("targetPos", this.targetPos)
-									.then(CommandNode.argument("path", this.path)
-											.then(CommandNode.argument("linkage", this.linkage)
-													.then(CommandNode.literal("from")
-															.then(CommandNode.literal("block")
-																	.then(CommandNode.argument("sourcePos", this.sourcePos)
-																			.label(Label.MODIFY_BLOCK_FROM_BLOCK)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_BLOCK_FROM_BLOCK_PATH))))
-															.then(CommandNode.literal("entity")
-																	.then(CommandNode.argument("sourceTarget", this.sourceTarget)
-																			.label(Label.MODIFY_BLOCK_FROM_ENTITY)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_BLOCK_FROM_ENTITY_PATH))))
-															.then(CommandNode.literal("storage")
-																	.then(CommandNode.argument("source", this.sourceTarget)
-																			.label(Label.MODIFY_BLOCK_FROM_STORAGE)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_BLOCK_FROM_STORAGE_PATH)))))
-													.then(CommandNode.literal("value")
-															.then(CommandNode.argument("value", this.value)
-																	.label(Label.MODIFY_BLOCK_VALUE)))
-													.then(CommandNode.literal("string")
-															.then(CommandNode.literal("block")
-																	.then(CommandNode.argument("sourcePos", this.sourcePos)
-																			.label(Label.MODIFY_BLOCK_STRING_BLOCK)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_BLOCK_STRING_BLOCK_PATH))))
-															.then(CommandNode.literal("entity")
-																	.then(CommandNode.argument("sourceTarget", this.sourceTarget)
-																			.label(Label.MODIFY_BLOCK_STRING_ENTITY)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_BLOCK_STRING_ENTITY_PATH))))
-															.then(CommandNode.literal("storage")
-																	.then(CommandNode.argument("source", this.sourceTarget)
-																			.label(Label.MODIFY_BLOCK_STRING_STORAGE)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_BLOCK_STRING_STORAGE_PATH)))))))))
-					.then(CommandNode.literal("entity")
-							.then(CommandNode.argument("target", this.target)
-									.then(CommandNode.argument("path", this.path)
-											.then(CommandNode.argument("linkage", this.linkage)
-													.then(CommandNode.literal("from")
-															.then(CommandNode.literal("block")
-																	.then(CommandNode.argument("sourcePos", this.sourcePos)
-																			.label(Label.MODIFY_ENTITY_FROM_BLOCK)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_ENTITY_FROM_BLOCK_PATH))))
-															.then(CommandNode.literal("entity")
-																	.then(CommandNode.argument("sourceTarget", this.sourceTarget)
-																			.label(Label.MODIFY_ENTITY_FROM_ENTITY)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_ENTITY_FROM_ENTITY_PATH))))
-															.then(CommandNode.literal("storage")
-																	.then(CommandNode.argument("source", this.sourceTarget)
-																			.label(Label.MODIFY_ENTITY_FROM_STORAGE)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_ENTITY_FROM_STORAGE_PATH)))))
-													.then(CommandNode.literal("value")
-															.then(CommandNode.argument("value", this.value)
-																	.label(Label.MODIFY_ENTITY_VALUE)))
-													.then(CommandNode.literal("string")
-															.then(CommandNode.literal("block")
-																	.then(CommandNode.argument("sourcePos", this.sourcePos)
-																			.label(Label.MODIFY_ENTITY_STRING_BLOCK)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_ENTITY_STRING_BLOCK_PATH))))
-															.then(CommandNode.literal("entity")
-																	.then(CommandNode.argument("sourceTarget", this.sourceTarget)
-																			.label(Label.MODIFY_ENTITY_STRING_ENTITY)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_ENTITY_STRING_ENTITY_PATH))))
-															.then(CommandNode.literal("storage")
-																	.then(CommandNode.argument("source", this.sourceTarget)
-																			.label(Label.MODIFY_ENTITY_STRING_STORAGE)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_ENTITY_STRING_STORAGE_PATH)))))))))
-					.then(CommandNode.literal("storage")
-							.then(CommandNode.argument("target", this.target)
-									.then(CommandNode.argument("path", this.path)
-											.then(CommandNode.argument("linkage", this.linkage)
-													.then(CommandNode.literal("from")
-															.then(CommandNode.literal("block")
-																	.then(CommandNode.argument("sourcePos", this.sourcePos)
-																			.label(Label.MODIFY_STORAGE_FROM_BLOCK)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_ENTITY_FROM_BLOCK_PATH))))
-															.then(CommandNode.literal("entity")
-																	.then(CommandNode.argument("sourceTarget", this.sourceTarget)
-																			.label(Label.MODIFY_STORAGE_FROM_ENTITY)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_STORAGE_FROM_ENTITY_PATH))))
-															.then(CommandNode.literal("storage")
-																	.then(CommandNode.argument("source", this.sourceTarget)
-																			.label(Label.MODIFY_STORAGE_FROM_STORAGE)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_STORAGE_FROM_STORAGE_PATH)))))
-													.then(CommandNode.literal("value")
-															.then(CommandNode.argument("value", this.value)
-																	.label(Label.MODIFY_STORAGE_VALUE)))
-													.then(CommandNode.literal("string")
-															.then(CommandNode.literal("block")
-																	.then(CommandNode.argument("sourcePos", this.sourcePos)
-																			.label(Label.MODIFY_STORAGE_STRING_BLOCK)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_STORAGE_STRING_BLOCK_PATH))))
-															.then(CommandNode.literal("entity")
-																	.then(CommandNode.argument("sourceTarget", this.sourceTarget)
-																			.label(Label.MODIFY_STORAGE_STRING_ENTITY)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_STORAGE_STRING_ENTITY_PATH))))
-															.then(CommandNode.literal("storage")
-																	.then(CommandNode.argument("source", this.sourceTarget)
-																			.label(Label.MODIFY_STORAGE_STRING_STORAGE)
-																			.then(CommandNode.argument("sourcePath", this.sourcePath)
-																					.label(Label.MODIFY_STORAGE_STRING_STORAGE_PATH))))))))))
-			.then(CommandNode.literal("remove")
-					.then(CommandNode.literal("block")
-							.then(CommandNode.argument("targetPos", this.targetPos)
-									.then(CommandNode.argument("path", this.path)
-											.label(Label.REMOVE_BLOCK))))
-					.then(CommandNode.literal("entity")
-							.then(CommandNode.argument("target", this.target)
-									.then(CommandNode.argument("path", this.path)
-											.label(Label.REMOVE_ENTITY))))
-					.then(CommandNode.literal("storage")
-							.then(CommandNode.argument("target", this.target)
-									.then(CommandNode.argument("path", this.path)
-											.label(Label.REMOVE_STORAGE)))));
-	
-	public BlockPosArgument targetPos()
-	{
-		return this.targetPos;
-	}
-	
-	public NbtPathArgument path()
-	{
-		return this.path;
-	}
-	
-	public PrimitiveArgument<Linkage> linkage()
-	{
-		return this.linkage;
-	}
-	
-	public PrimitiveArgument<Double> scale()
-	{
-		return this.scale;
-	}
-	
-	public TargetArgument target()
-	{
-		return this.target;
-	}
-	
-	public TagArgument nbt()
-	{
-		return this.nbt;
-	}
-	
-	public TargetArgument sourceTarget()
-	{
-		return this.sourceTarget;
-	}
-	
-	public BlockPosArgument sourcePos()
-	{
-		return this.sourcePos;
-	}
-	
-	public PrimitiveArgument<String> sourcePath()
-	{
-		return this.sourcePath;
-	}
-	
-	public PrimitiveArgument<String> value()
-	{
-		return this.value;
-	}
-	
-	public PrimitiveArgument<Integer> index()
-	{
-		return this.index;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		GET_BLOCK,
-		GET_BLOCK_PATH,
-		GET_BLOCK_PATH_SCALE,
-		GET_ENTITY,
-		GET_ENTITY_PATH,
-		GET_ENTITY_PATH_SCALE,
-		GET_STORAGE,
-		GET_STORAGE_PATH,
-		GET_STORAGE_PATH_SCALE,
-		MERGE_BLOCK,
-		MERGE_ENTITY,
-		MERGE_STORAGE,
-		MODIFY_BLOCK_FROM_BLOCK,
-		MODIFY_BLOCK_FROM_BLOCK_PATH,
-		MODIFY_BLOCK_FROM_ENTITY,
-		MODIFY_BLOCK_FROM_ENTITY_PATH,
-		MODIFY_BLOCK_FROM_STORAGE,
-		MODIFY_BLOCK_FROM_STORAGE_PATH,
-		MODIFY_BLOCK_VALUE,
-		MODIFY_BLOCK_STRING_BLOCK,
-		MODIFY_BLOCK_STRING_BLOCK_PATH,
-		MODIFY_BLOCK_STRING_ENTITY,
-		MODIFY_BLOCK_STRING_ENTITY_PATH,
-		MODIFY_BLOCK_STRING_STORAGE,
-		MODIFY_BLOCK_STRING_STORAGE_PATH,
-		MODIFY_ENTITY_FROM_BLOCK,
-		MODIFY_ENTITY_FROM_BLOCK_PATH,
-		MODIFY_ENTITY_FROM_ENTITY,
-		MODIFY_ENTITY_FROM_ENTITY_PATH,
-		MODIFY_ENTITY_FROM_STORAGE,
-		MODIFY_ENTITY_FROM_STORAGE_PATH,
-		MODIFY_ENTITY_VALUE,
-		MODIFY_ENTITY_STRING_BLOCK,
-		MODIFY_ENTITY_STRING_BLOCK_PATH,
-		MODIFY_ENTITY_STRING_ENTITY,
-		MODIFY_ENTITY_STRING_ENTITY_PATH,
-		MODIFY_ENTITY_STRING_STORAGE,
-		MODIFY_ENTITY_STRING_STORAGE_PATH,
-		MODIFY_STORAGE_FROM_BLOCK,
-		MODIFY_STORAGE_FROM_BLOCK_PATH,
-		MODIFY_STORAGE_FROM_ENTITY,
-		MODIFY_STORAGE_FROM_ENTITY_PATH,
-		MODIFY_STORAGE_FROM_STORAGE,
-		MODIFY_STORAGE_FROM_STORAGE_PATH,
-		MODIFY_STORAGE_VALUE,
-		MODIFY_STORAGE_STRING_BLOCK,
-		MODIFY_STORAGE_STRING_BLOCK_PATH,
-		MODIFY_STORAGE_STRING_ENTITY,
-		MODIFY_STORAGE_STRING_ENTITY_PATH,
-		MODIFY_STORAGE_STRING_STORAGE,
-		MODIFY_STORAGE_STRING_STORAGE_PATH,
-		REMOVE_BLOCK,
-		REMOVE_ENTITY,
-		REMOVE_STORAGE;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/DeOpCommandBuilder.java

@@ -1,14 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-public class DeOpCommandBuilder extends TargetCommandBuilder
-{
-	public DeOpCommandBuilder()
-	{
-		super("deop", Label.DEOP);
-	}
-	
-	public static enum Label
-	{
-		DEOP;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/DifficultyCommandBuilder.java

@@ -1,33 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import net.minecraft.world.Difficulty;
-
-public class DifficultyCommandBuilder extends CommandBuilder
-{
-	private final PrimitiveArgument<Difficulty> difficulty = Arguments.difficulty();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("difficulty")
-			.then(CommandNode.argument("difficulty", this.difficulty)
-					.label(Label.DIFFICULTY));
-	
-	public PrimitiveArgument<Difficulty> difficulty()
-	{
-		return this.difficulty;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		DIFFICULTY;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/EffectCommandBuilder.java

@@ -1,87 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.EffectArgument;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class EffectCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	private final EffectArgument effect = Arguments.effect();
-	private final PrimitiveArgument<Integer> seconds = Arguments.intArg();
-	private final PrimitiveArgument<Byte> amplifier = Arguments.byteArg();
-	private final PrimitiveArgument<Boolean> hideParticles = Arguments.boolArg();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("effect")
-			.then(CommandNode.literal("give")
-					.then(CommandNode.argument("targets", this.targets)
-							.then(CommandNode.argument("effect", this.effect)
-									.label(Label.GIVE)
-									.then(CommandNode.argument("seconds", this.seconds)
-											.label(Label.GIVE_SECONDS)
-											.then(CommandNode.argument("amplifier", this.amplifier)
-													.label(Label.GIVE_SECONDS_AMPLIFIER)
-													.then(CommandNode.argument("hideParticles", this.hideParticles)
-															.label(Label.GIVE_SECONDS_AMPLIFIER_HIDEPARTICLES))))
-									.then(CommandNode.literal("infinite")
-											.label(Label.GIVE_INFINITE)
-											.then(CommandNode.argument("amplifier", this.amplifier)
-													.label(Label.GIVE_INFINITE_AMPLIFIER)
-													.then(CommandNode.argument("hideParticles", this.hideParticles)
-															.label(Label.GIVE_INFINITE_AMPLIFIER_HIDEPARTICLES)))))))
-			.then(CommandNode.literal("clear")
-					.label(Label.CLEAR)
-					.then(CommandNode.argument("targets", this.targets)
-							.label(Label.CLEAR_TARGETS)
-							.then(CommandNode.argument("effect", this.effect)
-									.label(Label.CLEAR_TARGETS_EFFECT))));
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	public EffectArgument effect()
-	{
-		return this.effect;
-	}
-	
-	public PrimitiveArgument<Integer> seconds()
-	{
-		return this.seconds;
-	}
-	
-	public PrimitiveArgument<Byte> amplifier()
-	{
-		return this.amplifier;
-	}
-	
-	public PrimitiveArgument<Boolean> hideParticles()
-	{
-		return this.hideParticles;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		GIVE,
-		GIVE_SECONDS,
-		GIVE_SECONDS_AMPLIFIER,
-		GIVE_SECONDS_AMPLIFIER_HIDEPARTICLES,
-		GIVE_INFINITE,
-		GIVE_INFINITE_AMPLIFIER,
-		GIVE_INFINITE_AMPLIFIER_HIDEPARTICLES,
-		CLEAR,
-		CLEAR_TARGETS,
-		CLEAR_TARGETS_EFFECT;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/EnchantCommandBuilder.java

@@ -1,50 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.EnchantmentArgument;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class EnchantCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument target = Arguments.target();
-	private final EnchantmentArgument enchantment = Arguments.enchantment();
-	private final PrimitiveArgument<Integer> level = Arguments.intArg();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("enchant")
-			.then(CommandNode.argument("target", this.target)
-					.then(CommandNode.argument("enchantment", this.enchantment)
-							.label(Label.ENCHANT)
-							.then(CommandNode.argument("level", this.level)
-									.label(Label.ENCHANT_LEVEL))));
-	
-	public TargetArgument target()
-	{
-		return this.target;
-	}
-	
-	public EnchantmentArgument enchantment()
-	{
-		return this.enchantment;
-	}
-	
-	public PrimitiveArgument<Integer> level()
-	{
-		return this.level;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		ENCHANT,
-		ENCHANT_LEVEL;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/ExecuteCommandBuilder.java

@@ -1,731 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.ArgumentListArgument;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.BlockPosArgument;
-import exopandora.worldhandler.builder.argument.CommandArgument;
-import exopandora.worldhandler.builder.argument.DimensionArgument;
-import exopandora.worldhandler.builder.argument.EntitySummonArgument;
-import exopandora.worldhandler.builder.argument.NbtPathArgument;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.RangeArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-import exopandora.worldhandler.builder.argument.ArgumentListArgument.OptionalCommandBuilder;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument.Type;
-import net.minecraft.commands.arguments.EntityAnchorArgument.Anchor;
-import net.minecraft.core.Direction.Axis;
-import net.minecraft.resources.ResourceLocation;
-
-public class ExecuteCommandBuilder extends CommandBuilder
-{
-	private final CommandArgument command = new CommandArgument();
-	private final ArgumentListArgument modifiers = new ArgumentListArgument();
-	private final CommandNodeLiteral root = CommandNode.literal("execute")
-			.then(CommandNode.argument("modifiers", this.modifiers)
-					.then(CommandNode.literal("run")
-							.then(CommandNode.argument("command", this.command)
-									.label(Label.RUN))));
-	
-	public ArgumentListArgument modifiers()
-	{
-		return this.modifiers;
-	}
-	
-	public CommandArgument command()
-	{
-		return this.command;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		RUN;
-	}
-	
-	public static class AlignOptionalArgument extends OptionalCommandBuilder<AlignOptionalArgument.Label>
-	{
-		private final PrimitiveArgument<Axis> axis = Arguments.axis();
-		private final CommandNodeLiteral root = CommandNode.literal("align")
-				.then(CommandNode.argument("axis", this.axis)
-						.label(Label.AXIS));
-		
-		public AlignOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		public PrimitiveArgument<Axis> axis()
-		{
-			return this.axis;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			AXIS;
-		}
-	}
-	
-	public static class AnchoredOptionalArgument extends OptionalCommandBuilder<AnchoredOptionalArgument.Label>
-	{
-		private final PrimitiveArgument<Anchor> anchor = Arguments.anchor();
-		private final CommandNodeLiteral root = CommandNode.literal("anchored")
-				.then(CommandNode.argument("anchor", this.anchor)
-						.label(Label.ANCHOR));
-		
-		public AnchoredOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		public PrimitiveArgument<Anchor> anchor()
-		{
-			return this.anchor;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			ANCHOR;
-		}
-	}
-	
-	public static class AsOptionalArgument extends OptionalCommandBuilder<AsOptionalArgument.Label>
-	{
-		private final TargetArgument targets = Arguments.target();
-		private final CommandNodeLiteral root = CommandNode.literal("as")
-				.then(CommandNode.argument("targets", this.targets)
-						.label(Label.AS));
-		
-		public AsOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		public TargetArgument targets()
-		{
-			return this.targets;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			AS;
-		}
-	}
-	
-	public static class AtOptionalArgument extends OptionalCommandBuilder<AtOptionalArgument.Label>
-	{
-		private final TargetArgument targets = Arguments.target();
-		private final CommandNodeLiteral root = CommandNode.literal("at")
-				.then(CommandNode.argument("targets", this.targets)
-						.label(Label.AT));
-		
-		public AtOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		public TargetArgument targets()
-		{
-			return this.targets;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			AT;
-		}
-	}
-	
-	public static class FacingOptionalArgument extends OptionalCommandBuilder<FacingOptionalArgument.Label>
-	{
-		private final PrimitiveArgument<Anchor> anchor = Arguments.anchor();
-		private final BlockPosArgument pos = Arguments.blockPos();
-		private final TargetArgument targets = Arguments.target();
-		private final CommandNodeLiteral root = CommandNode.literal("facing")
-				.then(CommandNode.argument("pos", this.pos)
-						.label(Label.POS))
-				.then(CommandNode.literal("entity")
-						.then(CommandNode.argument("targets", this.targets)
-								.then(CommandNode.argument("anchor", this.anchor)
-										.label(Label.ENTITY))));
-		
-		public FacingOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		public PrimitiveArgument<Anchor> anchor()
-		{
-			return this.anchor;
-		}
-		
-		public BlockPosArgument pos()
-		{
-			return this.pos;
-		}
-		
-		public TargetArgument targets()
-		{
-			return this.targets;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			POS,
-			ENTITY;
-		}
-	}
-	
-	public static class InOptionalArgument extends OptionalCommandBuilder<InOptionalArgument.Label>
-	{
-		private final DimensionArgument dimension = Arguments.dimension();
-		private final CommandNodeLiteral root = CommandNode.literal("in")
-				.then(CommandNode.argument("dimension", this.dimension)
-						.label(Label.IN));
-		
-		public InOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		public DimensionArgument dimension()
-		{
-			return this.dimension;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			IN;
-		}
-	}
-	
-	public static class PositionedOptionalArgument extends OptionalCommandBuilder<PositionedOptionalArgument.Label>
-	{
-		private final BlockPosArgument pos = Arguments.blockPos();
-		private final TargetArgument targets = Arguments.target();
-		private final CommandNodeLiteral root = CommandNode.literal("positioned")
-				.then(CommandNode.argument("pos", this.pos)
-						.label(Label.POS))
-				.then(CommandNode.literal("as")
-						.then(CommandNode.argument("targets", this.targets)
-								.label(Label.AS)))
-				.then(CommandNode.literal("over")
-						.then(CommandNode.literal("world_surface")
-								.label(Label.OVER_WORLD_SURFACE))
-						.then(CommandNode.literal("motion_blocking")
-								.label(Label.OVER_MOTION_BLOCKING))
-						.then(CommandNode.literal("motion_blocking_no_leaves")
-								.label(Label.OVER_MOTION_BLOCKING_NO_LEAVES))
-						.then(CommandNode.literal("ocean_floor")
-								.label(Label.OVER_OCEAN_FLOOR)));
-		
-		public PositionedOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		public BlockPosArgument pos()
-		{
-			return this.pos;
-		}
-		
-		public TargetArgument targets()
-		{
-			return this.targets;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			POS,
-			AS,
-			OVER_WORLD_SURFACE,
-			OVER_MOTION_BLOCKING,
-			OVER_MOTION_BLOCKING_NO_LEAVES,
-			OVER_OCEAN_FLOOR;
-		}
-	}
-	
-	public static class RotatedOptionalArgument extends OptionalCommandBuilder<RotatedOptionalArgument.Label>
-	{
-		private final TargetArgument targets = Arguments.target();
-		private final CommandNodeLiteral root = CommandNode.literal("rotated")
-				.then(CommandNode.literal("as")
-						.then(CommandNode.argument("targets", this.targets)
-								.label(Label.ROTATED)));
-		
-		public RotatedOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		public TargetArgument targets()
-		{
-			return this.targets;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			ROTATED;
-		}
-	}
-	
-	private static class ConditionOptionalArgument extends OptionalCommandBuilder<ConditionOptionalArgument.Label>
-	{
-		private final BlockPosArgument pos = Arguments.blockPos();
-		private final PrimitiveArgument<ResourceLocation> block = Arguments.resourceLocation();
-		private final BlockPosArgument start = Arguments.blockPos();
-		private final BlockPosArgument end = Arguments.blockPos();
-		private final BlockPosArgument destination = Arguments.blockPos();
-		private final DimensionArgument dimension = Arguments.dimension();
-		private final NbtPathArgument path = Arguments.nbtPath();
-		private final PrimitiveArgument<ResourceLocation> predicate = Arguments.resourceLocation();
-		private final TargetArgument target = Arguments.target();
-		private final TargetArgument source = Arguments.target();
-		private final PrimitiveArgument<String> targetObjective = Arguments.word();
-		private final PrimitiveArgument<String> sourceObjective = Arguments.word();
-		private final RangeArgument<Integer> range = Arguments.intRange();
-		private final PrimitiveArgument<ResourceLocation> function = Arguments.resourceLocation();
-		private final CommandNodeLiteral root;
-		
-		public ConditionOptionalArgument(String condition, Label label)
-		{
-			super(label);
-			this.root = CommandNode.literal(condition)
-					.then(CommandNode.literal("block")
-							.then(CommandNode.argument("pos", this.pos)
-									.then(CommandNode.argument("block", this.block)
-											.label(Label.BLOCK))))
-					.then(CommandNode.literal("blocks")
-							.then(CommandNode.argument("start", this.start)
-									.then(CommandNode.argument("end", this.end)
-											.then(CommandNode.argument("destination", this.destination)
-													.then(CommandNode.literal("all")
-															.label(Label.BLOCKS_ALL))
-													.then(CommandNode.literal("masked")
-															.label(Label.BLOCKS_MASKED))))))
-					.then(CommandNode.literal("data")
-							.then(CommandNode.literal("block")
-									.then(CommandNode.argument("sourcePos", this.pos)
-											.then(CommandNode.argument("sourcePath", this.path)
-													.label(Label.DATA_BLOCK))))
-							.then(CommandNode.literal("entity")
-									.then(CommandNode.argument("sourceTarget", this.target)
-											.then(CommandNode.argument("sourcePath", this.path)
-													.label(Label.DATA_ENTITY))))
-							.then(CommandNode.literal("storage")
-									.then(CommandNode.argument("source", this.target)
-											.then(CommandNode.argument("sourcePath", this.path)
-													.label(Label.DATA_STORAGE)))))
-					.then(CommandNode.literal("dimension")
-							.then(CommandNode.argument("dimension", this.dimension)
-									.label(Label.DIMENSION)))
-					.then(CommandNode.literal("entity")
-							.then(CommandNode.argument("entites", this.target)
-									.label(Label.ENTITY)))
-					.then(CommandNode.literal("loaded")
-							.then(CommandNode.argument("pos", this.pos)
-									.label(Label.LOADED)))
-					.then(CommandNode.literal("predicate")
-							.then(CommandNode.argument("predicate", this.predicate)
-									.label(Label.PREDICATE)))
-					.then(CommandNode.literal("score")
-							.then(CommandNode.argument("target", this.target)
-									.then(CommandNode.argument("targetObjective", this.targetObjective)
-											.then(CommandNode.literal("<")
-													.then(CommandNode.argument("source", this.source)
-															.then(CommandNode.argument("sourceObjective", this.sourceObjective)
-																	.label(Label.SCORE_LT))))
-											.then(CommandNode.literal("<=")
-													.then(CommandNode.argument("source", this.source)
-															.then(CommandNode.argument("sourceObjective", this.sourceObjective)
-																	.label(Label.SCORE_LE))))
-											.then(CommandNode.literal("=")
-													.then(CommandNode.argument("source", this.source)
-															.then(CommandNode.argument("sourceObjective", this.sourceObjective)
-																	.label(Label.SCORE_EQ))))
-											.then(CommandNode.literal(">")
-													.then(CommandNode.argument("source", this.source)
-															.then(CommandNode.argument("sourceObjective", this.sourceObjective)
-																	.label(Label.SCORE_GT))))
-											.then(CommandNode.literal(">=")
-													.then(CommandNode.argument("source", this.source)
-															.then(CommandNode.argument("sourceObjective", this.sourceObjective)
-																	.label(Label.SCORE_GE))))
-											.then(CommandNode.literal("matches")
-													.then(CommandNode.argument("range", this.range)
-															.label(Label.SCORE_MATCHES))))))
-					.then(CommandNode.literal("function")
-							.then(CommandNode.argument("function", this.function)
-									.label(Label.FUNCTION)));
-		}
-		
-		public BlockPosArgument pos()
-		{
-			return this.pos;
-		}
-		
-		public PrimitiveArgument<ResourceLocation> block()
-		{
-			return this.block;
-		}
-		
-		public BlockPosArgument start()
-		{
-			return this.start;
-		}
-		
-		public BlockPosArgument end()
-		{
-			return this.end;
-		}
-		
-		public BlockPosArgument destination()
-		{
-			return this.destination;
-		}
-		
-		public NbtPathArgument path()
-		{
-			return this.path;
-		}
-		
-		public PrimitiveArgument<ResourceLocation> predicate()
-		{
-			return this.predicate;
-		}
-		
-		public TargetArgument targets()
-		{
-			return this.target;
-		}
-		
-		public TargetArgument source()
-		{
-			return this.source;
-		}
-		
-		public PrimitiveArgument<String> targetObjective()
-		{
-			return this.targetObjective;
-		}
-		
-		public PrimitiveArgument<String> sourceObjective()
-		{
-			return this.sourceObjective;
-		}
-		
-		public RangeArgument<Integer> range()
-		{
-			return this.range;
-		}
-		
-		public PrimitiveArgument<ResourceLocation> function()
-		{
-			return this.function;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			BLOCK,
-			BLOCKS_ALL,
-			BLOCKS_MASKED,
-			DATA_BLOCK,
-			DATA_ENTITY,
-			DATA_STORAGE,
-			DIMENSION,
-			ENTITY,
-			LOADED,
-			PREDICATE,
-			SCORE_LT,
-			SCORE_LE,
-			SCORE_EQ,
-			SCORE_GT,
-			SCORE_GE,
-			SCORE_MATCHES,
-			FUNCTION;
-		}
-	}
-	
-	public static class IfOptionalArgument extends ConditionOptionalArgument
-	{
-		public IfOptionalArgument(Label label)
-		{
-			super("if", label);
-		}
-	}
-	
-	public static class UnlessOptionalArgument extends ConditionOptionalArgument
-	{
-		public UnlessOptionalArgument(Label label)
-		{
-			super("unless", label);
-		}
-	}
-	
-	public static class StoreOptionalArgument extends OptionalCommandBuilder<StoreOptionalArgument.Label>
-	{
-		private final BlockPosArgument targetPos = Arguments.blockPos();
-		private final NbtPathArgument path = Arguments.nbtPath();
-		private final PrimitiveArgument<Type> type = Arguments.type();
-		private final PrimitiveArgument<Double> scale = Arguments.doubleArg();
-		private final PrimitiveArgument<ResourceLocation> id = Arguments.resourceLocation();
-		private final TargetArgument target = Arguments.target();
-		private final PrimitiveArgument<String> objective = Arguments.word();
-		
-		private final CommandNodeLiteral root = CommandNode.literal("store")
-				.then(CommandNode.literal("result")
-						.then(CommandNode.literal("block")
-								.then(CommandNode.argument("targetPos", this.targetPos)
-										.then(CommandNode.argument("path", this.path)
-												.then(CommandNode.argument("type", this.type)
-														.then(CommandNode.argument("scale", this.scale)
-																.label(Label.RESULT_BLOCK))))))
-						.then(CommandNode.literal("bossbar")
-								.then(CommandNode.argument("id", this.id)
-										.then(CommandNode.literal("max")
-												.label(Label.RESULT_BOSSBAR_MAX))
-										.then(CommandNode.literal("value")
-												.label(Label.RESULT_BOSSBAR_VALUE))))
-						.then(CommandNode.literal("entity")
-								.then(CommandNode.argument("target", this.target)
-										.then(CommandNode.argument("path", this.path)
-												.then(CommandNode.argument("type", this.type)
-														.then(CommandNode.argument("scale", this.scale)
-																.label(Label.RESULT_ENTITY))))))
-						.then(CommandNode.literal("score")
-								.then(CommandNode.argument("target", this.target)
-										.then(CommandNode.argument("objective", this.objective)
-												.label(Label.RESULT_SCORE))))
-						.then(CommandNode.literal("storage")
-								.then(CommandNode.argument("target", this.target)
-										.then(CommandNode.argument("path", this.path)
-												.then(CommandNode.argument("type", this.type)
-														.then(CommandNode.argument("scale", this.scale)
-																.label(Label.RESULT_STORAGE))))))
-				.then(CommandNode.literal("success")
-						.then(CommandNode.literal("block")
-								.then(CommandNode.argument("targetPos", this.targetPos)
-										.then(CommandNode.argument("path", this.path)
-												.then(CommandNode.argument("type", this.type)
-														.then(CommandNode.argument("scale", this.scale)
-																.label(Label.SUCCESS_BLOCK))))))
-						.then(CommandNode.literal("bossbar")
-								.then(CommandNode.argument("id", this.id)
-										.then(CommandNode.literal("max")
-												.label(Label.SUCCESS_BOSSBAR_MAX))
-										.then(CommandNode.literal("value")
-												.label(Label.SUCCESS_BOSSBAR_VALUE))))
-						.then(CommandNode.literal("entity")
-								.then(CommandNode.argument("target", this.target)
-										.then(CommandNode.argument("path", this.path)
-												.then(CommandNode.argument("type", this.type)
-														.then(CommandNode.argument("scale", this.scale)
-																.label(Label.SUCCESS_ENTITY))))))
-						.then(CommandNode.literal("score")
-								.then(CommandNode.argument("target", this.target)
-										.then(CommandNode.argument("objective", this.objective)
-												.label(Label.SUCCESS_SCORE))))
-						.then(CommandNode.literal("storage")
-								.then(CommandNode.argument("target", this.target)
-										.then(CommandNode.argument("path", this.path)
-												.then(CommandNode.argument("type", this.type)
-														.then(CommandNode.argument("scale", this.scale)
-																.label(Label.SUCCESS_STORAGE))))))));
-		
-		public StoreOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		public BlockPosArgument targetPos()
-		{
-			return this.targetPos;
-		}
-		
-		public NbtPathArgument path()
-		{
-			return this.path;
-		}
-		
-		public PrimitiveArgument<Type> type()
-		{
-			return this.type;
-		}
-		
-		public PrimitiveArgument<Double> scale()
-		{
-			return this.scale;
-		}
-		
-		public PrimitiveArgument<ResourceLocation> id()
-		{
-			return this.id;
-		}
-		
-		public TargetArgument target()
-		{
-			return this.target;
-		}
-		
-		public PrimitiveArgument<String> objective()
-		{
-			return this.objective;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			RESULT_BLOCK,
-			RESULT_BOSSBAR_MAX,
-			RESULT_BOSSBAR_VALUE,
-			RESULT_ENTITY,
-			RESULT_SCORE,
-			RESULT_STORAGE,
-			SUCCESS_BLOCK,
-			SUCCESS_BOSSBAR_MAX,
-			SUCCESS_BOSSBAR_VALUE,
-			SUCCESS_ENTITY,
-			SUCCESS_SCORE,
-			SUCCESS_STORAGE;
-		}
-	}
-	
-	public static class OnOptionalArgument extends OptionalCommandBuilder<OnOptionalArgument.Label>
-	{
-		private final CommandNodeLiteral root = CommandNode.literal("on")
-				.then(CommandNode.literal("attacker")
-						.label(Label.ATTACKER))
-				.then(CommandNode.literal("controller")
-						.label(Label.CONTROLLER))
-				.then(CommandNode.literal("leasher")
-						.label(Label.LEASHER))
-				.then(CommandNode.literal("origin")
-						.label(Label.ORIGIN))
-				.then(CommandNode.literal("owner")
-						.label(Label.OWNER))
-				.then(CommandNode.literal("passengers")
-						.label(Label.PASSENGERS))
-				.then(CommandNode.literal("target")
-						.label(Label.TARGET))
-				.then(CommandNode.literal("vehicle")
-						.label(Label.VEHICLE));
-		
-		public OnOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			ATTACKER,
-			CONTROLLER,
-			LEASHER,
-			ORIGIN,
-			OWNER,
-			PASSENGERS,
-			TARGET,
-			VEHICLE;
-		}
-	}
-	
-	public static class SummonOptionalArgument extends OptionalCommandBuilder<SummonOptionalArgument.Label>
-	{
-		private final EntitySummonArgument entity = Arguments.entitySummon();
-		
-		private final CommandNodeLiteral root = CommandNode.literal("on")
-				.then(CommandNode.argument("entity", this.entity)
-						.label(Label.SUMMON));
-		
-		public SummonOptionalArgument(Label label)
-		{
-			super(label);
-		}
-		
-		public EntitySummonArgument entity()
-		{
-			return entity;
-		}
-		
-		@Override
-		protected CommandNodeLiteral root()
-		{
-			return this.root;
-		}
-		
-		public static enum Label
-		{
-			SUMMON;
-		}
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/ExperienceCommandBuilder.java

@@ -1,66 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class ExperienceCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	private final PrimitiveArgument<Integer> amount = Arguments.intArg();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("experience")
-			.then(CommandNode.literal("add")
-					.then(CommandNode.argument("targets", this.targets)
-							.then(CommandNode.argument("amount", this.amount)
-									.label(Label.ADD)
-									.then(CommandNode.literal("points")
-											.label(Label.ADD_POINTS))
-									.then(CommandNode.literal("levels")
-											.label(Label.ADD_LEVELS)))))
-			.then(CommandNode.literal("set")
-					.then(CommandNode.argument("targets", this.targets)
-							.then(CommandNode.argument("amount", this.amount)
-									.label(Label.SET)
-									.then(CommandNode.literal("points")
-											.label(Label.SET_POINTS))
-									.then(CommandNode.literal("levels")
-											.label(Label.SET_LEVELS)))))
-			.then(CommandNode.literal("query")
-					.then(CommandNode.argument("targets", this.targets)
-							.then(CommandNode.literal("points")
-									.label(Label.QUERY_POINTS))
-							.then(CommandNode.literal("levels")
-									.label(Label.QUERY_LEVELS))));
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	public PrimitiveArgument<Integer> amount()
-	{
-		return this.amount;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		ADD,
-		ADD_POINTS,
-		ADD_LEVELS,
-		SET,
-		SET_POINTS,
-		SET_LEVELS,
-		QUERY_POINTS,
-		QUERY_LEVELS;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/FillCommandBuilder.java

@@ -1,70 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.BlockPosArgument;
-import exopandora.worldhandler.builder.argument.BlockPredicateArgument;
-import exopandora.worldhandler.builder.argument.BlockStateArgument;
-
-public class FillCommandBuilder extends CommandBuilder
-{
-	private final BlockPosArgument from = Arguments.blockPos();
-	private final BlockPosArgument to = Arguments.blockPos();
-	private final BlockStateArgument block = Arguments.blockState();
-	private final BlockPredicateArgument filter = Arguments.blockPredicate();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("fill")
-			.then(CommandNode.argument("from", this.from)
-					.then(CommandNode.argument("to", this.to)
-								.then(CommandNode.argument("block", this.block)
-										.label(Label.FILL)
-										.then(CommandNode.literal("destroy")
-												.label(Label.DESTROY))
-										.then(CommandNode.literal("hollow")
-												.label(Label.HOLLOW))
-										.then(CommandNode.literal("keep")
-												.label(Label.KEEP))
-										.then(CommandNode.literal("outline")
-												.label(Label.OUTLINE))
-										.then(CommandNode.literal("replace")
-												.then(CommandNode.argument("filter", this.filter)
-														.label(Label.REPLACE))))));
-	
-	public BlockPosArgument from()
-	{
-		return this.from;
-	}
-	
-	public BlockPosArgument to()
-	{
-		return this.to;
-	}
-	
-	public BlockStateArgument block()
-	{
-		return this.block;
-	}
-	
-	public BlockPredicateArgument filter()
-	{
-		return this.filter;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public enum Label
-	{
-		FILL,
-		DESTROY,
-		HOLLOW,
-		KEEP,
-		OUTLINE,
-		REPLACE;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/GameRuleCommandBuilder.java

@@ -1,41 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-
-public class GameRuleCommandBuilder extends CommandBuilder
-{
-	private final PrimitiveArgument<String> rule = Arguments.word();
-	private final PrimitiveArgument<String> value = Arguments.word();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("gamerule")
-			.then(CommandNode.argument("rule", this.rule)
-					.label(Label.GAMERULE)
-					.then(CommandNode.argument("value", this.value)
-							.label(Label.GAMERULE_VALUE)));
-	
-	public PrimitiveArgument<String> rule()
-	{
-		return this.rule;
-	}
-	
-	public PrimitiveArgument<String> value()
-	{
-		return this.value;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		GAMERULE,
-		GAMERULE_VALUE;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/GamemodeCommandBuilder.java

@@ -1,43 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.Gamemode;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class GamemodeCommandBuilder extends CommandBuilder
-{
-	private final PrimitiveArgument<Gamemode> gamemode = Arguments.gamemode();
-	private final TargetArgument target = Arguments.target();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("gamemode")
-			.then(CommandNode.argument("gamemode", this.gamemode)
-					.label(Label.GAMEMODE)
-					.then(CommandNode.argument("target", this.target)
-							.label(Label.PLAYER)));
-	
-	public PrimitiveArgument<Gamemode> gamemode()
-	{
-		return this.gamemode;
-	}
-	
-	public TargetArgument target()
-	{
-		return this.target;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public enum Label
-	{
-		GAMEMODE,
-		PLAYER;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/GiveCommandBuilder.java

@@ -1,50 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.ItemArgument;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class GiveCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	private final ItemArgument item = Arguments.item();
-	private final PrimitiveArgument<Integer> count = Arguments.intArg();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("give")
-			.then(CommandNode.argument("targets", this.targets)
-					.then(CommandNode.argument("item", this.item)
-							.label(Label.GIVE)
-							.then(CommandNode.argument("count", this.count)
-									.label(Label.GIVE_COUNT))));
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	public ItemArgument item()
-	{
-		return this.item;
-	}
-	
-	public PrimitiveArgument<Integer> count()
-	{
-		return this.count;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public enum Label
-	{
-		GIVE,
-		GIVE_COUNT;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/KickCommandBuilder.java

@@ -1,15 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-public class KickCommandBuilder extends TargetReasonCommandBuilder<KickCommandBuilder.Label>
-{
-	public KickCommandBuilder()
-	{
-		super("kick", Label.KICK, Label.KICK_REASON);
-	}
-	
-	public static enum Label
-	{
-		KICK,
-		KICK_REASON;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/KillCommandBuilder.java

@@ -1,34 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class KillCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("kill")
-			.label(Label.KILL)
-			.then(CommandNode.argument("targets", this.targets)
-					.label(Label.KILL_TARGETS));
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		KILL,
-		KILL_TARGETS;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/LiteralCommandBuilder.java

@@ -1,32 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-
-public class LiteralCommandBuilder extends CommandBuilder
-{
-	private final CommandNodeLiteral command;
-	
-	public LiteralCommandBuilder(String command)
-	{
-		this(command, Label.ROOT);
-	}
-	
-	public LiteralCommandBuilder(String command, Object label)
-	{
-		this.command = CommandNode.literal(command)
-				.label(label);
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.command;
-	}
-	
-	public static enum Label
-	{
-		ROOT;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/LocateCommandBuilder.java

@@ -1,54 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import net.minecraft.resources.ResourceLocation;
-
-public class LocateCommandBuilder extends CommandBuilder
-{
-	private final PrimitiveArgument<ResourceLocation> biome = Arguments.resourceLocation();
-	private final PrimitiveArgument<ResourceLocation> structure = Arguments.resourceLocation();
-	private final PrimitiveArgument<ResourceLocation> poi = Arguments.resourceLocation();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("locate")
-			.then(CommandNode.literal("biome")
-					.then(CommandNode.argument("biome", this.biome)
-							.label(Label.BIOME)))
-			.then(CommandNode.literal("structure")
-					.then(CommandNode.argument("structure", this.structure)
-							.label(Label.STRUCTURE)))
-			.then(CommandNode.literal("poi")
-					.then(CommandNode.argument("poi", this.poi)
-							.label(Label.POI)));
-	
-	public PrimitiveArgument<ResourceLocation> biome()
-	{
-		return this.biome;
-	}
-	
-	public PrimitiveArgument<ResourceLocation> structure()
-	{
-		return this.structure;
-	}
-	
-	public PrimitiveArgument<ResourceLocation> poi()
-	{
-		return this.poi;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		BIOME,
-		STRUCTURE,
-		POI;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/OpCommandBuilder.java

@@ -1,14 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-public class OpCommandBuilder extends TargetCommandBuilder
-{
-	public OpCommandBuilder()
-	{
-		super("op", Label.OP);
-	}
-	
-	public static enum Label
-	{
-		OP;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/PardonCommandBuilder.java

@@ -1,14 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-public class PardonCommandBuilder extends TargetCommandBuilder
-{
-	public PardonCommandBuilder()
-	{
-		super("pardon", Label.PARDON);
-	}
-	
-	public static enum Label
-	{
-		PARDON;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/RecipeCommandBuilder.java

@@ -1,53 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-import net.minecraft.resources.ResourceLocation;
-
-public class RecipeCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	private final PrimitiveArgument<ResourceLocation> recipe = Arguments.resourceLocation();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("recipe")
-			.then(CommandNode.literal("give")
-					.then(CommandNode.argument("targets", this.targets)
-							.then(CommandNode.argument("recipe", this.recipe)
-									.label(Label.GIVE))
-							.then(CommandNode.literal("*")
-									.label(Label.GIVE_ALL))))
-			.then(CommandNode.literal("take")
-					.then(CommandNode.argument("targets", this.targets)
-							.then(CommandNode.argument("recipe", this.recipe)
-									.label(Label.TAKE))
-							.then(CommandNode.literal("*")
-									.label(Label.TAKE_ALL))));
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	public PrimitiveArgument<ResourceLocation> recipe()
-	{
-		return this.recipe;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		GIVE,
-		GIVE_ALL,
-		TAKE,
-		TAKE_ALL;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/SaveAllCommandBuilder.java

@@ -1,14 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-public class SaveAllCommandBuilder extends LiteralCommandBuilder
-{
-	public SaveAllCommandBuilder()
-	{
-		super("save-all", Label.SAVE_ALL);
-	}
-	
-	public static enum Label
-	{
-		SAVE_ALL;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/SaveOffCommandBuilder.java

@@ -1,14 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-public class SaveOffCommandBuilder extends LiteralCommandBuilder
-{
-	public SaveOffCommandBuilder()
-	{
-		super("save-off", Label.SAVE_OFF);
-	}
-	
-	public static enum Label
-	{
-		SAVE_OFF;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/SaveOnCommandBuilder.java

@@ -1,14 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-public class SaveOnCommandBuilder extends LiteralCommandBuilder
-{
-	public SaveOnCommandBuilder()
-	{
-		super("save-on", Label.SAVE_ON);
-	}
-	
-	public static enum Label
-	{
-		SAVE_ON;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/ScoreboardCommandBuilder.java

@@ -1,222 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument.Operation;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-import net.minecraft.network.chat.Component;
-import net.minecraft.network.chat.Style;
-import net.minecraft.world.scores.criteria.ObjectiveCriteria.RenderType;
-
-public class ScoreboardCommandBuilder extends CommandBuilder
-{
-	private final PrimitiveArgument<String> objective = Arguments.word();
-	private final PrimitiveArgument<String> criteria = Arguments.criteria();
-	private final PrimitiveArgument<Component> displayName = Arguments.textComponent();
-	private final PrimitiveArgument<String> slot = Arguments.word();
-	private final PrimitiveArgument<RenderType> renderType = Arguments.renderType();
-	private final PrimitiveArgument<Boolean> displayAutoUpdate = Arguments.boolArg();
-	private final TargetArgument target = Arguments.target();
-	private final TargetArgument targets = Arguments.target();
-	private final PrimitiveArgument<Integer> score = Arguments.intArg();
-	private final PrimitiveArgument<Operation> operation = Arguments.operation();
-	private final PrimitiveArgument<String> sourceObjective = Arguments.word();
-	private final PrimitiveArgument<Style> style = Arguments.style();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("scoreboard")
-		.then(CommandNode.literal("objectives")
-			.label(Label.OBJECTIVES)
-			.then(CommandNode.literal("add")
-				.then(CommandNode.argument("objective", this.objective)
-					.then(CommandNode.argument("criteria", this.criteria)
-						.label(Label.OBJECTIVES_ADD)
-						.then(CommandNode.argument("displayName", this.displayName)
-							.label(Label.OBJECTIVES_ADD_DISPLAYNAME)))))
-			.then(CommandNode.literal("modify")
-				.then(CommandNode.argument("objective", this.objective)
-					.then(CommandNode.literal("displayname")
-						.then(CommandNode.argument("displayName", this.displayName)
-							.label(Label.OBJECTIVES_MODIFY_DISPLAYNAME)))
-					.then(CommandNode.literal("rendertype")
-						.then(CommandNode.argument("renderType", this.renderType)
-							.label(Label.OBJECTIVES_MODIFY_RENDERTYPE)))
-					.then(CommandNode.literal("displayautoupdate")
-						.then(CommandNode.argument("displayAutoUpdate", this.displayAutoUpdate)
-							.label(Label.OBJECTIVES_MODIFY_DISPLAYAUTOUPDATE)))
-					.then(CommandNode.literal("numberformat")
-						.label(Label.OBJECTIVES_MODIFY_NUMBERFORMAT)
-						.then(CommandNode.argument("styled", this.style)
-							.label(Label.OBJECTIVES_MODIFY_NUMBERFORMAT_STYLED))
-						.then(CommandNode.argument("fixed", this.displayName)
-							.label(Label.OBJECTIVES_MODIFY_NUMBERFORMAT_FIXED))
-						.then(CommandNode.literal("blank")
-							.label(Label.OBJECTIVES_MODIFY_NUMBERFORMAT_BLANK)))))
-			.then(CommandNode.literal("remove")
-				.then(CommandNode.argument("objective", this.objective)
-					.label(Label.OBJECTIVES_REMOVE)))
-			.then(CommandNode.literal("setdisplay")
-				.then(CommandNode.argument("slot", this.slot)
-					.label(Label.OBJECTIVES_SETDISPLAY_SLOT)
-					.then(CommandNode.argument("objective", this.objective)
-						.label(Label.OBJECTIVES_SETDISPLAY_SLOT_OBJECTIVE)))))
-		.then(CommandNode.literal("players")
-			.label(Label.PLAYERS)
-			.then(CommandNode.literal("list")
-				.label(Label.PLAYERS_LIST)
-				.then(CommandNode.argument("target", this.target)
-					.label(Label.PLAYERS_LIST_TARGET)))
-			.then(CommandNode.literal("set")
-				.then(CommandNode.argument("targets", this.targets)
-					.then(CommandNode.argument("objective", this.objective)
-						.then(CommandNode.argument("score", this.score)
-							.label(Label.PLAYERS_SET_SCORE)))))
-			.then(CommandNode.literal("get")
-				.then(CommandNode.argument("target", this.target)
-					.then(CommandNode.argument("objective", this.objective)
-						.label(Label.PLAYERS_GET_SCORE))))
-			.then(CommandNode.literal("set")
-				.then(CommandNode.argument("targets", this.targets)
-					.then(CommandNode.argument("objective", this.objective)
-						.then(CommandNode.argument("score", this.score)
-							.label(Label.PLAYERS_SET_SCORE)))))
-			.then(CommandNode.literal("add")
-				.then(CommandNode.argument("targets", this.targets)
-					.then(CommandNode.argument("objective", this.objective)
-						.then(CommandNode.argument("score", this.score)
-							.label(Label.PLAYERS_ADD_SCORE)))))
-			.then(CommandNode.literal("remove")
-				.then(CommandNode.argument("targets", this.targets)
-					.then(CommandNode.argument("objective", this.objective)
-						.then(CommandNode.argument("score", this.score)
-							.label(Label.PLAYERS_REMOVE_SCORE)))))
-			.then(CommandNode.literal("reset")
-				.then(CommandNode.argument("targets", this.targets)
-					.then(CommandNode.argument("objective", this.objective)
-						.label(Label.PLAYERS_RESET_SCORE))))
-			.then(CommandNode.literal("enable")
-				.then(CommandNode.argument("targets", this.targets)
-					.label(Label.PLAYERS_ENABLE)
-					.then(CommandNode.argument("objective", this.objective)
-						.label(Label.PLAYERS_ENABLE_OBJECTIVE))))
-			.then(CommandNode.literal("display")
-				.then(CommandNode.literal("name")
-					.then(CommandNode.argument("targets", this.targets)
-						.then(CommandNode.argument("objective", this.objective)
-							.label(Label.PLAYERS_DISPLAY)
-							.then(CommandNode.argument("name", this.displayName)
-								.label(Label.PLAYERS_DISPLAY_NAME))))
-				.then(CommandNode.literal("numberformat")
-					.then(CommandNode.argument("targets", this.targets)
-						.then(CommandNode.argument("objective", this.objective)
-							.label(Label.PLAYERS_DISPLAY_NUMBERFORMAT)
-							.then(CommandNode.argument("styled", this.style)
-								.label(Label.PLAYERS_DISPLAY_NUMBERFORMAT_STYLED))
-							.then(CommandNode.argument("fixed", this.displayName)
-								.label(Label.PLAYERS_DISPLAY_NUMBERFORMAT_FIXED))
-							.then(CommandNode.literal("blank")
-								.label(Label.PLAYERS_DISPLAY_NUMBERFORMAT_BLANK)))))))
-			.then(CommandNode.literal("operation")
-				.then(CommandNode.argument("targetObjective", this.objective)
-					.then(CommandNode.argument("operation", this.operation)
-						.then(CommandNode.argument("source", this.targets)
-							.then(CommandNode.argument("sourceObjective", this.sourceObjective)
-								.label(Label.PLAYERS_OPERATION)))))));
-	
-	public PrimitiveArgument<String> objective()
-	{
-		return this.objective;
-	}
-	
-	public PrimitiveArgument<String> criteria()
-	{
-		return this.criteria;
-	}
-	
-	public PrimitiveArgument<Component> displayName()
-	{
-		return this.displayName;
-	}
-	
-	public PrimitiveArgument<String> slot()
-	{
-		return this.slot;
-	}
-	
-	public PrimitiveArgument<RenderType> renderType()
-	{
-		return this.renderType;
-	}
-	
-	public TargetArgument target()
-	{
-		return this.target;
-	}
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	public PrimitiveArgument<Integer> score()
-	{
-		return this.score;
-	}
-	
-	public PrimitiveArgument<Operation> operation()
-	{
-		return this.operation;
-	}
-	
-	public PrimitiveArgument<String> sourceObjective()
-	{
-		return this.sourceObjective;
-	}
-	
-	public PrimitiveArgument<Style> style()
-	{
-		return this.style;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		OBJECTIVES,
-		OBJECTIVES_ADD,
-		OBJECTIVES_ADD_DISPLAYNAME,
-		OBJECTIVES_MODIFY_DISPLAYNAME,
-		OBJECTIVES_MODIFY_RENDERTYPE,
-		OBJECTIVES_MODIFY_DISPLAYAUTOUPDATE,
-		OBJECTIVES_MODIFY_NUMBERFORMAT,
-		OBJECTIVES_MODIFY_NUMBERFORMAT_STYLED,
-		OBJECTIVES_MODIFY_NUMBERFORMAT_FIXED,
-		OBJECTIVES_MODIFY_NUMBERFORMAT_BLANK,
-		OBJECTIVES_REMOVE,
-		OBJECTIVES_SETDISPLAY_SLOT,
-		OBJECTIVES_SETDISPLAY_SLOT_OBJECTIVE,
-		PLAYERS,
-		PLAYERS_LIST,
-		PLAYERS_LIST_TARGET,
-		PLAYERS_SET_SCORE,
-		PLAYERS_GET_SCORE,
-		PLAYERS_ADD_SCORE,
-		PLAYERS_REMOVE_SCORE,
-		PLAYERS_RESET_SCORE,
-		PLAYERS_ENABLE,
-		PLAYERS_ENABLE_OBJECTIVE,
-		PLAYERS_OPERATION,
-		PLAYERS_DISPLAY,
-		PLAYERS_DISPLAY_NAME,
-		PLAYERS_DISPLAY_NUMBERFORMAT,
-		PLAYERS_DISPLAY_NUMBERFORMAT_STYLED,
-		PLAYERS_DISPLAY_NUMBERFORMAT_FIXED,
-		PLAYERS_DISPLAY_NUMBERFORMAT_BLANK;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/SetBlockCommandBuilder.java

@@ -1,49 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.BlockPosArgument;
-import exopandora.worldhandler.builder.argument.BlockStateArgument;
-
-public class SetBlockCommandBuilder extends CommandBuilder
-{
-	private final BlockPosArgument pos = Arguments.blockPos();
-	private final BlockStateArgument block = Arguments.blockState();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("setblock")
-			.then(CommandNode.argument("pos", this.pos)
-					.then(CommandNode.argument("block", this.block)
-							.label(Label.SETBLOCK)
-							.then(CommandNode.literal("destroy")
-									.label(Label.DESTROY))
-							.then(CommandNode.literal("keep")
-									.label(Label.KEEP))
-							.then(CommandNode.literal("replace")
-									.label(Label.REPLACE))));
-	
-	public BlockPosArgument pos()
-	{
-		return this.pos;
-	}
-	
-	public BlockStateArgument block()
-	{
-		return this.block;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		SETBLOCK,
-		DESTROY,
-		KEEP,
-		REPLACE;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/SetSpawnCommandBuilder.java

@@ -1,52 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.AngleArgument;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.BlockPosArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class SetSpawnCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	private final BlockPosArgument pos = Arguments.blockPos();
-	private final AngleArgument angle = Arguments.angle();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("spawnpoint")
-			.then(CommandNode.argument("targets", this.targets)
-					.label(Label.SPAWNPOINT)
-					.then(CommandNode.argument("pos", this.pos)
-							.label(Label.SPAWNPOINT_POS)
-							.then(CommandNode.argument("angle", this.angle)
-									.label(Label.SPAWNPOINT_POS_ANGLE))));
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	public BlockPosArgument pos()
-	{
-		return this.pos;
-	}
-	
-	public AngleArgument angle()
-	{
-		return this.angle;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		SPAWNPOINT,
-		SPAWNPOINT_POS,
-		SPAWNPOINT_POS_ANGLE;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/SetWorldSpawnCommandBuilder.java

@@ -1,44 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.AngleArgument;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.BlockPosArgument;
-
-public class SetWorldSpawnCommandBuilder extends CommandBuilder
-{
-	private final BlockPosArgument pos = Arguments.blockPos();
-	private final AngleArgument angle = Arguments.angle();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("setworldspawn")
-			.label(Label.SET_WORLD_SPAWN)
-			.then(CommandNode.argument("pos", this.pos)
-					.label(Label.SET_WORLD_SPAWN_POS)
-					.then(CommandNode.argument("angle", this.angle)
-							.label(Label.SET_WORLD_SPAWN_POS_ANGLE)));
-	
-	public BlockPosArgument pos()
-	{
-		return this.pos;
-	}
-	
-	public AngleArgument angle()
-	{
-		return this.angle;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		SET_WORLD_SPAWN,
-		SET_WORLD_SPAWN_POS,
-		SET_WORLD_SPAWN_POS_ANGLE;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/StopCommandBuilder.java

@@ -1,14 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-public class StopCommandBuilder extends LiteralCommandBuilder
-{
-	public StopCommandBuilder()
-	{
-		super("stop", Label.STOP);
-	}
-	
-	public static enum Label
-	{
-		STOP;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/SummonCommandBuilder.java

@@ -1,52 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.BlockPosArgument;
-import exopandora.worldhandler.builder.argument.EntitySummonArgument;
-import exopandora.worldhandler.builder.argument.TagArgument;
-
-public class SummonCommandBuilder extends CommandBuilder
-{
-	private final EntitySummonArgument entity = Arguments.entitySummon();
-	private final BlockPosArgument pos = Arguments.blockPos();
-	private final TagArgument nbt = Arguments.tag();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("summon")
-			.then(CommandNode.argument("entity", this.entity)
-					.label(Label.SUMMON)
-					.then(CommandNode.argument("pos", this.pos)
-							.label(Label.SUMMON_POS)
-							.then(CommandNode.argument("nbt", this.nbt)
-									.label(Label.SUMMON_POS_NBT))));
-	
-	public EntitySummonArgument entity()
-	{
-		return this.entity;
-	}
-	
-	public BlockPosArgument pos()
-	{
-		return this.pos;
-	}
-	
-	public TagArgument nbt()
-	{
-		return this.nbt;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		SUMMON,
-		SUMMON_POS,
-		SUMMON_POS_NBT;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/TagCommandBuilder.java

@@ -1,48 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class TagCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	private final PrimitiveArgument<String> name = Arguments.word();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("tag")
-			.then(CommandNode.argument("targets", this.targets)
-					.then(CommandNode.literal("add")
-							.then(CommandNode.argument("name", this.name)
-									.label(Label.ADD)))
-					.then(CommandNode.literal("remove")
-							.then(CommandNode.argument("name", this.name)
-									.label(Label.REMOVE)))
-					.then(CommandNode.literal("list")
-							.label(Label.LIST)));
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	public PrimitiveArgument<String> name()
-	{
-		return this.name;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		ADD,
-		REMOVE,
-		LIST;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/TargetCommandBuilder.java

@@ -1,31 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class TargetCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	private final CommandNodeLiteral root;
-	
-	public TargetCommandBuilder(String root, Object label)
-	{
-		this.root = CommandNode.literal(root)
-				.then(CommandNode.argument("targets", this.targets)
-						.label(label));
-	}
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/TargetReasonCommandBuilder.java

@@ -1,41 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class TargetReasonCommandBuilder<T> extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	private final PrimitiveArgument<String> reason = Arguments.greedyString();
-	
-	private final CommandNodeLiteral root;
-	
-	public TargetReasonCommandBuilder(String root, T noReason, T reason)
-	{
-		this.root = CommandNode.literal(root)
-				.then(CommandNode.argument("targets", this.targets)
-						.label(noReason)
-						.then(CommandNode.argument("reason", this.reason)
-								.label(reason)));
-	}
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	public PrimitiveArgument<String> reason()
-	{
-		return this.reason;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/TeamCommandBuilder.java

@@ -1,91 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-import net.minecraft.network.chat.Component;
-
-public class TeamCommandBuilder extends CommandBuilder
-{
-	private final PrimitiveArgument<String> team = Arguments.word();
-	private final PrimitiveArgument<Component> displayName = Arguments.textComponent();
-	private final TargetArgument members = Arguments.target();
-	private final PrimitiveArgument<String> option = Arguments.word();
-	private final PrimitiveArgument<String> value = Arguments.string();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("team")
-			.then(CommandNode.literal("add")
-					.then(CommandNode.argument("team", this.team)
-							.label(Label.ADD)
-							.then(CommandNode.argument("displayName", this.displayName)
-									.label(Label.ADD_DISPLAYNAME))))
-			.then(CommandNode.literal("empty")
-					.then(CommandNode.argument("team", this.team)
-							.label(Label.EMPTY)))
-			.then(CommandNode.literal("join")
-					.then(CommandNode.argument("team", this.team)
-							.then(CommandNode.argument("members", this.members)
-									.label(Label.JOIN))))
-			.then(CommandNode.literal("leave")
-					.then(CommandNode.argument("members", this.members)
-							.label(Label.LEAVE)))
-			.then(CommandNode.literal("list")
-					.label(Label.LIST)
-					.then(CommandNode.argument("team", this.team)
-							.label(Label.LIST_TEAM)))
-			.then(CommandNode.literal("modify")
-					.then(CommandNode.argument("team", this.team)
-							.then(CommandNode.argument("option", this.option)
-									.then(CommandNode.argument("value", this.value)
-											.label(Label.MODIFY)))))
-			.then(CommandNode.literal("remove")
-					.then(CommandNode.argument("team", this.team)
-							.label(Label.REMOVE)));
-	
-	public PrimitiveArgument<String> team()
-	{
-		return this.team;
-	}
-	
-	public PrimitiveArgument<Component> displayName()
-	{
-		return this.displayName;
-	}
-	
-	public TargetArgument members()
-	{
-		return this.members;
-	}
-	
-	public PrimitiveArgument<String> option()
-	{
-		return this.option;
-	}
-	
-	public PrimitiveArgument<String> value()
-	{
-		return this.value;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		ADD,
-		ADD_DISPLAYNAME,
-		EMPTY,
-		JOIN,
-		LEAVE,
-		LIST,
-		LIST_TEAM,
-		MODIFY,
-		REMOVE;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/TimeCommandBuilder.java

@@ -1,59 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.TimeArgument;
-
-public class TimeCommandBuilder extends CommandBuilder
-{
-	private final TimeArgument time = Arguments.time();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("time")
-			.then(CommandNode.literal("add")
-					.then(CommandNode.argument("time", this.time)
-							.label(Label.ADD)))
-			.then(CommandNode.literal("query")
-					.then(CommandNode.literal("day")
-							.label(Label.QUERY_DAY))
-					.then(CommandNode.literal("daytime")
-							.label(Label.QUERY_DAYTIME))
-					.then(CommandNode.literal("gametime")
-							.label(Label.QUERY_GAMETIME)))
-			.then(CommandNode.literal("set")
-					.then(CommandNode.argument("time", this.time)
-							.label(Label.SET))
-					.then(CommandNode.literal("day")
-							.label(Label.SET_DAY))
-					.then(CommandNode.literal("midnight")
-							.label(Label.SET_MIDNIGHT))
-					.then(CommandNode.literal("night")
-							.label(Label.SET_NIGHT))
-					.then(CommandNode.literal("noon")
-							.label(Label.SET_NOON)));
-	
-	public TimeArgument time()
-	{
-		return this.time;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		ADD,
-		QUERY_DAY,
-		QUERY_DAYTIME,
-		QUERY_GAMETIME,
-		SET,
-		SET_DAY,
-		SET_MIDNIGHT,
-		SET_NIGHT,
-		SET_NOON;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/TriggerCommandBuilder.java

@@ -1,44 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.PrimitiveArgument;
-
-public class TriggerCommandBuilder extends CommandBuilder
-{
-	private final PrimitiveArgument<String> objective = Arguments.word();
-	private final PrimitiveArgument<Integer> value = Arguments.intArg();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("trigger")
-			.then(CommandNode.argument("objective", this.objective)
-					.then(CommandNode.literal("add")
-							.then(CommandNode.argument("value", this.value)
-									.label(Label.ADD)))
-					.then(CommandNode.literal("set")
-							.then(CommandNode.argument("value", this.value)
-									.label(Label.SET))));
-	
-	public PrimitiveArgument<String> objective()
-	{
-		return this.objective;
-	}
-	
-	public PrimitiveArgument<Integer> value()
-	{
-		return this.value;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		ADD,
-		SET;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/UsercontentCommandBuilder.java

@@ -1,94 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Map;
-import java.util.Set;
-
-import javax.annotation.Nullable;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.IDeserializableArgument;
-import exopandora.worldhandler.usercontent.factory.ArgumentFactory;
-import exopandora.worldhandler.usercontent.model.ArgumentType;
-import exopandora.worldhandler.usercontent.model.JsonArgument;
-
-public class UsercontentCommandBuilder extends CommandBuilder
-{
-	private final Map<String, IDeserializableArgument> arguments = new HashMap<String, IDeserializableArgument>();
-	private final Set<IDeserializableArgument> player = new HashSet<IDeserializableArgument>();
-	private final CommandNodeLiteral root;
-	private final String label;
-	
-	public UsercontentCommandBuilder(JsonArgument argument, String label)
-	{
-		this.root = CommandNode.literal(argument.getName()).label(argument.getLabel());
-		this.label = label;
-		this.createChildren(this.root, argument.getChildren());
-	}
-	
-	private void createChildren(CommandNode<?> root, List<JsonArgument> children)
-	{
-		if(children != null)
-		{
-			for(JsonArgument child : children)
-			{
-				CommandNode<?> node = this.createNode(child);
-				this.createChildren(node, child.getChildren());
-				root.then(node);
-			}
-		}
-	}
-	
-	private CommandNode<?> createNode(JsonArgument json)
-	{
-		if(json.getType() == null)
-		{
-			return CommandNode.literal(json.getName()).label(json.getLabel());
-		}
-		
-		IDeserializableArgument argument = this.arguments.computeIfAbsent(json.getName(), key -> ArgumentFactory.createArgument(json));
-		
-		if(ArgumentType.PLAYER.equals(json.getType()))
-		{
-			this.player.add(argument);
-		}
-		
-		return CommandNode.argument(json.getName(), argument).label(json.getLabel());
-	}
-	
-	public String getLabel()
-	{
-		return label;
-	}
-	
-	public void setPlayerName(String username)
-	{
-		this.player.forEach(argument -> argument.deserialize(username));
-	}
-	
-	@Nullable
-	public IDeserializableArgument getArgument(String name)
-	{
-		return this.arguments.get(name);
-	}
-	
-	public void setArgument(String key, String value)
-	{
-		IDeserializableArgument argument = this.arguments.get(key);
-		
-		if(argument != null)
-		{
-			argument.deserialize(value);
-		}
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/WHCommandBuilder.java

@@ -1,64 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.BlockPredicateArgument;
-import exopandora.worldhandler.builder.argument.BlockStateArgument;
-
-public class WHCommandBuilder extends CommandBuilder
-{
-	private final BlockStateArgument block = Arguments.blockState();
-	private final BlockPredicateArgument filter = Arguments.blockPredicate();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("wh")
-			.then(CommandNode.literal("clone")
-					.label(Label.CLONE)
-					.then(CommandNode.literal("filtered")
-							.then(CommandNode.argument("filter", this.filter)
-									.label(Label.CLONE_FILTERED)))
-					.then(CommandNode.literal("masked")
-							.label(Label.CLONE_MASKED))
-					.then(CommandNode.literal("replace")
-							.label(Label.CLONE_REPLACE)))
-			.then(CommandNode.literal("fill")
-					.then(CommandNode.argument("block", this.block)
-							.label(Label.FILL)))
-			.then(CommandNode.literal("pos1")
-					.label(Label.POS1))
-			.then(CommandNode.literal("pos2")
-					.label(Label.POS2))
-			.then(CommandNode.literal("replace")
-					.then(CommandNode.argument("block", this.block)
-							.then(CommandNode.argument("filter", this.filter)
-									.label(Label.REPLACE))));
-	
-	public BlockStateArgument block()
-	{
-		return this.block;
-	}
-	
-	public BlockPredicateArgument filter()
-	{
-		return this.filter;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		CLONE,
-		CLONE_FILTERED,
-		CLONE_MASKED,
-		CLONE_REPLACE,
-		FILL,
-		POS1,
-		POS2,
-		REPLACE;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/WeatherCommandBuilder.java

@@ -1,42 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.TimeArgument;
-
-public class WeatherCommandBuilder extends CommandBuilder
-{
-	private final TimeArgument duration = Arguments.time();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("weather")
-			.then(CommandNode.literal("clear")
-					.label(Label.CLEAR)
-					.then(CommandNode.argument("duration", this.duration)
-							.label(Label.CLEAR_DURATION)))
-			.then(CommandNode.literal("rain")
-					.label(Label.RAIN)
-					.then(CommandNode.argument("duration", this.duration)
-							.label(Label.RAIN_DURATION)))
-			.then(CommandNode.literal("thunder")
-					.label(Label.THUNDER)
-					.then(CommandNode.argument("duration", this.duration)
-							.label(Label.THUNDER_DURATION)));
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		CLEAR,
-		CLEAR_DURATION,
-		RAIN,
-		RAIN_DURATION,
-		THUNDER,
-		THUNDER_DURATION;
-	}
-}

src/main/java/exopandora/worldhandler/builder/impl/WhitelistCommandBuilder.java

@@ -1,49 +0,0 @@
-package exopandora.worldhandler.builder.impl;
-
-import exopandora.worldhandler.builder.CommandBuilder;
-import exopandora.worldhandler.builder.CommandNode;
-import exopandora.worldhandler.builder.CommandNodeLiteral;
-import exopandora.worldhandler.builder.argument.Arguments;
-import exopandora.worldhandler.builder.argument.TargetArgument;
-
-public class WhitelistCommandBuilder extends CommandBuilder
-{
-	private final TargetArgument targets = Arguments.target();
-	
-	private final CommandNodeLiteral root = CommandNode.literal("whitelist")
-			.then(CommandNode.literal("add")
-					.then(CommandNode.argument("target", this.targets)
-							.label(Label.ADD)))
-			.then(CommandNode.literal("remove")
-					.then(CommandNode.argument("target", this.targets)
-							.label(Label.REMOVE)))
-			.then(CommandNode.literal("reload")
-					.label(Label.RELOAD))
-			.then(CommandNode.literal("on")
-					.label(Label.ON))
-			.then(CommandNode.literal("off")
-					.label(Label.OFF))
-			.then(CommandNode.literal("list")
-					.label(Label.LIST));
-	
-	public TargetArgument targets()
-	{
-		return this.targets;
-	}
-	
-	@Override
-	protected CommandNodeLiteral root()
-	{
-		return this.root;
-	}
-	
-	public static enum Label
-	{
-		ADD,
-		REMOVE,
-		RELOAD,
-		ON,
-		OFF,
-		LIST;
-	}
-}