ffs

.github/ISSUE_TEMPLATE/bug.yml

@@ -1,67 +0,0 @@
-name: Iris Bug Report
-description: File a bug report for Iris
-labels: [ bug ]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thank you for taking the time to fill this out!
-        If this does not work for you, feel free to use the [blank](https://github.com/VolmitSoftware/Iris/issues/new) format.
-  - type: textarea
-    id: how
-    attributes:
-      label: Problem
-      description: Please give a text description of how you reached the problem
-      value: |
-        1. Install Iris...
-        2. Do this...
-        3. Do that...
-        4. Observe the error...
-    validations:
-      required: true
-  - type: textarea
-    id: what
-    attributes:
-      label: Solution
-      description: Explain where you think the problem comes from (optional)
-      placeholder: The code to place a is missing b and c...
-    validations:
-      required: false
-  - type: dropdown
-    id: mcversion
-    attributes:
-      label: Minecraft Version
-      description: What version of Minecraft is the server on?
-      options:
-        - 1.14.X
-        - 1.15.X
-        - 1.16.X
-        - 1.17
-        - 1.17.1
-        - 1.18
-        - 1.19
-        - 1.20
-        - 1.21
-        - 1.22
-    validations:
-      required: true
-  - type: input
-    id: irisversion
-    attributes:
-      label: Iris Version
-      description: What version of Iris are you running? (see console)
-      placeholder: DO NOT SAY "LATEST"
-    validations:
-      required: true
-  - type: input
-    id: logs
-    attributes:
-      label: Log
-      description: Paste a full log. Always use [mclogs](https://mclo.gs) Or [Pastebin](https://pastebin.com/). Must not be a crash report. Must be a full log. Must not be a screenshot of a log.
-      placeholder: https://mslog.gs/...
-    validations:
-      required: true
-  - type: markdown
-    id: thanks
-    attributes:
-      value: "Thank you for filling out the form! We will be with you soon. Please do not ask support to review your report."

.github/ISSUE_TEMPLATE/feature.yml

@@ -1,46 +0,0 @@
-name: Iris Feature Request
-description: File a feature request for Iris. If you want to report a bug this is not the place.
-labels: [ feature ]
-body:
-  - type: markdown
-    attributes:
-      value: |
-        Thank you for taking the time to fill this out!
-        If this does not work for you, feel free to use the [blank](https://github.com/VolmitSoftware/Iris/issues/new) format.
-  - type: dropdown
-    id: arc
-    attributes:
-      label: Adding, Removing, or Changing
-      description: What are you doing
-      options:
-        - Adding
-        - Removing
-        - Changing
-    validations:
-      required: true
-  - type: input
-    id: atype
-    attributes:
-      label: Type of Modification
-      description: What is it for?
-      value: I want to ...
-    validations:
-      required: true
-  - type: textarea
-    id: desc
-    attributes:
-      label: What are you trying to modify
-      description: Give as detailed of a description as you can for the modification that you want done (include pictures if applicable)
-      value: The way I would implement this is ...
-    validations:
-      required: true
-  - type: textarea
-    id: alternative
-    attributes:
-      label: Alternatives
-      description: What alternatives have you considered?
-      value: If this could not be implemented I would ...
-  - type: markdown
-    id: thanks
-    attributes:
-      value: "Thank you for filling out the form! We will be with you soon. Please do not ask support to review your report."

.gitignore

@@ -1,6 +1,5 @@
 
 build/
-libs/
 
 .gradle/
 
@@ -10,4 +9,4 @@ libs/
 
 collection/
 
-/core/src/main/java/com/volmit/iris/util/uniques/
+src/main/java/com/volmit/iris/util/uniques/

LICENSE.md

@@ -1,518 +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,46 +1,53 @@
-# Iris
+# IrisBukkit
 
 The master branch is for the latest version of minecraft.
 
-# [Support](https://discord.gg/3xxPTpT) **|** [Documentation](https://docs.volmit.com/iris/) **|** [Git](https://github.com/IrisDimensions)
+# [Support](https://discord.gg/3xxPTpT) **|** [Documentation](https://docs.volmit.com/iris/) **
+|** [Git](https://github.com/IrisDimensions)
 
 # Building
 
-Building Iris is fairly simple, though you will need to setup a few things if your system has never been used for java
+Building IrisBukkit is fairly simple, though you will need to setup a few things if your system has never been used for
+java
 development.
 
-Consider supporting our development by buying Iris on spigot! We work hard to make Iris the best it can be for everyone.
-
-## Preface: if you need help compiling and you are a developer / intend to help out in the community or with development we would love to help you regardless in the discord! however do not come to the discord asking for free copies, or a tutorial on how to compile.
+Consider supporting our development by buying IrisBukkit on spigot! We work hard to make IrisBukkit the best it can be
+for everyone.
 
 ### Command Line Builds
 
-1. Install [Java JDK 21](https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html)
+1. Install [Java JDK 17](https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html)
 2. Set the JDK installation path to `JAVA_HOME` as an environment variable.
     * Windows
         1. Start > Type `env` and press Enter
         2. Advanced > Environment Variables
         3. Under System Variables, click `New...`
         4. Variable Name: `JAVA_HOME`
-        5. Variable Value: `C:\Program Files\Java\jdk-21.0.1` (verify this exists after installing java don't just copy
+        5. Variable Value: `C:\Program Files\Java\jdk-17.0.1` (verify this exists after installing java don't just copy
            the example text)
     * MacOS
-        1. Run `/usr/libexec/java_home -V` and look for Java 21
+        1. Run `/usr/libexec/java_home -V` and look for Java 17
         2. Run `sudo nano ~/.zshenv`
         3. Add `export JAVA_HOME=$(/usr/libexec/java_home)` as a new line
         4. Use `CTRL + X`, then Press `Y`, Then `ENTER`
         5. Quit & Reopen Terminal and verify with `echo $JAVA_HOME`. It should print a directory
-3. Once the project has setup, run `gradlew iris`
-4. The Iris jar will be placed in `Iris/build/Iris-XXX-XXX.jar` Enjoy! Consider supporting us by buying it on spigot!
+3. If this is your first time building IrisBukkit for MC 1.18+ run `gradlew setup` inside the root IrisBukkit project
+   folder.
+   Otherwise, skip this step. Grab a coffee, this may take up to 5 minutes depending on your cpu & internet connection.
+4. Once the project has setup, run `gradlew iris`
+5. The IrisBukkit jar will be placed in `IrisBukkit/build/IrisBukkit-XXX-XXX.jar` Enjoy! Consider supporting us by
+   buying it on spigot!
 
 ### IDE Builds (for development)
 
-* Configure ITJ Gradle to use JDK 21 (in settings, search for gradle)
-* Add a build line in the build.gradle for your own build task to directly compile Iris into your plugins folder if you
+* Run `gradlew setup` any time you get dependency issues with craftbukkit
+* Configure ITJ Gradle to use JDK 17 (in settings, search for gradle)
+* Add a build line in the build.gradle for your own build task to directly compile IrisBukkit into your plugins folder
+  if you
   prefer.
 * Resync the project & run your newly created task (under the development folder in gradle tasks!)
 
-# Iris Toolbelt
+# IrisBukkit Toolbelt
 
 Everyone needs a tool-belt.
 
@@ -66,6 +73,7 @@ IrisAccess access=IrisToolbelt.createWorld() // If you like builders...
   .name("myWorld") // The world name
   .dimension("terrifyinghands")
   .seed(69133742) // The world seed
+  .headless(true)  // Headless make gen go fast
   .pregen(PregenTask // Define a pregen job to run
   .builder()
     .center(new Position2(0,0)) // REGION coords (1 region = 32x32 chunks)

build.gradle

@@ -0,0 +1,41 @@
+plugins {
+    id 'java'
+    id "io.freefair.lombok" version "6.3.0"
+}
+
+group 'com.volmit.iris'
+version '1.0-SNAPSHOT'
+
+jar {
+    manifest {
+        attributes('Contains-Sources': 'java,class')
+    }
+}
+
+allprojects {
+    apply plugin: 'java'
+
+    repositories {
+        maven { url "https://arcanearts.jfrog.io/artifactory/archives" }
+        mavenCentral()
+    }
+
+    dependencies {
+        compileOnly 'org.projectlombok:lombok:1.18.24'
+        annotationProcessor 'org.projectlombok:lombok:1.18.24'
+        annotationProcessor 'systems.manifold:manifold-ext:2022.1.19'
+        implementation 'art.arcane:Source:22.9.3'
+        implementation 'art.arcane:Cram:22.9.3'
+        implementation 'art.arcane:Amulet:22.9.5'
+        implementation 'com.google.code.gson:gson:2.9.0'
+        implementation 'com.github.ben-manes.caffeine:caffeine:3.1.1'
+        testImplementation 'org.junit.jupiter:junit-jupiter-api:5.8.2'
+        testRuntimeOnly 'org.junit.jupiter:junit-jupiter-engine:5.8.2'
+        testAnnotationProcessor 'systems.manifold:manifold-ext:2022.1.19'
+    }
+}
+
+dependencies {
+
+}
+

build.gradle.kts

@@ -1,281 +0,0 @@
-import de.undercouch.gradle.tasks.download.Download
-import xyz.jpenilla.runpaper.task.RunServer
-import kotlin.system.exitProcess
-
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2021 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-buildscript {
-    repositories.maven("https://jitpack.io")
-    dependencies.classpath("com.github.VolmitSoftware:NMSTools:c88961416f")
-}
-
-plugins {
-    java
-    `java-library`
-    alias(libs.plugins.download)
-    alias(libs.plugins.runPaper)
-}
-
-group = "com.volmit"
-version = "3.8.0-1.20.1-1.21.10"
-
-apply<ApiGenerator>()
-
-// ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
-// ======================== WINDOWS =============================
-registerCustomOutputTask("Cyberpwn", "C://Users/cyberpwn/Documents/development/server/plugins")
-registerCustomOutputTask("Psycho", "C://Dan/MinecraftDevelopment/Server/plugins")
-registerCustomOutputTask("ArcaneArts", "C://Users/arcane/Documents/development/server/plugins")
-registerCustomOutputTask("Coco", "D://mcsm/plugins")
-registerCustomOutputTask("Strange", "D://Servers/1.17 Test Server/plugins")
-registerCustomOutputTask("Vatuu", "D://Minecraft/Servers/1.19.4/plugins")
-registerCustomOutputTask("CrazyDev22", "C://Users/Julian/Desktop/server/plugins")
-registerCustomOutputTask("PixelFury", "C://Users/repix/workplace/Iris/1.21.3 - Development-Public-v3/plugins")
-registerCustomOutputTask("PixelFuryDev", "C://Users/repix/workplace/Iris/1.21 - Development-v3/plugins")
-// ========================== UNIX ==============================
-registerCustomOutputTaskUnix("CyberpwnLT", "/Users/danielmills/development/server/plugins")
-registerCustomOutputTaskUnix("PsychoLT", "/Users/brianfopiano/Developer/RemoteGit/Server/plugins")
-registerCustomOutputTaskUnix("PixelMac", "/Users/test/Desktop/mcserver/plugins")
-registerCustomOutputTaskUnix("CrazyDev22LT", "/home/julian/Desktop/server/plugins")
-// ==============================================================
-
-val serverMinHeap = "10G"
-val serverMaxHeap = "10G"
-val additionalFlags = "-XX:+AlwaysPreTouch"
-//Valid values are: none, truecolor, indexed256, indexed16, indexed8
-val color = "truecolor"
-val errorReporting = findProperty("errorReporting") as Boolean? ?: false
-
-val nmsBindings = mapOf(
-        "v1_21_R6" to "1.21.10-R0.1-SNAPSHOT",
-        "v1_21_R5" to "1.21.8-R0.1-SNAPSHOT",
-        "v1_21_R4" to "1.21.5-R0.1-SNAPSHOT",
-        "v1_21_R3" to "1.21.4-R0.1-SNAPSHOT",
-        "v1_21_R2" to "1.21.3-R0.1-SNAPSHOT",
-        "v1_21_R1" to "1.21.1-R0.1-SNAPSHOT",
-        "v1_20_R4" to "1.20.6-R0.1-SNAPSHOT",
-        "v1_20_R3" to "1.20.4-R0.1-SNAPSHOT",
-        "v1_20_R2" to "1.20.2-R0.1-SNAPSHOT",
-        "v1_20_R1" to "1.20.1-R0.1-SNAPSHOT",
-)
-val jvmVersion = mapOf<String, Int>()
-nmsBindings.forEach { (key, value) ->
-    project(":nms:$key") {
-        apply<JavaPlugin>()
-
-        nmsBinding {
-            jvm = jvmVersion.getOrDefault(key, 21)
-            version = value
-            type = NMSBinding.Type.DIRECT
-        }
-
-        dependencies {
-            compileOnly(project(":core"))
-            compileOnly(rootProject.libs.annotations)
-            compileOnly(rootProject.libs.byteBuddy.core)
-        }
-    }
-
-    tasks.register<RunServer>("runServer-$key") {
-        group = "servers"
-        minecraftVersion(value.split("-")[0])
-        minHeapSize = serverMinHeap
-        maxHeapSize = serverMaxHeap
-        pluginJars(tasks.jar.flatMap { it.archiveFile })
-        javaLauncher = javaToolchains.launcherFor { languageVersion = JavaLanguageVersion.of(jvmVersion.getOrDefault(key, 21))}
-        runDirectory.convention(layout.buildDirectory.dir("run/$key"))
-        systemProperty("disable.watchdog", "true")
-        systemProperty("net.kyori.ansi.colorLevel", color)
-        systemProperty("com.mojang.eula.agree", true)
-        systemProperty("iris.suppressReporting", !errorReporting)
-        jvmArgs("-javaagent:${project(":core:agent").tasks.jar.flatMap { it.archiveFile }.get().asFile.absolutePath}")
-        jvmArgs(additionalFlags.split(' '))
-    }
-}
-
-val jarJar: Configuration by configurations.creating
-dependencies {
-    for (key in nmsBindings.keys) {
-        implementation(project(":nms:$key", "reobf"))
-    }
-    implementation(project(":core", "shadow"))
-    jarJar(project(":core:agent"))
-}
-
-tasks {
-    jar {
-        duplicatesStrategy = DuplicatesStrategy.EXCLUDE
-        from(jarJar, configurations.runtimeClasspath.map { it.resolve().map(::zipTree) })
-        archiveFileName.set("Iris-${project.version}.jar")
-    }
-
-    register<Copy>("iris") {
-        group = "iris"
-        dependsOn("jar")
-        from(layout.buildDirectory.file("libs/Iris-${project.version}.jar"))
-        into(layout.buildDirectory)
-    }
-
-    register<Copy>("irisDev") {
-        group = "iris"
-        from(project(":core").layout.buildDirectory.files("libs/core-javadoc.jar", "libs/core-sources.jar"))
-        rename { it.replace("core", "Iris-${project.version}") }
-        into(layout.buildDirectory)
-        dependsOn(":core:sourcesJar")
-        dependsOn(":core:javadocJar")
-    }
-
-    val cli = file("sentry-cli.exe")
-    register<Download>("downloadCli") {
-        group = "io.sentry"
-        src("https://release-registry.services.sentry.io/apps/sentry-cli/latest?response=download&arch=x86_64&platform=${System.getProperty("os.name")}&package=sentry-cli")
-        dest(cli)
-
-        doLast {
-            cli.setExecutable(true)
-        }
-    }
-
-    register("release") {
-        group = "io.sentry"
-        dependsOn("downloadCli")
-        doLast {
-            val url = "http://sentry.volmit.com:8080"
-            val authToken = project.findProperty("sentry.auth.token") ?: System.getenv("SENTRY_AUTH_TOKEN")
-            val org = "sentry"
-            val projectName = "iris"
-            exec(cli, "--url", url , "--auth-token", authToken, "releases", "new", "-o", org, "-p", projectName, version)
-            exec(cli, "--url", url , "--auth-token", authToken, "releases", "set-commits", "-o", org, "-p", projectName, version, "--auto", "--ignore-missing")
-            //exec(cli, "--url", url, "--auth-token", authToken, "releases", "finalize", "-o", org, "-p", projectName, version)
-            cli.delete()
-        }
-    }
-}
-
-fun exec(vararg command: Any) {
-    val p = ProcessBuilder(command.map { it.toString() })
-        .start()
-    p.inputStream.reader().useLines { it.forEach(::println) }
-    p.errorStream.reader().useLines { it.forEach(::println) }
-    p.waitFor()
-}
-
-configurations.configureEach {
-    resolutionStrategy.cacheChangingModulesFor(60, "minutes")
-    resolutionStrategy.cacheDynamicVersionsFor(60, "minutes")
-}
-
-allprojects {
-    apply<JavaPlugin>()
-
-    repositories {
-        mavenCentral()
-        maven("https://repo.papermc.io/repository/maven-public/")
-        maven("https://repo.codemc.org/repository/maven-public/")
-
-        maven("https://jitpack.io") // EcoItems, score
-        maven("https://repo.nexomc.com/releases/") // nexo
-        maven("https://maven.devs.beer/") // itemsadder
-        maven("https://repo.extendedclip.com/releases/") // placeholderapi
-        maven("https://mvn.lumine.io/repository/maven-public/") // mythic
-        maven("https://nexus.phoenixdevt.fr/repository/maven-public/") //MMOItems
-        maven("https://repo.onarandombox.com/content/groups/public/") //Multiverse Core
-    }
-
-    dependencies {
-        // Provided or Classpath
-        compileOnly(rootProject.libs.lombok)
-        annotationProcessor(rootProject.libs.lombok)
-    }
-
-    /**
-     * We need parameter meta for the decree command system
-     */
-    tasks {
-        compileJava {
-            options.compilerArgs.add("-parameters")
-            options.encoding = "UTF-8"
-        }
-
-        javadoc {
-            options.encoding = "UTF-8"
-            options.quiet()
-            //options.addStringOption("Xdoclint:none") // TODO: Re-enable this
-        }
-
-        register<Jar>("sourcesJar") {
-            archiveClassifier.set("sources")
-            from(sourceSets.main.map { it.allSource })
-        }
-
-        register<Jar>("javadocJar") {
-            archiveClassifier.set("javadoc")
-            from(javadoc.map { it.destinationDir!! })
-        }
-    }
-}
-
-if (JavaVersion.current().toString() != "21") {
-    System.err.println()
-    System.err.println("=========================================================================================================")
-    System.err.println("You must run gradle on Java 21. You are using " + JavaVersion.current())
-    System.err.println()
-    System.err.println("=== For IDEs ===")
-    System.err.println("1. Configure the project for Java 21")
-    System.err.println("2. Configure the bundled gradle to use Java 21 in settings")
-    System.err.println()
-    System.err.println("=== For Command Line (gradlew) ===")
-    System.err.println("1. Install JDK 21 from https://www.oracle.com/java/technologies/javase/jdk21-archive-downloads.html")
-    System.err.println("2. Set JAVA_HOME environment variable to the new jdk installation folder such as C:\\Program Files\\Java\\jdk-21.0.4")
-    System.err.println("3. Open a new command prompt window to get the new environment variables if need be.")
-    System.err.println("=========================================================================================================")
-    System.err.println()
-    exitProcess(69)
-}
-
-
-fun registerCustomOutputTask(name: String, path: String) {
-    if (!System.getProperty("os.name").lowercase().contains("windows")) {
-        return
-    }
-
-    tasks.register<Copy>("build$name") {
-        group = "development"
-        outputs.upToDateWhen { false }
-        dependsOn("iris")
-        from(layout.buildDirectory.file("Iris-${project.version}.jar"))
-        into(file(path))
-        rename { "Iris.jar" }
-    }
-}
-
-fun registerCustomOutputTaskUnix(name: String, path: String) {
-    if (System.getProperty("os.name").lowercase().contains("windows")) {
-        return
-    }
-
-    tasks.register<Copy>("build$name") {
-        group = "development"
-        outputs.upToDateWhen { false }
-        dependsOn("iris")
-        from(layout.buildDirectory.file("Iris-${project.version}.jar"))
-        into(file(path))
-        rename { "Iris.jar" }
-    }
-}

buildSrc/build.gradle.kts

@@ -1,16 +0,0 @@
-plugins {
-    kotlin("jvm") version embeddedKotlinVersion
-}
-
-repositories {
-    mavenCentral()
-    gradlePluginPortal()
-    maven("https://jitpack.io")
-}
-
-dependencies {
-    implementation("org.ow2.asm:asm:9.8")
-    implementation("com.github.VolmitSoftware:NMSTools:c88961416f")
-    implementation("io.papermc.paperweight:paperweight-userdev:2.0.0-beta.18")
-    implementation("org.jetbrains.kotlinx:kotlinx-coroutines-core:1.10.2")
-}

buildSrc/src/main/kotlin/ApiGenerator.kt

@@ -1,121 +0,0 @@
-import org.gradle.api.DefaultTask
-import org.gradle.api.Plugin
-import org.gradle.api.Project
-import org.gradle.api.publish.PublishingExtension
-import org.gradle.api.publish.maven.MavenPublication
-import org.gradle.api.tasks.InputFile
-import org.gradle.api.tasks.OutputFile
-import org.gradle.api.tasks.TaskAction
-import org.gradle.jvm.tasks.Jar
-import org.objectweb.asm.*
-import java.io.File
-import java.util.jar.JarFile
-import java.util.jar.JarOutputStream
-
-class ApiGenerator : Plugin<Project> {
-    override fun apply(target: Project): Unit = with(target) {
-        plugins.apply("maven-publish")
-        val task = tasks.register("irisApi", GenerateApiTask::class.java)
-        extensions.findByType(PublishingExtension::class.java)!!.apply {
-            repositories.maven {
-                it.name = "deployDir"
-                it.url = targetDirectory.toURI()
-            }
-
-            publications.create("maven", MavenPublication::class.java) {
-                it.groupId = name
-                it.version = version.toString()
-                it.artifact(task)
-            }
-        }
-    }
-}
-
-abstract class GenerateApiTask : DefaultTask() {
-    init {
-        group = "iris"
-        dependsOn("jar")
-        finalizedBy("publishMavenPublicationToDeployDirRepository")
-        doLast {
-            logger.lifecycle("The API is located at ${outputFile.absolutePath}")
-        }
-    }
-
-    @InputFile
-    val inputFile: File = project.tasks
-        .named("jar", Jar::class.java)
-        .get()
-        .archiveFile
-        .get()
-        .asFile
-
-    @OutputFile
-    val outputFile: File = project.targetDirectory.resolve(inputFile.name)
-
-    @TaskAction
-    fun generate() {
-        JarFile(inputFile).use { jar ->
-            JarOutputStream(outputFile.apply { parentFile?.mkdirs() }.outputStream()).use { out ->
-                jar.stream()
-                    .parallel()
-                    .filter { !it.isDirectory }
-                    .filter { it.name.endsWith(".class") }
-                    .forEach {
-                        val bytes = jar.getInputStream(it).use { input ->
-                            val writer = ClassWriter(ClassWriter.COMPUTE_MAXS)
-                            val visitor = MethodClearingVisitor(writer)
-                            ClassReader(input).accept(visitor, 0)
-                            writer.toByteArray()
-                        }
-
-                        synchronized(out) {
-                            out.putNextEntry(it)
-                            out.write(bytes)
-                            out.closeEntry()
-                        }
-                    }
-            }
-        }
-    }
-}
-
-val Project.targetDirectory: File get() {
-    val dir = System.getenv("DEPLOY_DIR") ?: return project.layout.buildDirectory.dir("api").get().asFile
-    return File(dir)
-}
-
-private class MethodClearingVisitor(
-    cv: ClassVisitor
-) : ClassVisitor(Opcodes.ASM9, cv) {
-
-    override fun visitMethod(
-        access: Int,
-        name: String?,
-        descriptor: String?,
-        signature: String?,
-        exceptions: Array<out String>?
-    ) = ExceptionThrowingMethodVisitor(super.visitMethod(access, name, descriptor, signature, exceptions))
-}
-
-private class ExceptionThrowingMethodVisitor(
-    mv: MethodVisitor
-) : MethodVisitor(Opcodes.ASM9, mv) {
-
-    override fun visitCode() {
-        if (mv == null) return
-        mv.visitCode()
-
-        mv.visitTypeInsn(Opcodes.NEW, "java/lang/IllegalStateException")
-        mv.visitInsn(Opcodes.DUP)
-        mv.visitLdcInsn("Only API")
-        mv.visitMethodInsn(
-            Opcodes.INVOKESPECIAL,
-            "java/lang/IllegalStateException",
-            "<init>", "(Ljava/lang/String;)V", false
-        )
-        mv.visitInsn(Opcodes.ATHROW)
-
-        mv.visitMaxs(0, 0)
-        mv.visitEnd()
-    }
-}

buildSrc/src/main/kotlin/NMSBinding.kt

@@ -1,182 +0,0 @@
-import NMSBinding.Type
-import com.volmit.nmstools.NMSToolsExtension
-import com.volmit.nmstools.NMSToolsPlugin
-import io.papermc.paperweight.userdev.PaperweightUser
-import io.papermc.paperweight.userdev.PaperweightUserDependenciesExtension
-import io.papermc.paperweight.userdev.PaperweightUserExtension
-import io.papermc.paperweight.userdev.attribute.Obfuscation
-import io.papermc.paperweight.util.constants.REOBF_CONFIG
-import kotlinx.coroutines.Dispatchers
-import kotlinx.coroutines.launch
-import kotlinx.coroutines.runBlocking
-import org.gradle.api.*
-import org.gradle.api.attributes.Bundling
-import org.gradle.api.attributes.Category
-import org.gradle.api.attributes.LibraryElements
-import org.gradle.api.attributes.Usage
-import org.gradle.api.model.ObjectFactory
-import org.gradle.api.plugins.JavaPluginExtension
-import org.gradle.api.tasks.TaskAction
-import org.gradle.internal.extensions.core.extra
-import org.gradle.jvm.toolchain.JavaLanguageVersion
-import org.gradle.jvm.toolchain.JavaToolchainService
-import org.gradle.work.DisableCachingByDefault
-import java.io.RandomAccessFile
-import javax.inject.Inject
-
-class NMSBinding : Plugin<Project> {
-    override fun apply(target: Project): Unit = with(target) {
-        val config = extra["nms"] as? Config ?: throw GradleException("No NMS binding configuration found")
-        val jvm = config.jvm
-        val type = config.type
-
-        if (type == Type.USER_DEV) {
-            plugins.apply(PaperweightUser::class.java)
-            dependencies.extensions.findByType(PaperweightUserDependenciesExtension::class.java)
-                ?.paperDevBundle(config.version)
-
-            val java = extensions.findByType(JavaPluginExtension::class.java) ?: throw GradleException("Java plugin not found")
-            java.toolchain.languageVersion.set(JavaLanguageVersion.of(jvm))
-
-            val javaToolchains = project.extensions.getByType(JavaToolchainService::class.java) ?: throw GradleException("Java toolchain service not found")
-            extensions.configure(PaperweightUserExtension::class.java) {
-                it.javaLauncher.set(javaToolchains.launcherFor(java.toolchain))
-            }
-        } else {
-            extra["nmsTools.useBuildTools"] = type == Type.BUILD_TOOLS
-            plugins.apply(NMSToolsPlugin::class.java)
-            extensions.configure(NMSToolsExtension::class.java) {
-                it.jvm.set(jvm)
-                it.version.set(config.version)
-            }
-
-            configurations.register(REOBF_CONFIG) { conf ->
-                conf.isCanBeConsumed = true
-                conf.isCanBeResolved = false
-                conf.attributes {
-                    it.attribute(Usage.USAGE_ATTRIBUTE, objects.named(Usage.JAVA_RUNTIME))
-                    it.attribute(Category.CATEGORY_ATTRIBUTE, objects.named(Category.LIBRARY))
-                    it.attribute(LibraryElements.LIBRARY_ELEMENTS_ATTRIBUTE, objects.named(LibraryElements.JAR))
-                    it.attribute(Bundling.BUNDLING_ATTRIBUTE, objects.named(Bundling.EXTERNAL))
-                    it.attribute(Obfuscation.OBFUSCATION_ATTRIBUTE, objects.named(Obfuscation.OBFUSCATED))
-                }
-                conf.outgoing.artifact(tasks.named("remap"))
-            }
-        }
-
-        val (major, minor) = config.version.parseVersion()
-        if (major <= 20 && minor <= 4) return@with
-        tasks.register("convert", ConversionTask::class.java, type)
-        tasks.named("compileJava") { it.dependsOn("convert") }
-        rootProject.tasks.named("prepareKotlinBuildScriptModel") { it.dependsOn("$path:convert") }
-    }
-
-    @DisableCachingByDefault
-    abstract class ConversionTask @Inject constructor(type: Type) : DefaultTask() {
-        private val pattern: Regex
-        private val replacement: String
-
-        init {
-            group = "nms"
-            inputs.property("type", type)
-            val java = project.extensions.findByType(JavaPluginExtension::class.java) ?: throw GradleException("Java plugin not found")
-            val source = java.sourceSets.named("main").map { it.allJava }
-            inputs.files(source)
-            outputs.files(source)
-
-            if (type == Type.USER_DEV) {
-                pattern = "org\\.bukkit\\.craftbukkit\\.${project.name}".toRegex()
-                replacement = "org.bukkit.craftbukkit"
-            } else {
-                pattern = "org\\.bukkit\\.craftbukkit\\.(?!${project.name})".toRegex()
-                replacement = "org.bukkit.craftbukkit.${project.name}."
-            }
-        }
-
-        @TaskAction
-        fun process() {
-            val dispatcher = Dispatchers.IO.limitedParallelism(16)
-            runBlocking {
-                for (file in inputs.files) {
-                    if (file.extension !in listOf("java"))
-                        continue
-
-                    launch(dispatcher) {
-                        val output = ArrayList<String>()
-                        var changed = false
-
-                        file.bufferedReader().use {
-                            for (line in it.lines()) {
-                                if (line.startsWith("package") || line.isBlank()) {
-                                    output += line
-                                    continue
-                                }
-
-                                if (!line.startsWith("import")) {
-                                    if (!changed) return@launch
-                                    else {
-                                        output += line
-                                        continue
-                                    }
-                                }
-
-                                if (!line.contains(pattern)) {
-                                    output += line
-                                    continue
-                                }
-
-                                output += line.replace(pattern, replacement)
-                                changed = true
-                            }
-                        }
-
-                        if (changed) {
-                            RandomAccessFile(file, "r").use { raf ->
-                                val bytes = ByteArray(NEW_LINE_BYTES.size)
-                                raf.seek(raf.length() - bytes.size)
-                                raf.readFully(bytes)
-                                if (bytes.contentEquals(NEW_LINE_BYTES))
-                                    output += ""
-                            }
-
-                            file.writer().use {
-                                val iterator = output.iterator()
-                                while (iterator.hasNext()) {
-                                    it.append(iterator.next())
-                                    if (iterator.hasNext())
-                                        it.append(NEW_LINE)
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-        }
-    }
-
-    enum class Type {
-        USER_DEV,
-        BUILD_TOOLS,
-        DIRECT,
-    }
-}
-
-private val NEW_LINE = System.lineSeparator()
-private val NEW_LINE_BYTES = NEW_LINE.encodeToByteArray()
-private fun String.parseVersion() = substringBefore('-').split(".").let {
-    it[1].toInt() to it[2].toInt()
-}
-
-class Config(
-    var jvm: Int = 21,
-    var type: Type = Type.DIRECT
-) {
-    lateinit var version: String
-}
-
-fun Project.nmsBinding(action: Config.() -> Unit) {
-    extra["nms"] = Config().apply(action)
-    plugins.apply(NMSBinding::class.java)
-}
-
-private inline fun <reified T : Named> ObjectFactory.named(name: String): T = named(T::class.java, name)

bukkit/build.gradle

@@ -0,0 +1,290 @@
+plugins {
+    id 'java'
+    id "io.freefair.lombok" version "6.3.0"
+    id "com.github.johnrengelman.shadow" version "7.1.2"
+    id "de.undercouch.download" version "5.0.1"
+}
+
+group rootProject.group
+version rootProject.version
+
+def nmsVersion = "1.19"
+def apiVersion = '1.19'
+def spigotJarVersion = '1.19-R0.1-SNAPSHOT'
+def name = getRootProject().getName() // Defined in settings.gradle
+def main = 'com.volmit.iris.platform.bukkit.IrisBukkit'
+
+// ADD YOURSELF AS A NEW LINE IF YOU WANT YOUR OWN BUILD TASK GENERATED
+// ======================== WINDOWS =============================
+registerCustomOutputTask('Cyberpwn', 'C://Users/cyberpwn/Documents/development/server/plugins')
+registerCustomOutputTask('Psycho', 'D://Dan/MinecraftDevelopment/server/plugins')
+registerCustomOutputTask('ArcaneArts', 'C://Users/arcane/Documents/development/server/plugins')
+registerCustomOutputTask('Coco', 'D://Documents/MC/plugins')
+registerCustomOutputTask('Strange', 'D://Servers/1.17 Test Server/plugins')
+registerCustomOutputTask('Vatuu', 'D://Minecraft/Servers/1.19/plugins')
+// ========================== UNIX ==============================
+registerCustomOutputTaskUnix('CyberpwnLT', '/Users/danielmills/development/server/plugins')
+registerCustomOutputTaskUnix('PsychoLT', '/Users/brianfopiano/Desktop/REMOTES/RemoteMinecraft/plugins')
+// ==============================================================
+
+/**
+ * Gradle is weird sometimes, we need to delete the plugin yml from the build folder to actually filter properly.
+ */
+file(jar.archiveFile.get().getAsFile().getParentFile().getParentFile().getParentFile().getAbsolutePath() + '/build/resources/main/plugin.yml').delete()
+
+/**
+ * Expand properties into plugin yml
+ */
+processResources {
+    filesMatching('**/plugin.yml') {
+        expand(
+                'name': name.toString(),
+                'version': version.toString(),
+                'main': main.toString(),
+                'apiversion': apiVersion.toString()
+        )
+    }
+}
+
+/**
+ * We need parameter meta for the decree command system
+ */
+compileJava {
+    options.compilerArgs << '-parameters'
+}
+
+/**
+ * Configure Iris for shading
+ */
+shadowJar {
+    //minimize()
+    append("plugin.yml")
+    relocate 'com.dfsek.paralithic', 'com.volmit.iris.util.paralithic'
+    relocate 'art.arcane', 'com.volmit.iris.util.arcane'
+    relocate 'manifold', 'com.volmit.iris.util.manifold'
+    relocate 'art.arcane.source', 'com.volmit.iris.util.source'
+    relocate 'ChumBukkit.extensions', 'com.volmit.iris.util.extensions'
+    relocate 'IrisBukkit.extensions', 'com.volmit.iris.util.extensions'
+    relocate 'Fukkit.extensions', 'com.volmit.iris.util.extensions'
+    relocate 'Amulet.extensions', 'com.volmit.iris.util.extensions'
+    relocate 'Iris.extensions', 'com.volmit.iris.util.extensions'
+    dependencies {
+        include(dependency('art.arcane:'))
+        include(dependency('systems.manifold:'))
+        include(dependency("com.dfsek:Paralithic:"))
+        include(dependency(":engine"))
+    }
+}
+
+/**
+ * Faster dependency caches
+ */
+configurations.all {
+    resolutionStrategy.cacheChangingModulesFor 60, 'minutes'
+    resolutionStrategy.cacheDynamicVersionsFor 60, 'minutes'
+}
+
+configurations {
+    testImplementation.extendsFrom annotationProcessor
+}
+
+java {
+    toolchain {
+        languageVersion = JavaLanguageVersion.of(17)
+    }
+}
+
+repositories {
+    maven { url "https://arcanearts.jfrog.io/artifactory/archives" }
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'org.spigotmc:spigot-api:1.19-R0.1-SNAPSHOT'
+    implementation 'art.arcane:Fukkit:22.9.2'
+    implementation project(":engine")
+}
+
+if (JavaVersion.current() != JavaVersion.VERSION_1_8 &&
+        sourceSets.main.allJava.files.any { it.name == "module-info.java" }) {
+    tasks.withType(JavaCompile) {
+        options.compilerArgs += ['-Xplugin:Manifold', '--module-path', it.classpath.asPath]
+    }
+} else {
+    tasks.withType(JavaCompile) {
+        options.compilerArgs += ['-Xplugin:Manifold']
+    }
+}
+
+if (JavaVersion.current().toString() != "17") {
+    System.err.println()
+    System.err.println("=========================================================================================================")
+    System.err.println("You must run gradle on Java 17. You are using " + JavaVersion.current())
+    System.err.println()
+    System.err.println("=== For IDEs ===")
+    System.err.println("1. Configure the project for Java 17")
+    System.err.println("2. Configure the bundled gradle to use Java 17 in settings")
+    System.err.println()
+    System.err.println("=== For Command Line (gradlew) ===")
+    System.err.println("1. Install JDK 17 from https://www.oracle.com/java/technologies/javase/jdk17-archive-downloads.html")
+    System.err.println("2. Set JAVA_HOME environment variable to the new jdk installation folder such as C:\\Program Files\\Java\\jdk-17.0.1")
+    System.err.println("3. Open a new command prompt window to get the new environment variables if need be.")
+    System.err.println("=========================================================================================================")
+    System.err.println()
+    System.exit(69);
+}
+
+
+System.out.println(buildDir);
+def buildToolsJar = new File(buildDir, "buildtools/BuildTools.jar");
+def specialSourceJar = new File(buildDir, "specialsource/SpecialSource.jar");
+def buildToolsFolder = new File(buildDir, "buildtools");
+def specialSourceFolder = new File(buildDir, "specialsource");
+def buildToolsHint = new File(buildDir, "buildtools/craftbukkit-" + nmsVersion + ".jar");
+def outputShadeJar = new File(buildDir, "libs/bukkit-" + version + "-all.jar");
+def ssiJar = new File(buildDir, "specialsource/bukkit-" + version + "-all.jar");
+def ssobfJar = new File(buildDir, "specialsource/Iris-" + version + "-rmo.jar");
+def ssJar = new File(buildDir, "specialsource/Iris-" + version + "-rma.jar");
+def homePath = System.properties['user.home']
+def m2 = new File(homePath + "/.m2/repository")
+def m2s = m2.getAbsolutePath();
+
+// ======================== Building Mapped Jars =============================
+task downloadBuildtools(type: Download) {
+    group "remapping"
+    src 'https://hub.spigotmc.org/jenkins/job/BuildTools/lastSuccessfulBuild/artifact/target/BuildTools.jar'
+    dest buildToolsJar
+    onlyIf {
+        !buildToolsJar.exists()
+    }
+}
+
+task downloadSpecialSource(type: Download) {
+    group "remapping"
+    src 'https://repo.maven.apache.org/maven2/net/md-5/SpecialSource/1.10.0/SpecialSource-1.10.0-shaded.jar'
+    dest specialSourceJar
+    onlyIf {
+        !specialSourceJar.exists()
+    }
+}
+
+task executeBuildTools(dependsOn: downloadBuildtools, type: JavaExec)
+{
+    group "remapping"
+    classpath = files(buildToolsJar)
+    workingDir = buildToolsFolder
+    args = [
+            "--rev",
+            nmsVersion,
+            "--compile",
+            "craftbukkit",
+            "--remap"
+    ]
+    onlyIf {
+        !buildToolsHint.exists()
+    }
+}
+
+task copyBuildToSpecialSource(type: Copy)
+{
+    group "remapping"
+    from outputShadeJar
+    into specialSourceFolder
+    dependsOn(downloadSpecialSource, shadowJar)
+}
+
+task specialSourceRemapObfuscate(type: JavaExec)
+{
+    group "remapping"
+    dependsOn(copyBuildToSpecialSource, downloadSpecialSource, shadowJar)
+    workingDir = specialSourceFolder
+    classpath = files(specialSourceJar,
+            new File(m2s + "/org/spigotmc/spigot/" + spigotJarVersion + "/spigot-" + spigotJarVersion + "-remapped-mojang.jar"))
+    mainClass = "net.md_5.specialsource.SpecialSource"
+    args = [
+            "--live",
+            "-i",
+            ssiJar.getName(),
+            "-o",
+            ssobfJar.getName(),
+            "-m",
+            m2s + "/org/spigotmc/minecraft-server/" + spigotJarVersion + "/minecraft-server-" + spigotJarVersion + "-maps-mojang.txt",
+            "--reverse",
+    ]
+}
+
+task specialSourceRemap(type: JavaExec)
+{
+    group "remapping"
+    dependsOn(specialSourceRemapObfuscate)
+    workingDir = specialSourceFolder
+    classpath = files(specialSourceJar,
+            new File(m2s + "/org/spigotmc/spigot/" + spigotJarVersion + "/spigot-" + spigotJarVersion + "-remapped-obf.jar"))
+    mainClass = "net.md_5.specialsource.SpecialSource"
+    args = [
+            "--live",
+            "-i",
+            ssobfJar.getName(),
+            "-o",
+            ssJar.getName(),
+            "-m",
+            m2s + "/org/spigotmc/minecraft-server/" + spigotJarVersion + "/minecraft-server-" + spigotJarVersion + "-maps-spigot.csrg"
+    ]
+}
+
+tasks.compileJava.dependsOn(executeBuildTools)
+
+compileJava {
+    options.encoding = "UTF-8"
+}
+
+task setup()
+{
+    group("iris")
+    dependsOn(clean, executeBuildTools)
+}
+
+task iris(type: Copy)
+{
+    group "iris"
+    from ssJar
+    into buildDir
+    rename { String fileName ->
+        fileName.replace('Iris-' + version + '-rma.jar', "Iris-" + version + ".jar")
+    }
+    dependsOn(specialSourceRemap)
+}
+
+def registerCustomOutputTask(name, path) {
+    if (!System.properties['os.name'].toLowerCase().contains('windows')) {
+        return;
+    }
+
+    tasks.register('build' + name, Copy) {
+        group('development')
+        outputs.upToDateWhen { false }
+        dependsOn(iris)
+        from(new File(buildDir, "Iris-" + version + ".jar"))
+        into(file(path))
+        rename { String fileName ->
+            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
+        }
+    }
+}
+
+def registerCustomOutputTaskUnix(name, path) {
+    if (System.properties['os.name'].toLowerCase().contains('windows')) {
+        return;
+    }
+
+    tasks.register('build' + name, Copy) {
+        group('development')
+        outputs.upToDateWhen { false }
+        dependsOn(iris)
+        from(new File(buildDir, "Iris-" + version + ".jar"))
+        into(file(path))
+        rename { String fileName ->
+            fileName.replace("Iris-" + version + ".jar", "Iris.jar")
+        }
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkit.java

@@ -0,0 +1,217 @@
+package com.volmit.iris.platform.bukkit;
+
+import art.arcane.amulet.io.IO;
+import art.arcane.amulet.logging.LogListener;
+import com.volmit.iris.engine.EngineConfiguration;
+import com.volmit.iris.platform.IrisPlatform;
+import com.volmit.iris.platform.PlatformBiome;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import com.volmit.iris.platform.PlatformWorld;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitBiome;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitBlock;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitKey;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitWorld;
+import lombok.Data;
+import lombok.EqualsAndHashCode;
+import org.bukkit.Bukkit;
+import org.bukkit.ChatColor;
+import org.bukkit.Material;
+import org.bukkit.Warning;
+import org.bukkit.World;
+import org.bukkit.WorldCreator;
+import org.bukkit.block.Biome;
+import org.bukkit.command.ConsoleCommandSender;
+import org.bukkit.entity.Player;
+import org.bukkit.generator.ChunkGenerator;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.UUID;
+import java.util.stream.Stream;
+
+public class IrisBukkit extends JavaPlugin implements IrisPlatform, LogListener {
+    private static final String TAG = ChatColor.DARK_GRAY + "[" + ChatColor.GREEN + "Iris" + ChatColor.DARK_GREEN + "/";
+    private static final String TAG_STRIPPED = ChatColor.stripColor(TAG);
+    private static IrisBukkit instance;
+    private ConsoleCommandSender consoleSender;
+
+    public void onEnable() {
+        instance = this;
+        consoleSender = Bukkit.getConsoleSender();
+        LogListener.listener.set(this);
+
+        getServer().getScheduler().scheduleSyncDelayedTask(this, () -> {
+            World world = Bukkit.createWorld(new WorldCreator("iristests/" + UUID.randomUUID()).generator(new IrisBukkitChunkGenerator(this, EngineConfiguration.builder()
+                .timings(true).mutable(true)
+                .build())));
+            for(Player i : Bukkit.getOnlinePlayers())
+            {
+                i.teleport(world.getSpawnLocation());
+            }
+        }, 10);
+    }
+
+    public void onDisable() {
+        World w = null;
+        for(World i : Bukkit.getWorlds()) {
+            if(!i.getName().startsWith("iristest")) {
+                w = i;
+                break;
+            }
+        }
+
+        for(World i : Bukkit.getWorlds()) {
+            if(i.getName().startsWith("iristest"))
+            {
+                for(Player j : i.getPlayers())
+                {
+                    j.teleport(w.getSpawnLocation());
+                }
+
+                if(i.getGenerator() instanceof Closeable c)
+                {
+                    try {
+                        c.close();
+                    } catch(IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+
+                BukkitWorld.of(i).unloadChunks(false, true);
+                File folder = i.getWorldFolder();
+                Bukkit.unloadWorld(i, false);
+                IO.delete(folder);
+            }
+        }
+    }
+
+    public static IrisBukkit getInstance() {
+        return instance;
+    }
+
+    private void messageConsole(String color, String key, Object o) {
+        try {
+            consoleSender.sendMessage(TAG + key + ChatColor.DARK_GRAY + "]: " + color + o.toString());
+        }
+
+        catch(Throwable e) {
+            System.out.println(TAG_STRIPPED + key + "]: " + o.toString());
+        }
+    }
+
+    @Override
+    public void logError(String k, Object o) {
+        messageConsole(ChatColor.RED.toString(), k, o);
+    }
+
+    @Override
+    public void logInfo(String k, Object o) {
+        messageConsole(ChatColor.WHITE.toString(), k, o);
+    }
+
+    @Override
+    public void logWarning(String k, Object o) {
+        messageConsole(ChatColor.YELLOW.toString(), k, o);
+    }
+
+    @Override
+    public void logDebug(String k, Object o) {
+        messageConsole(ChatColor.GRAY.toString(), k, o);
+    }
+
+    @Override
+    public String getPlatformName() {
+        return "Bukkit";
+    }
+
+    @Override
+    public Stream<PlatformBlock> getBlocks() {
+        //This is because it's a method extension
+        //noinspection Convert2MethodRef
+        return Arrays.stream(Material.values())
+            .filter(i -> !i.isLegacy())
+            .filter(Material::isBlock)
+            .map(Material::createBlockData).map(i -> BukkitBlock.of(i));
+    }
+
+    @Override
+    public Stream<PlatformBiome> getBiomes() {
+        //This is because it's a method extension
+        //noinspection Convert2MethodRef
+        return Arrays.stream(Biome.values()).parallel().filter((i) -> i != Biome.CUSTOM).map(i -> BukkitBiome.of(i));
+    }
+
+    @Override
+    public boolean isWorldLoaded(String name) {
+        return Bukkit.getWorlds().keepWhere(i -> i.getName().equals(name)).isNotEmpty();
+    }
+
+    @Override
+    public PlatformWorld getWorld(String name) {
+        World w = Bukkit.getWorld(name);
+
+        if(w == null)
+        {
+            return null;
+        }
+
+        return BukkitWorld.of(w);
+    }
+
+    @Override
+    public PlatformBlock parseBlock(String raw) {
+        return BukkitBlock.of(Bukkit.createBlockData(raw));
+    }
+
+    @Override
+    public PlatformNamespaceKey key(String namespace, String key) {
+        return BukkitKey.of(namespace, key);
+    }
+
+    @Override
+    public File getStudioFolder(String dimension) {
+        File f = new File(getDataFolder(), "packs/" + dimension);
+        f.mkdirs();
+        return f;
+    }
+
+    @Override
+    public File getStudioFolder() {
+        File f = new File(getDataFolder(), "packs/");
+        f.mkdirs();
+        return f;
+    }
+
+    @Override
+    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
+        return new IrisBukkitChunkGenerator(this, EngineConfiguration.builder()
+            .threads(4)
+            .mutable(true)
+            .timings(true)
+            .build());
+    }
+
+    @Override
+    public void i(String s, Object o) {
+        logInfo(s, o);
+    }
+
+    @Override
+    public void f(String s, Object o) {
+        logError(s, o);
+    }
+
+    @Override
+    public void w(String s, Object o) {
+        logWarning(s, o);
+    }
+
+    @Override
+    public void d(String s, Object o) {
+        logDebug(s, o);
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkitChunkGenerator.java

@@ -0,0 +1,147 @@
+package com.volmit.iris.platform.bukkit;
+
+import art.arcane.chrono.Average;
+import art.arcane.chrono.PrecisionStopwatch;
+import art.arcane.spatial.hunk.Hunk;
+import com.volmit.iris.engine.EngineConfiguration;
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.feature.FeatureSizedTarget;
+import com.volmit.iris.engine.feature.FeatureTarget;
+import com.volmit.iris.engine.pipeline.PipedHunkStack;
+import com.volmit.iris.platform.IrisPlatform;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.bukkit.util.StaticBiomeProvider;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitWorld;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.block.Biome;
+import org.bukkit.generator.BiomeProvider;
+import org.bukkit.generator.ChunkGenerator;
+import com.volmit.iris.platform.bukkit.util.ChunkDataHunkView;
+import org.bukkit.generator.WorldInfo;
+
+import java.io.Closeable;
+import java.io.IOException;
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class IrisBukkitChunkGenerator extends ChunkGenerator implements Closeable {
+    private final IrisPlatform platform;
+    private final EngineConfiguration configuration;
+    private final AtomicReference<Engine> engine;
+    private final ReentrantLock engineLock;
+    private final AtomicInteger perSecond;
+    private final PrecisionStopwatch p = PrecisionStopwatch.start();
+    private final Average a = new Average(128);
+    private final StaticBiomeProvider staticBiomeProvider;
+
+    public IrisBukkitChunkGenerator(IrisPlatform platform, EngineConfiguration configuration) {
+        this.perSecond = new AtomicInteger(0);
+        this.platform = platform;
+        this.configuration = configuration;
+        this.staticBiomeProvider = new StaticBiomeProvider(Biome.PLAINS);
+        this.engine = new AtomicReference<>();
+        this.engineLock = new ReentrantLock();
+    }
+
+    @Override
+    public ChunkData generateChunkData(World world, Random random, int x, int z, BiomeGrid biome) {
+        PrecisionStopwatch pp = PrecisionStopwatch.start();
+        initEngine(world);
+        ChunkData data = Bukkit.createChunkData(world);
+        Hunk<PlatformBlock> chunk = new ChunkDataHunkView(data);
+        FeatureSizedTarget targetSize = FeatureSizedTarget.builder()
+            .width(chunk.getWidth())
+            .height(chunk.getHeight())
+            .depth(chunk.getDepth())
+            .offsetX(x << 4)
+            .offsetZ(z << 4)
+            .offsetY(0)
+            .build();
+        FeatureTarget<PlatformBlock> blockTarget = new FeatureTarget<>(chunk, targetSize);
+        PipedHunkStack stack = new PipedHunkStack();
+        stack.register(PlatformBlock.class, blockTarget);
+        engine.get().getPlumbing().generate(engine.get(), targetSize, stack);
+        perSecond.incrementAndGet();
+        a.put(pp.getMilliseconds());
+
+        if(p.getMilliseconds() > 1000)
+        {
+            p.reset();
+            p.begin();
+            System.out.println("PERSECOND: " + perSecond.getAndSet(0) + " AMS: " + ((int)Math.round(a.getAverage())) + "ms");
+        }
+
+        return data;
+    }
+
+    private void initEngine(World world) {
+        if(engine.get() == null)
+        {
+            engineLock.lock();
+
+            if(engine.get() == null)
+            {
+                try {
+                    engine.set(new Engine(platform, BukkitWorld.of(world), configuration));
+                } catch (IOException e) {
+                    throw new RuntimeException(e);
+                }
+            }
+
+            engineLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean canSpawn(World world, int x, int z) {
+        return false;
+    }
+
+    @Override
+    public BiomeProvider getDefaultBiomeProvider(WorldInfo worldInfo) {
+        return staticBiomeProvider;
+    }
+
+    @Override
+    public void close() throws IOException {
+        engine.get().close();
+    }
+
+    @Override
+    public boolean shouldGenerateNoise() {
+        return super.shouldGenerateNoise();
+    }
+
+    @Override
+    public boolean shouldGenerateSurface() {
+        return super.shouldGenerateSurface();
+    }
+
+    @Override
+    public boolean shouldGenerateBedrock() {
+        return super.shouldGenerateBedrock();
+    }
+
+    @Override
+    public boolean shouldGenerateCaves() {
+        return super.shouldGenerateCaves();
+    }
+
+    @Override
+    public boolean shouldGenerateDecorations() {
+        return super.shouldGenerateDecorations();
+    }
+
+    @Override
+    public boolean shouldGenerateMobs() {
+        return super.shouldGenerateMobs();
+    }
+
+    @Override
+    public boolean shouldGenerateStructures() {
+        return super.shouldGenerateStructures();
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/util/ChunkDataHunkView.java

@@ -0,0 +1,53 @@
+package com.volmit.iris.platform.bukkit.util;
+
+import art.arcane.spatial.hunk.Hunk;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitBlock;
+import org.bukkit.generator.ChunkGenerator;
+
+@SuppressWarnings("ClassCanBeRecord")
+public class ChunkDataHunkView implements Hunk<PlatformBlock> {
+    private final ChunkGenerator.ChunkData chunk;
+
+    public ChunkDataHunkView(ChunkGenerator.ChunkData chunk) {
+        this.chunk = chunk;
+    }
+
+    @Override
+    public int getWidth() {
+        return 16;
+    }
+
+    @Override
+    public int getDepth() {
+        return 16;
+    }
+
+    @Override
+    public int getHeight() {
+        return chunk.getMaxHeight() - chunk.getMinHeight();
+    }
+
+    @Override
+    public synchronized void set(int x1, int y1, int z1, int x2, int y2, int z2, PlatformBlock t) {
+        if(t == null) {
+            return;
+        }
+
+        chunk.setRegion(x1, y1 + chunk.getMinHeight(), z1, x2, y2 + chunk.getMinHeight(), z2, ((BukkitBlock)t).getDelegate());
+    }
+
+    @Override
+    public synchronized void setRaw(int x, int y, int z, PlatformBlock t) {
+        if(t == null) {
+            return;
+        }
+
+        chunk.setBlock(x, y + chunk.getMinHeight(), z, ((BukkitBlock)t).getDelegate());
+    }
+
+    @Override
+    public PlatformBlock getRaw(int x, int y, int z) {
+        return BukkitBlock.of(chunk.getBlockData(x, y + chunk.getMinHeight(), z));
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/util/StaticBiomeProvider.java

@@ -0,0 +1,27 @@
+package com.volmit.iris.platform.bukkit.util;
+
+import org.bukkit.block.Biome;
+import org.bukkit.generator.BiomeProvider;
+import org.bukkit.generator.WorldInfo;
+
+import java.util.Arrays;
+import java.util.List;
+
+public class StaticBiomeProvider extends BiomeProvider {
+    private static final List<Biome> ALL_BIOMES = Arrays.stream(Biome.values()).without((i) -> i.equals(Biome.CUSTOM)).toList().unmodifiable();
+    private final Biome defaultBiome;
+
+    public StaticBiomeProvider(Biome defaultBiome) {
+        this.defaultBiome = defaultBiome;
+    }
+
+    @Override
+    public Biome getBiome(WorldInfo worldInfo, int x, int y, int z) {
+        return defaultBiome;
+    }
+
+    @Override
+    public List<Biome> getBiomes(WorldInfo worldInfo) {
+        return ALL_BIOMES;
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitBiome.java

@@ -0,0 +1,24 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import com.volmit.iris.platform.PlatformBiome;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import lombok.Data;
+import org.bukkit.block.Biome;
+
+@Data
+public class BukkitBiome implements PlatformBiome {
+    private final Biome delegate;
+
+    private BukkitBiome(Biome delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public PlatformNamespaceKey getKey() {
+        return BukkitKey.of(delegate.getKey());
+    }
+
+    public static BukkitBiome of(Biome biome) {
+        return new BukkitBiome(biome);
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitBlock.java

@@ -0,0 +1,71 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import com.volmit.iris.platform.block.PlatformBlock;
+import lombok.Data;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.block.data.Ageable;
+import org.bukkit.block.data.BlockData;
+
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+@Data
+public class BukkitBlock implements PlatformBlock {
+    private final BlockData delegate;
+    private final Map<String, String> properties;
+
+    private BukkitBlock(BlockData delegate, Map<String, String> properties) {
+        this.delegate = delegate;
+        this.properties = properties;
+    }
+
+    private BukkitBlock(BlockData delegate) {
+        this.delegate = delegate;
+        String s = delegate.getAsString(true);
+
+        if(s.contains("[")) {
+            Map<String, String> properties = new HashMap<>();
+            String[] props = new String[] {s.split("\\Q[\\E")[1].split("\\Q]\\E")[0]};
+            String[] p;
+            if(props[0].contains(",")) {
+                for(String i : props[0].split("\\Q,\\E")) {
+                    p = i.split("\\Q=\\E");
+                    properties.put(p[0], p[1]);
+                }
+            } else {
+                p = props[0].split("\\Q=\\E");
+                properties.put(p[0], p[1]);
+            }
+
+            this.properties = Collections.unmodifiableMap(properties);
+        } else {
+            this.properties = Map.of();
+        }
+    }
+
+    @Override
+    public Map<String, String> getProperties() {
+        return null;
+    }
+
+    @Override
+    public PlatformNamespaceKey getKey() {
+        return BukkitKey.of(delegate.getMaterial().getKey());
+    }
+
+    public static BukkitBlock of(BlockData blockData) {
+        return new BukkitBlock(blockData);
+    }
+
+    public static BukkitBlock of(Material material) {
+        return of(material.createBlockData());
+    }
+
+    public static BukkitBlock of(String raw) {
+        return of(Bukkit.createBlockData(raw));
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitChunk.java

@@ -0,0 +1,35 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import com.volmit.iris.platform.PlatformChunk;
+import org.bukkit.Chunk;
+
+public class BukkitChunk implements PlatformChunk {
+    private final Chunk delegate;
+
+    private BukkitChunk(Chunk delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public int getX() {
+        return delegate.getX();
+    }
+
+    @Override
+    public int getZ() {
+        return delegate.getZ();
+    }
+
+    @Override
+    public void unload(boolean save, boolean force) {
+        if(force) {
+            delegate.getPluginChunkTickets().forEach(delegate::removePluginChunkTicket);
+        }
+
+        delegate.unload(save);
+    }
+
+    public static BukkitChunk of(Chunk chunk) {
+        return new BukkitChunk(chunk);
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitKey.java

@@ -0,0 +1,45 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import com.volmit.iris.platform.PlatformNamespaceKey;
+import lombok.Data;
+import org.bukkit.NamespacedKey;
+
+@Data
+public class BukkitKey implements PlatformNamespaceKey {
+    private final NamespacedKey delegate;
+
+    private BukkitKey(NamespacedKey delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public String getNamespace() {
+        return delegate.getNamespace();
+    }
+
+    @Override
+    public String getKey() {
+        return delegate.getKey();
+    }
+
+    public String toString() {
+        return delegate.toString();
+    }
+
+    public static BukkitKey of(String nsk) {
+        if(nsk.contains(":")) {
+            String[] f = nsk.split("\\Q:\\E");
+            return of(f[0], f[1]);
+        }
+
+        return of("minecraft", nsk);
+    }
+
+    public static BukkitKey of(String namespace, String key) {
+        return of(new NamespacedKey(namespace, key));
+    }
+
+    public static BukkitKey of(NamespacedKey key) {
+        return new BukkitKey(key);
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitPlayer.java

@@ -0,0 +1,60 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import art.arcane.amulet.geometry.Vec;
+import com.volmit.iris.platform.PlatformPlayer;
+import com.volmit.iris.platform.PlatformWorld;
+import org.bukkit.entity.Player;
+
+import java.util.UUID;
+
+public class BukkitPlayer implements PlatformPlayer {
+    private final Player delegate;
+
+    private BukkitPlayer(Player delegate) {
+        this.delegate = delegate;
+    }
+
+    @Override
+    public UUID getUUID() {
+        return delegate.getUniqueId();
+    }
+
+    @Override
+    public String getName() {
+        return delegate.getName();
+    }
+
+    @Override
+    public Vec getLocation() {
+        return delegate.getLocation().vec();
+    }
+
+    @Override
+    public PlatformWorld getWorld() {
+        return BukkitWorld.of(delegate.getWorld());
+    }
+
+    @Override
+    public boolean canUseIris() {
+        return delegate.isOp();
+    }
+
+    @Override
+    public void sendMessage(String message) {
+        delegate.sendMessage(message);
+    }
+
+    @Override
+    public void sendActionBar(String message) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void sendTitleMessage(String title, String subtitle, int in, int stay, int out) {
+        throw new UnsupportedOperationException();
+    }
+
+    public static BukkitPlayer of(Player player) {
+        return new BukkitPlayer(player);
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/wrapper/BukkitWorld.java

@@ -0,0 +1,91 @@
+package com.volmit.iris.platform.bukkit.wrapper;
+
+import com.volmit.iris.platform.PlatformBiome;
+import com.volmit.iris.platform.block.PlatformBlock;
+import com.volmit.iris.platform.PlatformChunk;
+import com.volmit.iris.platform.PlatformPlayer;
+import com.volmit.iris.platform.PlatformWorld;
+import com.volmit.iris.util.WorldHeight;
+import lombok.Data;
+import org.bukkit.World;
+
+import java.io.File;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
+@Data
+public class BukkitWorld implements PlatformWorld {
+    private final World delegate;
+    private final WorldHeight worldHeight;
+
+    private BukkitWorld(World delegate) {
+        this.delegate = delegate;
+        this.worldHeight = new WorldHeight(delegate.getMinHeight(), delegate.getMaxHeight());
+    }
+
+    @Override
+    public WorldHeight getHeight() {
+        return worldHeight;
+    }
+
+    @Override
+    public String getName() {
+        return delegate.getName();
+    }
+
+    @Override
+    public File getFolder() {
+        return delegate.getWorldFolder();
+    }
+
+    @Override
+    public Iterable<PlatformPlayer> getPlayers() {
+        //noinspection Convert2MethodRef
+        return delegate.getPlayers().stream().map(i -> BukkitPlayer.of(i)).collect(Collectors.toList());
+    }
+
+    @Override
+    public Iterable<PlatformChunk> getLoadedChunks() {
+        //noinspection Convert2MethodRef
+        return Arrays.stream(delegate.getLoadedChunks()).map(i -> BukkitChunk.of(i)).collect(Collectors.toList());
+    }
+
+    @Override
+    public PlatformChunk getOrLoadChunk(int x, int z) {
+        return BukkitChunk.of(delegate.getChunkAt(x, z));
+    }
+
+    @Override
+    public PlatformBlock getBlock(int x, int y, int z) {
+        return BukkitBlock.of(delegate.getBlockAt(x, y, z).getBlockData());
+    }
+
+    @Override
+    public PlatformBiome getBiome(int x, int y, int z) {
+        return BukkitBiome.of(delegate.getBiome(x, y, z));
+    }
+
+    @Override
+    public long getSeed() {
+        return delegate.getSeed();
+    }
+
+    @Override
+    public boolean isChunkLoaded(int x, int z) {
+        return delegate.isChunkLoaded(x, z);
+    }
+
+    @Override
+    public void setBlock(int x, int y, int z, PlatformBlock block) {
+        delegate.setBlockData(x, y, z, ((BukkitBlock) block).getDelegate());
+    }
+
+    @Override
+    public void setBiome(int x, int y, int z, PlatformBiome biome) {
+        delegate.setBiome(x, y, z, ((BukkitBiome) biome).getDelegate());
+    }
+
+    public static BukkitWorld of(World world) {
+        return new BukkitWorld(world);
+    }
+}

bukkit/src/main/resources/plugin.yml

@@ -0,0 +1,8 @@
+name: Iris
+main: com.volmit.iris.platform.bukkit.IrisBukkit
+version: 1.0.0
+api-version: 1.19
+libraries:
+- org.apache-extras.beanshell:bsh:2.0b6
+- com.google.code.gson:gson:2.8.9
+- com.github.ben-manes.caffeine:caffeine:3.1.1

core/agent/build.gradle.kts

@@ -1,12 +0,0 @@
-plugins {
-    java
-}
-
-tasks.jar {
-    manifest.attributes(
-        "Agent-Class" to "com.volmit.iris.util.agent.Installer",
-        "Premain-Class" to "com.volmit.iris.util.agent.Installer",
-        "Can-Redefine-Classes" to true,
-        "Can-Retransform-Classes" to true
-    )
-}

core/agent/src/main/java/com/volmit/iris/util/agent/Installer.java

@@ -1,29 +0,0 @@
-package com.volmit.iris.util.agent;
-
-import java.lang.instrument.Instrumentation;
-
-public class Installer {
-    private static volatile Instrumentation instrumentation;
-
-    public static Instrumentation getInstrumentation() {
-        Instrumentation instrumentation = Installer.instrumentation;
-        if (instrumentation == null) {
-            throw new IllegalStateException("The agent is not loaded or this method is not called via the system class loader");
-        }
-        return instrumentation;
-    }
-
-    public static void premain(String arguments, Instrumentation instrumentation) {
-        doMain(instrumentation);
-    }
-
-    public static void agentmain(String arguments, Instrumentation instrumentation) {
-        doMain(instrumentation);
-    }
-
-    private static synchronized void doMain(Instrumentation instrumentation) {
-        if (Installer.instrumentation != null)
-            return;
-        Installer.instrumentation = instrumentation;
-    }
-}

core/build.gradle.kts

@@ -1,211 +0,0 @@
-import io.github.slimjar.func.slimjarHelper
-import io.github.slimjar.resolver.data.Mirror
-import org.ajoberstar.grgit.Grgit
-import java.net.URI
-
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2021 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-plugins {
-    java
-    `java-library`
-    alias(libs.plugins.shadow)
-    alias(libs.plugins.sentry)
-    alias(libs.plugins.slimjar)
-    alias(libs.plugins.grgit)
-    alias(libs.plugins.kotlin.jvm)
-    alias(libs.plugins.kotlin.lombok)
-}
-
-val apiVersion = "1.19"
-val main = "com.volmit.iris.Iris"
-val lib = "com.volmit.iris.util"
-
-/**
- * Dependencies.
- *
- * Provided or classpath dependencies are not shaded and are available on the runtime classpath
- *
- * Shaded dependencies are not available at runtime, nor are they available on mvn central so they
- * need to be shaded into the jar (increasing binary size)
- *
- * Dynamically loaded dependencies are defined in the plugin.yml (updating these must be updated in the
- * plugin.yml also, otherwise they wont be available). These do not increase binary size). Only declare
- * these dependencies if they are available on mvn central.
- */
-dependencies {
-    // Provided or Classpath
-    compileOnly(libs.spigot)
-    compileOnly(libs.log4j.api)
-    compileOnly(libs.log4j.core)
-
-    // Third Party Integrations
-    compileOnly(libs.nexo)
-    compileOnly(libs.itemsadder)
-    compileOnly(libs.placeholderApi)
-    compileOnly(libs.score)
-    compileOnly(libs.mmoitems)
-    compileOnly(libs.ecoitems)
-    compileOnly(libs.mythic)
-    compileOnly(libs.mythicChrucible)
-    compileOnly(libs.kgenerators) {
-        isTransitive = false
-    }
-    compileOnly(libs.multiverseCore)
-
-    // Shaded
-    implementation(slimjarHelper("spigot"))
-
-    // Dynamically Loaded
-    slim(libs.paralithic)
-    slim(libs.paperlib)
-    slim(libs.adventure.api)
-    slim(libs.adventure.minimessage)
-    slim(libs.adventure.platform)
-    slim(libs.bstats)
-    slim(libs.sentry)
-
-    slim(libs.commons.io)
-    slim(libs.commons.lang)
-    slim(libs.commons.lang3)
-    slim(libs.commons.math3)
-    slim(libs.oshi)
-    slim(libs.lz4)
-    slim(libs.fastutil)
-    slim(libs.lru)
-    slim(libs.zip)
-    slim(libs.gson)
-    slim(libs.asm)
-    slim(libs.caffeine)
-    slim(libs.byteBuddy.core)
-    slim(libs.byteBuddy.agent)
-    slim(libs.dom4j)
-    slim(libs.jaxen)
-
-    // Script Engine
-    slim(libs.kotlin.stdlib)
-    slim(libs.kotlin.coroutines)
-    slim(libs.kotlin.scripting.common)
-    slim(libs.kotlin.scripting.jvm)
-    slim(libs.kotlin.scripting.jvm.host)
-    slim(libs.kotlin.scripting.dependencies.maven) {
-        constraints {
-            slim(libs.mavenCore)
-        }
-    }
-}
-
-java {
-    disableAutoTargetJvm()
-}
-
-sentry {
-    url = "http://sentry.volmit.com:8080/"
-    autoInstallation.enabled = false
-    includeSourceContext = true
-
-    org = "sentry"
-    projectName = "iris"
-    authToken = findProperty("sentry.auth.token") as String? ?: System.getenv("SENTRY_AUTH_TOKEN")
-}
-
-slimJar {
-    mirrors = listOf(Mirror(
-        URI.create("https://maven-central.storage-download.googleapis.com/maven2").toURL(),
-        URI.create("https://repo.maven.apache.org/maven2/").toURL()
-    ))
-
-    relocate("com.dfsek.paralithic", "$lib.paralithic")
-    relocate("io.papermc.lib", "$lib.paper")
-    relocate("net.kyori", "$lib.kyori")
-    relocate("org.bstats", "$lib.metrics")
-    relocate("io.sentry", "$lib.sentry")
-    relocate("org.apache.maven", "$lib.maven")
-    relocate("org.codehaus.plexus", "$lib.plexus")
-    relocate("org.eclipse.sisu", "$lib.sisu")
-    relocate("org.eclipse.aether", "$lib.aether")
-    relocate("com.google.inject", "$lib.guice")
-    relocate("org.dom4j", "$lib.dom4j")
-    relocate("org.jaxen", "$lib.jaxen")
-    relocate("com.github.benmanes.caffeine", "$lib.caffeine")
-}
-
-tasks {
-    /**
-     * We need parameter meta for the decree command system
-     */
-    compileJava {
-        options.compilerArgs.add("-parameters")
-        options.encoding = "UTF-8"
-    }
-
-    /**
-     * Expand properties into plugin yml
-     */
-    processResources {
-        inputs.properties(
-            "name" to rootProject.name,
-            "version" to rootProject.version,
-            "apiVersion" to apiVersion,
-            "main" to main,
-        )
-        filesMatching("**/plugin.yml") {
-            expand(inputs.properties)
-        }
-    }
-
-    shadowJar {
-        mergeServiceFiles()
-        //minimize()
-        relocate("io.github.slimjar", "$lib.slimjar")
-        exclude("modules/loader-agent.isolated-jar")
-    }
-}
-
-val templateSource = file("src/main/templates")
-val templateDest = layout.buildDirectory.dir("generated/sources/templates")
-val generateTemplates = tasks.register<Copy>("generateTemplates") {
-    inputs.properties(
-        "environment" to if (project.hasProperty("release")) "production" else "development",
-        "commit" to provider {
-            val res = runCatching { project.extensions.getByType<Grgit>().head().id }
-            res.getOrDefault("")
-                .takeIf { it.length == 40 } ?: {
-                logger.error("Git commit hash not found", res.exceptionOrNull())
-                "unknown"
-            }()
-        },
-    )
-
-    from(templateSource)
-    into(templateDest)
-    rename { "com/volmit/iris/$it" }
-    expand(inputs.properties)
-}
-
-tasks.generateSentryBundleIdJava {
-    dependsOn(generateTemplates)
-}
-
-rootProject.tasks.named("prepareKotlinBuildScriptModel") {
-    dependsOn(generateTemplates)
-}
-
-sourceSets.main {
-    java.srcDir(generateTemplates.map { it.outputs })
-}

core/src/main/java/com/volmit/iris/Iris.java

@@ -1,878 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris;
-
-import com.google.gson.JsonObject;
-import com.google.gson.JsonParseException;
-import com.google.gson.JsonParser;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.IrisWorlds;
-import com.volmit.iris.core.ServerConfigurator;
-import com.volmit.iris.core.link.IrisPapiExpansion;
-import com.volmit.iris.core.link.MultiverseCoreLink;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.v1X.NMSBinding1X;
-import com.volmit.iris.core.pregenerator.LazyPregenerator;
-import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.EnginePanic;
-import com.volmit.iris.engine.object.IrisCompat;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisWorld;
-import com.volmit.iris.engine.platform.BukkitChunkGenerator;
-import com.volmit.iris.core.safeguard.IrisSafeguard;
-import com.volmit.iris.engine.platform.PlatformChunkGenerator;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.exceptions.IrisException;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.function.NastyRunnable;
-import com.volmit.iris.util.io.FileWatcher;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.io.InstanceState;
-import com.volmit.iris.util.io.JarScanner;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.misc.Bindings;
-import com.volmit.iris.util.misc.SlimJar;
-import com.volmit.iris.util.misc.getHardware;
-import com.volmit.iris.util.parallel.MultiBurst;
-import com.volmit.iris.util.plugin.IrisService;
-import com.volmit.iris.util.plugin.VolmitPlugin;
-import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.plugin.chunk.ChunkTickets;
-import com.volmit.iris.util.scheduling.J;
-import com.volmit.iris.util.scheduling.Queue;
-import com.volmit.iris.util.scheduling.ShurikenQueue;
-import lombok.NonNull;
-import org.bukkit.*;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.command.Command;
-import org.bukkit.command.CommandSender;
-import org.bukkit.entity.Player;
-import org.bukkit.event.*;
-import org.bukkit.generator.BiomeProvider;
-import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.plugin.IllegalPluginAccessException;
-import org.bukkit.plugin.Plugin;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.*;
-import java.lang.annotation.Annotation;
-import java.net.URL;
-import java.util.*;
-import java.util.function.Predicate;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import static com.volmit.iris.core.safeguard.IrisSafeguard.*;
-import static com.volmit.iris.core.safeguard.ServerBootSFG.passedserversoftware;
-
-@SuppressWarnings("CanBeFinal")
-public class Iris extends VolmitPlugin implements Listener {
-    private static final Queue<Runnable> syncJobs = new ShurikenQueue<>();
-
-    public static Iris instance;
-    public static Bindings.Adventure audiences;
-    public static MultiverseCoreLink linkMultiverseCore;
-    public static IrisCompat compat;
-    public static FileWatcher configWatcher;
-    public static ChunkTickets tickets;
-    private static VolmitSender sender;
-    private static Thread shutdownHook;
-
-    static {
-        try {
-            InstanceState.updateInstanceId();
-        } catch (Throwable ignored) {
-
-        }
-    }
-
-    private final KList<Runnable> postShutdown = new KList<>();
-    private KMap<Class<? extends IrisService>, IrisService> services;
-
-    public static VolmitSender getSender() {
-        if (sender == null) {
-            sender = new VolmitSender(Bukkit.getConsoleSender());
-            sender.setTag(instance.getTag());
-        }
-        return sender;
-    }
-
-    @SuppressWarnings("unchecked")
-    public static <T> T service(Class<T> c) {
-        return (T) instance.services.get(c);
-    }
-
-    public static void callEvent(Event e) {
-        if (!e.isAsynchronous()) {
-            J.s(() -> Bukkit.getPluginManager().callEvent(e));
-        } else {
-            Bukkit.getPluginManager().callEvent(e);
-        }
-    }
-
-    public static KList<Object> initialize(String s, Class<? extends Annotation> slicedClass) {
-        JarScanner js = new JarScanner(instance.getJarFile(), s);
-        KList<Object> v = new KList<>();
-        J.attempt(js::scan);
-        for (Class<?> i : js.getClasses()) {
-            if (slicedClass == null || i.isAnnotationPresent(slicedClass)) {
-                try {
-                    v.add(i.getDeclaredConstructor().newInstance());
-                } catch (Throwable ignored) {
-
-                }
-            }
-        }
-
-        return v;
-    }
-
-    public static KList<Class<?>> getClasses(String s, Class<? extends Annotation> slicedClass) {
-        JarScanner js = new JarScanner(instance.getJarFile(), s);
-        KList<Class<?>> v = new KList<>();
-        J.attempt(js::scan);
-        for (Class<?> i : js.getClasses()) {
-            if (slicedClass == null || i.isAnnotationPresent(slicedClass)) {
-                try {
-                    v.add(i);
-                } catch (Throwable ignored) {
-
-                }
-            }
-        }
-
-        return v;
-    }
-
-    public static KList<Object> initialize(String s) {
-        return initialize(s, null);
-    }
-
-    public static void sq(Runnable r) {
-        synchronized (syncJobs) {
-            syncJobs.queue(r);
-        }
-    }
-
-    public static File getTemp() {
-        return instance.getDataFolder("cache", "temp");
-    }
-
-    public static void msg(String string) {
-        try {
-            getSender().sendMessage(string);
-        } catch (Throwable e) {
-            try {
-                instance.getLogger().info(instance.getTag() + string.replaceAll("(<([^>]+)>)", ""));
-            } catch (Throwable ignored1) {
-
-            }
-        }
-    }
-
-    public static File getCached(String name, String url) {
-        String h = IO.hash(name + "@" + url);
-        File f = Iris.instance.getDataFile("cache", h.substring(0, 2), h.substring(3, 5), h);
-
-        if (!f.exists()) {
-            try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream()); FileOutputStream fileOutputStream = new FileOutputStream(f)) {
-                byte[] dataBuffer = new byte[1024];
-                int bytesRead;
-                while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
-                    fileOutputStream.write(dataBuffer, 0, bytesRead);
-                    Iris.verbose("Aquiring " + name);
-                }
-            } catch (IOException e) {
-                Iris.reportError(e);
-            }
-        }
-
-        return f.exists() ? f : null;
-    }
-
-    public static String getNonCached(String name, String url) {
-        String h = IO.hash(name + "*" + url);
-        File f = Iris.instance.getDataFile("cache", h.substring(0, 2), h.substring(3, 5), h);
-
-        try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream()); FileOutputStream fileOutputStream = new FileOutputStream(f)) {
-            byte[] dataBuffer = new byte[1024];
-            int bytesRead;
-            while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
-                fileOutputStream.write(dataBuffer, 0, bytesRead);
-            }
-        } catch (IOException e) {
-            Iris.reportError(e);
-        }
-
-        try {
-            return IO.readAll(f);
-        } catch (IOException e) {
-            Iris.reportError(e);
-        }
-
-        return "";
-    }
-
-    public static File getNonCachedFile(String name, String url) {
-        String h = IO.hash(name + "*" + url);
-        File f = Iris.instance.getDataFile("cache", h.substring(0, 2), h.substring(3, 5), h);
-        Iris.verbose("Download " + name + " -> " + url);
-        try (BufferedInputStream in = new BufferedInputStream(new URL(url).openStream()); FileOutputStream fileOutputStream = new FileOutputStream(f)) {
-            byte[] dataBuffer = new byte[1024];
-            int bytesRead;
-            while ((bytesRead = in.read(dataBuffer, 0, 1024)) != -1) {
-                fileOutputStream.write(dataBuffer, 0, bytesRead);
-            }
-
-            fileOutputStream.flush();
-        } catch (IOException e) {
-            e.printStackTrace();
-            Iris.reportError(e);
-        }
-
-        return f;
-    }
-
-    public static void warn(String format, Object... objs) {
-        msg(C.YELLOW + String.format(format, objs));
-    }
-
-    public static void error(String format, Object... objs) {
-        msg(C.RED + String.format(format, objs));
-    }
-
-    public static void debug(String string) {
-        if (!IrisSettings.get().getGeneral().isDebug()) {
-            return;
-        }
-
-        try {
-            throw new RuntimeException();
-        } catch (Throwable e) {
-            try {
-                String[] cc = e.getStackTrace()[1].getClassName().split("\\Q.\\E");
-
-                if (cc.length > 5) {
-                    debug(cc[3] + "/" + cc[4] + "/" + cc[cc.length - 1], e.getStackTrace()[1].getLineNumber(), string);
-                } else {
-                    debug(cc[3] + "/" + cc[4], e.getStackTrace()[1].getLineNumber(), string);
-                }
-            } catch (Throwable ex) {
-                debug("Origin", -1, string);
-            }
-        }
-    }
-
-    public static void debug(String category, int line, String string) {
-        if (!IrisSettings.get().getGeneral().isDebug()) {
-            return;
-        }
-        if (IrisSettings.get().getGeneral().isUseConsoleCustomColors()) {
-            msg("<gradient:#095fe0:#a848db>" + category + " <#bf3b76>" + line + "<reset> " + C.LIGHT_PURPLE + string.replaceAll("\\Q<\\E", "[").replaceAll("\\Q>\\E", "]"));
-        } else {
-            msg(C.BLUE + category + ":" + C.AQUA + line + C.RESET + C.LIGHT_PURPLE + " " + string.replaceAll("\\Q<\\E", "[").replaceAll("\\Q>\\E", "]"));
-
-        }
-    }
-
-    public static void verbose(String string) {
-        debug(string);
-    }
-
-    public static void success(String string) {
-        msg(C.IRIS + string);
-    }
-
-    public static void info(String format, Object... args) {
-        msg(C.WHITE + String.format(format, args));
-    }
-    public static void safeguard(String format, Object... args) {
-        msg(C.RESET + String.format(format, args));
-    }
-
-    @SuppressWarnings("deprecation")
-    public static void later(NastyRunnable object) {
-        try {
-            Bukkit.getScheduler().scheduleAsyncDelayedTask(instance, () ->
-            {
-                try {
-                    object.run();
-                } catch (Throwable e) {
-                    e.printStackTrace();
-                    Iris.reportError(e);
-                }
-            }, RNG.r.i(100, 1200));
-        } catch (IllegalPluginAccessException ignored) {
-
-        }
-    }
-
-    public static int jobCount() {
-        return syncJobs.size();
-    }
-
-    public static void clearQueues() {
-        synchronized (syncJobs) {
-            syncJobs.clear();
-        }
-    }
-
-    public static int getJavaVersion() {
-        String version = System.getProperty("java.version");
-        if (version.startsWith("1.")) {
-            version = version.substring(2, 3);
-        } else {
-            int dot = version.indexOf(".");
-            if (dot != -1) {
-                version = version.substring(0, dot);
-            }
-        }
-        return Integer.parseInt(version);
-    }
-
-    public static String getJava() {
-        String javaRuntimeName = System.getProperty("java.vm.name");
-        String javaRuntimeVendor = System.getProperty("java.vendor");
-        String javaRuntimeVersion = System.getProperty("java.vm.version");
-        return String.format("%s %s (build %s)", javaRuntimeName, javaRuntimeVendor, javaRuntimeVersion);
-    }
-
-    public static void reportErrorChunk(int x, int z, Throwable e, String extra) {
-        if (IrisSettings.get().getGeneral().isDebug()) {
-            File f = instance.getDataFile("debug", "chunk-errors", "chunk." + x + "." + z + ".txt");
-
-            if (!f.exists()) {
-                J.attempt(() -> {
-                    PrintWriter pw = new PrintWriter(f);
-                    pw.println("Thread: " + Thread.currentThread().getName());
-                    pw.println("First: " + new Date(M.ms()));
-                    e.printStackTrace(pw);
-                    pw.close();
-                });
-            }
-
-            Iris.debug("Chunk " + x + "," + z + " Exception Logged: " + e.getClass().getSimpleName() + ": " + C.RESET + "" + C.LIGHT_PURPLE + e.getMessage());
-        }
-    }
-
-    public static void reportError(Throwable e) {
-        Bindings.capture(e);
-        if (IrisSettings.get().getGeneral().isDebug()) {
-            String n = e.getClass().getCanonicalName() + "-" + e.getStackTrace()[0].getClassName() + "-" + e.getStackTrace()[0].getLineNumber();
-
-            if (e.getCause() != null) {
-                n += "-" + e.getCause().getStackTrace()[0].getClassName() + "-" + e.getCause().getStackTrace()[0].getLineNumber();
-            }
-
-            File f = instance.getDataFile("debug", "caught-exceptions", n + ".txt");
-
-            if (!f.exists()) {
-                J.attempt(() -> {
-                    PrintWriter pw = new PrintWriter(f);
-                    pw.println("Thread: " + Thread.currentThread().getName());
-                    pw.println("First: " + new Date(M.ms()));
-                    e.printStackTrace(pw);
-                    pw.close();
-                });
-            }
-
-            Iris.debug("Exception Logged: " + e.getClass().getSimpleName() + ": " + C.RESET + "" + C.LIGHT_PURPLE + e.getMessage());
-        }
-    }
-
-    public static void dump() {
-        try {
-            File fi = Iris.instance.getDataFile("dump", "td-" + new java.sql.Date(M.ms()) + ".txt");
-            FileOutputStream fos = new FileOutputStream(fi);
-            Map<Thread, StackTraceElement[]> f = Thread.getAllStackTraces();
-            PrintWriter pw = new PrintWriter(fos);
-            for (Thread i : f.keySet()) {
-                pw.println("========================================");
-                pw.println("Thread: '" + i.getName() + "' ID: " + i.getId() + " STATUS: " + i.getState().name());
-
-                for (StackTraceElement j : f.get(i)) {
-                    pw.println("    @ " + j.toString());
-                }
-
-                pw.println("========================================");
-                pw.println();
-                pw.println();
-            }
-
-            pw.close();
-            Iris.info("DUMPED! See " + fi.getAbsolutePath());
-        } catch (Throwable e) {
-            e.printStackTrace();
-        }
-    }
-
-    public static void panic() {
-        EnginePanic.panic();
-    }
-
-    public static void addPanic(String s, String v) {
-        EnginePanic.add(s, v);
-    }
-
-    public Iris() {
-        instance = this;
-        SlimJar.load();
-    }
-
-    private void enable() {
-        services = new KMap<>();
-        setupAudience();
-        Bindings.setupSentry();
-        initialize("com.volmit.iris.core.service").forEach((i) -> services.put((Class<? extends IrisService>) i.getClass(), (IrisService) i));
-        IO.delete(new File("iris"));
-        compat = IrisCompat.configured(getDataFile("compat.json"));
-        ServerConfigurator.configure();
-        IrisSafeguard.IrisSafeguardSystem();
-        getSender().setTag(getTag());
-        IrisSafeguard.splash(true);
-        tickets = new ChunkTickets();
-        linkMultiverseCore = new MultiverseCoreLink();
-        configWatcher = new FileWatcher(getDataFile("settings.json"));
-        services.values().forEach(IrisService::onEnable);
-        services.values().forEach(this::registerListener);
-        addShutdownHook();
-        J.s(() -> {
-            J.a(IrisSafeguard::suggestPaper);
-            J.a(() -> IO.delete(getTemp()));
-            J.a(LazyPregenerator::loadLazyGenerators, 100);
-            J.a(this::bstats);
-            J.ar(this::checkConfigHotload, 60);
-            J.sr(this::tickQueue, 0);
-            J.s(this::setupPapi);
-            J.a(ServerConfigurator::configure, 20);
-            IrisSafeguard.splash(false);
-
-            autoStartStudio();
-            checkForBukkitWorlds(s -> true);
-            IrisToolbelt.retainMantleDataForSlice(String.class.getCanonicalName());
-            IrisToolbelt.retainMantleDataForSlice(BlockData.class.getCanonicalName());
-        });
-    }
-
-    public void addShutdownHook() {
-        if (shutdownHook != null) {
-            Runtime.getRuntime().removeShutdownHook(shutdownHook);
-        }
-        shutdownHook = new Thread(() -> {
-            Bukkit.getWorlds()
-                    .stream()
-                    .map(IrisToolbelt::access)
-                    .filter(Objects::nonNull)
-                    .forEach(PlatformChunkGenerator::close);
-
-            MultiBurst.burst.close();
-            MultiBurst.ioBurst.close();
-            services.clear();
-        });
-        Runtime.getRuntime().addShutdownHook(shutdownHook);
-    }
-
-    public void checkForBukkitWorlds(Predicate<String> filter) {
-        try {
-            IrisWorlds.readBukkitWorlds().forEach((s, generator) -> {
-                try {
-                    if (Bukkit.getWorld(s) != null || !filter.test(s)) return;
-
-                    Iris.info("Loading World: %s | Generator: %s", s, generator);
-                    var gen = getDefaultWorldGenerator(s, generator);
-                    var dim = loadDimension(s, generator);
-                    assert dim != null && gen != null;
-
-                    Iris.info(C.LIGHT_PURPLE + "Preparing Spawn for " + s + "' using Iris:" + generator + "...");
-                    WorldCreator c = new WorldCreator(s)
-                            .generator(gen)
-                            .environment(dim.getEnvironment());
-                    INMS.get().createWorld(c);
-                    Iris.info(C.LIGHT_PURPLE + "Loaded " + s + "!");
-                } catch (Throwable e) {
-                    Iris.error("Failed to load world " + s + "!");
-                    e.printStackTrace();
-                }
-            });
-        } catch (Throwable e) {
-            e.printStackTrace();
-            reportError(e);
-        }
-    }
-
-    private void autoStartStudio() {
-        if (IrisSettings.get().getStudio().isAutoStartDefaultStudio()) {
-            Iris.info("Starting up auto Studio!");
-            try {
-                Player r = new KList<>(getServer().getOnlinePlayers()).getRandom();
-                Iris.service(StudioSVC.class).open(r != null ? new VolmitSender(r) : getSender(), 1337, IrisSettings.get().getGenerator().getDefaultWorldType(), (w) -> {
-                    J.s(() -> {
-                        for (Player i : getServer().getOnlinePlayers()) {
-                            i.setGameMode(GameMode.SPECTATOR);
-                            i.teleport(new Location(w, 0, 200, 0));
-                        }
-                    });
-                });
-            } catch (IrisException e) {
-                reportError(e);
-            }
-        }
-    }
-
-    private void setupAudience() {
-        try {
-            audiences = new Bindings.Adventure(this);
-        } catch (Throwable e) {
-            e.printStackTrace();
-            IrisSettings.get().getGeneral().setUseConsoleCustomColors(false);
-            IrisSettings.get().getGeneral().setUseCustomColorsIngame(false);
-            Iris.error("Failed to setup Adventure API... No custom colors :(");
-        }
-    }
-
-    public void postShutdown(Runnable r) {
-        postShutdown.add(r);
-    }
-
-    public void onEnable() {
-        enable();
-        super.onEnable();
-        Bukkit.getPluginManager().registerEvents(this, this);
-        setupChecks();
-    }
-
-    public void onDisable() {
-        services.values().forEach(IrisService::onDisable);
-        Bukkit.getScheduler().cancelTasks(this);
-        HandlerList.unregisterAll((Plugin) this);
-        postShutdown.forEach(Runnable::run);
-        super.onDisable();
-
-        J.attempt(new JarScanner(instance.getJarFile(), "", false)::scanAll);
-    }
-
-    private void setupPapi() {
-        if (Bukkit.getPluginManager().getPlugin("PlaceholderAPI") != null) {
-            new IrisPapiExpansion().register();
-        }
-    }
-
-    @Override
-    public void start() {
-
-    }
-
-    @Override
-    public void stop() {
-
-    }
-
-    @Override
-    public String getTag(String subTag) {
-        if (unstablemode) {
-            return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.RED + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
-        }
-        if (warningmode) {
-            return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.GOLD + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
-        }
-        return C.BOLD + "" + C.DARK_GRAY + "[" + C.BOLD + "" + C.IRIS + "Iris" + C.BOLD + C.DARK_GRAY + "]" + C.RESET + "" + C.GRAY + ": ";
-
-    }
-
-    private boolean setupChecks() {
-        boolean passed = true;
-        Iris.info("Version Information: " + instance.getServer().getVersion() + " | " + instance.getServer().getBukkitVersion());
-        if (INMS.get() instanceof NMSBinding1X) {
-            passed = false;
-            Iris.warn("============================================");
-            Iris.warn("=");
-            Iris.warn("=");
-            Iris.warn("=");
-            Iris.warn("Iris is not compatible with this version of Minecraft.");
-            Iris.warn("=");
-            Iris.warn("=");
-            Iris.warn("=");
-            Iris.warn("============================================");
-        }
-
-        try {
-            Class.forName("io.papermc.paper.configuration.PaperConfigurations");
-        } catch (ClassNotFoundException e) {
-            Iris.info(C.RED + "Iris requires paper or above to function properly..");
-            return false;
-        }
-
-        try {
-            Class.forName("org.purpurmc.purpur.PurpurConfig");
-        } catch (ClassNotFoundException e) {
-            Iris.info("We recommend using Purpur for the best experience with Iris.");
-            Iris.info("Purpur is a fork of Paper that is optimized for performance and stability.");
-            Iris.info("Plugins that work on Spigot / Paper work on Purpur.");
-            Iris.info("You can download it here: https://purpurmc.org");
-            return false;
-        }
-        return passed;
-    }
-
-    private void checkConfigHotload() {
-        if (configWatcher.checkModified()) {
-            IrisSettings.invalidate();
-            IrisSettings.get();
-            configWatcher.checkModified();
-            Iris.info("Hotloaded settings.json ");
-        }
-    }
-
-    private void tickQueue() {
-        synchronized (Iris.syncJobs) {
-            if (!Iris.syncJobs.hasNext()) {
-                return;
-            }
-
-            long ms = M.ms();
-
-            while (Iris.syncJobs.hasNext() && M.ms() - ms < 25) {
-                try {
-                    Iris.syncJobs.next().run();
-                } catch (Throwable e) {
-                    e.printStackTrace();
-                    Iris.reportError(e);
-                }
-            }
-        }
-    }
-
-    private void bstats() {
-        if (IrisSettings.get().getGeneral().isPluginMetrics()) {
-            Bindings.setupBstats(this);
-        }
-    }
-
-    @Override
-    public boolean onCommand(CommandSender sender, Command command, String label, String[] args) {
-        return super.onCommand(sender, command, label, args);
-    }
-
-    public void imsg(CommandSender s, String msg) {
-        s.sendMessage(C.IRIS + "[" + C.DARK_GRAY + "Iris" + C.IRIS + "]" + C.GRAY + ": " + msg);
-    }
-
-    @Nullable
-    @Override
-    public BiomeProvider getDefaultBiomeProvider(@NotNull String worldName, @Nullable String id) {
-        Iris.debug("Biome Provider Called for " + worldName + " using ID: " + id);
-        return super.getDefaultBiomeProvider(worldName, id);
-    }
-
-    @Override
-    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
-        Iris.debug("Default World Generator Called for " + worldName + " using ID: " + id);
-        if (id == null || id.isEmpty()) id = IrisSettings.get().getGenerator().getDefaultWorldType();
-        Iris.debug("Generator ID: " + id + " requested by bukkit/plugin");
-        IrisDimension dim = loadDimension(worldName, id);
-        if (dim == null) {
-            throw new RuntimeException("Can't find dimension " + id + "!");
-        }
-
-        Iris.debug("Assuming IrisDimension: " + dim.getName());
-
-        IrisWorld w = IrisWorld.builder()
-                .name(worldName)
-                .seed(1337)
-                .environment(dim.getEnvironment())
-                .worldFolder(new File(Bukkit.getWorldContainer(), worldName))
-                .minHeight(dim.getMinHeight())
-                .maxHeight(dim.getMaxHeight())
-                .build();
-
-        Iris.debug("Generator Config: " + w.toString());
-
-        File ff = new File(w.worldFolder(), "iris/pack");
-        var files = ff.listFiles();
-        if (files == null || files.length == 0)
-            IO.delete(ff);
-
-        if (!ff.exists()) {
-            ff.mkdirs();
-            service(StudioSVC.class).installIntoWorld(getSender(), dim.getLoadKey(), w.worldFolder());
-        }
-
-        return new BukkitChunkGenerator(w, false, ff, dim.getLoadKey());
-    }
-
-    @Nullable
-    public static IrisDimension loadDimension(@NonNull String worldName, @NonNull String id) {
-        File pack = new File(Bukkit.getWorldContainer(), String.join(File.separator, worldName, "iris", "pack"));
-        var dimension = pack.isDirectory() ? IrisData.get(pack).getDimensionLoader().load(id) : null;
-        if (dimension == null) dimension = IrisData.loadAnyDimension(id, null);
-        if (dimension == null) {
-            Iris.warn("Unable to find dimension type " + id + " Looking for online packs...");
-            Iris.service(StudioSVC.class).downloadSearch(new VolmitSender(Bukkit.getConsoleSender()), id, false);
-            dimension = IrisData.loadAnyDimension(id, null);
-
-            if (dimension != null) {
-                Iris.info("Resolved missing dimension, proceeding.");
-            }
-        }
-
-        return dimension;
-    }
-
-    public void splash() {
-        if (!IrisSettings.get().getGeneral().isSplashLogoStartup()) {
-            return;
-        }
-
-        String padd = Form.repeat(" ", 8);
-        String padd2 = Form.repeat(" ", 4);
-        String[] info = {"", "", "", "", "", padd2 + C.IRIS + " Iris", padd2 + C.GRAY + " by " + "<rainbow>Volmit Software", padd2 + C.GRAY + " v" + C.IRIS + getDescription().getVersion()};
-        if (unstablemode) {
-            info = new String[]{"", "", "", "", "", padd2 + C.RED + " Iris", padd2 + C.GRAY + " by " + C.DARK_RED + "Volmit Software", padd2 + C.GRAY + " v" + C.RED + getDescription().getVersion()};
-        }
-        if (warningmode) {
-            info = new String[]{"", "", "", "", "", padd2 + C.GOLD + " Iris", padd2 + C.GRAY + " by " + C.GOLD + "Volmit Software", padd2 + C.GRAY + " v" + C.GOLD + getDescription().getVersion()};
-        }
-
-        String[] splashstable = {
-                padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
-                padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + C.IRIS + "   .(((()))).                     ",
-                padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + C.IRIS + "  .((((((())))))).                  ",
-                padd + C.GRAY + "@@@&&&&&" + C.DARK_GRAY + "&&&&&&&" + C.IRIS + "  ((((((((()))))))))               " + C.GRAY + " @",
-                padd + C.GRAY + "@@@&&&&" + C.DARK_GRAY + "@@@@@&" + C.IRIS + "    ((((((((-)))))))))              " + C.GRAY + " @@",
-                padd + C.GRAY + "@@@&&" + C.IRIS + "            ((((((({ }))))))))           " + C.GRAY + " &&@@@",
-                padd + C.GRAY + "@@" + C.IRIS + "               ((((((((-)))))))))    " + C.DARK_GRAY + "&@@@@@" + C.GRAY + "&&&&@@@",
-                padd + C.GRAY + "@" + C.IRIS + "                ((((((((()))))))))  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&@@@",
-                padd + C.GRAY + "" + C.IRIS + "                  '((((((()))))))'  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&&@@@",
-                padd + C.GRAY + "" + C.IRIS + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
-                padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
-        };
-
-        String[] splashunstable = {
-                padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
-                padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + C.RED + "   .(((()))).                     ",
-                padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + C.RED + "  .((((((())))))).                  ",
-                padd + C.GRAY + "@@@&&&&&" + C.DARK_GRAY + "&&&&&&&" + C.RED + "  ((((((((()))))))))               " + C.GRAY + " @",
-                padd + C.GRAY + "@@@&&&&" + C.DARK_GRAY + "@@@@@&" + C.RED + "    ((((((((-)))))))))              " + C.GRAY + " @@",
-                padd + C.GRAY + "@@@&&" + C.RED + "            ((((((({ }))))))))           " + C.GRAY + " &&@@@",
-                padd + C.GRAY + "@@" + C.RED + "               ((((((((-)))))))))    " + C.DARK_GRAY + "&@@@@@" + C.GRAY + "&&&&@@@",
-                padd + C.GRAY + "@" + C.RED + "                ((((((((()))))))))  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&@@@",
-                padd + C.GRAY + "" + C.RED + "                  '((((((()))))))'  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&&@@@",
-                padd + C.GRAY + "" + C.RED + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
-                padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
-        };
-        String[] splashwarning = {
-                padd + C.GRAY + "   @@@@@@@@@@@@@@" + C.DARK_GRAY + "@@@",
-                padd + C.GRAY + " @@&&&&&&&&&" + C.DARK_GRAY + "&&&&&&" + C.GOLD + "   .(((()))).                     ",
-                padd + C.GRAY + "@@@&&&&&&&&" + C.DARK_GRAY + "&&&&&" + C.GOLD + "  .((((((())))))).                  ",
-                padd + C.GRAY + "@@@&&&&&" + C.DARK_GRAY + "&&&&&&&" + C.GOLD + "  ((((((((()))))))))               " + C.GRAY + " @",
-                padd + C.GRAY + "@@@&&&&" + C.DARK_GRAY + "@@@@@&" + C.GOLD + "    ((((((((-)))))))))              " + C.GRAY + " @@",
-                padd + C.GRAY + "@@@&&" + C.GOLD + "            ((((((({ }))))))))           " + C.GRAY + " &&@@@",
-                padd + C.GRAY + "@@" + C.GOLD + "               ((((((((-)))))))))    " + C.DARK_GRAY + "&@@@@@" + C.GRAY + "&&&&@@@",
-                padd + C.GRAY + "@" + C.GOLD + "                ((((((((()))))))))  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&@@@",
-                padd + C.GRAY + "" + C.GOLD + "                  '((((((()))))))'  " + C.DARK_GRAY + "&&&&&" + C.GRAY + "&&&&&&&&@@@",
-                padd + C.GRAY + "" + C.GOLD + "                     '(((())))'   " + C.DARK_GRAY + "&&&&&&&&" + C.GRAY + "&&&&&&&@@",
-                padd + C.GRAY + "                               " + C.DARK_GRAY + "@@@" + C.GRAY + "@@@@@@@@@@@@@@"
-        };
-        String[] splash;
-        File freeSpace = new File(Bukkit.getWorldContainer() + ".");
-        if (unstablemode) {
-            splash = splashunstable;
-        } else if (warningmode) {
-            splash = splashwarning;
-        } else {
-            splash = splashstable;
-        }
-
-        if (!passedserversoftware) {
-            Iris.info("Server type & version: " + C.RED + Bukkit.getVersion());
-        } else { Iris.info("Server type & version: " + Bukkit.getVersion()); }
-        Iris.info("Java: " + getJava());
-        if (getHardware.getProcessMemory() < 5999) {
-            Iris.warn("6GB+ Ram is recommended");
-            Iris.warn("Process Memory: " + getHardware.getProcessMemory() + " MB");
-        }
-        Iris.info("Bukkit distro: " + Bukkit.getName());
-        Iris.info("Custom Biomes: " + INMS.get().countCustomBiomes());
-        setupChecks();
-        printPacks();
-
-        for (int i = 0; i < info.length; i++) {
-            splash[i] += info[i];
-        }
-
-        Iris.info("\n\n " + new KList<>(splash).toString("\n") + "\n");
-    }
-
-    private void printPacks() {
-        File packFolder = Iris.service(StudioSVC.class).getWorkspaceFolder();
-        File[] packs = packFolder.listFiles(File::isDirectory);
-        if (packs == null || packs.length == 0)
-            return;
-        Iris.info("Custom Dimensions: " + packs.length);
-        for (File f : packs)
-            printPack(f);
-    }
-
-    private void printPack(File pack) {
-        String dimName = pack.getName();
-        String version = "???";
-        try (FileReader r = new FileReader(new File(pack, "dimensions/" + dimName + ".json"))) {
-            JsonObject json = JsonParser.parseReader(r).getAsJsonObject();
-            if (json.has("version"))
-                version = json.get("version").getAsString();
-        } catch (IOException | JsonParseException ignored) {
-        }
-        Iris.info("  " + dimName + " v" + version);
-    }
-
-    public int getIrisVersion() {
-        String input = Iris.instance.getDescription().getVersion();
-        int hyphenIndex = input.indexOf('-');
-        if (hyphenIndex != -1) {
-            String result = input.substring(0, hyphenIndex);
-            result = result.replaceAll("\\.", "");
-            return Integer.parseInt(result);
-        }
-        return -1;
-    }
-
-    public int getMCVersion() {
-        try {
-            String version = Bukkit.getVersion();
-            Matcher matcher = Pattern.compile("\\(MC: ([\\d.]+)\\)").matcher(version);
-            if (matcher.find()) {
-                version = matcher.group(1).replaceAll("\\.", "");
-                long versionNumber = Long.parseLong(version);
-                if (versionNumber > Integer.MAX_VALUE) {
-                    return -1;
-                }
-                return (int) versionNumber;
-            }
-            return -1;
-        } catch (Exception e) {
-            return -1;
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/IrisSettings.java

@@ -1,276 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core;
-
-import com.google.gson.Gson;
-import com.volmit.iris.Iris;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.json.JSONException;
-import com.volmit.iris.util.json.JSONObject;
-import com.volmit.iris.util.misc.getHardware;
-import com.volmit.iris.util.plugin.VolmitSender;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-import java.io.File;
-import java.io.IOException;
-
-@SuppressWarnings("SynchronizeOnNonFinalField")
-@Data
-public class IrisSettings {
-    public static IrisSettings settings;
-    private IrisSettingsGeneral general = new IrisSettingsGeneral();
-    private IrisSettingsWorld world = new IrisSettingsWorld();
-    private IrisSettingsGUI gui = new IrisSettingsGUI();
-    private IrisSettingsAutoconfiguration autoConfiguration = new IrisSettingsAutoconfiguration();
-    private IrisSettingsGenerator generator = new IrisSettingsGenerator();
-    private IrisSettingsConcurrency concurrency = new IrisSettingsConcurrency();
-    private IrisSettingsStudio studio = new IrisSettingsStudio();
-    private IrisSettingsPerformance performance = new IrisSettingsPerformance();
-    private IrisSettingsUpdater updater = new IrisSettingsUpdater();
-    private IrisSettingsPregen pregen = new IrisSettingsPregen();
-    private IrisSettingsSentry sentry = new IrisSettingsSentry();
-
-    public static int getThreadCount(int c) {
-        return Math.max(switch (c) {
-            case -1, -2, -4 -> Runtime.getRuntime().availableProcessors() / -c;
-            default -> Math.max(c, 2);
-        }, 1);
-    }
-
-    public static IrisSettings get() {
-        if (settings != null) {
-            return settings;
-        }
-
-        settings = new IrisSettings();
-
-        File s = Iris.instance.getDataFile("settings.json");
-
-        if (!s.exists()) {
-            try {
-                IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
-            } catch (JSONException | IOException e) {
-                e.printStackTrace();
-                Iris.reportError(e);
-            }
-        } else {
-            try {
-                String ss = IO.readAll(s);
-                settings = new Gson().fromJson(ss, IrisSettings.class);
-                try {
-                    IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
-                } catch (IOException e) {
-                    e.printStackTrace();
-                }
-            } catch (Throwable ee) {
-                // Iris.reportError(ee); causes a self-reference & stackoverflow
-                Iris.error("Configuration Error in settings.json! " + ee.getClass().getSimpleName() + ": " + ee.getMessage());
-            }
-        }
-
-        return settings;
-    }
-
-    public static void invalidate() {
-        synchronized (settings) {
-            settings = null;
-        }
-    }
-
-    public void forceSave() {
-        File s = Iris.instance.getDataFile("settings.json");
-
-        try {
-            IO.writeAll(s, new JSONObject(new Gson().toJson(settings)).toString(4));
-        } catch (JSONException | IOException e) {
-            e.printStackTrace();
-            Iris.reportError(e);
-        }
-    }
-
-    @Data
-    public static class IrisSettingsAutoconfiguration {
-        public boolean configureSpigotTimeoutTime = true;
-        public boolean configurePaperWatchdogDelay = true;
-        public boolean autoRestartOnCustomBiomeInstall = true;
-    }
-
-    @Data
-    public static class IrisAsyncTeleport {
-        public boolean enabled = false;
-        public int loadViewDistance = 2;
-        public boolean urgent = false;
-    }
-
-    @Data
-    public static class IrisSettingsWorld {
-        public IrisAsyncTeleport asyncTeleport = new IrisAsyncTeleport();
-        public boolean postLoadBlockUpdates = true;
-        public boolean forcePersistEntities = true;
-        public boolean anbientEntitySpawningSystem = true;
-        public long asyncTickIntervalMS = 700;
-        public double targetSpawnEntitiesPerChunk = 0.95;
-        public boolean markerEntitySpawningSystem = true;
-        public boolean effectSystem = true;
-        public boolean worldEditWandCUI = true;
-        public boolean globalPregenCache = false;
-    }
-
-    @Data
-    public static class IrisSettingsConcurrency {
-        public int parallelism = -1;
-        public int ioParallelism = -2;
-        public int worldGenParallelism = -1;
-
-        public int getWorldGenThreads() {
-            return getThreadCount(worldGenParallelism);
-        }
-    }
-
-    @Data
-    public static class IrisSettingsPregen {
-        public boolean useCacheByDefault = true;
-        public boolean useHighPriority = false;
-        public boolean useVirtualThreads = false;
-        public boolean useTicketQueue = true;
-        public int maxConcurrency = 256;
-    }
-
-    @Data
-    public static class IrisSettingsPerformance {
-        private IrisSettingsEngineSVC engineSVC = new IrisSettingsEngineSVC();
-        public boolean trimMantleInStudio = false; 
-        public int mantleKeepAlive = 30;
-        public int noiseCacheSize = 1_024;
-        public int resourceLoaderCacheSize = 1_024;
-        public int objectLoaderCacheSize = 4_096;
-        public int scriptLoaderCacheSize = 512;
-        public int tectonicPlateSize = -1;
-        public int mantleCleanupDelay = 200;
-
-        public int getTectonicPlateSize() {
-            if (tectonicPlateSize > 0)
-                return tectonicPlateSize;
-
-            return (int) (getHardware.getProcessMemory() / 200L);
-        }
-    }
-
-    @Data
-    public static class IrisSettingsUpdater {
-        public int maxConcurrency = 256;
-        public boolean nativeThreads = false;
-        public double threadMultiplier = 2;
-
-        public double chunkLoadSensitivity = 0.7;
-        public MsRange emptyMsRange = new MsRange(80, 100);
-        public MsRange defaultMsRange = new MsRange(20, 40);
-
-        public int getMaxConcurrency() {
-            return Math.max(Math.abs(maxConcurrency), 1);
-        }
-
-        public double getThreadMultiplier() {
-            return Math.min(Math.abs(threadMultiplier), 0.1);
-        }
-
-        public double getChunkLoadSensitivity() {
-            return Math.min(chunkLoadSensitivity, 0.9);
-        }
-    }
-
-    @Data
-    @NoArgsConstructor
-    @AllArgsConstructor
-    public static class MsRange {
-        public int min = 20;
-        public int max = 40;
-    }
-
-    @Data
-    public static class IrisSettingsGeneral {
-        public boolean DoomsdayAnnihilationSelfDestructMode = false;
-        public boolean commandSounds = true;
-        public boolean debug = false;
-        public boolean dumpMantleOnError = false;
-        public boolean disableNMS = false;
-        public boolean pluginMetrics = true;
-        public boolean splashLogoStartup = true;
-        public boolean useConsoleCustomColors = true;
-        public boolean useCustomColorsIngame = true;
-        public boolean adjustVanillaHeight = false;
-        public String forceMainWorld = "";
-        public int spinh = -20;
-        public int spins = 7;
-        public int spinb = 8;
-        public String cartographerMessage = "Iris does not allow cartographers in its world due to crashes.";
-
-
-        @SuppressWarnings("BooleanMethodIsAlwaysInverted")
-        public boolean canUseCustomColors(VolmitSender volmitSender) {
-            return volmitSender.isPlayer() ? useCustomColorsIngame : useConsoleCustomColors;
-        }
-    }
-
-    @Data
-    public static class IrisSettingsSentry {
-        public boolean includeServerId = true;
-        public boolean disableAutoReporting = false;
-        public boolean debug = false;
-    }
-
-    @Data
-    public static class IrisSettingsGUI {
-        public boolean useServerLaunchedGuis = true;
-        public boolean maximumPregenGuiFPS = false;
-        public boolean colorMode = true;
-    }
-
-    @Data
-    public static class IrisSettingsGenerator {
-        public String defaultWorldType = "overworld";
-        public int maxBiomeChildDepth = 4;
-        public boolean preventLeafDecay = true;
-        public boolean useMulticore = false;
-        public boolean useMulticoreMantle = false;
-        public boolean offsetNoiseTypes = false;
-        public boolean earlyCustomBlocks = false;
-    }
-
-    @Data
-    public static class IrisSettingsStudio {
-        public boolean studio = true;
-        public boolean openVSCode = true;
-        public boolean disableTimeAndWeather = true;
-        public boolean autoStartDefaultStudio = false;
-    }
-
-    @Data
-    public static class IrisSettingsEngineSVC {
-        public boolean useVirtualThreads = true;
-        public boolean forceMulticoreWrite = false;
-        public int priority = Thread.NORM_PRIORITY;
-
-        public int getPriority() {
-            return Math.max(Math.min(priority, Thread.MAX_PRIORITY), Thread.MIN_PRIORITY);
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/IrisWorlds.java

@@ -1,126 +0,0 @@
-package com.volmit.iris.core;
-
-import com.google.gson.Gson;
-import com.google.gson.GsonBuilder;
-import com.google.gson.reflect.TypeToken;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.engine.data.cache.AtomicCache;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.misc.ServerProperties;
-import org.bukkit.Bukkit;
-import org.bukkit.configuration.file.YamlConfiguration;
-
-import java.io.File;
-import java.io.IOException;
-import java.io.OutputStreamWriter;
-import java.lang.reflect.Type;
-import java.util.Objects;
-import java.util.stream.Stream;
-
-public class IrisWorlds {
-    private static final AtomicCache<IrisWorlds> cache = new AtomicCache<>();
-    private static final Gson GSON = new GsonBuilder().setPrettyPrinting().create();
-    private static final Type TYPE = TypeToken.getParameterized(KMap.class, String.class, String.class).getType();
-    private final KMap<String, String> worlds;
-    private volatile boolean dirty = false;
-
-    private IrisWorlds(KMap<String, String> worlds) {
-        this.worlds = worlds;
-        readBukkitWorlds().forEach(this::put0);
-        save();
-    }
-
-    public static IrisWorlds get() {
-        return cache.aquire(() -> {
-            File file = Iris.instance.getDataFile("worlds.json");
-            if (!file.exists()) {
-                return new IrisWorlds(new KMap<>());
-            }
-
-            try {
-                String json = IO.readAll(file);
-                KMap<String, String> worlds = GSON.fromJson(json, TYPE);
-                return new IrisWorlds(Objects.requireNonNullElseGet(worlds, KMap::new));
-            } catch (Throwable e) {
-                Iris.error("Failed to load worlds.json!");
-                e.printStackTrace();
-                Iris.reportError(e);
-            }
-
-            return new IrisWorlds(new KMap<>());
-        });
-    }
-
-    public void put(String name, String type) {
-        put0(name, type);
-        save();
-    }
-
-    private void put0(String name, String type) {
-        String old = worlds.put(name, type);
-        if (!type.equals(old))
-            dirty = true;
-    }
-
-    public KMap<String, String> getWorlds() {
-        clean();
-        return readBukkitWorlds().put(worlds);
-    }
-
-    public Stream<IrisData> getPacks() {
-        return getDimensions()
-                .map(IrisDimension::getLoader)
-                .filter(Objects::nonNull);
-    }
-
-    public Stream<IrisDimension> getDimensions() {
-        return getWorlds()
-                .entrySet()
-                .stream()
-                .map(entry -> Iris.loadDimension(entry.getKey(), entry.getValue()))
-                .filter(Objects::nonNull);
-    }
-
-    public void clean() {
-        dirty = worlds.entrySet().removeIf(entry -> !new File(Bukkit.getWorldContainer(), entry.getKey() + "/iris/pack/dimensions/" + entry.getValue() + ".json").exists());
-    }
-
-    public synchronized void save() {
-        clean();
-        if (!dirty) return;
-        try {
-            IO.write(Iris.instance.getDataFile("worlds.json"), OutputStreamWriter::new, writer -> GSON.toJson(worlds, TYPE, writer));
-            dirty = false;
-        } catch (IOException e) {
-            Iris.error("Failed to save worlds.json!");
-            e.printStackTrace();
-            Iris.reportError(e);
-        }
-    }
-
-    public static KMap<String, String> readBukkitWorlds() {
-        var bukkit = YamlConfiguration.loadConfiguration(ServerProperties.BUKKIT_YML);
-        var worlds = bukkit.getConfigurationSection("worlds");
-        if (worlds == null) return new KMap<>();
-
-        var result = new KMap<String, String>();
-        for (String world : worlds.getKeys(false)) {
-            var gen = worlds.getString(world + ".generator");
-            if (gen == null) continue;
-
-            String loadKey;
-            if (gen.equalsIgnoreCase("iris")) {
-                loadKey = IrisSettings.get().getGenerator().getDefaultWorldType();
-            } else if (gen.startsWith("Iris:")) {
-                loadKey = gen.substring(5);
-            } else continue;
-
-            result.put(world, loadKey);
-        }
-
-        return result;
-    }
-}

core/src/main/java/com/volmit/iris/core/ServerConfigurator.java

@@ -1,314 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.datapack.DataVersion;
-import com.volmit.iris.core.nms.datapack.IDataFixer;
-import com.volmit.iris.engine.object.*;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.misc.ServerProperties;
-import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.J;
-import lombok.NonNull;
-import lombok.SneakyThrows;
-import org.bukkit.Bukkit;
-import org.bukkit.configuration.InvalidConfigurationException;
-import org.bukkit.configuration.file.FileConfiguration;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.entity.Player;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.File;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.Objects;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicIntegerArray;
-import java.util.stream.Stream;
-
-public class ServerConfigurator {
-    public static void configure() {
-        IrisSettings.IrisSettingsAutoconfiguration s = IrisSettings.get().getAutoConfiguration();
-        if (s.isConfigureSpigotTimeoutTime()) {
-            J.attempt(ServerConfigurator::increaseKeepAliveSpigot);
-        }
-
-        if (s.isConfigurePaperWatchdogDelay()) {
-            J.attempt(ServerConfigurator::increasePaperWatchdog);
-        }
-
-        installDataPacks(true);
-    }
-
-    private static void increaseKeepAliveSpigot() throws IOException, InvalidConfigurationException {
-        File spigotConfig = new File("spigot.yml");
-        FileConfiguration f = new YamlConfiguration();
-        f.load(spigotConfig);
-        long tt = f.getLong("settings.timeout-time");
-
-        long spigotTimeout = TimeUnit.MINUTES.toSeconds(5);
-
-        if (tt < spigotTimeout) {
-            Iris.warn("Updating spigot.yml timeout-time: " + tt + " -> " + spigotTimeout + " (5 minutes)");
-            Iris.warn("You can disable this change (autoconfigureServer) in Iris settings, then change back the value.");
-            f.set("settings.timeout-time", spigotTimeout);
-            f.save(spigotConfig);
-        }
-    }
-    private static void increasePaperWatchdog() throws IOException, InvalidConfigurationException {
-        File spigotConfig = new File("config/paper-global.yml");
-        FileConfiguration f = new YamlConfiguration();
-        f.load(spigotConfig);
-        long tt = f.getLong("watchdog.early-warning-delay");
-
-        long watchdog = TimeUnit.MINUTES.toMillis(3);
-        if (tt < watchdog) {
-            Iris.warn("Updating paper.yml watchdog early-warning-delay: " + tt + " -> " + watchdog + " (3 minutes)");
-            Iris.warn("You can disable this change (autoconfigureServer) in Iris settings, then change back the value.");
-            f.set("watchdog.early-warning-delay", watchdog);
-            f.save(spigotConfig);
-        }
-    }
-
-    private static KList<File> getDatapacksFolder() {
-        if (!IrisSettings.get().getGeneral().forceMainWorld.isEmpty()) {
-            return new KList<File>().qadd(new File(Bukkit.getWorldContainer(), IrisSettings.get().getGeneral().forceMainWorld + "/datapacks"));
-        }
-        KList<File> worlds = new KList<>();
-        Bukkit.getServer().getWorlds().forEach(w -> worlds.add(new File(w.getWorldFolder(), "datapacks")));
-        if (worlds.isEmpty()) worlds.add(new File(Bukkit.getWorldContainer(), ServerProperties.LEVEL_NAME + "/datapacks"));
-        return worlds;
-    }
-
-    public static boolean installDataPacks(boolean fullInstall) {
-        return installDataPacks(DataVersion.getDefault(), fullInstall);
-    }
-
-    public static boolean installDataPacks(IDataFixer fixer, boolean fullInstall) {
-        if (fixer == null) {
-            Iris.error("Unable to install datapacks, fixer is null!");
-            return false;
-        }
-        Iris.info("Checking Data Packs...");
-        DimensionHeight height = new DimensionHeight(fixer);
-        KList<File> folders = getDatapacksFolder();
-        KMap<String, KSet<String>> biomes = new KMap<>();
-
-        try (Stream<IrisData> stream = allPacks()) {
-            stream.flatMap(height::merge)
-                    .parallel()
-                    .forEach(dim -> {
-                        Iris.verbose("  Checking Dimension " + dim.getLoadFile().getPath());
-                        dim.installBiomes(fixer, dim::getLoader, folders, biomes.computeIfAbsent(dim.getLoadKey(), k -> new KSet<>()));
-                        dim.installDimensionType(fixer, folders);
-                    });
-        }
-        IrisDimension.writeShared(folders, height);
-        Iris.info("Data Packs Setup!");
-
-        return fullInstall && verifyDataPacksPost(IrisSettings.get().getAutoConfiguration().isAutoRestartOnCustomBiomeInstall());
-    }
-
-    private static boolean verifyDataPacksPost(boolean allowRestarting) {
-        try (Stream<IrisData> stream = allPacks()) {
-            boolean bad = stream
-                    .map(data -> {
-                        Iris.verbose("Checking Pack: " + data.getDataFolder().getPath());
-                        var loader = data.getDimensionLoader();
-                        return loader.loadAll(loader.getPossibleKeys())
-                                .stream()
-                                .filter(Objects::nonNull)
-                                .map(ServerConfigurator::verifyDataPackInstalled)
-                                .toList()
-                                .contains(false);
-                    })
-                    .toList()
-                    .contains(true);
-            if (!bad) return false;
-        }
-
-
-        if (allowRestarting) {
-            restart();
-        } else if (INMS.get().supportsDataPacks()) {
-            Iris.error("============================================================================");
-            Iris.error(C.ITALIC + "You need to restart your server to properly generate custom biomes.");
-            Iris.error(C.ITALIC + "By continuing, Iris will use backup biomes in place of the custom biomes.");
-            Iris.error("----------------------------------------------------------------------------");
-            Iris.error(C.UNDERLINE + "IT IS HIGHLY RECOMMENDED YOU RESTART THE SERVER BEFORE GENERATING!");
-            Iris.error("============================================================================");
-
-            for (Player i : Bukkit.getOnlinePlayers()) {
-                if (i.isOp() || i.hasPermission("iris.all")) {
-                    VolmitSender sender = new VolmitSender(i, Iris.instance.getTag("WARNING"));
-                    sender.sendMessage("There are some Iris Packs that have custom biomes in them");
-                    sender.sendMessage("You need to restart your server to use these packs.");
-                }
-            }
-
-            J.sleep(3000);
-        }
-        return true;
-    }
-
-    public static void restart() {
-        J.s(() -> {
-            Iris.warn("New data pack entries have been installed in Iris! Restarting server!");
-            Iris.warn("This will only happen when your pack changes (updates/first time setup)");
-            Iris.warn("(You can disable this auto restart in iris settings)");
-            J.s(() -> {
-                Iris.warn("Looks like the restart command didn't work. Stopping the server instead!");
-                Bukkit.shutdown();
-            }, 100);
-            Bukkit.dispatchCommand(Bukkit.getConsoleSender(), "restart");
-        });
-    }
-
-    public static boolean verifyDataPackInstalled(IrisDimension dimension) {
-        KSet<String> keys = new KSet<>();
-        boolean warn = false;
-
-        for (IrisBiome i : dimension.getAllBiomes(dimension::getLoader)) {
-            if (i.isCustom()) {
-                for (IrisBiomeCustom j : i.getCustomDerivitives()) {
-                    keys.add(dimension.getLoadKey() + ":" + j.getId());
-                }
-            }
-        }
-        String key = getWorld(dimension.getLoader());
-        if (key == null) key = dimension.getLoadKey();
-        else key += "/" + dimension.getLoadKey();
-
-        if (!INMS.get().supportsDataPacks()) {
-            if (!keys.isEmpty()) {
-                Iris.warn("===================================================================================");
-                Iris.warn("Pack " + key + " has " + keys.size() + " custom biome(s). ");
-                Iris.warn("Your server version does not yet support datapacks for iris.");
-                Iris.warn("The world will generate these biomes as backup biomes.");
-                Iris.warn("====================================================================================");
-            }
-
-            return true;
-        }
-
-        for (String i : keys) {
-            Object o = INMS.get().getCustomBiomeBaseFor(i);
-
-            if (o == null) {
-                Iris.warn("The Biome " + i + " is not registered on the server.");
-                warn = true;
-            }
-        }
-
-        if (INMS.get().missingDimensionTypes(dimension.getDimensionTypeKey())) {
-            Iris.warn("The Dimension Type for " + dimension.getLoadFile() + " is not registered on the server.");
-            warn = true;
-        }
-
-        if (warn) {
-            Iris.error("The Pack " + key + " is INCAPABLE of generating custom biomes");
-            Iris.error("If not done automatically, restart your server before generating with this pack!");
-        }
-
-        return !warn;
-    }
-
-    public static Stream<IrisData> allPacks() {
-        return Stream.concat(listFiles(Iris.instance.getDataFolder("packs"))
-                .filter(File::isDirectory)
-                .filter( base -> {
-                    var content = new File(base, "dimensions").listFiles();
-                    return content != null && content.length > 0;
-                })
-                .map(IrisData::get), IrisWorlds.get().getPacks());
-    }
-
-    @Nullable
-    public static String getWorld(@NonNull IrisData data) {
-        String worldContainer = Bukkit.getWorldContainer().getAbsolutePath();
-        if (!worldContainer.endsWith(File.separator)) worldContainer += File.separator;
-        
-        String path = data.getDataFolder().getAbsolutePath();
-        if (!path.startsWith(worldContainer)) return null;
-        int l = path.endsWith(File.separator) ? 11 : 10;
-        return path.substring(worldContainer.length(), path.length() - l);
-    }
-
-    @SneakyThrows
-    private static Stream<File> listFiles(File parent) {
-        if (!parent.isDirectory()) return Stream.empty();
-        return Files.walk(parent.toPath()).map(Path::toFile);
-    }
-
-    public static class DimensionHeight {
-        private final IDataFixer fixer;
-        private final AtomicIntegerArray[] dimensions = new AtomicIntegerArray[3];
-
-        public DimensionHeight(IDataFixer fixer) {
-            this.fixer = fixer;
-            for (int i = 0; i < 3; i++) {
-                dimensions[i] = new AtomicIntegerArray(new int[]{
-                        Integer.MAX_VALUE, Integer.MIN_VALUE, Integer.MIN_VALUE
-                });
-            }
-        }
-
-        public Stream<IrisDimension> merge(IrisData data) {
-            Iris.verbose("Checking Pack: " + data.getDataFolder().getPath());
-            var loader = data.getDimensionLoader();
-            return loader.loadAll(loader.getPossibleKeys())
-                    .stream()
-                    .filter(Objects::nonNull)
-                    .peek(this::merge);
-        }
-
-        public void merge(IrisDimension dimension) {
-            AtomicIntegerArray array = dimensions[dimension.getBaseDimension().ordinal()];
-            array.updateAndGet(0, min -> Math.min(min, dimension.getMinHeight()));
-            array.updateAndGet(1, max -> Math.max(max, dimension.getMaxHeight()));
-            array.updateAndGet(2, logical -> Math.max(logical, dimension.getLogicalHeight()));
-        }
-
-        public String[] jsonStrings() {
-            var dims = IDataFixer.Dimension.values();
-            var arr = new String[3];
-            for (int i = 0; i < 3; i++) {
-                arr[i] = jsonString(dims[i]);
-            }
-            return arr;
-        }
-
-        public String jsonString(IDataFixer.Dimension dimension) {
-            var data = dimensions[dimension.ordinal()];
-            int minY = data.get(0);
-            int maxY = data.get(1);
-            int logicalHeight = data.get(2);
-            if (minY == Integer.MAX_VALUE || maxY == Integer.MIN_VALUE || Integer.MIN_VALUE == logicalHeight)
-                return null;
-            return fixer.createDimension(dimension, minY, maxY - minY, logicalHeight, null).toString(4);
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/commands/CommandDeveloper.java

@@ -1,459 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.google.gson.JsonArray;
-import com.google.gson.JsonElement;
-import com.google.gson.JsonObject;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.ServerConfigurator;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.datapack.DataVersion;
-import com.volmit.iris.core.service.IrisEngineSVC;
-import com.volmit.iris.core.tools.IrisPackBenchmarking;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.annotations.Snippet;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.context.IrisContext;
-import com.volmit.iris.engine.object.IrisJigsawStructurePlacement;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.decree.specialhandlers.NullableDimensionHandler;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.io.CountingDataInputStream;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.mantle.TectonicPlate;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.matter.Matter;
-import com.volmit.iris.util.nbt.mca.MCAFile;
-import com.volmit.iris.util.nbt.mca.MCAUtil;
-import com.volmit.iris.util.parallel.MultiBurst;
-import com.volmit.iris.util.plugin.VolmitSender;
-import lombok.SneakyThrows;
-import net.jpountz.lz4.LZ4BlockInputStream;
-import net.jpountz.lz4.LZ4BlockOutputStream;
-import net.jpountz.lz4.LZ4FrameInputStream;
-import net.jpountz.lz4.LZ4FrameOutputStream;
-import org.apache.commons.lang.RandomStringUtils;
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.World;
-
-import java.io.*;
-import java.net.InetAddress;
-import java.net.NetworkInterface;
-import java.nio.file.Files;
-import java.util.*;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.stream.Collectors;
-import java.util.zip.GZIPInputStream;
-import java.util.zip.GZIPOutputStream;
-
-@Decree(name = "Developer", origin = DecreeOrigin.BOTH, description = "Iris World Manager", aliases = {"dev"})
-public class CommandDeveloper implements DecreeExecutor {
-    private CommandTurboPregen turboPregen;
-    private CommandLazyPregen lazyPregen;
-
-    @Decree(description = "Get Loaded TectonicPlates Count", origin = DecreeOrigin.BOTH, sync = true)
-    public void EngineStatus() {
-        Iris.service(IrisEngineSVC.class)
-                .engineStatus(sender());
-    }
-
-    @Decree(description = "Send a test exception to sentry")
-    public void Sentry() {
-        Engine engine = engine();
-        if (engine != null) IrisContext.getOr(engine);
-        Iris.reportError(new Exception("This is a test"));
-    }
-
-    @Decree(description = "Test")
-    public void mantle(@Param(defaultValue = "false") boolean plate, @Param(defaultValue = "21474836474") String name) throws Throwable {
-        var base = Iris.instance.getDataFile("dump", "pv." + name + ".ttp.lz4b.bin");
-        var section = Iris.instance.getDataFile("dump", "pv." + name + ".section.bin");
-
-        //extractSection(base, section, 5604930, 4397);
-
-        if (plate) {
-            try (var in = CountingDataInputStream.wrap(new BufferedInputStream(new FileInputStream(base)))) {
-                new TectonicPlate(1088, in, true);
-            } catch (Throwable e) {
-                e.printStackTrace();
-            }
-        } else Matter.read(section);
-        if (!TectonicPlate.hasError())
-            Iris.info("Read " + (plate ? base : section).length() + " bytes from " + (plate ? base : section).getAbsolutePath());
-    }
-
-    private void extractSection(File source, File target, long offset, int length) throws IOException {
-        var raf = new RandomAccessFile(source, "r");
-        var bytes = new byte[length];
-        raf.seek(offset);
-        raf.readFully(bytes);
-        raf.close();
-        Files.write(target.toPath(), bytes);
-    }
-
-    @Decree(description = "Test")
-    public void dumpThreads() {
-        try {
-            File fi = Iris.instance.getDataFile("dump", "td-" + new java.sql.Date(M.ms()) + ".txt");
-            FileOutputStream fos = new FileOutputStream(fi);
-            Map<Thread, StackTraceElement[]> f = Thread.getAllStackTraces();
-            PrintWriter pw = new PrintWriter(fos);
-
-            pw.println(Thread.activeCount() + "/" + f.size());
-            var run = Runtime.getRuntime();
-            pw.println("Memory:");
-            pw.println("\tMax: " + run.maxMemory());
-            pw.println("\tTotal: " + run.totalMemory());
-            pw.println("\tFree: " + run.freeMemory());
-            pw.println("\tUsed: " + (run.totalMemory() - run.freeMemory()));
-
-            for (Thread i : f.keySet()) {
-                pw.println("========================================");
-                pw.println("Thread: '" + i.getName() + "' ID: " + i.getId() + " STATUS: " + i.getState().name());
-
-                for (StackTraceElement j : f.get(i)) {
-                    pw.println("    @ " + j.toString());
-                }
-
-                pw.println("========================================");
-                pw.println();
-                pw.println();
-            }
-
-            pw.close();
-            Iris.info("DUMPED! See " + fi.getAbsolutePath());
-        } catch (Throwable e) {
-            e.printStackTrace();
-        }
-    }
-
-    @SneakyThrows
-    @Decree(description = "Generate Iris structures for all loaded datapack structures")
-    public void generateStructures(
-            @Param(description = "The pack to add the generated structures to", aliases = "pack", defaultValue = "null", customHandler = NullableDimensionHandler.class)
-            IrisDimension dimension,
-            @Param(description = "Ignore existing structures", defaultValue = "false")
-            boolean force
-    ) {
-        var map = INMS.get().collectStructures();
-        if (map.isEmpty()) {
-            sender().sendMessage(C.IRIS + "No structures found");
-            return;
-        }
-
-        sender().sendMessage(C.IRIS + "Found " + map.size() + " structures");
-
-        final File dataDir;
-        final IrisData data;
-        final Set<String> existingStructures;
-        final Map<String, Set<String>> snippets;
-        final File dimensionFile;
-        final File structuresFolder;
-        final File snippetsFolder;
-
-        var dimensionObj = new JsonObject();
-
-        if (dimension == null) {
-            dataDir = Iris.instance.getDataFolder("structures");
-            IO.delete(dataDir);
-            data = IrisData.get(dataDir);
-            existingStructures = Set.of();
-            snippets = Map.of();
-            dimensionFile = new File(dataDir, "structures.json");
-        } else {
-            data = dimension.getLoader();
-            dataDir = data.getDataFolder();
-            existingStructures = new KSet<>(data.getJigsawStructureLoader().getPossibleKeys());
-
-            dimensionObj = data.getGson().fromJson(IO.readAll(dimension.getLoadFile()), JsonObject.class);
-            snippets = Optional.ofNullable(dimensionObj.getAsJsonArray("jigsawStructures"))
-                    .map(array -> array.asList()
-                            .stream()
-                            .filter(JsonElement::isJsonPrimitive)
-                            .collect(Collectors.toMap(element -> data.getGson()
-                                            .fromJson(element, IrisJigsawStructurePlacement.class)
-                                            .getStructure(),
-                                    element -> Set.of(element.getAsString()),
-                                    KSet::merge)))
-                    .orElse(Map.of());
-
-            dimensionFile = dimension.getLoadFile();
-        }
-        structuresFolder = new File(dataDir, "jigsaw-structures");
-        snippetsFolder = new File(dataDir, "snippet" + "/" + IrisJigsawStructurePlacement.class.getAnnotation(Snippet.class).value());
-
-        var gson = data.getGson();
-        var jigsawStructures = Optional.ofNullable(dimensionObj.getAsJsonArray("jigsawStructures"))
-                .orElse(new JsonArray(map.size()));
-
-        map.forEach((key, placement) -> {
-            String loadKey = "datapack/" + key.namespace() + "/" + key.key();
-            if (existingStructures.contains(loadKey) && !force)
-                return;
-
-            var structures = placement.structures();
-            var obj = placement.toJson(loadKey);
-            if (obj == null || structures.isEmpty()) {
-                sender().sendMessage(C.RED + "Failed to generate hook for " + key);
-                return;
-            }
-            File snippetFile = new File(snippetsFolder, loadKey + ".json");
-            try {
-                IO.writeAll(snippetFile, gson.toJson(obj));
-            } catch (IOException e) {
-                sender().sendMessage(C.RED + "Failed to generate snippet for " + key);
-                e.printStackTrace();
-                return;
-            }
-
-            Set<String> loadKeys = snippets.getOrDefault(loadKey, Set.of(loadKey));
-            jigsawStructures.asList().removeIf(e -> loadKeys.contains((e.isJsonObject() ? e.getAsJsonObject().get("structure") : e).getAsString()));
-            jigsawStructures.add("snippet/" + loadKey);
-
-            String structureKey;
-            if (structures.size() > 1) {
-                KList<String> common = new KList<>();
-                for (int i = 0; i < structures.size(); i++) {
-                    var tags = structures.get(i).tags();
-                    if (i == 0) common.addAll(tags);
-                    else common.removeIf(tag -> !tags.contains(tag));
-                }
-                structureKey = common.isNotEmpty() ? "#" + common.getFirst() : structures.getFirst().key();
-            } else structureKey = structures.getFirst().key();
-
-            JsonArray array = new JsonArray();
-            if (structures.size() > 1) {
-                structures.stream()
-                        .flatMap(structure -> {
-                            String[] arr = new String[structure.weight()];
-                            Arrays.fill(arr, structure.key());
-                            return Arrays.stream(arr);
-                        })
-                        .forEach(array::add);
-            } else array.add(structureKey);
-
-            obj = new JsonObject();
-            obj.addProperty("structureKey", structureKey);
-            obj.add("datapackStructures", array);
-
-            File out = new File(structuresFolder, loadKey + ".json");
-            out.getParentFile().mkdirs();
-            try {
-                IO.writeAll(out, gson.toJson(obj));
-            } catch (IOException e) {
-                e.printStackTrace();
-            }
-        });
-
-        dimensionObj.add("jigsawStructures", jigsawStructures);
-        IO.writeAll(dimensionFile, gson.toJson(dimensionObj));
-
-        data.hotloaded();
-    }
-
-    @Decree(description = "Test")
-    public void packBenchmark(
-            @Param(description = "The pack to bench", aliases = {"pack"}, defaultValue = "overworld")
-            IrisDimension dimension,
-            @Param(description = "Radius in regions", defaultValue = "2048")
-            int radius,
-            @Param(description = "Open GUI while benchmarking", defaultValue = "false")
-            boolean gui
-    ) {
-        new IrisPackBenchmarking(dimension, radius, gui);
-    }
-
-    @Decree(description = "Upgrade to another Minecraft version")
-    public void upgrade(
-            @Param(description = "The version to upgrade to", defaultValue = "latest") DataVersion version) {
-        sender().sendMessage(C.GREEN + "Upgrading to " + version.getVersion() + "...");
-        ServerConfigurator.installDataPacks(version.get(), false);
-        sender().sendMessage(C.GREEN + "Done upgrading! You can now update your server version to " + version.getVersion());
-    }
-
-    @Decree(description = "test")
-    public void mca (
-            @Param(description = "String") String world) {
-        try {
-            File[] McaFiles = new File(world, "region").listFiles((dir, name) -> name.endsWith(".mca"));
-            for (File mca : McaFiles) {
-                MCAFile MCARegion = MCAUtil.read(mca);
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-    }
-
-    @Decree(description = "UnloadChunks for good reasons.")
-    public void unloadchunks() {
-        List<World> IrisWorlds = new ArrayList<>();
-        int chunksUnloaded = 0;
-        for (World world : Bukkit.getWorlds()) {
-            try {
-                if (IrisToolbelt.access(world).getEngine() != null) {
-                    IrisWorlds.add(world);
-                }
-            } catch (Exception e) {
-                // no
-            }
-        }
-
-        for (World world : IrisWorlds) {
-            for (Chunk chunk : world.getLoadedChunks()) {
-                if (chunk.isLoaded()) {
-                    chunk.unload();
-                    chunksUnloaded++;
-                }
-            }
-        }
-        Iris.info(C.IRIS + "Chunks Unloaded: " + chunksUnloaded);
-
-    }
-
-    @Decree
-    public void objects(@Param(defaultValue = "overworld") IrisDimension dimension) {
-        var loader = dimension.getLoader().getObjectLoader();
-        var sender = sender();
-        var keys = loader.getPossibleKeys();
-        var burst = MultiBurst.burst.burst(keys.length);
-        AtomicInteger failed = new AtomicInteger();
-        for (String key : keys) {
-            burst.queue(() -> {
-                if (loader.load(key) == null)
-                    failed.incrementAndGet();
-            });
-        }
-        burst.complete();
-        sender.sendMessage(C.RED + "Failed to load " + failed.get() + " of " + keys.length + " objects");
-    }
-
-    @Decree(description = "Test", aliases = {"ip"})
-    public void network() {
-        try {
-            Enumeration<NetworkInterface> networkInterfaces = NetworkInterface.getNetworkInterfaces();
-            for (NetworkInterface ni : Collections.list(networkInterfaces)) {
-                Iris.info("Display Name: %s", ni.getDisplayName());
-                Enumeration<InetAddress> inetAddresses = ni.getInetAddresses();
-                for (InetAddress ia : Collections.list(inetAddresses)) {
-                    Iris.info("IP: %s", ia.getHostAddress());
-                }
-            }
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Decree(description = "Test the compression algorithms")
-    public void compression(
-            @Param(description = "base IrisWorld") World world,
-            @Param(description = "raw TectonicPlate File") String path,
-            @Param(description = "Algorithm to Test") String algorithm,
-            @Param(description = "Amount of Tests") int amount,
-            @Param(description = "Is versioned", defaultValue = "false") boolean versioned) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", Bukkit.getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
-            return;
-        }
-
-        File file = new File(path);
-        if (!file.exists()) return;
-
-        Engine engine = IrisToolbelt.access(world).getEngine();
-        if(engine != null) {
-            int height = engine.getTarget().getHeight();
-            ExecutorService service = Executors.newFixedThreadPool(1);
-            VolmitSender sender = sender();
-            service.submit(() -> {
-                try {
-                    CountingDataInputStream raw = CountingDataInputStream.wrap(new FileInputStream(file));
-                    TectonicPlate plate = new TectonicPlate(height, raw, versioned);
-                    raw.close();
-
-                    double d1 = 0;
-                    double d2 = 0;
-                    long size = 0;
-                    File folder = new File("tmp");
-                    folder.mkdirs();
-                    for (int i = 0; i < amount; i++) {
-                        File tmp = new File(folder, RandomStringUtils.randomAlphanumeric(10) + "." + algorithm + ".bin");
-                        DataOutputStream dos = createOutput(tmp, algorithm);
-                        long start = System.currentTimeMillis();
-                        plate.write(dos);
-                        dos.close();
-                        d1 += System.currentTimeMillis() - start;
-                        if (size == 0)
-                            size = tmp.length();
-                        start = System.currentTimeMillis();
-                        CountingDataInputStream din = createInput(tmp, algorithm);
-                        new TectonicPlate(height, din, true);
-                        din.close();
-                        d2 += System.currentTimeMillis() - start;
-                        tmp.delete();
-                    }
-                    IO.delete(folder);
-                    sender.sendMessage(algorithm + " is " + Form.fileSize(size) + " big after compression");
-                    sender.sendMessage(algorithm + " Took " + d2/amount + "ms to read");
-                    sender.sendMessage(algorithm + " Took " + d1/amount + "ms to write");
-                } catch (Throwable e) {
-                    e.printStackTrace();
-                }
-            });
-            service.shutdown();
-		} else {
-            Iris.info(C.RED + "Engine is null!");
-        }
-    }
-
-    private CountingDataInputStream createInput(File file, String algorithm) throws Throwable {
-        FileInputStream in = new FileInputStream(file);
-
-        return CountingDataInputStream.wrap(switch (algorithm) {
-            case "gzip" -> new GZIPInputStream(in);
-            case "lz4f" -> new LZ4FrameInputStream(in);
-            case "lz4b" -> new LZ4BlockInputStream(in);
-            default -> throw new IllegalStateException("Unexpected value: " + algorithm);
-        });
-    }
-
-    private DataOutputStream createOutput(File file, String algorithm) throws Throwable {
-        FileOutputStream out = new FileOutputStream(file);
-
-        return new DataOutputStream(switch (algorithm) {
-            case "gzip" -> new GZIPOutputStream(out);
-            case "lz4f" -> new LZ4FrameOutputStream(out);
-            case "lz4b" -> new LZ4BlockOutputStream(out);
-            default -> throw new IllegalStateException("Unexpected value: " + algorithm);
-        });
-    }
-}
-
-

core/src/main/java/com/volmit/iris/core/commands/CommandEdit.java

@@ -1,179 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.engine.object.*;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-
-import java.awt.*;
-
-
-@Decree(name = "edit", origin = DecreeOrigin.PLAYER, studio = true, description = "Edit something")
-public class CommandEdit implements DecreeExecutor {
-
-    private boolean noStudio() {
-        if (!sender().isPlayer()) {
-            sender().sendMessage(C.RED + "Players only!");
-            return true;
-        }
-        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
-            sender().sendMessage(C.RED + "No studio world is open!");
-            return true;
-        }
-        if (!engine().isStudio()) {
-            sender().sendMessage(C.RED + "You must be in a studio world!");
-            return true;
-        }
-        return false;
-    }
-
-
-    @Decree(description = "Edit the biome you specified", aliases = {"b"}, origin = DecreeOrigin.PLAYER)
-    public void biome(@Param(contextual = false, description = "The biome to edit") IrisBiome biome) {
-        if (noStudio()) {
-            return;
-        }
-        try {
-            if (biome == null || biome.getLoadFile() == null) {
-                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
-                return;
-            }
-            Desktop.getDesktop().open(biome.getLoadFile());
-            sender().sendMessage(C.GREEN + "Opening " + biome.getTypeName() + " " + biome.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
-        }
-    }
-
-    @Decree(description = "Edit the region you specified", aliases = {"r"}, origin = DecreeOrigin.PLAYER)
-    public void region(@Param(contextual = false, description = "The region to edit") IrisRegion region) {
-        if (noStudio()) {
-            return;
-        }
-        try {
-            if (region == null || region.getLoadFile() == null) {
-                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
-                return;
-            }
-            Desktop.getDesktop().open(region.getLoadFile());
-            sender().sendMessage(C.GREEN + "Opening " + region.getTypeName() + " " + region.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
-        }
-    }
-
-    @Decree(description = "Edit the dimension you specified", aliases = {"d"}, origin = DecreeOrigin.PLAYER)
-    public void dimension(@Param(contextual = false, description = "The dimension to edit") IrisDimension dimension) {
-        if (noStudio()) {
-            return;
-        }
-        try {
-            if (dimension == null || dimension.getLoadFile() == null) {
-                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
-                return;
-            }
-            Desktop.getDesktop().open(dimension.getLoadFile());
-            sender().sendMessage(C.GREEN + "Opening " + dimension.getTypeName() + " " + dimension.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
-        }
-    }
-
-    @Decree(description = "Edit the cave file you specified", aliases = {"c"}, origin = DecreeOrigin.PLAYER)
-    public void cave(@Param(contextual = false, description = "The cave to edit") IrisCave cave) {
-        if (noStudio()) {
-            return;
-        }
-        try {
-            if (cave == null || cave.getLoadFile() == null) {
-                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
-                return;
-            }
-            Desktop.getDesktop().open(cave.getLoadFile());
-            sender().sendMessage(C.GREEN + "Opening " + cave.getTypeName() + " " + cave.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
-        }
-    }
-
-    @Decree(description = "Edit the structure file you specified", aliases = {"jigsawstructure", "structure"}, origin = DecreeOrigin.PLAYER)
-    public void jigsaw(@Param(contextual = false, description = "The jigsaw structure to edit") IrisJigsawStructure jigsaw) {
-        if (noStudio()) {
-            return;
-        }
-        try {
-            if (jigsaw == null || jigsaw.getLoadFile() == null) {
-                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
-                return;
-            }
-            Desktop.getDesktop().open(jigsaw.getLoadFile());
-            sender().sendMessage(C.GREEN + "Opening " + jigsaw.getTypeName() + " " + jigsaw.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
-        }
-    }
-
-    @Decree(description = "Edit the pool file you specified", aliases = {"jigsawpool", "pool"}, origin = DecreeOrigin.PLAYER)
-    public void jigsawPool(@Param(contextual = false, description = "The jigsaw pool to edit") IrisJigsawPool pool) {
-        if (noStudio()) {
-            return;
-        }
-        try {
-            if (pool == null || pool.getLoadFile() == null) {
-                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
-                return;
-            }
-            Desktop.getDesktop().open(pool.getLoadFile());
-            sender().sendMessage(C.GREEN + "Opening " + pool.getTypeName() + " " + pool.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
-        }
-    }
-
-    @Decree(description = "Edit the jigsaw piece file you specified", aliases = {"jigsawpiece", "piece"}, origin = DecreeOrigin.PLAYER)
-    public void jigsawPiece(@Param(contextual = false, description = "The jigsaw piece to edit") IrisJigsawPiece piece) {
-        if (noStudio()) {
-            return;
-        }
-        try {
-            if (piece == null || piece.getLoadFile() == null) {
-                sender().sendMessage(C.GOLD + "Cannot find the file; Perhaps it was not loaded directly from a file?");
-                return;
-            }
-            Desktop.getDesktop().open(piece.getLoadFile());
-            sender().sendMessage(C.GREEN + "Opening " + piece.getTypeName() + " " + piece.getLoadFile().getName().split("\\Q.\\E")[0] + " in VSCode! ");
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            sender().sendMessage(C.RED + "Cant find the file. Or registrant does not exist");
-        }
-    }
-
-}

core/src/main/java/com/volmit/iris/core/commands/CommandFind.java

@@ -1,117 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisJigsawStructure;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
-import com.volmit.iris.util.format.C;
-
-@Decree(name = "find", origin = DecreeOrigin.PLAYER, description = "Iris Find commands", aliases = "goto")
-public class CommandFind implements DecreeExecutor {
-    @Decree(description = "Find a biome")
-    public void biome(
-            @Param(description = "The biome to look for")
-            IrisBiome biome,
-            @Param(description = "Should you be teleported", defaultValue = "true")
-            boolean teleport
-    ) {
-        Engine e = engine();
-
-        if (e == null) {
-            sender().sendMessage(C.GOLD + "Not in an Iris World!");
-            return;
-        }
-
-        e.gotoBiome(biome, player(), teleport);
-    }
-
-    @Decree(description = "Find a region")
-    public void region(
-            @Param(description = "The region to look for")
-            IrisRegion region,
-            @Param(description = "Should you be teleported", defaultValue = "true")
-            boolean teleport
-    ) {
-        Engine e = engine();
-
-        if (e == null) {
-            sender().sendMessage(C.GOLD + "Not in an Iris World!");
-            return;
-        }
-
-        e.gotoRegion(region, player(), teleport);
-    }
-
-    @Decree(description = "Find a structure")
-    public void structure(
-            @Param(description = "The structure to look for")
-            IrisJigsawStructure structure,
-            @Param(description = "Should you be teleported", defaultValue = "true")
-            boolean teleport
-    ) {
-        Engine e = engine();
-
-        if (e == null) {
-            sender().sendMessage(C.GOLD + "Not in an Iris World!");
-            return;
-        }
-
-        e.gotoJigsaw(structure, player(), teleport);
-    }
-
-    @Decree(description = "Find a point of interest.")
-    public void poi(
-            @Param(description = "The type of PoI to look for.")
-            String type,
-            @Param(description = "Should you be teleported", defaultValue = "true")
-            boolean teleport
-    ) {
-        Engine e = engine();
-        if (e == null) {
-            sender().sendMessage(C.GOLD + "Not in an Iris World!");
-            return;
-        }
-
-        e.gotoPOI(type, player(), teleport);
-    }
-
-    @Decree(description = "Find an object")
-    public void object(
-            @Param(description = "The object to look for", customHandler = ObjectHandler.class)
-            String object,
-            @Param(description = "Should you be teleported", defaultValue = "true")
-            boolean teleport
-    ) {
-        Engine e = engine();
-
-        if (e == null) {
-            sender().sendMessage(C.GOLD + "Not in an Iris World!");
-            return;
-        }
-
-        e.gotoObject(object, player(), teleport);
-    }
-}

core/src/main/java/com/volmit/iris/core/commands/CommandIris.java

@@ -1,540 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.decree.specialhandlers.NullablePlayerHandler;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.misc.ServerProperties;
-import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.J;
-import lombok.SneakyThrows;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.configuration.ConfigurationSection;
-import org.bukkit.configuration.file.YamlConfiguration;
-import org.bukkit.entity.Player;
-import org.bukkit.scheduler.BukkitRunnable;
-
-import java.io.*;
-import java.util.List;
-import java.util.concurrent.atomic.AtomicReference;
-
-import static com.volmit.iris.core.service.EditSVC.deletingWorld;
-import static com.volmit.iris.util.misc.ServerProperties.BUKKIT_YML;
-import static org.bukkit.Bukkit.getServer;
-
-@Decree(name = "iris", aliases = {"ir", "irs"}, description = "Basic Command")
-public class CommandIris implements DecreeExecutor {
-    private CommandUpdater updater;
-    private CommandStudio studio;
-    private CommandPregen pregen;
-    private CommandSettings settings;
-    private CommandObject object;
-    private CommandJigsaw jigsaw;
-    private CommandWhat what;
-    private CommandEdit edit;
-    private CommandFind find;
-    private CommandDeveloper developer;
-    public static boolean worldCreation = false;
-    private static final AtomicReference<Thread> mainWorld = new AtomicReference<>();
-    String WorldEngine;
-    String worldNameToCheck = "YourWorldName";
-    VolmitSender sender = Iris.getSender();
-
-    @Decree(description = "Create a new world", aliases = {"+", "c"})
-    public void create(
-            @Param(aliases = "world-name", description = "The name of the world to create")
-            String name,
-            @Param(aliases = "dimension", description = "The dimension type to create the world with", defaultValue = "default")
-            IrisDimension type,
-            @Param(description = "The seed to generate the world with", defaultValue = "1337")
-            long seed,
-            @Param(aliases = "main-world", description = "Whether or not to automatically use this world as the main world", defaultValue = "false")
-            boolean main
-    ) {
-        if (name.equalsIgnoreCase("iris")) {
-            sender().sendMessage(C.RED + "You cannot use the world name \"iris\" for creating worlds as Iris uses this directory for studio worlds.");
-            sender().sendMessage(C.RED + "May we suggest the name \"IrisWorld\" instead?");
-            return;
-        }
-
-        if (name.equalsIgnoreCase("benchmark")) {
-            sender().sendMessage(C.RED + "You cannot use the world name \"benchmark\" for creating worlds as Iris uses this directory for Benchmarking Packs.");
-            sender().sendMessage(C.RED + "May we suggest the name \"IrisWorld\" instead?");
-            return;
-        }
-
-        if (new File(Bukkit.getWorldContainer(), name).exists()) {
-            sender().sendMessage(C.RED + "That folder already exists!");
-            return;
-        }
-
-        try {
-            worldCreation = true;
-            IrisToolbelt.createWorld()
-                    .dimension(type.getLoadKey())
-                    .name(name)
-                    .seed(seed)
-                    .sender(sender())
-                    .studio(false)
-                    .create();
-            if (main) {
-                Runtime.getRuntime().addShutdownHook(mainWorld.updateAndGet(old -> {
-                    if (old != null) Runtime.getRuntime().removeShutdownHook(old);
-                    return new Thread(() -> updateMainWorld(name));
-                }));
-            }
-        } catch (Throwable e) {
-            sender().sendMessage(C.RED + "Exception raised during creation. See the console for more details.");
-            Iris.error("Exception raised during world creation: " + e.getMessage());
-            Iris.reportError(e);
-            worldCreation = false;
-            return;
-        }
-        worldCreation = false;
-        sender().sendMessage(C.GREEN + "Successfully created your world!");
-        if (main) sender().sendMessage(C.GREEN + "Your world will automatically be set as the main world when the server restarts.");
-    }
-
-    @SneakyThrows
-    private void updateMainWorld(String newName) {
-        File worlds = Bukkit.getWorldContainer();
-        var data = ServerProperties.DATA;
-        try (var in = new FileInputStream(ServerProperties.SERVER_PROPERTIES)) {
-            data.load(in);
-        }
-        for (String sub : List.of("datapacks", "playerdata", "advancements", "stats")) {
-            IO.copyDirectory(new File(worlds, ServerProperties.LEVEL_NAME + "/" + sub).toPath(), new File(worlds, newName + "/" + sub).toPath());
-        }
-
-        data.setProperty("level-name", newName);
-        try (var out = new FileOutputStream(ServerProperties.SERVER_PROPERTIES)) {
-            data.store(out, null);
-        }
-    }
-
-    @Decree(description = "Teleport to another world", aliases = {"tp"}, sync = true)
-    public void teleport(
-            @Param(description = "World to teleport to")
-            World world,
-            @Param(description = "Player to teleport", defaultValue = "---", customHandler = NullablePlayerHandler.class)
-            Player player
-    ) {
-        if (player == null && sender().isPlayer())
-            player = sender().player();
-
-        final Player target = player;
-        if (target == null) {
-            sender().sendMessage(C.RED + "The specified player does not exist.");
-            return;
-        }
-
-        new BukkitRunnable() {
-            @Override
-            public void run() {
-                target.teleport(world.getSpawnLocation());
-                new VolmitSender(target).sendMessage(C.GREEN + "You have been teleported to " + world.getName() + ".");
-            }
-        }.runTask(Iris.instance);
-    }
-
-    @Decree(description = "Print version information")
-    public void version() {
-        sender().sendMessage(C.GREEN + "Iris v" + Iris.instance.getDescription().getVersion() + " by Volmit Software");
-    }
-
-    /*
-    /todo
-    @Decree(description = "Benchmark a pack", origin = DecreeOrigin.CONSOLE)
-    public void packbenchmark(
-            @Param(description = "Dimension to benchmark")
-            IrisDimension type
-    ) throws InterruptedException {
-
-         BenchDimension = type.getLoadKey();
-
-        IrisPackBenchmarking.runBenchmark();
-    } */
-
-    @Decree(description = "Print world height information", origin = DecreeOrigin.PLAYER)
-    public void height() {
-        if (sender().isPlayer()) {
-            sender().sendMessage(C.GREEN + "" + sender().player().getWorld().getMinHeight() + " to " + sender().player().getWorld().getMaxHeight());
-            sender().sendMessage(C.GREEN + "Total Height: " + (sender().player().getWorld().getMaxHeight() - sender().player().getWorld().getMinHeight()));
-        } else {
-            World mainWorld = getServer().getWorlds().get(0);
-            Iris.info(C.GREEN + "" + mainWorld.getMinHeight() + " to " + mainWorld.getMaxHeight());
-            Iris.info(C.GREEN + "Total Height: " + (mainWorld.getMaxHeight() - mainWorld.getMinHeight()));
-        }
-    }
-
-    @Decree(description = "QOL command to open a overworld studio world.", sync = true)
-    public void so() {
-        sender().sendMessage(C.GREEN + "Opening studio for the \"Overworld\" pack (seed: 1337)");
-        Iris.service(StudioSVC.class).open(sender(), 1337, "overworld");
-    }
-
-    @Decree(description = "Check access of all worlds.", aliases = {"accesslist"})
-    public void worlds() {
-        KList<World> IrisWorlds = new KList<>();
-        KList<World> BukkitWorlds = new KList<>();
-
-        for (World w : Bukkit.getServer().getWorlds()) {
-            try {
-                Engine engine = IrisToolbelt.access(w).getEngine();
-                if (engine != null) {
-                    IrisWorlds.add(w);
-                }
-            } catch (Exception e) {
-                BukkitWorlds.add(w);
-            }
-        }
-
-        if (sender().isPlayer()) {
-            sender().sendMessage(C.BLUE + "Iris Worlds: ");
-            for (World IrisWorld : IrisWorlds.copy()) {
-                sender().sendMessage(C.IRIS + "- " +IrisWorld.getName());
-            }
-            sender().sendMessage(C.GOLD + "Bukkit Worlds: ");
-            for (World BukkitWorld : BukkitWorlds.copy()) {
-                sender().sendMessage(C.GRAY + "- " +BukkitWorld.getName());
-            }
-        } else {
-            Iris.info(C.BLUE + "Iris Worlds: ");
-            for (World IrisWorld : IrisWorlds.copy()) {
-                Iris.info(C.IRIS + "- " +IrisWorld.getName());
-            }
-            Iris.info(C.GOLD + "Bukkit Worlds: ");
-            for (World BukkitWorld : BukkitWorlds.copy()) {
-                Iris.info(C.GRAY + "- " +BukkitWorld.getName());
-            }
-            
-        }
-    }
-
-    @Decree(description = "Remove an Iris world", aliases = {"del", "rm", "delete"}, sync = true)
-    public void remove(
-            @Param(description = "The world to remove")
-            World world,
-            @Param(description = "Whether to also remove the folder (if set to false, just does not load the world)", defaultValue = "true")
-            boolean delete
-    ) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
-            return;
-        }
-        sender().sendMessage(C.GREEN + "Removing world: " + world.getName());
-
-        if (!IrisToolbelt.evacuate(world)) {
-            sender().sendMessage(C.RED + "Failed to evacuate world: " + world.getName());
-            return;
-        }
-
-        if (!Bukkit.unloadWorld(world, false)) {
-            sender().sendMessage(C.RED + "Failed to unload world: " + world.getName());
-            return;
-        }
-
-        try {
-            if (IrisToolbelt.removeWorld(world)) {
-                sender().sendMessage(C.GREEN + "Successfully removed " + world.getName() + " from bukkit.yml");
-            } else {
-                sender().sendMessage(C.YELLOW + "Looks like the world was already removed from bukkit.yml");
-            }
-        } catch (IOException e) {
-            sender().sendMessage(C.RED + "Failed to save bukkit.yml because of " + e.getMessage());
-            e.printStackTrace();
-        }
-        IrisToolbelt.evacuate(world, "Deleting world");
-        deletingWorld = true;
-        if (!delete) {
-            deletingWorld = false;
-            return;
-        }
-        VolmitSender sender = sender();
-        J.a(() -> {
-            int retries = 12;
-
-            if (deleteDirectory(world.getWorldFolder())) {
-                sender.sendMessage(C.GREEN + "Successfully removed world folder");
-            } else {
-                while(true){
-                    if (deleteDirectory(world.getWorldFolder())){
-                        sender.sendMessage(C.GREEN + "Successfully removed world folder");
-                        break;
-                    }
-                    retries--;
-                    if (retries == 0){
-                        sender.sendMessage(C.RED + "Failed to remove world folder");
-                        break;
-                    }
-                    J.sleep(3000);
-                }
-            }
-            deletingWorld = false;
-        });
-    }
-
-    public static boolean deleteDirectory(File dir) {
-        if (dir.isDirectory()) {
-            File[] children = dir.listFiles();
-            for (int i = 0; i < children.length; i++) {
-                boolean success = deleteDirectory(children[i]);
-                if (!success) {
-                    return false;
-                }
-            }
-        }
-        return dir.delete();
-    }
-
-    @Decree(description = "Set aura spins")
-    public void aura(
-            @Param(description = "The h color value", defaultValue = "-20")
-            int h,
-            @Param(description = "The s color value", defaultValue = "7")
-            int s,
-            @Param(description = "The b color value", defaultValue = "8")
-            int b
-    ) {
-        IrisSettings.get().getGeneral().setSpinh(h);
-        IrisSettings.get().getGeneral().setSpins(s);
-        IrisSettings.get().getGeneral().setSpinb(b);
-        IrisSettings.get().forceSave();
-        sender().sendMessage("<rainbow>Aura Spins updated to " + h + " " + s + " " + b);
-    }
-
-    @Decree(description = "Bitwise calculations")
-    public void bitwise(
-            @Param(description = "The first value to run calculations on")
-            int value1,
-            @Param(description = "The operator: | & ^ ≺≺ ≻≻ ％")
-            String operator,
-            @Param(description = "The second value to run calculations on")
-            int value2
-    ) {
-        Integer v = null;
-        switch (operator) {
-            case "|" -> v = value1 | value2;
-            case "&" -> v = value1 & value2;
-            case "^" -> v = value1 ^ value2;
-            case "%" -> v = value1 % value2;
-            case ">>" -> v = value1 >> value2;
-            case "<<" -> v = value1 << value2;
-        }
-        if (v == null) {
-            sender().sendMessage(C.RED + "The operator you entered: (" + operator + ") is invalid!");
-            return;
-        }
-        sender().sendMessage(C.GREEN + "" + value1 + " " + C.GREEN + operator.replaceAll("<", "≺").replaceAll(">", "≻").replaceAll("%", "％") + " " + C.GREEN + value2 + C.GREEN + " returns " + C.GREEN + v);
-    }
-
-    @Decree(description = "Toggle debug")
-    public void debug(
-            @Param(name = "on", description = "Whether or not debug should be on", defaultValue = "other")
-            Boolean on
-    ) {
-        boolean to = on == null ? !IrisSettings.get().getGeneral().isDebug() : on;
-        IrisSettings.get().getGeneral().setDebug(to);
-        IrisSettings.get().forceSave();
-        sender().sendMessage(C.GREEN + "Set debug to: " + to);
-    }
-
-    //TODO fix pack trimming
-    @Decree(description = "Download a project.", aliases = "dl")
-    public void download(
-            @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
-            String pack,
-            @Param(name = "branch", description = "The branch to download from", defaultValue = "main")
-            String branch,
-            //@Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
-            //boolean trim,
-            @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
-            boolean overwrite
-    ) {
-        boolean trim = false;
-        sender().sendMessage(C.GREEN + "Downloading pack: " + pack + "/" + branch + (trim ? " trimmed" : "") + (overwrite ? " overwriting" : ""));
-        if (pack.equals("overworld")) {
-            String url = "https://github.com/IrisDimensions/overworld/releases/download/" + INMS.OVERWORLD_TAG + "/overworld.zip";
-            Iris.service(StudioSVC.class).downloadRelease(sender(), url, trim, overwrite);
-        } else {
-            Iris.service(StudioSVC.class).downloadSearch(sender(), "IrisDimensions/" + pack + "/" + branch, trim, overwrite);
-        }
-    }
-
-    @Decree(description = "Get metrics for your world", aliases = "measure", origin = DecreeOrigin.PLAYER)
-    public void metrics() {
-        if (!IrisToolbelt.isIrisWorld(world())) {
-            sender().sendMessage(C.RED + "You must be in an Iris world");
-            return;
-        }
-        sender().sendMessage(C.GREEN + "Sending metrics...");
-        engine().printMetrics(sender());
-    }
-
-    @Decree(description = "Reload configuration file (this is also done automatically)")
-    public void reload() {
-        IrisSettings.invalidate();
-        IrisSettings.get();
-        sender().sendMessage(C.GREEN + "Hotloaded settings");
-    }
-
-    @Decree(description = "Update the pack of a world (UNSAFE!)", name = "^world", aliases = "update-world")
-    public void updateWorld(
-            @Param(description = "The world to update", contextual = true)
-            World world,
-            @Param(description = "The pack to install into the world", contextual = true, aliases = "dimension")
-            IrisDimension pack,
-            @Param(description = "Make sure to make a backup & read the warnings first!", defaultValue = "false", aliases = "c")
-            boolean confirm,
-            @Param(description = "Should Iris download the pack again for you", defaultValue = "false", name = "fresh-download", aliases = {"fresh", "new"})
-            boolean freshDownload
-    ) {
-        if (!confirm) {
-            sender().sendMessage(new String[]{
-                    C.RED + "You should always make a backup before using this",
-                    C.YELLOW + "Issues caused by this can be, but are not limited to:",
-                    C.YELLOW + " - Broken chunks (cut-offs) between old and new chunks (before & after the update)",
-                    C.YELLOW + " - Regenerated chunks that do not fit in with the old chunks",
-                    C.YELLOW + " - Structures not spawning again when regenerating",
-                    C.YELLOW + " - Caves not lining up",
-                    C.YELLOW + " - Terrain layers not lining up",
-                    C.RED + "Now that you are aware of the risks, and have made a back-up:",
-                    C.RED + "/iris ^world " + world.getName() + " " + pack.getLoadKey() + " confirm=true"
-            });
-            return;
-        }
-
-        File folder = world.getWorldFolder();
-        folder.mkdirs();
-
-        if (freshDownload) {
-            Iris.service(StudioSVC.class).downloadSearch(sender(), pack.getLoadKey(), false, true);
-        }
-
-        Iris.service(StudioSVC.class).installIntoWorld(sender(), pack.getLoadKey(), folder);
-    }
-
-    @Decree(description = "Unload an Iris World", origin = DecreeOrigin.PLAYER, sync = true)
-    public void unloadWorld(
-            @Param(description = "The world to unload")
-            World world
-    ) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
-            return;
-        }
-        sender().sendMessage(C.GREEN + "Unloading world: " + world.getName());
-        try {
-            IrisToolbelt.evacuate(world);
-            Bukkit.unloadWorld(world, false);
-            sender().sendMessage(C.GREEN + "World unloaded successfully.");
-        } catch (Exception e) {
-            sender().sendMessage(C.RED + "Failed to unload the world: " + e.getMessage());
-            e.printStackTrace();
-        }
-    }
-
-    @Decree(description = "Load an Iris World", origin = DecreeOrigin.PLAYER, sync = true, aliases = {"import"})
-    public void loadWorld(
-            @Param(description = "The name of the world to load")
-            String world
-    ) {
-        World worldloaded = Bukkit.getWorld(world);
-        worldNameToCheck = world;
-        boolean worldExists = doesWorldExist(worldNameToCheck);
-        WorldEngine = world;
-
-        if (!worldExists) {
-            sender().sendMessage(C.YELLOW + world + " Doesnt exist on the server.");
-            return;
-        }
-
-        String pathtodim = world + File.separator +"iris"+File.separator +"pack"+File.separator +"dimensions"+File.separator;
-        File directory = new File(Bukkit.getWorldContainer(), pathtodim);
-
-        String dimension = null;
-        if (directory.exists() && directory.isDirectory()) {
-            File[] files = directory.listFiles();
-            if (files != null) {
-                for (File file : files) {
-                    if (file.isFile()) {
-                        String fileName = file.getName();
-                        if (fileName.endsWith(".json")) {
-                            dimension = fileName.substring(0, fileName.length() - 5);
-                            sender().sendMessage(C.BLUE + "Generator: " + dimension);
-                        }
-                    }
-                }
-            }
-        } else {
-            sender().sendMessage(C.GOLD + world + " is not an iris world.");
-            return;
-        }
-        sender().sendMessage(C.GREEN + "Loading world: " + world);
-
-        YamlConfiguration yml = YamlConfiguration.loadConfiguration(BUKKIT_YML);
-        String gen = "Iris:" + dimension;
-        ConfigurationSection section = yml.contains("worlds") ? yml.getConfigurationSection("worlds") : yml.createSection("worlds");
-        if (!section.contains(world)) {
-            section.createSection(world).set("generator", gen);
-            try {
-                yml.save(BUKKIT_YML);
-                Iris.info("Registered \"" + world + "\" in bukkit.yml");
-            } catch (IOException e) {
-                Iris.error("Failed to update bukkit.yml!");
-                e.printStackTrace();
-                return;
-            }
-        }
-        Iris.instance.checkForBukkitWorlds(world::equals);
-        sender().sendMessage(C.GREEN + world + " loaded successfully.");
-    }
-    @Decree(description = "Evacuate an iris world", origin = DecreeOrigin.PLAYER, sync = true)
-    public void evacuate(
-            @Param(description = "Evacuate the world")
-            World world
-    ) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "This is not an Iris world. Iris worlds: " + String.join(", ", getServer().getWorlds().stream().filter(IrisToolbelt::isIrisWorld).map(World::getName).toList()));
-            return;
-        }
-        sender().sendMessage(C.GREEN + "Evacuating world" + world.getName());
-        IrisToolbelt.evacuate(world);
-    }
-
-    boolean doesWorldExist(String worldName) {
-        File worldContainer = Bukkit.getWorldContainer();
-        File worldDirectory = new File(worldContainer, worldName);
-        return worldDirectory.exists() && worldDirectory.isDirectory();
-    }
-}

core/src/main/java/com/volmit/iris/core/commands/CommandJigsaw.java

@@ -1,121 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.edit.JigsawEditor;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.engine.framework.placer.WorldObjectPlacer;
-import com.volmit.iris.engine.jigsaw.PlannedStructure;
-import com.volmit.iris.engine.object.IrisJigsawPiece;
-import com.volmit.iris.engine.object.IrisJigsawStructure;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.engine.object.IrisPosition;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-
-import java.io.File;
-
-@Decree(name = "jigsaw", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris jigsaw commands")
-public class CommandJigsaw implements DecreeExecutor {
-    @Decree(description = "Edit a jigsaw piece")
-    public void edit(
-            @Param(description = "The jigsaw piece to edit")
-            IrisJigsawPiece piece
-    ) {
-        File dest = piece.getLoadFile();
-        new JigsawEditor(player(), piece, IrisData.loadAnyObject(piece.getObject(), data()), dest);
-    }
-
-    @Decree(description = "Place a jigsaw structure")
-    public void place(
-            @Param(description = "The jigsaw structure to place")
-            IrisJigsawStructure structure
-    ) {
-        PrecisionStopwatch p = PrecisionStopwatch.start();
-        try {
-            var world = world();
-            WorldObjectPlacer placer = new WorldObjectPlacer(world);
-            PlannedStructure ps = new PlannedStructure(structure, new IrisPosition(player().getLocation().add(0, world.getMinHeight(), 0)), new RNG(), true);
-            VolmitSender sender = sender();
-            sender.sendMessage(C.GREEN + "Generated " + ps.getPieces().size() + " pieces in " + Form.duration(p.getMilliseconds(), 2));
-            ps.place(placer, failed -> sender.sendMessage(failed ? C.GREEN + "Placed the structure!" : C.RED + "Failed to place the structure!"));
-        } catch (IllegalArgumentException e) {
-            sender().sendMessage(C.RED + "Failed to place the structure: " + e.getMessage());
-        }
-    }
-
-    @Decree(description = "Create a jigsaw piece")
-    public void create(
-            @Param(description = "The name of the jigsaw piece")
-            String piece,
-            @Param(description = "The project to add the jigsaw piece to")
-            String project,
-            @Param(description = "The object to use for this piece", customHandler = ObjectHandler.class)
-            String object
-    ) {
-        IrisObject o = IrisData.loadAnyObject(object, data());
-
-        if (object == null) {
-            sender().sendMessage(C.RED + "Failed to find existing object");
-            return;
-        }
-
-        File dest = Iris.instance.getDataFile("packs", project, "jigsaw-pieces", piece + ".json");
-        new JigsawEditor(player(), null, o, dest);
-        sender().sendMessage(C.GRAY + "* Right Click blocks to make them connectors");
-        sender().sendMessage(C.GRAY + "* Right Click connectors to orient them");
-        sender().sendMessage(C.GRAY + "* Shift + Right Click connectors to remove them");
-        sender().sendMessage(C.GREEN + "Remember to use /iris jigsaw save");
-    }
-
-    @Decree(description = "Exit the current jigsaw editor")
-    public void exit() {
-        JigsawEditor editor = JigsawEditor.editors.get(player());
-
-        if (editor == null) {
-            sender().sendMessage(C.GOLD + "You don't have any pieces open to exit!");
-            return;
-        }
-
-        editor.exit();
-        sender().sendMessage(C.GREEN + "Exited Jigsaw Editor");
-    }
-
-    @Decree(description = "Save & Exit the current jigsaw editor")
-    public void save() {
-        JigsawEditor editor = JigsawEditor.editors.get(player());
-
-        if (editor == null) {
-            sender().sendMessage(C.GOLD + "You don't have any pieces open to save!");
-            return;
-        }
-
-        editor.close();
-        sender().sendMessage(C.GREEN + "Saved & Exited Jigsaw Editor");
-    }
-}

core/src/main/java/com/volmit/iris/core/commands/CommandLazyPregen.java

@@ -1,121 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.gui.PregeneratorJob;
-import com.volmit.iris.core.pregenerator.LazyPregenerator;
-import com.volmit.iris.core.pregenerator.PregenTask;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.math.Position2;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.io.IOException;
-
-@Decree(name = "lazypregen", aliases = "lazy", description = "Pregenerate your Iris worlds!")
-public class CommandLazyPregen implements DecreeExecutor {
-    public String worldName;
-    @Decree(description = "Pregenerate a world")
-    public void start(
-            @Param(description = "The radius of the pregen in blocks", aliases = "size")
-            int radius,
-            @Param(description = "The world to pregen", contextual = true)
-            World world,
-            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
-            Vector center,
-            @Param(aliases = "maxcpm", description = "Limit the chunks per minute the pregen will generate", defaultValue = "999999999")
-            int cpm,
-            @Param(aliases = "silent", description = "Silent generation", defaultValue = "false")
-            boolean silent
-            ) {
-
-        worldName = world.getName();
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File lazyFile = new File(worldDirectory, "lazygen.json");
-        if (lazyFile.exists()) {
-            sender().sendMessage(C.BLUE + "Lazy pregen is already in progress");
-            Iris.info(C.YELLOW + "Lazy pregen is already in progress");
-            return;
-        }
-
-        try {
-            if (sender().isPlayer() && access() == null) {
-                sender().sendMessage(C.RED + "The engine access for this world is null!");
-                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
-            }
-
-            LazyPregenerator.LazyPregenJob pregenJob = LazyPregenerator.LazyPregenJob.builder()
-                    .world(worldName)
-                    .healingPosition(0)
-                    .healing(false)
-                    .chunksPerMinute(cpm)
-                    .radiusBlocks(radius)
-                    .position(0)
-                    .silent(silent)
-                    .build();
-
-            File lazyGenFile = new File(worldDirectory, "lazygen.json");
-            LazyPregenerator pregenerator = new LazyPregenerator(pregenJob, lazyGenFile);
-            pregenerator.start();
-
-            String msg = C.GREEN + "LazyPregen started in " + C.GOLD + worldName + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
-            sender().sendMessage(msg);
-            Iris.info(msg);
-        } catch (Throwable e) {
-            sender().sendMessage(C.RED + "Epic fail. See console.");
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-    }
-
-    @Decree(description = "Stop the active pregeneration task", aliases = "x")
-    public void stop(
-            @Param(aliases = "world", description = "The world to pause")
-            World world
-    ) throws IOException {
-        if (LazyPregenerator.getInstance() != null) {
-            LazyPregenerator.getInstance().shutdownInstance(world);
-            sender().sendMessage(C.LIGHT_PURPLE + "Closed lazygen instance for " + world.getName());
-        } else {
-            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
-        }
-    }
-
-    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
-    public void pause(
-            @Param(aliases = "world", description = "The world to pause")
-            World world
-    ) {
-        if (LazyPregenerator.getInstance() != null) {
-            LazyPregenerator.getInstance().setPausedLazy(world);
-            sender().sendMessage(C.GREEN + "Paused/unpaused Lazy Pregen, now: " + (LazyPregenerator.getInstance().isPausedLazy(world) ? "Paused" : "Running") + ".");
-        } else {
-            sender().sendMessage(C.YELLOW + "No active Lazy Pregen tasks to pause/unpause.");
-
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/commands/CommandObject.java

@@ -1,577 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.link.WorldEditLink;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.service.ObjectSVC;
-import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.core.service.WandSVC;
-import com.volmit.iris.core.tools.IrisConverter;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.*;
-import com.volmit.iris.util.data.Cuboid;
-import com.volmit.iris.util.data.IrisCustomData;
-import com.volmit.iris.util.data.registry.Materials;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.decree.specialhandlers.ObjectHandler;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.math.Direction;
-import com.volmit.iris.util.math.RNG;
-import org.bukkit.*;
-import org.bukkit.block.Block;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.io.IOException;
-import java.text.NumberFormat;
-import java.util.*;
-
-@Decree(name = "object", aliases = "o", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris object manipulation")
-public class CommandObject implements DecreeExecutor {
-
-    private static final Set<Material> skipBlocks = Set.of(Materials.GRASS, Material.SNOW, Material.VINE, Material.TORCH, Material.DEAD_BUSH,
-            Material.POPPY, Material.DANDELION);
-
-    public static IObjectPlacer createPlacer(World world, Map<Block, BlockData> futureBlockChanges) {
-
-        return new IObjectPlacer() {
-            @Override
-            public int getHighest(int x, int z, IrisData data) {
-                return world.getHighestBlockYAt(x, z);
-            }
-
-            @Override
-            public int getHighest(int x, int z, IrisData data, boolean ignoreFluid) {
-                return world.getHighestBlockYAt(x, z, ignoreFluid ? HeightMap.OCEAN_FLOOR : HeightMap.MOTION_BLOCKING);
-            }
-
-            @Override
-            public void set(int x, int y, int z, BlockData d) {
-                Block block = world.getBlockAt(x, y, z);
-
-                //Prevent blocks being set in or bellow bedrock
-                if (y <= world.getMinHeight() || block.getType() == Material.BEDROCK) return;
-
-                futureBlockChanges.put(block, block.getBlockData());
-
-                if (d instanceof IrisCustomData data) {
-                    block.setBlockData(data.getBase(), false);
-                    Iris.warn("Tried to place custom block at " + x + ", " + y + ", " + z + " which is not supported!");
-                } else block.setBlockData(d, false);
-            }
-
-            @Override
-            public BlockData get(int x, int y, int z) {
-                return world.getBlockAt(x, y, z).getBlockData();
-            }
-
-            @Override
-            public boolean isPreventingDecay() {
-                return false;
-            }
-
-            @Override
-            public boolean isCarved(int x, int y, int z) {
-                return false;
-            }
-
-            @Override
-            public boolean isSolid(int x, int y, int z) {
-                return world.getBlockAt(x, y, z).getType().isSolid();
-            }
-
-            @Override
-            public boolean isUnderwater(int x, int z) {
-                return false;
-            }
-
-            @Override
-            public int getFluidHeight() {
-                return 63;
-            }
-
-            @Override
-            public boolean isDebugSmartBore() {
-                return false;
-            }
-
-            @Override
-            public void setTile(int xx, int yy, int zz, TileData tile) {
-                tile.toBukkitTry(world.getBlockAt(xx, yy, zz));
-            }
-
-            @Override
-            public <T> void setData(int xx, int yy, int zz, T data) {
-
-            }
-
-            @Override
-            public <T> T getData(int xx, int yy, int zz, Class<T> t) {
-                return null;
-            }
-
-            @Override
-            public Engine getEngine() {
-                return null;
-            }
-        };
-    }
-
-    @Decree(description = "Check the composition of an object")
-    public void analyze(
-            @Param(description = "The object to analyze", customHandler = ObjectHandler.class)
-            String object
-    ) {
-        IrisObject o = IrisData.loadAnyObject(object, data());
-        sender().sendMessage("Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD() + "");
-        sender().sendMessage("Blocks Used: " + NumberFormat.getIntegerInstance().format(o.getBlocks().size()));
-
-        var queue = o.getBlocks().values();
-        Map<Material, Set<BlockData>> unsorted = new HashMap<>();
-        Map<BlockData, Integer> amounts = new HashMap<>();
-        Map<Material, Integer> materials = new HashMap<>();
-        while (queue.hasNext()) {
-            BlockData block = queue.next();
-
-            //unsorted.put(block.getMaterial(), block);
-
-            if (!amounts.containsKey(block)) {
-                amounts.put(block, 1);
-
-
-            } else
-                amounts.put(block, amounts.get(block) + 1);
-
-            if (!materials.containsKey(block.getMaterial())) {
-                materials.put(block.getMaterial(), 1);
-                unsorted.put(block.getMaterial(), new HashSet<>());
-                unsorted.get(block.getMaterial()).add(block);
-            } else {
-                materials.put(block.getMaterial(), materials.get(block.getMaterial()) + 1);
-                unsorted.get(block.getMaterial()).add(block);
-            }
-
-        }
-
-        List<Material> sortedMatsList = amounts.keySet().stream().map(BlockData::getMaterial)
-                .sorted().toList();
-        Set<Material> sortedMats = new TreeSet<>(Comparator.comparingInt(materials::get).reversed());
-        sortedMats.addAll(sortedMatsList);
-        sender().sendMessage("== Blocks in object ==");
-
-        int n = 0;
-        for (Material mat : sortedMats) {
-            int amount = materials.get(mat);
-            List<BlockData> set = new ArrayList<>(unsorted.get(mat));
-            set.sort(Comparator.comparingInt(amounts::get).reversed());
-            BlockData data = set.get(0);
-            int dataAmount = amounts.get(data);
-
-            String string = " - " + mat.toString() + "*" + amount;
-            if (data.getAsString(true).contains("[")) {
-                string = string + " --> [" + data.getAsString(true).split("\\[")[1]
-                        .replaceAll("true", ChatColor.GREEN + "true" + ChatColor.GRAY)
-                        .replaceAll("false", ChatColor.RED + "false" + ChatColor.GRAY) + "*" + dataAmount;
-            }
-
-            sender().sendMessage(string);
-
-            n++;
-
-            if (n >= 10) {
-                sender().sendMessage("  + " + (sortedMats.size() - n) + " other block types");
-                return;
-            }
-        }
-    }
-
-    @Decree(description = "Shrink an object to its minimum size")
-    public void shrink(@Param(description = "The object to shrink", customHandler = ObjectHandler.class) String object) {
-        IrisObject o = IrisData.loadAnyObject(object, data());
-        sender().sendMessage("Current Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD());
-        o.shrinkwrap();
-        sender().sendMessage("New Object Size: " + o.getW() + " * " + o.getH() + " * " + o.getD());
-        try {
-            o.write(o.getLoadFile());
-        } catch (IOException e) {
-            sender().sendMessage("Failed to save object " + o.getLoadFile() + ": " + e.getMessage());
-            e.printStackTrace();
-        }
-    }
-
-    @Decree(description = "Convert .schem files in the 'convert' folder to .iob files.")
-    public void convert () {
-        try {
-            IrisConverter.convertSchematics(sender());
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-
-    }
-
-    @Decree(description = "Get a powder that reveals objects", studio = true, aliases = "d")
-    public void dust() {
-        player().getInventory().addItem(WandSVC.createDust());
-        sender().playSound(Sound.AMBIENT_SOUL_SAND_VALLEY_ADDITIONS, 1f, 1.5f);
-    }
-
-    @Decree(description = "Contract a selection based on your looking direction", aliases = "-")
-    public void contract(
-            @Param(description = "The amount to inset by", defaultValue = "1")
-            int amount
-    ) {
-        if (!WandSVC.isHoldingWand(player())) {
-            sender().sendMessage("Hold your wand.");
-            return;
-        }
-
-
-        Location[] b = WandSVC.getCuboid(player());
-        if (b == null || b[0] == null || b[1] == null) {
-            sender().sendMessage("No area selected.");
-            return;
-        }
-        Location a1 = b[0].clone();
-        Location a2 = b[1].clone();
-        Cuboid cursor = new Cuboid(a1, a2);
-        Direction d = Direction.closest(player().getLocation().getDirection()).reverse();
-        assert d != null;
-        cursor = cursor.expand(d, -amount);
-        b[0] = cursor.getLowerNE();
-        b[1] = cursor.getUpperSW();
-        player().getInventory().setItemInMainHand(WandSVC.createWand(b[0], b[1]));
-        player().updateInventory();
-        sender().playSound(Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 0.55f);
-    }
-
-    @Decree(description = "Set point 1 to look", aliases = "p1")
-    public void position1(
-            @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
-            boolean here
-    ) {
-        if (!WandSVC.isHoldingWand(player())) {
-            sender().sendMessage("Ready your Wand.");
-            return;
-        }
-
-        if (WandSVC.isHoldingWand(player())) {
-            Location[] g = WandSVC.getCuboid(player());
-
-            if (g == null) {
-                return;
-            }
-            if (!here) {
-                // TODO: WARNING HEIGHT
-                g[1] = player().getTargetBlock(null, 256).getLocation().clone();
-            } else {
-                g[1] = player().getLocation().getBlock().getLocation().clone().add(0, -1, 0);
-            }
-            player().setItemInHand(WandSVC.createWand(g[0], g[1]));
-        }
-    }
-
-    @Decree(description = "Set point 2 to look", aliases = "p2")
-    public void position2(
-            @Param(description = "Whether to use your current position, or where you look", defaultValue = "true")
-            boolean here
-    ) {
-        if (!WandSVC.isHoldingWand(player())) {
-            sender().sendMessage("Ready your Wand.");
-            return;
-        }
-
-        if (WandSVC.isHoldingIrisWand(player())) {
-            Location[] g = WandSVC.getCuboid(player());
-
-            if (g == null) {
-                return;
-            }
-
-            if (!here) {
-                // TODO: WARNING HEIGHT
-                g[0] = player().getTargetBlock(null, 256).getLocation().clone();
-            } else {
-                g[0] = player().getLocation().getBlock().getLocation().clone().add(0, -1, 0);
-            }
-            player().setItemInHand(WandSVC.createWand(g[0], g[1]));
-        }
-    }
-
-    @Decree(description = "Paste an object", sync = true)
-    public void paste(
-            @Param(description = "The object to paste", customHandler = ObjectHandler.class)
-            String object,
-            @Param(description = "Whether or not to edit the object (need to hold wand)", defaultValue = "false")
-            boolean edit,
-            @Param(description = "The amount of degrees to rotate by", defaultValue = "0")
-            int rotate,
-            @Param(description = "The factor by which to scale the object placement", defaultValue = "1")
-            double scale
-//            ,
-//            @Param(description = "The scale interpolator to use", defaultValue = "none")
-//            IrisObjectPlacementScaleInterpolator interpolator
-    ) {
-        IrisObject o = IrisData.loadAnyObject(object, data());
-        double maxScale = Double.max(10 - o.getBlocks().size() / 10000d, 1);
-        if (scale > maxScale) {
-            sender().sendMessage(C.YELLOW + "Indicated scale exceeds maximum. Downscaled to maximum: " + maxScale);
-            scale = maxScale;
-        }
-
-        sender().playSound(Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1f, 1.5f);
-
-        IrisObjectPlacement placement = new IrisObjectPlacement();
-        placement.setRotation(IrisObjectRotation.of(0, rotate, 0));
-
-        ItemStack wand = player().getInventory().getItemInMainHand();
-        Location block = player().getTargetBlock(skipBlocks, 256).getLocation().clone().add(0, 1, 0);
-
-        Map<Block, BlockData> futureChanges = new HashMap<>();
-
-        if (scale != 1) {
-            o = o.scaled(scale, IrisObjectPlacementScaleInterpolator.TRICUBIC);
-        }
-
-        o.place(block.getBlockX(), block.getBlockY() + (int) o.getCenter().getY(), block.getBlockZ(), createPlacer(block.getWorld(), futureChanges), placement, new RNG(), null);
-
-        Iris.service(ObjectSVC.class).addChanges(futureChanges);
-
-        if (edit) {
-            ItemStack newWand = WandSVC.createWand(block.clone().subtract(o.getCenter()).add(o.getW() - 1,
-                    o.getH() + o.getCenter().clone().getY() - 1, o.getD() - 1), block.clone().subtract(o.getCenter().clone().setY(0)));
-            if (WandSVC.isWand(wand)) {
-                wand = newWand;
-                player().getInventory().setItemInMainHand(wand);
-                sender().sendMessage("Updated wand for " + "objects/" + o.getLoadKey() + ".iob ");
-            } else {
-                int slot = WandSVC.findWand(player().getInventory());
-                if (slot == -1) {
-                    player().getInventory().addItem(newWand);
-                    sender().sendMessage("Given new wand for " + "objects/" + o.getLoadKey() + ".iob ");
-                } else {
-                    player().getInventory().setItem(slot, newWand);
-                    sender().sendMessage("Updated wand for " + "objects/" + o.getLoadKey() + ".iob ");
-                }
-            }
-        } else {
-            sender().sendMessage(C.IRIS + "Placed " + object);
-        }
-    }
-
-    @Decree(description = "Save an object")
-    public void save(
-            @Param(description = "The dimension to store the object in", contextual = true)
-            IrisDimension dimension,
-            @Param(description = "The file to store it in, can use / for subfolders")
-            String name,
-            @Param(description = "Overwrite existing object files", defaultValue = "false", aliases = "force")
-            boolean overwrite,
-            @Param(description = "Use legacy TileState serialization if possible", defaultValue = "true")
-            boolean legacy
-    ) {
-        IrisObject o = WandSVC.createSchematic(player(), legacy);
-
-        if (o == null) {
-            sender().sendMessage(C.YELLOW + "You need to hold your wand!");
-            return;
-        }
-
-        File file = Iris.service(StudioSVC.class).getWorkspaceFile(dimension.getLoadKey(), "objects", name + ".iob");
-
-        if (file.exists() && !overwrite) {
-            sender().sendMessage(C.RED + "File already exists. Set overwrite=true to overwrite it.");
-            return;
-        }
-        try {
-            o.write(file, sender());
-        } catch (IOException e) {
-            sender().sendMessage(C.RED + "Failed to save object because of an IOException: " + e.getMessage());
-            Iris.reportError(e);
-        }
-
-        sender().playSound(Sound.BLOCK_ENCHANTMENT_TABLE_USE, 1f, 1.5f);
-        sender().sendMessage(C.GREEN + "Successfully object to saved: " + dimension.getLoadKey() + "/objects/" + name);
-    }
-
-    @Decree(description = "Shift a selection in your looking direction", aliases = "-")
-    public void shift(
-            @Param(description = "The amount to shift by", defaultValue = "1")
-            int amount
-    ) {
-        if (!WandSVC.isHoldingWand(player())) {
-            sender().sendMessage("Hold your wand.");
-            return;
-        }
-
-        Location[] b = WandSVC.getCuboid(player());
-        if (b == null || b[0] == null || b[1] == null) {
-            sender().sendMessage("No area selected.");
-            return;
-        }
-        Location a1 = b[0].clone();
-        Location a2 = b[1].clone();
-        Direction d = Direction.closest(player().getLocation().getDirection()).reverse();
-        if (d == null) {
-            return; // HOW DID THIS HAPPEN
-        }
-        a1.add(d.toVector().multiply(amount));
-        a2.add(d.toVector().multiply(amount));
-        Cuboid cursor = new Cuboid(a1, a2);
-        b[0] = cursor.getLowerNE();
-        b[1] = cursor.getUpperSW();
-        player().getInventory().setItemInMainHand(WandSVC.createWand(b[0], b[1]));
-        player().updateInventory();
-        sender().playSound(Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 0.55f);
-    }
-
-    @Decree(description = "Undo a number of pastes", aliases = "-")
-    public void undo(
-            @Param(description = "The amount of pastes to undo", defaultValue = "1")
-            int amount
-    ) {
-        ObjectSVC service = Iris.service(ObjectSVC.class);
-        int actualReverts = Math.min(service.getUndos().size(), amount);
-        service.revertChanges(actualReverts);
-        sender().sendMessage(C.BLUE + "Reverted " + actualReverts + C.BLUE +" pastes!");
-    }
-
-    @Decree(description = "Gets an object wand and grabs the current WorldEdit selection.", aliases = "we", origin = DecreeOrigin.PLAYER, studio = true)
-    public void we() {
-        if (!Bukkit.getPluginManager().isPluginEnabled("WorldEdit")) {
-            sender().sendMessage(C.RED + "You can't get a WorldEdit selection without WorldEdit, you know.");
-            return;
-        }
-
-        Cuboid locs = WorldEditLink.getSelection(sender().player());
-
-        if (locs == null) {
-            sender().sendMessage(C.RED + "You don't have a WorldEdit selection in this world.");
-            return;
-        }
-
-        sender().player().getInventory().addItem(WandSVC.createWand(locs.getLowerNE(), locs.getUpperSW()));
-        sender().sendMessage(C.GREEN + "A fresh wand with your current WorldEdit selection on it!");
-    }
-
-    @Decree(description = "Get an object wand", sync = true)
-    public void wand() {
-        player().getInventory().addItem(WandSVC.createWand());
-        sender().playSound(Sound.ITEM_ARMOR_EQUIP_NETHERITE, 1f, 1.5f);
-        sender().sendMessage(C.GREEN + "Poof! Good luck building!");
-    }
-
-    @Decree(name = "x&y", description = "Autoselect up, down & out", sync = true)
-    public void xay() {
-        if (!WandSVC.isHoldingWand(player())) {
-            sender().sendMessage(C.YELLOW + "Hold your wand!");
-            return;
-        }
-
-        Location[] b = WandSVC.getCuboid(player());
-        if (b == null || b[0] == null || b[1] == null) {
-            sender().sendMessage("No area selected.");
-            return;
-        }
-        Location a1 = b[0].clone();
-        Location a2 = b[1].clone();
-        Location a1x = b[0].clone();
-        Location a2x = b[1].clone();
-        Cuboid cursor = new Cuboid(a1, a2);
-        Cuboid cursorx = new Cuboid(a1, a2);
-
-        while (!cursor.containsOnly(Material.AIR)) {
-            a1.add(new org.bukkit.util.Vector(0, 1, 0));
-            a2.add(new org.bukkit.util.Vector(0, 1, 0));
-            cursor = new Cuboid(a1, a2);
-        }
-
-        a1.add(new org.bukkit.util.Vector(0, -1, 0));
-        a2.add(new org.bukkit.util.Vector(0, -1, 0));
-
-        while (!cursorx.containsOnly(Material.AIR)) {
-            a1x.add(new org.bukkit.util.Vector(0, -1, 0));
-            a2x.add(new org.bukkit.util.Vector(0, -1, 0));
-            cursorx = new Cuboid(a1x, a2x);
-        }
-
-        a1x.add(new org.bukkit.util.Vector(0, 1, 0));
-        a2x.add(new Vector(0, 1, 0));
-        b[0] = a1;
-        b[1] = a2x;
-        cursor = new Cuboid(b[0], b[1]);
-        cursor = cursor.contract(Cuboid.CuboidDirection.North);
-        cursor = cursor.contract(Cuboid.CuboidDirection.South);
-        cursor = cursor.contract(Cuboid.CuboidDirection.East);
-        cursor = cursor.contract(Cuboid.CuboidDirection.West);
-        b[0] = cursor.getLowerNE();
-        b[1] = cursor.getUpperSW();
-        player().getInventory().setItemInMainHand(WandSVC.createWand(b[0], b[1]));
-        player().updateInventory();
-        sender().playSound(Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 0.55f);
-        sender().sendMessage(C.GREEN + "Auto-select complete!");
-    }
-
-    @Decree(name = "x+y", description = "Autoselect up & out", sync = true)
-    public void xpy() {
-        if (!WandSVC.isHoldingWand(player())) {
-            sender().sendMessage(C.YELLOW + "Hold your wand!");
-            return;
-        }
-
-        Location[] b = WandSVC.getCuboid(player());
-        if (b == null || b[0] == null || b[1] == null) {
-            sender().sendMessage("No area selected.");
-            return;
-        }
-        b[0].add(new Vector(0, 1, 0));
-        b[1].add(new Vector(0, 1, 0));
-        Location a1 = b[0].clone();
-        Location a2 = b[1].clone();
-        Cuboid cursor = new Cuboid(a1, a2);
-
-        while (!cursor.containsOnly(Material.AIR)) {
-            a1.add(new Vector(0, 1, 0));
-            a2.add(new Vector(0, 1, 0));
-            cursor = new Cuboid(a1, a2);
-        }
-
-        a1.add(new Vector(0, -1, 0));
-        a2.add(new Vector(0, -1, 0));
-        b[0] = a1;
-        a2 = b[1];
-        cursor = new Cuboid(a1, a2);
-        cursor = cursor.contract(Cuboid.CuboidDirection.North);
-        cursor = cursor.contract(Cuboid.CuboidDirection.South);
-        cursor = cursor.contract(Cuboid.CuboidDirection.East);
-        cursor = cursor.contract(Cuboid.CuboidDirection.West);
-        b[0] = cursor.getLowerNE();
-        b[1] = cursor.getUpperSW();
-        player().getInventory().setItemInMainHand(WandSVC.createWand(b[0], b[1]));
-        player().updateInventory();
-        sender().playSound(Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 0.55f);
-        sender().sendMessage(C.GREEN + "Auto-select complete!");
-    }
-}

core/src/main/java/com/volmit/iris/core/commands/CommandPregen.java

@@ -1,86 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.gui.PregeneratorJob;
-import com.volmit.iris.core.pregenerator.PregenTask;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.math.Position2;
-import org.bukkit.World;
-import org.bukkit.util.Vector;
-
-@Decree(name = "pregen", aliases = "pregenerate", description = "Pregenerate your Iris worlds!")
-public class CommandPregen implements DecreeExecutor {
-    @Decree(description = "Pregenerate a world")
-    public void start(
-            @Param(description = "The radius of the pregen in blocks", aliases = "size")
-            int radius,
-            @Param(description = "The world to pregen", contextual = true)
-            World world,
-            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
-            Vector center,
-            @Param(description = "Open the Iris pregen gui", defaultValue = "true")
-            boolean gui
-            ) {
-        try {
-            if (sender().isPlayer() && access() == null) {
-                sender().sendMessage(C.RED + "The engine access for this world is null!");
-                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
-            }
-            radius = Math.max(radius, 1024);
-            IrisToolbelt.pregenerate(PregenTask
-                    .builder()
-                    .center(new Position2(center.getBlockX(), center.getBlockZ()))
-                    .gui(gui)
-                    .radiusX(radius)
-                    .radiusZ(radius)
-                    .build(), world);
-            String msg = C.GREEN + "Pregen started in " + C.GOLD + world.getName() + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
-            sender().sendMessage(msg);
-            Iris.info(msg);
-        } catch (Throwable e) {
-            sender().sendMessage(C.RED + "Epic fail. See console.");
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-    }
-
-    @Decree(description = "Stop the active pregeneration task", aliases = "x")
-    public void stop() {
-        if (PregeneratorJob.shutdownInstance()) {
-            Iris.info( C.BLUE + "Finishing up mca region...");
-        } else {
-            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
-        }
-    }
-
-    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
-    public void pause() {
-        if (PregeneratorJob.pauseResume()) {
-            sender().sendMessage(C.GREEN + "Paused/unpaused pregeneration task, now: " + (PregeneratorJob.isPaused() ? "Paused" : "Running") + ".");
-        } else {
-            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to pause/unpause.");
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/commands/CommandSettings.java

@@ -1,25 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.util.decree.DecreeExecutor;
-
-public class CommandSettings implements DecreeExecutor {
-
-}

core/src/main/java/com/volmit/iris/core/commands/CommandStudio.java

@@ -1,955 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.gui.NoiseExplorerGUI;
-import com.volmit.iris.core.gui.VisionGUI;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.project.IrisProject;
-import com.volmit.iris.core.service.ConversionSVC;
-import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.*;
-import com.volmit.iris.engine.platform.PlatformChunkGenerator;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.decree.DecreeContext;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.function.Function2;
-import com.volmit.iris.util.function.NoiseProvider;
-import com.volmit.iris.util.interpolation.InterpolationMethod;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.json.JSONArray;
-import com.volmit.iris.util.json.JSONObject;
-import com.volmit.iris.util.mantle.MantleChunk;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.math.Position2;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.math.Spiraler;
-import com.volmit.iris.util.noise.CNG;
-import com.volmit.iris.util.parallel.MultiBurst;
-import com.volmit.iris.util.parallel.SyncExecutor;
-import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.J;
-import com.volmit.iris.util.scheduling.O;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import com.volmit.iris.util.scheduling.jobs.ParallelRadiusJob;
-import io.papermc.lib.PaperLib;
-import org.bukkit.*;
-import org.bukkit.event.inventory.InventoryType;
-import org.bukkit.inventory.Inventory;
-import org.bukkit.util.BlockVector;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.io.FileNotFoundException;
-import java.io.IOException;
-import java.io.PrintWriter;
-import java.nio.file.Files;
-import java.nio.file.attribute.FileTime;
-import java.time.Duration;
-import java.time.temporal.ChronoUnit;
-import java.util.Arrays;
-import java.util.Date;
-import java.util.Objects;
-import java.util.concurrent.CountDownLatch;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Supplier;
-
-@Decree(name = "studio", aliases = {"std", "s"}, description = "Studio Commands", studio = true)
-public class CommandStudio implements DecreeExecutor {
-    private CommandFind find;
-    private CommandEdit edit;
-    //private CommandDeepSearch deepSearch;
-
-    public static String hrf(Duration duration) {
-        return duration.toString().substring(2).replaceAll("(\\d[HMS])(?!$)", "$1 ").toLowerCase();
-    }
-
-    //TODO fix pack trimming
-    @Decree(description = "Download a project.", aliases = "dl")
-    public void download(
-            @Param(name = "pack", description = "The pack to download", defaultValue = "overworld", aliases = "project")
-            String pack,
-            @Param(name = "branch", description = "The branch to download from", defaultValue = "master")
-            String branch,
-            //@Param(name = "trim", description = "Whether or not to download a trimmed version (do not enable when editing)", defaultValue = "false")
-            //boolean trim,
-            @Param(name = "overwrite", description = "Whether or not to overwrite the pack with the downloaded one", aliases = "force", defaultValue = "false")
-            boolean overwrite
-    ) {
-        new CommandIris().download(pack, branch, overwrite);
-    }
-
-    @Decree(description = "Open a new studio world", aliases = "o", sync = true)
-    public void open(
-            @Param(defaultValue = "default", description = "The dimension to open a studio for", aliases = "dim")
-            IrisDimension dimension,
-            @Param(defaultValue = "1337", description = "The seed to generate the studio with", aliases = "s")
-            long seed) {
-        sender().sendMessage(C.GREEN + "Opening studio for the \"" + dimension.getName() + "\" pack (seed: " + seed + ")");
-        Iris.service(StudioSVC.class).open(sender(), seed, dimension.getLoadKey());
-    }
-
-    @Decree(description = "Open VSCode for a dimension", aliases = {"vsc", "edit"})
-    public void vscode(
-            @Param(defaultValue = "default", description = "The dimension to open VSCode for", aliases = "dim")
-            IrisDimension dimension
-    ) {
-        sender().sendMessage(C.GREEN + "Opening VSCode for the \"" + dimension.getName() + "\" pack");
-        Iris.service(StudioSVC.class).openVSCode(sender(), dimension.getLoadKey());
-    }
-
-    @Decree(description = "Close an open studio project", aliases = {"x", "c"}, sync = true)
-    public void close() {
-        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
-            sender().sendMessage(C.RED + "No open studio projects.");
-            return;
-        }
-
-        Iris.service(StudioSVC.class).close();
-        sender().sendMessage(C.GREEN + "Project Closed.");
-    }
-
-    @Decree(description = "Create a new studio project", aliases = "+", sync = true)
-    public void create(
-            @Param(description = "The name of this new Iris Project.")
-            String name,
-            @Param(description = "Copy the contents of an existing project in your packs folder and use it as a template in this new project.", contextual = true)
-            IrisDimension template) {
-        if (template != null) {
-            Iris.service(StudioSVC.class).create(sender(), name, template.getLoadKey());
-        } else {
-            Iris.service(StudioSVC.class).create(sender(), name);
-        }
-    }
-
-    @Decree(description = "Get the version of a pack")
-    public void version(
-            @Param(defaultValue = "default", description = "The dimension get the version of", aliases = "dim", contextual = true)
-            IrisDimension dimension
-    ) {
-        sender().sendMessage(C.GREEN + "The \"" + dimension.getName() + "\" pack has version: " + dimension.getVersion());
-    }
-
-    @Decree(name = "regen", description = "Regenerate nearby chunks.", aliases = "rg", sync = true, origin = DecreeOrigin.PLAYER)
-    public void regen(
-            @Param(name = "radius", description = "The radius of nearby cunks", defaultValue = "5")
-            int radius
-    ) {
-        World world = player().getWorld();
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "You must be in an Iris World to use regen!");
-        }
-
-        VolmitSender sender = sender();
-        var loc = player().getLocation().clone();
-
-        J.a(() -> {
-            PlatformChunkGenerator plat = IrisToolbelt.access(world);
-            Engine engine = plat.getEngine();
-            DecreeContext.touch(sender);
-            try (SyncExecutor executor = new SyncExecutor(20);
-                 var service = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors())
-            ) {
-                int x = loc.getBlockX() >> 4;
-                int z = loc.getBlockZ() >> 4;
-
-                int rad = engine.getMantle().getRadius();
-                var mantle = engine.getMantle().getMantle();
-                var chunkMap = new KMap<Position2, MantleChunk>();
-                ParallelRadiusJob prep = new ParallelRadiusJob(Integer.MAX_VALUE, service) {
-                    @Override
-                    protected void execute(int rX, int rZ) {
-                        if (Math.abs(rX) <= radius && Math.abs(rZ) <= radius) {
-                            mantle.deleteChunk(rX + x, rZ + z);
-                            return;
-                        }
-                        rX += x;
-                        rZ += z;
-                        chunkMap.put(new Position2(rX, rZ), mantle.getChunk(rX, rZ));
-                        mantle.deleteChunk(rX, rZ);
-                    }
-
-                    @Override
-                    public String getName() {
-                        return "Preparing Mantle";
-                    }
-                }.retarget(radius + rad, 0, 0);
-                CountDownLatch pLatch = new CountDownLatch(1);
-                prep.execute(sender(), pLatch::countDown);
-                pLatch.await();
-
-
-                ParallelRadiusJob job = new ParallelRadiusJob(Integer.MAX_VALUE, service) {
-                    @Override
-                    protected void execute(int x, int z) {
-                        plat.injectChunkReplacement(world, x, z, executor);
-                    }
-
-                    @Override
-                    public String getName() {
-                        return "Regenerating";
-                    }
-                }.retarget(radius, x, z);
-                CountDownLatch latch = new CountDownLatch(1);
-                job.execute(sender(), latch::countDown);
-                latch.await();
-
-                int sections = mantle.getWorldHeight() >> 4;
-                chunkMap.forEach((pos, chunk) -> {
-                    var c = mantle.getChunk(pos.getX(), pos.getZ()).use();
-                    try {
-                        c.copyFlags(chunk);
-                        c.clear();
-                        for (int y = 0; y < sections; y++) {
-                            var slice = chunk.get(y);
-                            if (slice == null) continue;
-                            var s = c.getOrCreate(y);
-                            slice.getSliceMap().forEach(s::putSlice);
-                        }
-                    } finally {
-                        c.release();
-                    }
-                });
-            } catch (Throwable e) {
-                sender().sendMessage("Error while regenerating chunks");
-                e.printStackTrace();
-            } finally {
-                DecreeContext.remove();
-            }
-        });
-    }
-
-    @Decree(description = "Convert objects in the \"convert\" folder")
-    public void convert() {
-        Iris.service(ConversionSVC.class).check(sender());
-        //IrisConverter.convertSchematics(sender());
-    }
-
-    @Decree(description = "Execute a script", aliases = "run", origin = DecreeOrigin.PLAYER)
-    public void execute(
-            @Param(description = "The script to run")
-            IrisScript script
-    ) {
-        engine().getExecution().execute(script.getLoadKey());
-    }
-
-    @Decree(description = "Open the noise explorer (External GUI)", aliases = {"nmap", "n"})
-    public void noise() {
-        if (noGUI()) return;
-        sender().sendMessage(C.GREEN + "Opening Noise Explorer!");
-        NoiseExplorerGUI.launch();
-    }
-
-    @Decree(description = "Charges all spawners in the area", aliases = "zzt", origin = DecreeOrigin.PLAYER)
-    public void charge() {
-        if (!IrisToolbelt.isIrisWorld(world())) {
-            sender().sendMessage(C.RED + "You must be in an Iris world to charge spawners!");
-            return;
-        }
-        sender().sendMessage(C.GREEN + "Charging spawners!");
-        engine().getWorldManager().chargeEnergy();
-    }
-
-    @Decree(description = "Preview noise gens (External GUI)", aliases = {"generator", "gen"})
-    public void explore(
-            @Param(description = "The generator to explore", contextual = true)
-            IrisGenerator generator,
-            @Param(description = "The seed to generate with", defaultValue = "12345")
-            long seed
-    ) {
-        if (noGUI()) return;
-        sender().sendMessage(C.GREEN + "Opening Noise Explorer!");
-
-        Supplier<Function2<Double, Double, Double>> l = () -> {
-
-            if (generator == null) {
-                return (x, z) -> 0D;
-            }
-
-            return (x, z) -> generator.getHeight(x, z, new RNG(seed).nextParallelRNG(3245).lmax());
-        };
-        NoiseExplorerGUI.launch(l, "Custom Generator");
-    }
-
-    @Decree(description = "Hotload a studio", aliases = {"reload", "h"})
-    public void hotload() {
-        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
-            sender().sendMessage(C.RED + "No studio world open!");
-            return;
-        }
-        Iris.service(StudioSVC.class).getActiveProject().getActiveProvider().getEngine().hotload();
-        sender().sendMessage(C.GREEN + "Hotloaded");
-    }
-
-    @Decree(description = "Show loot if a chest were right here", origin = DecreeOrigin.PLAYER, sync = true)
-    public void loot(
-            @Param(description = "Fast insertion of items in virtual inventory (may cause performance drop)", defaultValue = "false")
-            boolean fast,
-            @Param(description = "Whether or not to append to the inventory currently open (if false, clears opened inventory)", defaultValue = "true")
-            boolean add
-    ) {
-        if (noStudio()) return;
-
-        KList<IrisLootTable> tables = engine().getLootTables(RNG.r, player().getLocation().getBlock());
-        Inventory inv = Bukkit.createInventory(null, 27 * 2);
-
-        try {
-            engine().addItems(true, inv, RNG.r, tables, InventorySlotType.STORAGE, player().getWorld(), player().getLocation().getBlockX(), player().getLocation().getBlockY(), player().getLocation().getBlockZ(), 1);
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            sender().sendMessage(C.RED + "Cannot add items to virtual inventory because of: " + e.getMessage());
-            return;
-        }
-
-
-        O<Integer> ta = new O<>();
-        ta.set(-1);
-
-        var sender = sender();
-        var player = player();
-        var engine = engine();
-
-        ta.set(Bukkit.getScheduler().scheduleSyncRepeatingTask(Iris.instance, () ->
-        {
-            if (!player.getOpenInventory().getType().equals(InventoryType.CHEST)) {
-                Bukkit.getScheduler().cancelTask(ta.get());
-                sender.sendMessage(C.GREEN + "Opened inventory!");
-                return;
-            }
-
-            if (!add) {
-                inv.clear();
-            }
-
-            engine.addItems(true, inv, new RNG(RNG.r.imax()), tables, InventorySlotType.STORAGE, player.getWorld(), player.getLocation().getBlockX(), player.getLocation().getBlockY(), player.getLocation().getBlockZ(), 1);
-        }, 0, fast ? 5 : 35));
-
-        sender().sendMessage(C.GREEN + "Opening inventory now!");
-        player().openInventory(inv);
-    }
-
-    @Decree(description = "Calculate the chance for each region to generate", origin = DecreeOrigin.PLAYER)
-    public void regions(@Param(description = "The radius in chunks", defaultValue = "500") int radius) {
-        var engine = engine();
-        if (engine == null) {
-            sender().sendMessage(C.RED + "Only works in an Iris world!");
-            return;
-        }
-        var sender = sender();
-        var player = player();
-        Thread.ofVirtual()
-                .start(() -> {
-                    int d = radius * 2;
-                    KMap<String, AtomicInteger> data = new KMap<>();
-                    engine.getDimension().getRegions().forEach(key -> data.put(key, new AtomicInteger(0)));
-                    var multiBurst = new MultiBurst("Region Sampler");
-                    var executor = multiBurst.burst(radius * radius);
-                    sender.sendMessage(C.GRAY + "Generating data...");
-                    var loc = player.getLocation();
-                    int totalTasks = d * d;
-                    AtomicInteger completedTasks = new AtomicInteger(0);
-                    int c = J.ar(() -> sender.sendProgress((double) completedTasks.get() / totalTasks, "Finding regions"), 0);
-                    new Spiraler(d, d, (x, z) -> executor.queue(() -> {
-                        var region = engine.getRegion((x << 4) + 8, (z << 4) + 8);
-                        data.computeIfAbsent(region.getLoadKey(), (k) -> new AtomicInteger(0))
-                                .incrementAndGet();
-                        completedTasks.incrementAndGet();
-                    })).setOffset(loc.getBlockX(), loc.getBlockZ()).drain();
-                    executor.complete();
-                    multiBurst.close();
-                    J.car(c);
-
-                    sender.sendMessage(C.GREEN + "Done!");
-                    var loader = engine.getData().getRegionLoader();
-                    data.forEach((k, v) -> sender.sendMessage(C.GREEN + k + ": " + loader.load(k).getRarity() + " / " + Form.f((double) v.get() / totalTasks * 100, 2) + "%"));
-                });
-    }
-
-    @Decree(description = "Get all structures in a radius of chunks", aliases = "dist", origin = DecreeOrigin.PLAYER)
-    public void distances(@Param(description = "The radius in chunks") int radius) {
-        var engine = engine();
-        if (engine == null) {
-            sender().sendMessage(C.RED + "Only works in an Iris world!");
-            return;
-        }
-        var sender = sender();
-        int d = radius * 2;
-        KMap<String, KList<Position2>> data = new KMap<>();
-        var multiBurst = new MultiBurst("Distance Sampler");
-        var executor = multiBurst.burst(radius * radius);
-
-        sender.sendMessage(C.GRAY + "Generating data...");
-        var loc = player().getLocation();
-        int totalTasks = d * d;
-        AtomicInteger completedTasks = new AtomicInteger(0);
-        int c = J.ar(() -> {
-            sender.sendProgress((double) completedTasks.get() / totalTasks, "Finding structures");
-        }, 0);
-
-        new Spiraler(d, d, (x, z) -> executor.queue(() -> {
-            var struct = engine.getStructureAt(x, z);
-            if (struct != null) {
-                data.computeIfAbsent(struct.getLoadKey(), (k) -> new KList<>()).add(new Position2(x, z));
-            }
-            completedTasks.incrementAndGet();
-        })).setOffset(loc.getBlockX(), loc.getBlockZ()).drain();
-
-        executor.complete();
-        multiBurst.close();
-        J.car(c);
-
-        for (var key : data.keySet()) {
-            var list = data.get(key);
-            KList<Long> distances = new KList<>(list.size() - 1);
-            for (int i = 0; i < list.size(); i++) {
-                var pos = list.get(i);
-                double dist = Integer.MAX_VALUE;
-                for (var p : list) {
-                    if (p.equals(pos)) continue;
-                    dist = Math.min(dist, Math.sqrt(Math.pow(pos.getX() - p.getX(), 2) + Math.pow(pos.getZ() - p.getZ(), 2)));
-                }
-                if (dist == Integer.MAX_VALUE) continue;
-                distances.add(Math.round(dist * 16));
-            }
-            long[] array = new long[distances.size()];
-            for (int i = 0; i < distances.size(); i++) {
-                array[i] = distances.get(i);
-            }
-            Arrays.sort(array);
-            long min = array.length > 0 ? array[0] : 0;
-            long max = array.length > 0 ? array[array.length - 1] : 0;
-            long sum = Arrays.stream(array).sum();
-            long avg = array.length > 0 ? Math.round(sum / (double) array.length) : 0;
-            String msg = "%s: %s => min: %s/max: %s -> avg: %s".formatted(key, list.size(), min, max, avg);
-            sender.sendMessage(msg);
-        }
-        if (data.isEmpty()) {
-            sender.sendMessage(C.RED + "No data found!");
-        } else {
-            sender.sendMessage(C.GREEN + "Done!");
-        }
-    }
-
-
-    @Decree(description = "Render a world map (External GUI)", aliases = "render")
-    public void map(
-            @Param(name = "world", description = "The world to open the generator for", contextual = true)
-            World world
-    ) {
-        if (noGUI()) return;
-
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.RED + "You need to be in or specify an Iris-generated world!");
-            return;
-        }
-
-        VisionGUI.launch(IrisToolbelt.access(world).getEngine(), 0);
-        sender().sendMessage(C.GREEN + "Opening map!");
-    }
-
-    @Decree(description = "Package a dimension into a compressed format", aliases = "package")
-    public void pkg(
-            @Param(name = "dimension", description = "The dimension pack to compress", contextual = true, defaultValue = "default")
-            IrisDimension dimension,
-            @Param(name = "obfuscate", description = "Whether or not to obfuscate the pack", defaultValue = "false")
-            boolean obfuscate,
-            @Param(name = "minify", description = "Whether or not to minify the pack", defaultValue = "true")
-            boolean minify
-    ) {
-        Iris.service(StudioSVC.class).compilePackage(sender(), dimension.getLoadKey(), obfuscate, minify);
-    }
-
-    @Decree(description = "Profiles the performance of a dimension", origin = DecreeOrigin.PLAYER)
-    public void profile(
-            @Param(description = "The dimension to profile", contextual = true, defaultValue = "default")
-            IrisDimension dimension
-    ) {
-        // Todo: Make this more accurate
-        File pack = dimension.getLoadFile().getParentFile().getParentFile();
-        File report = Iris.instance.getDataFile("profile.txt");
-        IrisProject project = new IrisProject(pack);
-        IrisData data = IrisData.get(pack);
-
-        KList<String> fileText = new KList<>();
-
-        KMap<NoiseStyle, Double> styleTimings = new KMap<>();
-        KMap<InterpolationMethod, Double> interpolatorTimings = new KMap<>();
-        KMap<String, Double> generatorTimings = new KMap<>();
-        KMap<String, Double> biomeTimings = new KMap<>();
-        KMap<String, Double> regionTimings = new KMap<>();
-
-        sender().sendMessage("Calculating Performance Metrics for Noise generators");
-
-        for (NoiseStyle i : NoiseStyle.values()) {
-            CNG c = i.create(new RNG(i.hashCode()));
-
-            for (int j = 0; j < 3000; j++) {
-                c.noise(j, j + 1000, j * j);
-                c.noise(j, -j);
-            }
-
-            PrecisionStopwatch px = PrecisionStopwatch.start();
-
-            for (int j = 0; j < 100000; j++) {
-                c.noise(j, j + 1000, j * j);
-                c.noise(j, -j);
-            }
-
-            styleTimings.put(i, px.getMilliseconds());
-        }
-
-        fileText.add("Noise Style Performance Impacts: ");
-
-        for (NoiseStyle i : styleTimings.sortKNumber()) {
-            fileText.add(i.name() + ": " + styleTimings.get(i));
-        }
-
-        fileText.add("");
-
-        sender().sendMessage("Calculating Interpolator Timings...");
-
-        for (InterpolationMethod i : InterpolationMethod.values()) {
-            IrisInterpolator in = new IrisInterpolator();
-            in.setFunction(i);
-            in.setHorizontalScale(8);
-
-            NoiseProvider np = (x, z) -> Math.random();
-
-            for (int j = 0; j < 3000; j++) {
-                in.interpolate(j, -j, np);
-            }
-
-            PrecisionStopwatch px = PrecisionStopwatch.start();
-
-            for (int j = 0; j < 100000; j++) {
-                in.interpolate(j + 10000, -j - 100000, np);
-            }
-
-            interpolatorTimings.put(i, px.getMilliseconds());
-        }
-
-        fileText.add("Noise Interpolator Performance Impacts: ");
-
-        for (InterpolationMethod i : interpolatorTimings.sortKNumber()) {
-            fileText.add(i.name() + ": " + interpolatorTimings.get(i));
-        }
-
-        fileText.add("");
-
-        sender().sendMessage("Processing Generator Scores: ");
-
-        KMap<String, KList<String>> btx = new KMap<>();
-
-        for (String i : data.getGeneratorLoader().getPossibleKeys()) {
-            KList<String> vv = new KList<>();
-            IrisGenerator g = data.getGeneratorLoader().load(i);
-            KList<IrisNoiseGenerator> composites = g.getAllComposites();
-            double score = 0;
-            int m = 0;
-            for (IrisNoiseGenerator j : composites) {
-                m++;
-                score += styleTimings.get(j.getStyle().getStyle());
-                vv.add("Composite Noise Style " + m + " " + j.getStyle().getStyle().name() + ": " + styleTimings.get(j.getStyle().getStyle()));
-            }
-
-            score += interpolatorTimings.get(g.getInterpolator().getFunction());
-            vv.add("Interpolator " + g.getInterpolator().getFunction().name() + ": " + interpolatorTimings.get(g.getInterpolator().getFunction()));
-            generatorTimings.put(i, score);
-            btx.put(i, vv);
-        }
-
-        fileText.add("Project Generator Performance Impacts: ");
-
-        for (String i : generatorTimings.sortKNumber()) {
-            fileText.add(i + ": " + generatorTimings.get(i));
-
-            btx.get(i).forEach((ii) -> fileText.add("  " + ii));
-        }
-
-        fileText.add("");
-
-        KMap<String, KList<String>> bt = new KMap<>();
-
-        for (String i : data.getBiomeLoader().getPossibleKeys()) {
-            KList<String> vv = new KList<>();
-            IrisBiome b = data.getBiomeLoader().load(i);
-            double score = 0;
-
-            int m = 0;
-            for (IrisBiomePaletteLayer j : b.getLayers()) {
-                m++;
-                score += styleTimings.get(j.getStyle().getStyle());
-                vv.add("Palette Layer " + m + ": " + styleTimings.get(j.getStyle().getStyle()));
-            }
-
-            score += styleTimings.get(b.getBiomeStyle().getStyle());
-            vv.add("Biome Style: " + styleTimings.get(b.getBiomeStyle().getStyle()));
-            score += styleTimings.get(b.getChildStyle().getStyle());
-            vv.add("Child Style: " + styleTimings.get(b.getChildStyle().getStyle()));
-            biomeTimings.put(i, score);
-            bt.put(i, vv);
-        }
-
-        fileText.add("Project Biome Performance Impacts: ");
-
-        for (String i : biomeTimings.sortKNumber()) {
-            fileText.add(i + ": " + biomeTimings.get(i));
-
-            bt.get(i).forEach((ff) -> fileText.add("  " + ff));
-        }
-
-        fileText.add("");
-
-        for (String i : data.getRegionLoader().getPossibleKeys()) {
-            IrisRegion b = data.getRegionLoader().load(i);
-            double score = 0;
-
-            score += styleTimings.get(b.getLakeStyle().getStyle());
-            score += styleTimings.get(b.getRiverStyle().getStyle());
-            regionTimings.put(i, score);
-        }
-
-        fileText.add("Project Region Performance Impacts: ");
-
-        for (String i : regionTimings.sortKNumber()) {
-            fileText.add(i + ": " + regionTimings.get(i));
-        }
-
-        fileText.add("");
-
-        double m = 0;
-        for (double i : biomeTimings.v()) {
-            m += i;
-        }
-        m /= biomeTimings.size();
-        double mm = 0;
-        for (double i : generatorTimings.v()) {
-            mm += i;
-        }
-        mm /= generatorTimings.size();
-        m += mm;
-        double mmm = 0;
-        for (double i : regionTimings.v()) {
-            mmm += i;
-        }
-        mmm /= regionTimings.size();
-        m += mmm;
-
-        fileText.add("Average Score: " + m);
-        sender().sendMessage("Score: " + Form.duration(m, 0));
-
-        try {
-            IO.writeAll(report, fileText.toString("\n"));
-        } catch (IOException e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-
-        sender().sendMessage(C.GREEN + "Done! " + report.getPath());
-    }
-
-    @Decree(description = "Spawn an Iris entity", aliases = "summon", origin = DecreeOrigin.PLAYER)
-    public void spawn(
-            @Param(description = "The entity to spawn")
-            IrisEntity entity,
-            @Param(description = "The location to spawn the entity at", contextual = true)
-            Vector location
-    ) {
-        if (!IrisToolbelt.isIrisWorld(player().getWorld())) {
-            sender().sendMessage(C.RED + "You have to be in an Iris world to spawn entities properly. Trying to spawn the best we can do.");
-        }
-        entity.spawn(engine(), new Location(world(), location.getX(), location.getY(), location.getZ()));
-    }
-
-    @Decree(description = "Teleport to the active studio world", aliases = "stp", origin = DecreeOrigin.PLAYER, sync = true)
-    public void tpstudio() {
-        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
-            sender().sendMessage(C.RED + "No studio world is open!");
-            return;
-        }
-
-        if (IrisToolbelt.isIrisWorld(world()) && engine().isStudio()) {
-            sender().sendMessage(C.RED + "You are already in a studio world!");
-            return;
-        }
-
-        sender().sendMessage(C.GREEN + "Sending you to the studio world!");
-        player().teleport(Iris.service(StudioSVC.class).getActiveProject().getActiveProvider().getTarget().getWorld().spawnLocation());
-        player().setGameMode(GameMode.SPECTATOR);
-    }
-
-    @Decree(description = "Update your dimension projects VSCode workspace")
-    public void update(
-            @Param(description = "The dimension to update the workspace of", contextual = true, defaultValue = "default")
-            IrisDimension dimension
-    ) {
-        sender().sendMessage(C.GOLD + "Updating Code Workspace for " + dimension.getName() + "...");
-        if (new IrisProject(dimension.getLoader().getDataFolder()).updateWorkspace()) {
-            sender().sendMessage(C.GREEN + "Updated Code Workspace for " + dimension.getName());
-        } else {
-            sender().sendMessage(C.RED + "Invalid project: " + dimension.getName() + ". Try deleting the code-workspace file and try again.");
-        }
-    }
-
-    @Decree(aliases = "find-objects", description = "Get information about nearby structures")
-    public void objects() {
-        if (!IrisToolbelt.isIrisWorld(player().getWorld())) {
-            sender().sendMessage(C.RED + "You must be in an Iris world");
-            return;
-        }
-
-        World world = player().getWorld();
-
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage("You must be in an iris world.");
-            return;
-        }
-        KList<Chunk> chunks = new KList<>();
-        int bx = player().getLocation().getChunk().getX();
-        int bz = player().getLocation().getChunk().getZ();
-
-        try {
-            Location l = player().getTargetBlockExact(48, FluidCollisionMode.NEVER).getLocation();
-
-            int cx = l.getChunk().getX();
-            int cz = l.getChunk().getZ();
-            new Spiraler(3, 3, (x, z) -> chunks.addIfMissing(world.getChunkAt(x + cx, z + cz))).drain();
-        } catch (Throwable e) {
-            Iris.reportError(e);
-        }
-
-        new Spiraler(3, 3, (x, z) -> chunks.addIfMissing(world.getChunkAt(x + bx, z + bz))).drain();
-        sender().sendMessage("Capturing IGenData from " + chunks.size() + " nearby chunks.");
-        try {
-            File ff = Iris.instance.getDataFile("reports/" + M.ms() + ".txt");
-            PrintWriter pw = new PrintWriter(ff);
-            pw.println("=== Iris Chunk Report ===");
-            pw.println("== General Info ==");
-            pw.println("Iris Version: " + Iris.instance.getDescription().getVersion());
-            pw.println("Bukkit Version: " + Bukkit.getBukkitVersion());
-            pw.println("MC Version: " + Bukkit.getVersion());
-            pw.println("PaperSpigot: " + (PaperLib.isPaper() ? "Yup!" : "Nope!"));
-            pw.println("Report Captured At: " + new Date());
-            pw.println("Chunks: (" + chunks.size() + "): ");
-
-            for (Chunk i : chunks) {
-                pw.println("- [" + i.getX() + ", " + i.getZ() + "]");
-            }
-
-            int regions = 0;
-            long size = 0;
-            String age = "No idea...";
-
-            try {
-                for (File i : Objects.requireNonNull(new File(world.getWorldFolder(), "region").listFiles())) {
-                    if (i.isFile()) {
-                        size += i.length();
-                    }
-                }
-            } catch (Throwable e) {
-                Iris.reportError(e);
-            }
-
-            try {
-                FileTime creationTime = (FileTime) Files.getAttribute(world.getWorldFolder().toPath(), "creationTime");
-                age = hrf(Duration.of(M.ms() - creationTime.toMillis(), ChronoUnit.MILLIS));
-            } catch (IOException e) {
-                Iris.reportError(e);
-            }
-
-            KList<String> biomes = new KList<>();
-            KList<String> caveBiomes = new KList<>();
-            KMap<String, KMap<String, KList<String>>> objects = new KMap<>();
-
-            for (Chunk i : chunks) {
-                for (int j = 0; j < 16; j += 3) {
-
-                    for (int k = 0; k < 16; k += 3) {
-
-                        assert engine() != null;
-                        IrisBiome bb = engine().getSurfaceBiome((i.getX() * 16) + j, (i.getZ() * 16) + k);
-                        IrisBiome bxf = engine().getCaveBiome((i.getX() * 16) + j, (i.getZ() * 16) + k);
-                        biomes.addIfMissing(bb.getName() + " [" + Form.capitalize(bb.getInferredType().name().toLowerCase()) + "] " + " (" + bb.getLoadFile().getName() + ")");
-                        caveBiomes.addIfMissing(bxf.getName() + " (" + bxf.getLoadFile().getName() + ")");
-                        exportObjects(bb, pw, engine(), objects);
-                        exportObjects(bxf, pw, engine(), objects);
-                    }
-                }
-            }
-
-            regions = Objects.requireNonNull(new File(world.getWorldFolder().getPath() + "/region").list()).length;
-
-            pw.println();
-            pw.println("== World Info ==");
-            pw.println("World Name: " + world.getName());
-            pw.println("Age: " + age);
-            pw.println("Folder: " + world.getWorldFolder().getPath());
-            pw.println("Regions: " + Form.f(regions));
-            pw.println("Chunks: max. " + Form.f(regions * 32 * 32));
-            pw.println("World Size: min. " + Form.fileSize(size));
-            pw.println();
-            pw.println("== Biome Info ==");
-            pw.println("Found " + biomes.size() + " Biome(s): ");
-
-            for (String i : biomes) {
-                pw.println("- " + i);
-            }
-            pw.println();
-
-            pw.println("== Object Info ==");
-
-            for (String i : objects.k()) {
-                pw.println("- " + i);
-
-                for (String j : objects.get(i).k()) {
-                    pw.println("  @ " + j);
-
-                    for (String k : objects.get(i).get(j)) {
-                        pw.println("    * " + k);
-                    }
-                }
-            }
-
-            pw.println();
-            pw.close();
-
-            sender().sendMessage("Reported to: " + ff.getPath());
-        } catch (FileNotFoundException e) {
-            e.printStackTrace();
-            Iris.reportError(e);
-        }
-    }
-
-    private void exportObjects(IrisBiome bb, PrintWriter pw, Engine g, KMap<String, KMap<String, KList<String>>> objects) {
-        String n1 = bb.getName() + " [" + Form.capitalize(bb.getInferredType().name().toLowerCase()) + "] " + " (" + bb.getLoadFile().getName() + ")";
-        int m = 0;
-        KSet<String> stop = new KSet<>();
-        for (IrisObjectPlacement f : bb.getObjects()) {
-            m++;
-            String n2 = "Placement #" + m + " (" + f.getPlace().size() + " possible objects)";
-
-            for (String i : f.getPlace()) {
-                String nn3 = i + ": [ERROR] Failed to find object!";
-
-                try {
-                    if (stop.contains(i)) {
-                        continue;
-                    }
-
-                    File ff = g.getData().getObjectLoader().findFile(i);
-                    BlockVector sz = IrisObject.sampleSize(ff);
-                    nn3 = i + ": size=[" + sz.getBlockX() + "," + sz.getBlockY() + "," + sz.getBlockZ() + "] location=[" + ff.getPath() + "]";
-                    stop.add(i);
-                } catch (Throwable e) {
-                    Iris.reportError(e);
-                }
-
-                String n3 = nn3;
-                objects.computeIfAbsent(n1, (k1) -> new KMap<>())
-                        .computeIfAbsent(n2, (k) -> new KList<>()).addIfMissing(n3);
-            }
-        }
-    }
-
-    /**
-     * @return true if server GUIs are not enabled
-     */
-    private boolean noGUI() {
-        if (!IrisSettings.get().getGui().isUseServerLaunchedGuis()) {
-            sender().sendMessage(C.RED + "You must have server launched GUIs enabled in the settings!");
-            return true;
-        }
-        return false;
-    }
-
-    /**
-     * @return true if no studio is open or the player is not in one
-     */
-    private boolean noStudio() {
-        if (!sender().isPlayer()) {
-            sender().sendMessage(C.RED + "Players only!");
-            return true;
-        }
-        if (!Iris.service(StudioSVC.class).isProjectOpen()) {
-            sender().sendMessage(C.RED + "No studio world is open!");
-            return true;
-        }
-        if (!engine().isStudio()) {
-            sender().sendMessage(C.RED + "You must be in a studio world!");
-            return true;
-        }
-        return false;
-    }
-
-
-    public void files(File clean, KList<File> files) {
-        if (clean.isDirectory()) {
-            for (File i : clean.listFiles()) {
-                files(i, files);
-            }
-        } else if (clean.getName().endsWith(".json")) {
-            try {
-                files.add(clean);
-            } catch (Throwable e) {
-                Iris.reportError(e);
-                Iris.error("Failed to beautify " + clean.getAbsolutePath() + " You may have errors in your json!");
-            }
-        }
-    }
-
-    private void fixBlocks(JSONObject obj) {
-        for (String i : obj.keySet()) {
-            Object o = obj.get(i);
-
-            if (i.equals("block") && o instanceof String && !o.toString().trim().isEmpty() && !o.toString().contains(":")) {
-                obj.put(i, "minecraft:" + o);
-            }
-
-            if (o instanceof JSONObject) {
-                fixBlocks((JSONObject) o);
-            } else if (o instanceof JSONArray) {
-                fixBlocks((JSONArray) o);
-            }
-        }
-    }
-
-    private void fixBlocks(JSONArray obj) {
-        for (int i = 0; i < obj.length(); i++) {
-            Object o = obj.get(i);
-
-            if (o instanceof JSONObject) {
-                fixBlocks((JSONObject) o);
-            } else if (o instanceof JSONArray) {
-                fixBlocks((JSONArray) o);
-            }
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/commands/CommandTurboPregen.java

@@ -1,131 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.pregenerator.LazyPregenerator;
-import com.volmit.iris.core.pregenerator.TurboPregenerator;
-import com.volmit.iris.core.pregenerator.TurboPregenerator;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.io.IOException;
-
-@Decree(name = "turbopregen", aliases = "turbo", description = "Pregenerate your Iris worlds!")
-public class CommandTurboPregen implements DecreeExecutor {
-    public String worldName;
-    @Decree(description = "Pregenerate a world")
-    public void start(
-            @Param(description = "The radius of the pregen in blocks", aliases = "size")
-            int radius,
-            @Param(description = "The world to pregen", contextual = true)
-            World world,
-            @Param(aliases = "middle", description = "The center location of the pregen. Use \"me\" for your current location", defaultValue = "0,0")
-            Vector center
-            ) {
-
-        worldName = world.getName();
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File TurboFile = new File(worldDirectory, "turbogen.json");
-        if (TurboFile.exists()) {
-            if (TurboPregenerator.getInstance() != null) {
-                sender().sendMessage(C.BLUE + "Turbo pregen is already in progress");
-                Iris.info(C.YELLOW + "Turbo pregen is already in progress");
-                return;
-            } else {
-                try {
-                    TurboFile.delete();
-                } catch (Exception e){
-                   Iris.error("Failed to delete the old instance file of Turbo Pregen!");
-                   return;
-                }
-            }
-        }
-
-        try {
-            if (sender().isPlayer() && access() == null) {
-                sender().sendMessage(C.RED + "The engine access for this world is null!");
-                sender().sendMessage(C.RED + "Please make sure the world is loaded & the engine is initialized. Generate a new chunk, for example.");
-            }
-
-            TurboPregenerator.TurboPregenJob pregenJob = TurboPregenerator.TurboPregenJob.builder()
-                    .world(worldName)
-                    .radiusBlocks(radius)
-                    .position(0)
-                    .build();
-
-            File TurboGenFile = new File(worldDirectory, "turbogen.json");
-            TurboPregenerator pregenerator = new TurboPregenerator(pregenJob, TurboGenFile);
-            pregenerator.start();
-
-            String msg = C.GREEN + "TurboPregen started in " + C.GOLD + worldName + C.GREEN + " of " + C.GOLD + (radius * 2) + C.GREEN + " by " + C.GOLD + (radius * 2) + C.GREEN + " blocks from " + C.GOLD + center.getX() + "," + center.getZ();
-            sender().sendMessage(msg);
-            Iris.info(msg);
-        } catch (Throwable e) {
-            sender().sendMessage(C.RED + "Epic fail. See console.");
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-    }
-
-    @Decree(description = "Stop the active pregeneration task", aliases = "x")
-    public void stop(@Param(aliases = "world", description = "The world to pause") World world) throws IOException {
-        TurboPregenerator turboPregenInstance = TurboPregenerator.getInstance();
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File turboFile = new File(worldDirectory, "turbogen.json");
-
-        if (turboPregenInstance != null) {
-            turboPregenInstance.shutdownInstance(world);
-            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
-        } else if (turboFile.exists() && turboFile.delete()) {
-            sender().sendMessage(C.LIGHT_PURPLE + "Closed Turbogen instance for " + world.getName());
-        } else if (turboFile.exists()) {
-            Iris.error("Failed to delete the old instance file of Turbo Pregen!");
-        } else {
-            sender().sendMessage(C.YELLOW + "No active pregeneration tasks to stop");
-        }
-    }
-
-    @Decree(description = "Pause / continue the active pregeneration task", aliases = {"t", "resume", "unpause"})
-    public void pause(
-            @Param(aliases = "world", description = "The world to pause")
-            World world
-    ) {
-        if (TurboPregenerator.getInstance() != null) {
-            TurboPregenerator.setPausedTurbo(world);
-            sender().sendMessage(C.GREEN + "Paused/unpaused Turbo Pregen, now: " + (TurboPregenerator.isPausedTurbo(world) ? "Paused" : "Running") + ".");
-        } else {
-            File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-            File TurboFile = new File(worldDirectory, "turbogen.json");
-            if (TurboFile.exists()){
-                TurboPregenerator.loadTurboGenerator(world.getName());
-                sender().sendMessage(C.YELLOW + "Started Turbo Pregen back up!");
-            } else {
-                sender().sendMessage(C.YELLOW + "No active Turbo Pregen tasks to pause/unpause.");
-            }
-
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/commands/CommandUpdater.java

@@ -1,102 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import lombok.Synchronized;
-import org.bukkit.World;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.pregenerator.ChunkUpdater;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.format.Form;
-
-@Decree(name = "updater", origin = DecreeOrigin.BOTH, description = "Iris World Updater")
-public class CommandUpdater implements DecreeExecutor {
-    private final Object lock = new Object();
-    private transient ChunkUpdater chunkUpdater;
-
-    @Decree(description = "Updates all chunk in the specified world")
-    public void start(
-            @Param(description = "World to update chunks at", contextual = true)
-            World world
-    ) {
-        if (!IrisToolbelt.isIrisWorld(world)) {
-            sender().sendMessage(C.GOLD + "This is not an Iris world");
-            return;
-        }
-        synchronized (lock) {
-            if (chunkUpdater != null) {
-                chunkUpdater.stop();
-            }
-
-            chunkUpdater = new ChunkUpdater(world);
-            if (sender().isPlayer()) {
-                sender().sendMessage(C.GREEN + "Updating " + world.getName()  + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
-            } else {
-                Iris.info(C.GREEN + "Updating " + world.getName() + C.GRAY + " Total chunks: " + Form.f(chunkUpdater.getChunks()));
-            }
-            chunkUpdater.start();
-        }
-    }
-
-    @Synchronized("lock")
-    @Decree(description = "Pause the updater")
-    public void pause( ) {
-        if (chunkUpdater == null) {
-            sender().sendMessage(C.GOLD + "You cant pause something that doesnt exist?");
-            return;
-        }
-        boolean status = chunkUpdater.pause();
-        if (sender().isPlayer()) {
-            if (status) {
-                sender().sendMessage(C.IRIS + "Paused task for: " + C.GRAY + chunkUpdater.getName());
-            } else {
-                sender().sendMessage(C.IRIS + "Unpause task for: " + C.GRAY + chunkUpdater.getName());
-            }
-        } else {
-            if (status) {
-                Iris.info(C.IRIS + "Paused task for: " + C.GRAY + chunkUpdater.getName());
-            } else {
-                Iris.info(C.IRIS + "Unpause task for: " + C.GRAY + chunkUpdater.getName());
-            }
-        }
-    }
-
-    @Synchronized("lock")
-    @Decree(description = "Stops the updater")
-    public void stop() {
-        if (chunkUpdater == null) {
-            sender().sendMessage(C.GOLD + "You cant stop something that doesnt exist?");
-            return;
-        }
-        if (sender().isPlayer()) {
-            sender().sendMessage("Stopping Updater for: " + C.GRAY + chunkUpdater.getName());
-        } else {
-            Iris.info("Stopping Updater for: " + C.GRAY + chunkUpdater.getName());
-        }
-        chunkUpdater.stop();
-    }
-}
-
-

core/src/main/java/com/volmit/iris/core/commands/CommandWhat.java

@@ -1,169 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.commands;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.edit.BlockSignal;
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.decree.DecreeExecutor;
-import com.volmit.iris.util.decree.DecreeOrigin;
-import com.volmit.iris.util.decree.annotations.Decree;
-import com.volmit.iris.util.decree.annotations.Param;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.matter.MatterMarker;
-import com.volmit.iris.util.scheduling.J;
-import org.bukkit.Chunk;
-import org.bukkit.FluidCollisionMode;
-import org.bukkit.Material;
-import org.bukkit.block.Biome;
-import org.bukkit.block.data.BlockData;
-
-import java.util.Objects;
-import java.util.concurrent.atomic.AtomicInteger;
-
-@Decree(name = "what", origin = DecreeOrigin.PLAYER, studio = true, description = "Iris What?")
-public class CommandWhat implements DecreeExecutor {
-    @Decree(description = "What is in my hand?", origin = DecreeOrigin.PLAYER)
-    public void hand() {
-        try {
-            BlockData bd = player().getInventory().getItemInMainHand().getType().createBlockData();
-            if (!bd.getMaterial().equals(Material.AIR)) {
-                sender().sendMessage("Material: " + C.GREEN + bd.getMaterial().name());
-                sender().sendMessage("Full: " + C.WHITE + bd.getAsString(true));
-            } else {
-                sender().sendMessage("Please hold a block/item");
-            }
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            Material bd = player().getInventory().getItemInMainHand().getType();
-            if (!bd.equals(Material.AIR)) {
-                sender().sendMessage("Material: " + C.GREEN + bd.name());
-            } else {
-                sender().sendMessage("Please hold a block/item");
-            }
-        }
-    }
-
-    @Decree(description = "What biome am i in?", origin = DecreeOrigin.PLAYER)
-    public void biome() {
-        try {
-            IrisBiome b = engine().getBiome(player().getLocation().getBlockX(), player().getLocation().getBlockY() - player().getWorld().getMinHeight(), player().getLocation().getBlockZ());
-            sender().sendMessage("IBiome: " + b.getLoadKey() + " (" + b.getDerivative().name() + ")");
-
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            sender().sendMessage("Non-Iris Biome: " + player().getLocation().getBlock().getBiome().name());
-
-            if (player().getLocation().getBlock().getBiome().equals(Biome.CUSTOM)) {
-                try {
-                    sender().sendMessage("Data Pack Biome: " + INMS.get().getTrueBiomeBaseKey(player().getLocation()) + " (ID: " + INMS.get().getTrueBiomeBaseId(INMS.get().getTrueBiomeBase(player().getLocation())) + ")");
-                } catch (Throwable ee) {
-                    Iris.reportError(ee);
-                }
-            }
-        }
-    }
-
-    @Decree(description = "What region am i in?", origin = DecreeOrigin.PLAYER)
-    public void region() {
-        try {
-            Chunk chunk = world().getChunkAt(player().getLocation().getBlockZ() / 16, player().getLocation().getBlockZ() /  16);
-            IrisRegion r = engine().getRegion(chunk);
-            sender().sendMessage("IRegion: " + r.getLoadKey() + " (" + r.getName() + ")");
-
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            sender().sendMessage(C.IRIS + "Iris worlds only.");
-        }
-    }
-
-    @Decree(description = "What block am i looking at?", origin = DecreeOrigin.PLAYER)
-    public void block() {
-        BlockData bd;
-        try {
-            bd = player().getTargetBlockExact(128, FluidCollisionMode.NEVER).getBlockData();
-        } catch (NullPointerException e) {
-            Iris.reportError(e);
-            sender().sendMessage("Please look at any block, not at the sky");
-            bd = null;
-        }
-
-        if (bd != null) {
-            sender().sendMessage("Material: " + C.GREEN + bd.getMaterial().name());
-            sender().sendMessage("Full: " + C.WHITE + bd.getAsString(true));
-
-            if (B.isStorage(bd)) {
-                sender().sendMessage(C.YELLOW + "* Storage Block (Loot Capable)");
-            }
-
-            if (B.isLit(bd)) {
-                sender().sendMessage(C.YELLOW + "* Lit Block (Light Capable)");
-            }
-
-            if (B.isFoliage(bd)) {
-                sender().sendMessage(C.YELLOW + "* Foliage Block");
-            }
-
-            if (B.isDecorant(bd)) {
-                sender().sendMessage(C.YELLOW + "* Decorant Block");
-            }
-
-            if (B.isFluid(bd)) {
-                sender().sendMessage(C.YELLOW + "* Fluid Block");
-            }
-
-            if (B.isFoliagePlantable(bd)) {
-                sender().sendMessage(C.YELLOW + "* Plantable Foliage Block");
-            }
-
-            if (B.isSolid(bd)) {
-                sender().sendMessage(C.YELLOW + "* Solid Block");
-            }
-        }
-    }
-
-    @Decree(description = "Show markers in chunk", origin = DecreeOrigin.PLAYER)
-    public void markers(@Param(description = "Marker name such as cave_floor or cave_ceiling") String marker) {
-        Chunk c = player().getLocation().getChunk();
-
-        if (IrisToolbelt.isIrisWorld(c.getWorld())) {
-            int m = 1;
-            AtomicInteger v = new AtomicInteger(0);
-
-            for (int xxx = c.getX() - 4; xxx <= c.getX() + 4; xxx++) {
-                for (int zzz = c.getZ() - 4; zzz <= c.getZ() + 4; zzz++) {
-                    IrisToolbelt.access(c.getWorld()).getEngine().getMantle().findMarkers(xxx, zzz, new MatterMarker(marker))
-                            .convert((i) -> i.toLocation(c.getWorld())).forEach((i) -> {
-                                J.s(() -> BlockSignal.of(i.getBlock(), 100));
-                                v.incrementAndGet();
-                            });
-                }
-            }
-
-            sender().sendMessage("Found " + v.get() + " Nearby Markers (" + marker + ")");
-        } else {
-            sender().sendMessage(C.IRIS + "Iris worlds only.");
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/edit/BlockEditor.java

@@ -1,43 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.edit;
-
-import org.bukkit.block.Biome;
-import org.bukkit.block.data.BlockData;
-
-import java.io.Closeable;
-
-public interface BlockEditor extends Closeable {
-    long last();
-
-    void set(int x, int y, int z, BlockData d);
-
-    BlockData get(int x, int y, int z);
-
-    void setBiome(int x, int z, Biome b);
-
-    void setBiome(int x, int y, int z, Biome b);
-
-    @Override
-    void close();
-
-    Biome getBiome(int x, int y, int z);
-
-    Biome getBiome(int x, int z);
-}

core/src/main/java/com/volmit/iris/core/edit/BlockSignal.java

@@ -1,107 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.edit;
-
-import com.volmit.iris.util.parallel.MultiBurst;
-import com.volmit.iris.util.scheduling.J;
-import com.volmit.iris.util.scheduling.SR;
-import org.bukkit.Location;
-import org.bukkit.block.Block;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.entity.FallingBlock;
-import org.bukkit.entity.Player;
-import org.bukkit.util.Vector;
-
-import java.util.concurrent.atomic.AtomicInteger;
-
-@SuppressWarnings("InstantiationOfUtilityClass")
-public class BlockSignal {
-    public static final AtomicInteger active = new AtomicInteger(0);
-
-    public BlockSignal(Block block, int ticks) {
-        active.incrementAndGet();
-        Location tg = block.getLocation().clone().add(0.5, 0, 0.5);
-        FallingBlock e = block.getWorld().spawnFallingBlock(tg, block.getBlockData());
-        e.setGravity(false);
-        e.setInvulnerable(true);
-        e.setGlowing(true);
-        e.setDropItem(false);
-        e.setHurtEntities(false);
-        e.setSilent(true);
-        e.setTicksLived(1);
-        e.setVelocity(new Vector(0, 0, 0));
-        J.s(() -> {
-            e.remove();
-            active.decrementAndGet();
-            BlockData type = block.getBlockData();
-            MultiBurst.burst.lazy(() -> {
-                for (Player i : block.getWorld().getPlayers()) {
-                    i.sendBlockChange(block.getLocation(), block.getBlockData());
-                }
-            });
-        }, ticks);
-    }
-
-    public static void of(Block block, int ticks) {
-        new BlockSignal(block, ticks);
-    }
-
-    public static void of(Block block) {
-        of(block, 100);
-    }
-
-    public static Runnable forever(Block block) {
-        Location tg = block.getLocation().clone().add(0.5, 0, 0.5).clone();
-        FallingBlock e = block.getWorld().spawnFallingBlock(tg.clone(), block.getBlockData());
-        e.setGravity(false);
-        e.setInvulnerable(true);
-        e.setGlowing(true);
-        e.teleport(tg.clone());
-        e.setDropItem(false);
-        e.setHurtEntities(false);
-        e.setSilent(true);
-        e.setTicksLived(1);
-        e.setVelocity(new Vector(0, 0, 0));
-
-        new SR(20) {
-            @Override
-            public void run() {
-                if (e.isDead()) {
-                    cancel();
-                    return;
-                }
-
-                e.setTicksLived(1);
-                e.teleport(tg.clone());
-                e.setVelocity(new Vector(0, 0, 0));
-            }
-        };
-
-        return () -> {
-            e.remove();
-            BlockData type = block.getBlockData();
-
-            MultiBurst.burst.lazy(() -> {
-                for (Player i : block.getWorld().getPlayers()) {
-                    i.sendBlockChange(block.getLocation(), block.getBlockData());
-                }
-            });
-        };
-    }
-}

core/src/main/java/com/volmit/iris/core/edit/BukkitBlockEditor.java

@@ -1,75 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.edit;
-
-import com.volmit.iris.util.math.M;
-import org.bukkit.World;
-import org.bukkit.block.Biome;
-import org.bukkit.block.data.BlockData;
-
-@SuppressWarnings("ClassCanBeRecord")
-public class BukkitBlockEditor implements BlockEditor {
-    private final World world;
-
-    public BukkitBlockEditor(World world) {
-        this.world = world;
-    }
-
-    @Override
-    public void set(int x, int y, int z, BlockData d) {
-        world.getBlockAt(x, y, z).setBlockData(d, false);
-    }
-
-    @Override
-    public BlockData get(int x, int y, int z) {
-        return world.getBlockAt(x, y, z).getBlockData();
-    }
-
-    @Override
-    public void close() {
-
-    }
-
-    @Override
-    public long last() {
-        return M.ms();
-    }
-
-    @SuppressWarnings("deprecation")
-    @Override
-    public void setBiome(int x, int z, Biome b) {
-        world.setBiome(x, z, b);
-    }
-
-    @Override
-    public void setBiome(int x, int y, int z, Biome b) {
-        world.setBiome(x, y, z, b);
-    }
-
-    @Override
-    public Biome getBiome(int x, int y, int z) {
-        return world.getBiome(x, y, z);
-    }
-
-    @SuppressWarnings("deprecation")
-    @Override
-    public Biome getBiome(int x, int z) {
-        return world.getBiome(x, z);
-    }
-}

core/src/main/java/com/volmit/iris/core/edit/DustRevealer.java

@@ -1,127 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.edit;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.math.BlockPosition;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.J;
-import lombok.Data;
-import org.bukkit.Sound;
-import org.bukkit.World;
-import org.bukkit.block.Block;
-
-@SuppressWarnings("ALL")
-@Data
-public class DustRevealer {
-    private final Engine engine;
-    private final World world;
-    private final BlockPosition block;
-    private final String key;
-    private final KList<BlockPosition> hits;
-
-    public DustRevealer(Engine engine, World world, BlockPosition block, String key, KList<BlockPosition> hits) {
-        this.engine = engine;
-        this.world = world;
-        this.block = block;
-        this.key = key;
-        this.hits = hits;
-
-        J.s(() -> {
-            new BlockSignal(world.getBlockAt(block.getX(), block.getY(), block.getZ()), 10);
-            if (M.r(0.25)) {
-                world.playSound(block.toBlock(world).getLocation(), Sound.BLOCK_AMETHYST_BLOCK_CHIME, 1f, RNG.r.f(0.2f, 2f));
-            }
-            J.a(() -> {
-                while (BlockSignal.active.get() > 128) {
-                    J.sleep(5);
-                }
-
-                try {
-                    is(new BlockPosition(block.getX() + 1, block.getY(), block.getZ()));
-                    is(new BlockPosition(block.getX() - 1, block.getY(), block.getZ()));
-                    is(new BlockPosition(block.getX(), block.getY() + 1, block.getZ()));
-                    is(new BlockPosition(block.getX(), block.getY() - 1, block.getZ()));
-                    is(new BlockPosition(block.getX(), block.getY(), block.getZ() + 1));
-                    is(new BlockPosition(block.getX(), block.getY(), block.getZ() - 1));
-                    is(new BlockPosition(block.getX() + 1, block.getY(), block.getZ() + 1));
-                    is(new BlockPosition(block.getX() + 1, block.getY(), block.getZ() - 1));
-                    is(new BlockPosition(block.getX() - 1, block.getY(), block.getZ() + 1));
-                    is(new BlockPosition(block.getX() - 1, block.getY(), block.getZ() - 1));
-                    is(new BlockPosition(block.getX() + 1, block.getY() + 1, block.getZ()));
-                    is(new BlockPosition(block.getX() + 1, block.getY() - 1, block.getZ()));
-                    is(new BlockPosition(block.getX() - 1, block.getY() + 1, block.getZ()));
-                    is(new BlockPosition(block.getX() - 1, block.getY() - 1, block.getZ()));
-                    is(new BlockPosition(block.getX(), block.getY() + 1, block.getZ() - 1));
-                    is(new BlockPosition(block.getX(), block.getY() + 1, block.getZ() + 1));
-                    is(new BlockPosition(block.getX(), block.getY() - 1, block.getZ() - 1));
-                    is(new BlockPosition(block.getX(), block.getY() - 1, block.getZ() + 1));
-                    is(new BlockPosition(block.getX() - 1, block.getY() + 1, block.getZ() - 1));
-                    is(new BlockPosition(block.getX() - 1, block.getY() + 1, block.getZ() + 1));
-                    is(new BlockPosition(block.getX() - 1, block.getY() - 1, block.getZ() - 1));
-                    is(new BlockPosition(block.getX() - 1, block.getY() - 1, block.getZ() + 1));
-                    is(new BlockPosition(block.getX() + 1, block.getY() + 1, block.getZ() - 1));
-                    is(new BlockPosition(block.getX() + 1, block.getY() + 1, block.getZ() + 1));
-                    is(new BlockPosition(block.getX() + 1, block.getY() - 1, block.getZ() - 1));
-                    is(new BlockPosition(block.getX() + 1, block.getY() - 1, block.getZ() + 1));
-                } catch (Throwable e) {
-                    Iris.reportError(e);
-                    e.printStackTrace();
-                }
-            });
-        }, RNG.r.i(2, 8));
-    }
-
-    public static void spawn(Block block, VolmitSender sender) {
-        World world = block.getWorld();
-        Engine access = IrisToolbelt.access(world).getEngine();
-
-        if (access != null) {
-            String a = access.getObjectPlacementKey(block.getX(), block.getY() - block.getWorld().getMinHeight(), block.getZ());
-            if (a != null) {
-                world.playSound(block.getLocation(), Sound.ITEM_LODESTONE_COMPASS_LOCK, 1f, 0.1f);
-
-                sender.sendMessage("Found object " + a);
-                J.a(() -> {
-                    new DustRevealer(access, world, new BlockPosition(block.getX(), block.getY(), block.getZ()), a, new KList<>());
-                });
-            }
-        }
-    }
-
-    private boolean is(BlockPosition a) {
-        int betterY = a.getY() - world.getMinHeight();
-        if (isValidTry(a) && engine.getObjectPlacementKey(a.getX(), betterY, a.getZ()) != null && engine.getObjectPlacementKey(a.getX(), betterY, a.getZ()).equals(key)) {
-            hits.add(a);
-            new DustRevealer(engine, world, a, key, hits);
-            return true;
-        }
-
-        return false;
-    }
-
-    private boolean isValidTry(BlockPosition b) {
-        return !hits.contains(b);
-    }
-}

core/src/main/java/com/volmit/iris/core/edit/JigsawEditor.java

@@ -1,253 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.edit;
-
-import com.google.gson.Gson;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.service.WandSVC;
-import com.volmit.iris.engine.object.*;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.Cuboid;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.json.JSONObject;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.scheduling.ChronoLatch;
-import com.volmit.iris.util.scheduling.J;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.Particle;
-import org.bukkit.Sound;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.block.Action;
-import org.bukkit.event.player.PlayerInteractEvent;
-import org.bukkit.event.player.PlayerMoveEvent;
-import org.bukkit.util.Vector;
-
-import java.io.File;
-import java.io.IOException;
-import java.util.List;
-import java.util.concurrent.ExecutionException;
-
-public class JigsawEditor implements Listener {
-    public static final KMap<Player, JigsawEditor> editors = new KMap<>();
-    private final Player player;
-    private final IrisObject object;
-    private final File targetSaveLocation;
-    private final IrisJigsawPiece piece;
-    private final Location origin;
-    private final Cuboid cuboid;
-    private final int ticker;
-    private final KMap<IrisPosition, Runnable> falling = new KMap<>();
-    private final ChronoLatch cl = new ChronoLatch(100);
-    private Location target;
-
-    public JigsawEditor(Player player, IrisJigsawPiece piece, IrisObject object, File saveLocation) {
-        if (editors.containsKey(player)) {
-            editors.get(player).close();
-        }
-
-        editors.put(player, this);
-        if (object == null) {
-            throw new RuntimeException("Object is null! " + piece.getObject());
-        }
-        this.object = object;
-        this.player = player;
-        origin = player.getLocation().clone().add(0, 7, 0);
-        target = origin;
-        this.targetSaveLocation = saveLocation;
-        this.piece = piece == null ? new IrisJigsawPiece() : piece;
-        this.piece.setObject(object.getLoadKey());
-        cuboid = new Cuboid(origin.clone(), origin.clone().add(object.getW() - 1, object.getH() - 1, object.getD() - 1));
-        ticker = J.sr(this::onTick, 0);
-        J.s(() -> object.placeCenterY(origin));
-        Iris.instance.registerListener(this);
-    }
-
-    @EventHandler
-    public void on(PlayerMoveEvent e) {
-        if (e.getPlayer().equals(player)) {
-            try {
-                target = player.getTargetBlockExact(7).getLocation();
-            } catch (Throwable ex) {
-                Iris.reportError(ex);
-                target = player.getLocation();
-                return;
-            }
-
-            if (cuboid.contains(target)) {
-                for (IrisPosition i : falling.k()) {
-                    Location at = toLocation(i);
-
-                    if (at.equals(target)) {
-                        falling.remove(i).run();
-                    }
-                }
-            }
-        }
-    }
-
-    public Location toLocation(IrisPosition i) {
-        return origin.clone()
-                .add(new Vector(i.getX(), i.getY(), i.getZ()))
-                .add(object.getCenter())
-                .getBlock()
-                .getLocation();
-    }
-
-    public IrisPosition toPosition(Location l) {
-        return new IrisPosition(l.clone().getBlock().getLocation()
-                .subtract(origin.clone())
-                .subtract(object.getCenter())
-                .add(1, 1, 1)
-                .toVector());
-    }
-
-    @EventHandler
-    public void on(PlayerInteractEvent e) {
-        if (e.getAction().equals(Action.RIGHT_CLICK_BLOCK)) {
-            if (e.getClickedBlock() != null && cuboid.contains(e.getClickedBlock().getLocation()) && e.getPlayer().equals(player)) {
-                IrisPosition pos = toPosition(e.getClickedBlock().getLocation());
-                IrisJigsawPieceConnector connector = null;
-                for (IrisJigsawPieceConnector i : piece.getConnectors()) {
-                    if (i.getPosition().equals(pos)) {
-                        connector = i;
-                        break;
-                    }
-                }
-
-                if (!player.isSneaking() && connector == null) {
-                    connector = new IrisJigsawPieceConnector();
-                    connector.setDirection(IrisDirection.getDirection(e.getBlockFace()));
-                    connector.setPosition(pos);
-                    piece.getConnectors().add(connector);
-                    player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_ADD_ITEM, 1f, 1f);
-                } else if (player.isSneaking() && connector != null) {
-                    piece.getConnectors().remove(connector);
-                    player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_REMOVE_ITEM, 1f, 1f);
-                } else if (connector != null && !player.isSneaking()) {
-                    connector.setDirection(IrisDirection.getDirection(e.getBlockFace()));
-                    player.playSound(e.getClickedBlock().getLocation(), Sound.ENTITY_ITEM_FRAME_ROTATE_ITEM, 1f, 1f);
-                }
-            }
-        }
-    }
-
-    private void removeKey(JSONObject o, String... path) {
-        if (path.length == 1) {
-            o.remove(path[0]);
-            return;
-        }
-
-        List<String> s = new java.util.ArrayList<>(List.of(path));
-        s.remove(0);
-        removeKey(o.getJSONObject(path[0]), s.toArray(new String[0]));
-    }
-
-    private List<JSONObject> getObjectsInArray(JSONObject a) { // This gets all the objects in an array that are connectors
-        KList<JSONObject> o = new KList<>();
-
-        for (int i = 0; i < a.getJSONArray("connectors").length(); i++) {
-            o.add(a.getJSONArray("connectors").getJSONObject(i));
-        }
-
-        return o;
-    }
-
-    public void close() {
-        exit();
-        try {
-            JSONObject j = new JSONObject(new Gson().toJson(piece));
-            // Remove sub-key
-            removeKey(j, "placementOptions", "translateCenter"); // should work
-            J.attempt(() -> j.getJSONObject("placementOptions").remove("translateCenter")); // otherwise
-
-            // remove root key
-            removeKey(j, "placementOptions"); // should work
-            j.remove("placementOptions"); // otherwise
-
-            // Remove key in all objects in array
-            for (JSONObject i : getObjectsInArray(j)) {
-                removeKey(i, "rotateConnector");
-            }
-
-            IO.writeAll(targetSaveLocation, j.toString(4));
-        } catch (IOException e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-    }
-
-    public void exit() {
-        J.car(ticker);
-        Iris.instance.unregisterListener(this);
-        try {
-            J.sfut(() -> {
-                object.unplaceCenterY(origin);
-                falling.v().forEach(Runnable::run);
-            }).get();
-        } catch (InterruptedException | ExecutionException e) {
-            e.printStackTrace();
-        }
-        editors.remove(player);
-    }
-
-    public void onTick() {
-        if (cl.flip()) {
-            Iris.service(WandSVC.class).draw(cuboid, player);
-
-            f:
-            for (IrisPosition i : falling.k()) {
-                for (IrisJigsawPieceConnector j : piece.getConnectors()) {
-                    if (j.getPosition().equals(i)) {
-                        continue f;
-                    }
-                }
-
-                falling.remove(i).run();
-            }
-
-            for (IrisJigsawPieceConnector i : piece.getConnectors()) {
-                IrisPosition pos = i.getPosition();
-                Location at = toLocation(pos);
-
-                Vector dir = i.getDirection().toVector().clone();
-
-
-                for (int ix = 0; ix < RNG.r.i(1, 3); ix++) {
-                    at.getWorld().spawnParticle(Particle.SOUL_FIRE_FLAME, at.clone().getBlock().getLocation().add(0.25, 0.25, 0.25).add(RNG.r.d(0.5), RNG.r.d(0.5), RNG.r.d(0.5)), 0, dir.getX(), dir.getY(), dir.getZ(), 0.092 + RNG.r.d(-0.03, 0.08));
-                }
-
-                if (at.getBlock().getLocation().equals(target)) {
-                    continue;
-                }
-
-                if (!falling.containsKey(pos)) {
-                    if (at.getBlock().getType().isAir()) {
-                        at.getBlock().setType(Material.STONE);
-                    }
-
-                    falling.put(pos, BlockSignal.forever(at.getBlock()));
-                }
-            }
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/events/IrisEngineEvent.java

@@ -1,47 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.events;
-
-import com.volmit.iris.engine.framework.Engine;
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-
-@EqualsAndHashCode(callSuper = true)
-@Data
-@AllArgsConstructor
-public class IrisEngineEvent extends Event {
-    private static final HandlerList handlers = new HandlerList();
-    private Engine engine;
-
-    public IrisEngineEvent() {
-        super(true);
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-}

core/src/main/java/com/volmit/iris/core/events/IrisEngineHotloadEvent.java

@@ -1,39 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.events;
-
-import com.volmit.iris.engine.framework.Engine;
-import org.bukkit.event.HandlerList;
-
-public class IrisEngineHotloadEvent extends IrisEngineEvent {
-    private static final HandlerList handlers = new HandlerList();
-
-    public IrisEngineHotloadEvent(Engine engine) {
-        super(engine);
-    }
-
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-}

core/src/main/java/com/volmit/iris/core/events/IrisLootEvent.java

@@ -1,113 +0,0 @@
-package com.volmit.iris.core.events;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.InventorySlotType;
-import com.volmit.iris.engine.object.IrisLootTable;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.scheduling.J;
-import lombok.Getter;
-import org.bukkit.*;
-import org.bukkit.block.Block;
-import org.bukkit.event.Event;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.world.LootGenerateEvent;
-
-import org.bukkit.inventory.Inventory;
-import org.bukkit.inventory.InventoryHolder;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.loot.LootContext;
-import org.bukkit.loot.LootTable;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Random;
-
-@Getter
-public class IrisLootEvent extends Event {
-    private static final HandlerList handlers = new HandlerList();
-    private static final LootTable EMPTY = new LootTable() {
-        @NotNull
-        @Override
-        public NamespacedKey getKey() {
-            return new NamespacedKey(Iris.instance, "empty");
-        }
-
-        @NotNull
-        @Override
-        public Collection<ItemStack> populateLoot(@Nullable Random random, @NotNull LootContext context) {
-            return List.of();
-        }
-
-        @Override
-        public void fillInventory(@NotNull Inventory inventory, @Nullable Random random, @NotNull LootContext context) {
-        }
-    };
-
-    private final Engine engine;
-    private final Block block;
-    private final InventorySlotType slot;
-    private final KList<IrisLootTable> tables;
-
-    /**
-     * Constructor for IrisLootEvent with mode selection.
-     *
-     * @param engine The engine instance.
-     * @param block The block associated with the event.
-     * @param slot The inventory slot type.
-     * @param tables The list of IrisLootTables. (mutable*)
-     */
-    public IrisLootEvent(Engine engine, Block block, InventorySlotType slot, KList<IrisLootTable> tables) {
-        this.engine = engine;
-        this.block = block;
-        this.slot = slot;
-        this.tables = tables;
-    }
-
-    @Override
-    public HandlerList getHandlers() {
-        return handlers;
-    }
-
-    /**
-     * Required method to get the HandlerList for this event.
-     *
-     * @return The HandlerList.
-     */
-    public static HandlerList getHandlerList() {
-        return handlers;
-    }
-
-    /**
-     * Triggers the corresponding Bukkit loot event.
-     * This method integrates your custom IrisLootTables with Bukkit's LootGenerateEvent,
-     * allowing other plugins to modify or cancel the loot generation.
-     *
-     * @return true when the event was canceled
-     */
-    public static boolean callLootEvent(KList<ItemStack> loot, Inventory inv, World world, int x, int y, int z) {
-        InventoryHolder holder = inv.getHolder();
-        Location loc = new Location(world, x, y, z);
-        if (holder == null) {
-            holder = new InventoryHolder() {
-                @NotNull
-                @Override
-                public Inventory getInventory() {
-                    return inv;
-                }
-            };
-        }
-
-        LootContext context = new LootContext.Builder(loc).build();
-        LootGenerateEvent event = new LootGenerateEvent(world, null, holder, EMPTY, context, loot, true);
-        if (!Bukkit.isPrimaryThread()) {
-            Iris.warn("LootGenerateEvent was not called on the main thread, please report this issue.");
-            Thread.dumpStack();
-            J.sfut(() -> Bukkit.getPluginManager().callEvent(event)).join();
-        } else Bukkit.getPluginManager().callEvent(event);
-
-        return event.isCancelled();
-    }
-}

core/src/main/java/com/volmit/iris/core/gui/NoiseExplorerGUI.java

@@ -1,336 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.events.IrisEngineHotloadEvent;
-import com.volmit.iris.engine.object.NoiseStyle;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.function.Function2;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.math.RollingSequence;
-import com.volmit.iris.util.noise.CNG;
-import com.volmit.iris.util.parallel.BurstExecutor;
-import com.volmit.iris.util.parallel.MultiBurst;
-import com.volmit.iris.util.scheduling.J;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-
-import javax.imageio.ImageIO;
-import javax.swing.*;
-import java.awt.*;
-import java.awt.event.*;
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.IOException;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.Supplier;
-
-public class NoiseExplorerGUI extends JPanel implements MouseWheelListener, Listener {
-
-    private static final long serialVersionUID = 2094606939770332040L;
-
-    static JComboBox<String> combo;
-    @SuppressWarnings("CanBeFinal")
-    static boolean hd = false;
-    static double ascale = 10;
-    static double oxp = 0;
-    static double ozp = 0;
-    static double mxx = 0;
-    static double mzz = 0;
-    @SuppressWarnings("CanBeFinal")
-    static boolean down = false;
-    @SuppressWarnings("CanBeFinal")
-    RollingSequence r = new RollingSequence(20);
-    @SuppressWarnings("CanBeFinal")
-    boolean colorMode = IrisSettings.get().getGui().colorMode;
-    double scale = 1;
-    CNG cng = NoiseStyle.STATIC.create(new RNG(RNG.r.nextLong()));
-    @SuppressWarnings("CanBeFinal")
-    MultiBurst gx = MultiBurst.burst;
-    ReentrantLock l = new ReentrantLock();
-    BufferedImage img;
-    int w = 0;
-    int h = 0;
-    Function2<Double, Double, Double> generator;
-    Supplier<Function2<Double, Double, Double>> loader;
-    double ox = 0; //Offset X
-    double oz = 0; //Offset Y
-    double mx = 0;
-    double mz = 0;
-    double lx = Double.MAX_VALUE; //MouseX
-    double lz = Double.MAX_VALUE; //MouseY
-    double t;
-    double tz;
-
-    public NoiseExplorerGUI() {
-        Iris.instance.registerListener(this);
-        addMouseWheelListener(this);
-        addMouseMotionListener(new MouseMotionListener() {
-            @Override
-            public void mouseMoved(MouseEvent e) {
-                Point cp = e.getPoint();
-
-                lx = (cp.getX());
-                lz = (cp.getY());
-                mx = lx;
-                mz = lz;
-            }
-
-            @Override
-            public void mouseDragged(MouseEvent e) {
-                Point cp = e.getPoint();
-                ox += (lx - cp.getX()) * scale;
-                oz += (lz - cp.getY()) * scale;
-                lx = cp.getX();
-                lz = cp.getY();
-            }
-        });
-    }
-
-    private static void createAndShowGUI(Supplier<Function2<Double, Double, Double>> loader, String genName) {
-        JFrame frame = new JFrame("Noise Explorer: " + genName);
-        NoiseExplorerGUI nv = new NoiseExplorerGUI();
-        frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
-        JLayeredPane pane = new JLayeredPane();
-        nv.setSize(new Dimension(1440, 820));
-        pane.add(nv, 1, 0);
-        nv.loader = loader;
-        nv.generator = loader.get();
-        frame.add(pane);
-        File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
-
-        if (file != null) {
-            try {
-                frame.setIconImage(ImageIO.read(file));
-            } catch (IOException e) {
-                Iris.reportError(e);
-            }
-        }
-        frame.setSize(1440, 820);
-        frame.setVisible(true);
-    }
-
-    private static void createAndShowGUI() {
-        JFrame frame = new JFrame("Noise Explorer");
-        NoiseExplorerGUI nv = new NoiseExplorerGUI();
-        frame.setDefaultCloseOperation(JFrame.HIDE_ON_CLOSE);
-        KList<String> li = new KList<>(NoiseStyle.values()).toStringList().sort();
-        combo = new JComboBox<>(li.toArray(new String[0]));
-        combo.setSelectedItem("STATIC");
-        combo.setFocusable(false);
-        combo.addActionListener(e -> {
-            @SuppressWarnings("unchecked")
-            String b = (String) (((JComboBox<String>) e.getSource()).getSelectedItem());
-            NoiseStyle s = NoiseStyle.valueOf(b);
-            nv.cng = s.create(RNG.r.nextParallelRNG(RNG.r.imax()));
-        });
-
-        combo.setSize(500, 30);
-        JLayeredPane pane = new JLayeredPane();
-        nv.setSize(new Dimension(1440, 820));
-        pane.add(nv, 1, 0);
-        pane.add(combo, 2, 0);
-        frame.add(pane);
-        File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
-
-        if (file != null) {
-            try {
-                frame.setIconImage(ImageIO.read(file));
-            } catch (IOException e) {
-                Iris.reportError(e);
-            }
-        }
-        frame.setSize(1440, 820);
-        frame.setVisible(true);
-        frame.addWindowListener(new java.awt.event.WindowAdapter() {
-            @Override
-            public void windowClosing(java.awt.event.WindowEvent windowEvent) {
-                Iris.instance.unregisterListener(nv);
-            }
-        });
-    }
-
-    public static void launch(Supplier<Function2<Double, Double, Double>> gen, String genName) {
-        EventQueue.invokeLater(() -> createAndShowGUI(gen, genName));
-    }
-
-    public static void launch() {
-        EventQueue.invokeLater(NoiseExplorerGUI::createAndShowGUI);
-    }
-
-    @EventHandler
-    public void on(IrisEngineHotloadEvent e) {
-        if (generator != null)
-            generator = loader.get();
-    }
-
-    public void mouseWheelMoved(MouseWheelEvent e) {
-
-        int notches = e.getWheelRotation();
-        if (e.isControlDown()) {
-            t = t + ((0.0025 * t) * notches);
-            return;
-        }
-
-        scale = scale + ((0.044 * scale) * notches);
-        scale = Math.max(scale, 0.00001);
-    }
-
-    @Override
-    public void paint(Graphics g) {
-        if (scale < ascale) {
-            ascale -= Math.abs(scale - ascale) * 0.16;
-        }
-
-        if (scale > ascale) {
-            ascale += Math.abs(ascale - scale) * 0.16;
-        }
-
-        if (t < tz) {
-            tz -= Math.abs(t - tz) * 0.29;
-        }
-
-        if (t > tz) {
-            tz += Math.abs(tz - t) * 0.29;
-        }
-
-        if (ox < oxp) {
-            oxp -= Math.abs(ox - oxp) * 0.16;
-        }
-
-        if (ox > oxp) {
-            oxp += Math.abs(oxp - ox) * 0.16;
-        }
-
-        if (oz < ozp) {
-            ozp -= Math.abs(oz - ozp) * 0.16;
-        }
-
-        if (oz > ozp) {
-            ozp += Math.abs(ozp - oz) * 0.16;
-        }
-
-        if (mx < mxx) {
-            mxx -= Math.abs(mx - mxx) * 0.16;
-        }
-
-        if (mx > mxx) {
-            mxx += Math.abs(mxx - mx) * 0.16;
-        }
-
-        if (mz < mzz) {
-            mzz -= Math.abs(mz - mzz) * 0.16;
-        }
-
-        if (mz > mzz) {
-            mzz += Math.abs(mzz - mz) * 0.16;
-        }
-
-        PrecisionStopwatch p = PrecisionStopwatch.start();
-        int accuracy = hd ? 1 : M.clip((r.getAverage() / 12D), 2D, 128D).intValue();
-        accuracy = down ? accuracy * 4 : accuracy;
-        int v = 1000;
-
-        if (g instanceof Graphics2D gg) {
-
-            if (getParent().getWidth() != w || getParent().getHeight() != h) {
-                w = getParent().getWidth();
-                h = getParent().getHeight();
-                img = null;
-            }
-
-            if (img == null) {
-                img = new BufferedImage(w / accuracy, h / accuracy, BufferedImage.TYPE_INT_RGB);
-            }
-
-            BurstExecutor e = gx.burst(w);
-
-            for (int x = 0; x < w / accuracy; x++) {
-                int xx = x;
-
-                int finalAccuracy = accuracy;
-                e.queue(() -> {
-                    for (int z = 0; z < h / finalAccuracy; z++) {
-                        double n = generator != null ? generator.apply(((xx * finalAccuracy) * ascale) + oxp, ((z * finalAccuracy) * ascale) + ozp) : cng.noise(((xx * finalAccuracy) * ascale) + oxp, ((z * finalAccuracy) * ascale) + ozp);
-                        n = n > 1 ? 1 : n < 0 ? 0 : n;
-
-                        try {
-                            //Color color = colorMode ? Color.getHSBColor((float) (n), 1f - (float) (n * n * n * n * n * n), 1f - (float) n) : Color.getHSBColor(0f, 0f, (float) n);
-                            Color color = colorMode ? Color.getHSBColor((float) (0.666f - n * 0.666f), 1f, (float) (1f - n * 0.8f)) : Color.getHSBColor(0f, 0f, (float) n);
-                            int rgb = color.getRGB();
-                            img.setRGB(xx, z, rgb);
-                        } catch (Throwable ignored) {
-                        }
-                    }
-                });
-            }
-
-            e.complete();
-            gg.drawImage(img, 0, 0, getParent().getWidth() * accuracy, getParent().getHeight() * accuracy, (img, infoflags, x, y, width, height) -> true);
-        }
-
-        p.end();
-
-        t += 1D;
-        r.put(p.getMilliseconds());
-
-        if (!isVisible()) {
-            return;
-        }
-
-        if (!getParent().isVisible()) {
-            return;
-        }
-
-        if (!getParent().getParent().isVisible()) {
-            return;
-        }
-
-        EventQueue.invokeLater(() ->
-        {
-            J.sleep((long) Math.max(0, 32 - r.getAverage()));
-            repaint();
-        });
-    }
-
-    static class HandScrollListener extends MouseAdapter {
-        private static final Point pp = new Point();
-
-        @Override
-        public void mouseDragged(MouseEvent e) {
-            JViewport vport = (JViewport) e.getSource();
-            JComponent label = (JComponent) vport.getView();
-            Point cp = e.getPoint();
-            Point vp = vport.getViewPosition();
-            vp.translate(pp.x - cp.x, pp.y - cp.y);
-            label.scrollRectToVisible(new Rectangle(vp, vport.getSize()));
-
-            pp.setLocation(cp);
-        }
-
-        @Override
-        public void mousePressed(MouseEvent e) {
-            pp.setLocation(e.getPoint());
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/gui/PregeneratorJob.java

@@ -1,452 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.pregenerator.IrisPregenerator;
-import com.volmit.iris.core.pregenerator.PregenListener;
-import com.volmit.iris.core.pregenerator.PregenTask;
-import com.volmit.iris.core.pregenerator.PregeneratorMethod;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.format.MemoryMonitor;
-import com.volmit.iris.util.function.Consumer2;
-import com.volmit.iris.util.mantle.Mantle;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.math.Position2;
-import com.volmit.iris.util.scheduling.ChronoLatch;
-import com.volmit.iris.util.scheduling.J;
-
-import javax.swing.*;
-import java.awt.*;
-import java.awt.event.KeyEvent;
-import java.awt.event.KeyListener;
-import java.awt.image.BufferedImage;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.TimeUnit;
-import java.util.concurrent.atomic.AtomicReference;
-import java.util.concurrent.locks.ReentrantLock;
-import java.util.function.Consumer;
-
-public class PregeneratorJob implements PregenListener {
-    private static final Color COLOR_EXISTS = parseColor("#4d7d5b");
-    private static final Color COLOR_BLACK = parseColor("#4d7d5b");
-    private static final Color COLOR_MANTLE = parseColor("#3c2773");
-    private static final Color COLOR_GENERATING = parseColor("#66967f");
-    private static final Color COLOR_NETWORK = parseColor("#a863c2");
-    private static final Color COLOR_NETWORK_GENERATING = parseColor("#836b8c");
-    private static final Color COLOR_GENERATED = parseColor("#65c295");
-    private static final Color COLOR_CLEANED = parseColor("#34eb93");
-    private static final AtomicReference<PregeneratorJob> instance = new AtomicReference<>();
-    private final MemoryMonitor monitor;
-    private final PregenTask task;
-    private final boolean saving;
-    private final KList<Consumer<Double>> onProgress = new KList<>();
-    private final KList<Runnable> whenDone = new KList<>();
-    private final IrisPregenerator pregenerator;
-    private final Position2 min;
-    private final Position2 max;
-    private final ChronoLatch cl = new ChronoLatch(TimeUnit.MINUTES.toMillis(1));
-    private final Engine engine;
-    private final ExecutorService service;
-    private JFrame frame;
-    private PregenRenderer renderer;
-    private int rgc = 0;
-    private String[] info;
-
-    public PregeneratorJob(PregenTask task, PregeneratorMethod method, Engine engine) {
-        instance.updateAndGet(old -> {
-            if (old != null) {
-                old.pregenerator.close();
-                old.close();
-            }
-            return this;
-        });
-        this.engine = engine;
-        monitor = new MemoryMonitor(50);
-        saving = false;
-        info = new String[]{"Initializing..."};
-        this.task = task;
-        this.pregenerator = new IrisPregenerator(task, method, this);
-        max = new Position2(0, 0);
-        min = new Position2(Integer.MAX_VALUE, Integer.MAX_VALUE);
-        task.iterateAllChunks((xx, zz) -> {
-            min.setX(Math.min(xx, min.getX()));
-            min.setZ(Math.min(zz, min.getZ()));
-            max.setX(Math.max(xx, max.getX()));
-            max.setZ(Math.max(zz, max.getZ()));
-        });
-
-        if (IrisSettings.get().getGui().isUseServerLaunchedGuis() && task.isGui()) {
-            open();
-        }
-
-        var t = new Thread(() -> {
-            J.sleep(1000);
-            this.pregenerator.start();
-        }, "Iris Pregenerator");
-        t.setPriority(Thread.MIN_PRIORITY);
-        t.start();
-        service = Executors.newVirtualThreadPerTaskExecutor();
-    }
-
-    public static boolean shutdownInstance() {
-        PregeneratorJob inst = instance.get();
-        if (inst == null) {
-            return false;
-        }
-
-        J.a(inst.pregenerator::close);
-        return true;
-    }
-
-    public static PregeneratorJob getInstance() {
-        return instance.get();
-    }
-
-    public static boolean pauseResume() {
-        PregeneratorJob inst = instance.get();
-        if (inst == null) {
-            return false;
-        }
-
-        if (isPaused()) {
-            inst.pregenerator.resume();
-        } else {
-            inst.pregenerator.pause();
-        }
-        return true;
-    }
-
-    public static boolean isPaused() {
-        PregeneratorJob inst = instance.get();
-        if (inst == null) {
-            return true;
-        }
-
-        return inst.paused();
-    }
-
-    private static Color parseColor(String c) {
-        String v = (c.startsWith("#") ? c : "#" + c).trim();
-        try {
-            return Color.decode(v);
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            Iris.error("Error Parsing 'color', (" + c + ")");
-        }
-
-        return Color.RED;
-    }
-
-    public Mantle getMantle() {
-        return pregenerator.getMantle();
-    }
-
-    public PregeneratorJob onProgress(Consumer<Double> c) {
-        onProgress.add(c);
-        return this;
-    }
-
-    public PregeneratorJob whenDone(Runnable r) {
-        whenDone.add(r);
-        return this;
-    }
-
-    public void drawRegion(int x, int z, Color color) {
-        J.a(() -> task.iterateChunks(x, z, (xx, zz) -> {
-            draw(xx, zz, color);
-            J.sleep(3);
-        }));
-    }
-
-    public void draw(int x, int z, Color color) {
-        try {
-            if (renderer != null && frame != null && frame.isVisible()) {
-                renderer.func.accept(new Position2(x, z), color);
-            }
-        } catch (Throwable ignored) {
-            Iris.error("Failed to draw pregen");
-        }
-    }
-
-    public void stop() {
-        J.a(() -> {
-            pregenerator.close();
-            close();
-            instance.compareAndSet(this, null);
-        });
-    }
-
-    public void close() {
-        J.a(() -> {
-            try {
-                monitor.close();
-                J.sleep(3000);
-                frame.setVisible(false);
-            } catch (Throwable ignored) {
-                Iris.error("Error closing pregen gui");
-            }
-        });
-    }
-
-    public void open() {
-        J.a(() -> {
-            try {
-                frame = new JFrame("Pregen View");
-                renderer = new PregenRenderer();
-                frame.addKeyListener(renderer);
-                renderer.l = new ReentrantLock();
-                renderer.frame = frame;
-                renderer.job = this;
-                renderer.func = (c, b) -> {
-                    renderer.l.lock();
-                    renderer.order.add(() -> renderer.draw(c, b, renderer.bg));
-                    renderer.l.unlock();
-                };
-                frame.add(renderer);
-                frame.setSize(1000, 1000);
-                frame.setVisible(true);
-            } catch (Throwable ignored) {
-                Iris.error("Error opening pregen gui");
-            }
-        });
-    }
-
-    @Override
-    public void onTick(double chunksPerSecond, double chunksPerMinute, double regionsPerMinute, double percent, long generated, long totalChunks, long chunksRemaining, long eta, long elapsed, String method, boolean cached) {
-        info = new String[]{
-                (paused() ? "PAUSED" : (saving ? "Saving... " : "Generating")) + " " + Form.f(generated) + " of " + Form.f(totalChunks) + " (" + Form.pc(percent, 0) + " Complete)",
-                "Speed: " + (cached ? "Cached " : "") + Form.f(chunksPerSecond, 0) + " Chunks/s, " + Form.f(regionsPerMinute, 1) + " Regions/m, " + Form.f(chunksPerMinute, 0) + " Chunks/m",
-                Form.duration(eta, 2) + " Remaining " + " (" + Form.duration(elapsed, 2) + " Elapsed)",
-                "Generation Method: " + method,
-                "Memory: " + Form.memSize(monitor.getUsedBytes(), 2) + " (" + Form.pc(monitor.getUsagePercent(), 0) + ") Pressure: " + Form.memSize(monitor.getPressure(), 0) + "/s",
-
-        };
-
-        for (Consumer<Double> i : onProgress) {
-            i.accept(percent);
-        }
-    }
-
-    @Override
-    public void onChunkGenerating(int x, int z) {
-        draw(x, z, COLOR_GENERATING);
-    }
-
-    @Override
-    public void onChunkGenerated(int x, int z, boolean cached) {
-        if (renderer == null || frame == null || !frame.isVisible()) return;
-        service.submit(() -> {
-            if (engine != null) {
-                draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
-                return;
-            }
-
-            draw(x, z, COLOR_GENERATED);
-        });
-    }
-
-    @Override
-    public void onRegionGenerated(int x, int z) {
-        shouldGc();
-        rgc++;
-    }
-
-    private void shouldGc() {
-        if (cl.flip() && rgc > 16) {
-            System.gc();
-        }
-    }
-
-    @Override
-    public void onRegionGenerating(int x, int z) {
-
-    }
-
-    @Override
-    public void onChunkCleaned(int x, int z) {
-        //draw(x, z, COLOR_CLEANED);
-    }
-
-    @Override
-    public void onRegionSkipped(int x, int z) {
-
-    }
-
-    @Override
-    public void onNetworkStarted(int x, int z) {
-        drawRegion(x, z, COLOR_NETWORK);
-    }
-
-    @Override
-    public void onNetworkFailed(int x, int z) {
-
-    }
-
-    @Override
-    public void onNetworkReclaim(int revert) {
-
-    }
-
-    @Override
-    public void onNetworkGeneratedChunk(int x, int z) {
-        draw(x, z, COLOR_NETWORK_GENERATING);
-    }
-
-    @Override
-    public void onNetworkDownloaded(int x, int z) {
-        drawRegion(x, z, COLOR_NETWORK);
-    }
-
-    @Override
-    public void onClose() {
-        close();
-        instance.compareAndSet(this, null);
-        whenDone.forEach(Runnable::run);
-        service.shutdownNow();
-    }
-
-    @Override
-    public void onSaving() {
-
-    }
-
-    @Override
-    public void onChunkExistsInRegionGen(int x, int z) {
-        if (engine != null) {
-            draw(x, z, engine.draw((x << 4) + 8, (z << 4) + 8));
-            return;
-        }
-
-        draw(x, z, COLOR_EXISTS);
-    }
-
-    private Position2 getMax() {
-        return max;
-    }
-
-    private Position2 getMin() {
-        return min;
-    }
-
-    private boolean paused() {
-        return pregenerator.paused();
-    }
-
-    private String[] getProgress() {
-        return info;
-    }
-
-    public static class PregenRenderer extends JPanel implements KeyListener {
-        private static final long serialVersionUID = 2094606939770332040L;
-        private final KList<Runnable> order = new KList<>();
-        private final int res = 512;
-        private final BufferedImage image = new BufferedImage(res, res, BufferedImage.TYPE_INT_RGB);
-        Graphics2D bg;
-        private PregeneratorJob job;
-        private ReentrantLock l;
-        private Consumer2<Position2, Color> func;
-        private JFrame frame;
-
-        public PregenRenderer() {
-
-        }
-
-        public void paint(int x, int z, Color c) {
-            func.accept(new Position2(x, z), c);
-        }
-
-        @Override
-        public void paint(Graphics gx) {
-            Graphics2D g = (Graphics2D) gx;
-            bg = (Graphics2D) image.getGraphics();
-            l.lock();
-
-            while (order.isNotEmpty()) {
-                try {
-                    order.pop().run();
-                } catch (Throwable e) {
-                    Iris.reportError(e);
-
-                }
-            }
-
-            l.unlock();
-            g.drawImage(image, 0, 0, getParent().getWidth(), getParent().getHeight(), (img, infoflags, x, y, width, height) -> true);
-            g.setColor(Color.WHITE);
-            g.setFont(new Font("Hevetica", Font.BOLD, 13));
-            String[] prog = job.getProgress();
-            int h = g.getFontMetrics().getHeight() + 5;
-            int hh = 20;
-
-            if (job.paused()) {
-                g.drawString("PAUSED", 20, hh += h);
-
-                g.drawString("Press P to Resume", 20, hh += h);
-            } else {
-                for (String i : prog) {
-                    g.drawString(i, 20, hh += h);
-                }
-
-                g.drawString("Press P to Pause", 20, hh += h);
-            }
-
-            J.sleep(IrisSettings.get().getGui().isMaximumPregenGuiFPS() ? 4 : 250);
-            repaint();
-        }
-
-        private void draw(Position2 p, Color c, Graphics2D bg) {
-            double pw = M.lerpInverse(job.getMin().getX(), job.getMax().getX(), p.getX());
-            double ph = M.lerpInverse(job.getMin().getZ(), job.getMax().getZ(), p.getZ());
-            double pwa = M.lerpInverse(job.getMin().getX(), job.getMax().getX(), p.getX() + 1);
-            double pha = M.lerpInverse(job.getMin().getZ(), job.getMax().getZ(), p.getZ() + 1);
-            int x = (int) M.lerp(0, res, pw);
-            int z = (int) M.lerp(0, res, ph);
-            int xa = (int) M.lerp(0, res, pwa);
-            int za = (int) M.lerp(0, res, pha);
-            bg.setColor(c);
-            bg.fillRect(x, z, xa - x, za - z);
-        }
-
-        @Override
-        public void keyTyped(KeyEvent e) {
-
-        }
-
-        @Override
-        public void keyPressed(KeyEvent e) {
-
-        }
-
-        @Override
-        public void keyReleased(KeyEvent e) {
-            if (e.getKeyCode() == KeyEvent.VK_P) {
-                PregeneratorJob.pauseResume();
-            }
-        }
-
-        public void close() {
-            frame.setVisible(false);
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/gui/VisionGUI.java

@@ -1,870 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.gui;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.gui.components.IrisRenderer;
-import com.volmit.iris.core.gui.components.RenderType;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.IrisComplex;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisRegion;
-import com.volmit.iris.engine.object.IrisWorld;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.math.BlockPosition;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.math.RollingSequence;
-import com.volmit.iris.util.scheduling.ChronoLatch;
-import com.volmit.iris.util.scheduling.J;
-import com.volmit.iris.util.scheduling.O;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import org.bukkit.Location;
-import org.bukkit.entity.LivingEntity;
-import org.bukkit.entity.Player;
-
-import javax.imageio.ImageIO;
-import javax.swing.*;
-import javax.swing.event.MouseInputListener;
-import java.awt.*;
-import java.awt.event.*;
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.io.IOException;
-import java.util.Locale;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.function.BiFunction;
-
-import static com.volmit.iris.util.data.registry.Attributes.MAX_HEALTH;
-
-public class VisionGUI extends JPanel implements MouseWheelListener, KeyListener, MouseMotionListener, MouseInputListener {
-    private static final long serialVersionUID = 2094606939770332040L;
-    private final KList<LivingEntity> lastEntities = new KList<>();
-    private final KMap<String, Long> notifications = new KMap<>();
-    private final ChronoLatch centities = new ChronoLatch(1000);
-    private final RollingSequence rs = new RollingSequence(512);
-    private final O<Integer> m = new O<>();
-    private final KMap<BlockPosition, BufferedImage> positions = new KMap<>();
-    private final KMap<BlockPosition, BufferedImage> fastpositions = new KMap<>();
-    private final KSet<BlockPosition> working = new KSet<>();
-    private final KSet<BlockPosition> workingfast = new KSet<>();
-    double tfps = 240D;
-    int ltc = 3;
-    private RenderType currentType = RenderType.BIOME;
-    private boolean help = true;
-    private boolean helpIgnored = false;
-    private boolean shift = false;
-    private Player player = null;
-    private boolean debug = false;
-    private boolean control = false;
-    private boolean eco = false;
-    private boolean lowtile = false;
-    private boolean follow = false;
-    private boolean alt = false;
-    private IrisRenderer renderer;
-    private IrisWorld world;
-    private double velocity = 0;
-    private int lowq = 12;
-    private double scale = 128;
-    private double mscale = 4D;
-    private int w = 0;
-    private int h = 0;
-    private double lx = 0;
-    private double lz = 0;
-    private double ox = 0;
-    private double oz = 0;
-    private double hx = 0;
-    private double hz = 0;
-    private double oxp = 0;
-    private double ozp = 0;
-    private Engine engine;
-    private int tid = 0;
-    private final ExecutorService e = Executors.newFixedThreadPool(Runtime.getRuntime().availableProcessors(), r -> {
-        tid++;
-        Thread t = new Thread(r);
-        t.setName("Iris HD Renderer " + tid);
-        t.setPriority(Thread.MIN_PRIORITY);
-        t.setUncaughtExceptionHandler((et, e) ->
-        {
-            Iris.info("Exception encountered in " + et.getName());
-            e.printStackTrace();
-        });
-
-        return t;
-    });
-
-    private final ExecutorService eh = Executors.newFixedThreadPool(ltc, r -> {
-        tid++;
-        Thread t = new Thread(r);
-        t.setName("Iris Renderer " + tid);
-        t.setPriority(Thread.NORM_PRIORITY);
-        t.setUncaughtExceptionHandler((et, e) ->
-        {
-            Iris.info("Exception encountered in " + et.getName());
-            e.printStackTrace();
-        });
-
-        return t;
-    });
-    private BufferedImage texture;
-
-    public VisionGUI(JFrame frame) {
-        m.set(8);
-        rs.put(1);
-        addMouseWheelListener(this);
-        addMouseMotionListener(this);
-        addMouseListener(this);
-        frame.addKeyListener(this);
-        J.a(() -> {
-            J.sleep(10000);
-
-            if (!helpIgnored && help) {
-                help = false;
-            }
-        });
-        frame.addWindowListener(new java.awt.event.WindowAdapter() {
-            @Override
-            public void windowClosing(java.awt.event.WindowEvent windowEvent) {
-                e.shutdown();
-                eh.shutdown();
-            }
-        });
-    }
-
-    private static void createAndShowGUI(Engine r, int s, IrisWorld world) {
-        JFrame frame = new JFrame("Vision");
-        VisionGUI nv = new VisionGUI(frame);
-        nv.world = world;
-        nv.engine = r;
-        nv.renderer = new IrisRenderer(r);
-        frame.add(nv);
-        frame.setSize(1440, 820);
-        frame.setVisible(true);
-        File file = Iris.getCached("Iris Icon", "https://raw.githubusercontent.com/VolmitSoftware/Iris/master/icon.png");
-
-        if (file != null) {
-            try {
-                nv.texture = ImageIO.read(file);
-                frame.setIconImage(ImageIO.read(file));
-            } catch (IOException e) {
-                Iris.reportError(e);
-
-            }
-        }
-    }
-
-    public static void launch(Engine g, int i) {
-        J.a(() ->
-                createAndShowGUI(g, i, g.getWorld()));
-    }
-
-    public boolean updateEngine() {
-        if (engine.isClosed()) {
-            if (world.hasRealWorld()) {
-                try {
-                    engine = IrisToolbelt.access(world.realWorld()).getEngine();
-                    return !engine.isClosed();
-                } catch (Throwable e) {
-
-                }
-            }
-        }
-
-        return false;
-    }
-
-    @Override
-    public void mouseMoved(MouseEvent e) {
-        Point cp = e.getPoint();
-        lx = (cp.getX());
-        lz = (cp.getY());
-    }
-
-    @Override
-    public void mouseDragged(MouseEvent e) {
-        Point cp = e.getPoint();
-        ox += (lx - cp.getX()) * scale;
-        oz += (lz - cp.getY()) * scale;
-        lx = cp.getX();
-        lz = cp.getY();
-    }
-
-    public int getColor(double wx, double wz) {
-        BiFunction<Double, Double, Integer> colorFunction = (d, dx) -> Color.black.getRGB();
-
-        switch (currentType) {
-            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD ->
-                    colorFunction = (x, z) -> engine.getComplex().getTrueBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case BIOME_LAND ->
-                    colorFunction = (x, z) -> engine.getComplex().getLandBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case BIOME_SEA ->
-                    colorFunction = (x, z) -> engine.getComplex().getSeaBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case REGION ->
-                    colorFunction = (x, z) -> engine.getComplex().getRegionStream().get(x, z).getColor(engine.getComplex(), currentType).getRGB();
-            case CAVE_LAND ->
-                    colorFunction = (x, z) -> engine.getComplex().getCaveBiomeStream().get(x, z).getColor(engine, currentType).getRGB();
-            case HEIGHT ->
-                    colorFunction = (x, z) -> Color.getHSBColor(engine.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
-        }
-
-        return colorFunction.apply(wx, wz);
-    }
-
-    public void notify(String s) {
-        notifications.put(s, M.ms() + 2500);
-    }
-
-    @Override
-    public void keyTyped(KeyEvent e) {
-
-    }
-
-    @Override
-    public void keyPressed(KeyEvent e) {
-        if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
-            shift = true;
-        }
-        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
-            control = true;
-        }
-        if (e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
-            debug = true;
-        }
-        if (e.getKeyCode() == KeyEvent.VK_SLASH) {
-            help = true;
-            helpIgnored = true;
-        }
-        if (e.getKeyCode() == KeyEvent.VK_ALT) {
-            alt = true;
-        }
-    }
-
-    @Override
-    public void keyReleased(KeyEvent e) {
-        if (e.getKeyCode() == KeyEvent.VK_SEMICOLON) {
-            debug = false;
-        }
-        if (e.getKeyCode() == KeyEvent.VK_SHIFT) {
-            shift = false;
-        }
-
-        if (e.getKeyCode() == KeyEvent.VK_CONTROL) {
-            control = false;
-        }
-        if (e.getKeyCode() == KeyEvent.VK_SLASH) {
-            help = false;
-            helpIgnored = true;
-        }
-        if (e.getKeyCode() == KeyEvent.VK_ALT) {
-            alt = false;
-        }
-
-        // Pushes
-        if (e.getKeyCode() == KeyEvent.VK_F) {
-            follow = !follow;
-
-            if (player != null && follow) {
-                notify("Following " + player.getName() + ". Press F to disable");
-            } else if (follow) {
-                notify("Can't follow, no one is in the world");
-                follow = false;
-            } else {
-                notify("Follow Off");
-            }
-
-            return;
-        }
-
-        if (e.getKeyCode() == KeyEvent.VK_R) {
-            dump();
-            notify("Refreshing Chunks");
-            return;
-        }
-
-        if (e.getKeyCode() == KeyEvent.VK_P) {
-            lowtile = !lowtile;
-            dump();
-            notify("Rendering " + (lowtile ? "Low" : "High") + " Quality Tiles");
-            return;
-        }
-        if (e.getKeyCode() == KeyEvent.VK_E) {
-            eco = !eco;
-            dump();
-            notify("Using " + (eco ? "60" : "Uncapped") + " FPS Limit");
-            return;
-        }
-        if (e.getKeyCode() == KeyEvent.VK_EQUALS) {
-            mscale = mscale + ((0.044 * mscale) * -3);
-            mscale = Math.max(mscale, 0.00001);
-            dump();
-            return;
-        }
-        if (e.getKeyCode() == KeyEvent.VK_MINUS) {
-            mscale = mscale + ((0.044 * mscale) * 3);
-            mscale = Math.max(mscale, 0.00001);
-            dump();
-            return;
-        }
-
-        if (e.getKeyCode() == KeyEvent.VK_BACK_SLASH) {
-            mscale = 1D;
-            dump();
-            notify("Zoom Reset");
-            return;
-        }
-
-        int currentMode = currentType.ordinal();
-
-        for (RenderType i : RenderType.values()) {
-            if (e.getKeyChar() == String.valueOf(i.ordinal() + 1).charAt(0)) {
-                if (i.ordinal() != currentMode) {
-                    currentType = i;
-                    dump();
-                    notify("Rendering " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
-                    return;
-                }
-            }
-        }
-
-        if (e.getKeyCode() == KeyEvent.VK_M) {
-            currentType = RenderType.values()[(currentMode + 1) % RenderType.values().length];
-            notify("Rendering " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
-            dump();
-        }
-    }
-
-    private void dump() {
-        positions.clear();
-        fastpositions.clear();
-    }
-
-    public BufferedImage getTile(KSet<BlockPosition> fg, int div, int x, int z, O<Integer> m) {
-        BlockPosition key = new BlockPosition((int) mscale, Math.floorDiv(x, div), Math.floorDiv(z, div));
-        fg.add(key);
-
-        if (positions.containsKey(key)) {
-            return positions.get(key);
-        }
-
-        if (fastpositions.containsKey(key)) {
-            if (!working.contains(key) && working.size() < 9) {
-                m.set(m.get() - 1);
-
-                if (m.get() >= 0 && velocity < 50) {
-                    working.add(key);
-                    double mk = mscale;
-                    double mkd = scale;
-                    e.submit(() ->
-                    {
-                        PrecisionStopwatch ps = PrecisionStopwatch.start();
-                        BufferedImage b = renderer.render(x * mscale, z * mscale, div * mscale, div / (lowtile ? 3 : 1), currentType);
-                        rs.put(ps.getMilliseconds());
-                        working.remove(key);
-
-                        if (mk == mscale && mkd == scale) {
-                            positions.put(key, b);
-                        }
-                    });
-                }
-            }
-
-            return fastpositions.get(key);
-        }
-
-        if (workingfast.contains(key) || workingfast.size() > Runtime.getRuntime().availableProcessors()) {
-            return null;
-        }
-
-        workingfast.add(key);
-        double mk = mscale;
-        double mkd = scale;
-        eh.submit(() ->
-        {
-            PrecisionStopwatch ps = PrecisionStopwatch.start();
-            BufferedImage b = renderer.render(x * mscale, z * mscale, div * mscale, div / lowq, currentType);
-            rs.put(ps.getMilliseconds());
-            workingfast.remove(key);
-
-            if (mk == mscale && mkd == scale) {
-                fastpositions.put(key, b);
-            }
-        });
-        return null;
-    }
-
-    private double getWorldX(double screenX) {
-        return (mscale * screenX) + ((oxp / scale) * mscale);
-    }
-
-    private double getWorldZ(double screenZ) {
-        return (mscale * screenZ) + ((ozp / scale) * mscale);
-    }
-
-    private double getScreenX(double x) {
-        return (x / mscale) - ((oxp / scale));
-    }
-
-    private double getScreenZ(double z) {
-        return (z / mscale) - ((ozp / scale));
-    }
-
-    @Override
-    public void paint(Graphics gx) {
-
-        if (engine.isClosed()) {
-            EventQueue.invokeLater(() -> {
-                try {
-                    setVisible(false);
-                } catch (Throwable e) {
-
-                }
-            });
-
-            return;
-        }
-
-        if (updateEngine()) {
-            dump();
-        }
-
-        if (ox < oxp) {
-            velocity = Math.abs(ox - oxp) * 0.36;
-            oxp -= velocity;
-        }
-
-        if (ox > oxp) {
-            velocity = Math.abs(oxp - ox) * 0.36;
-            oxp += velocity;
-        }
-
-        if (oz < ozp) {
-            velocity = Math.abs(oz - ozp) * 0.36;
-            ozp -= velocity;
-        }
-
-        if (oz > ozp) {
-            velocity = Math.abs(ozp - oz) * 0.36;
-            ozp += velocity;
-        }
-
-        if (lx < hx) {
-            hx -= Math.abs(lx - hx) * 0.36;
-        }
-
-        if (lx > hx) {
-            hx += Math.abs(hx - lx) * 0.36;
-        }
-
-        if (lz < hz) {
-            hz -= Math.abs(lz - hz) * 0.36;
-        }
-
-        if (lz > hz) {
-            hz += Math.abs(hz - lz) * 0.36;
-        }
-
-        if (Math.abs(lx - hx) < 0.5) {
-            hx = lx;
-        }
-        if (Math.abs(lz - hz) < 0.5) {
-            hz = lz;
-        }
-
-        if (centities.flip()) {
-            J.s(() -> {
-                synchronized (lastEntities) {
-                    lastEntities.clear();
-                    lastEntities.addAll(world.getEntitiesByClass(LivingEntity.class));
-                }
-            });
-        }
-        lowq = Math.max(Math.min((int) M.lerp(8, 28, velocity / 1000D), 28), 8);
-        PrecisionStopwatch p = PrecisionStopwatch.start();
-        Graphics2D g = (Graphics2D) gx;
-        w = getWidth();
-        h = getHeight();
-        double vscale = scale;
-        scale = w / 12D;
-
-        if (scale != vscale) {
-            positions.clear();
-        }
-
-        KSet<BlockPosition> gg = new KSet<>();
-        int iscale = (int) scale;
-        g.setColor(Color.white);
-        g.clearRect(0, 0, w, h);
-        double offsetX = oxp / scale;
-        double offsetZ = ozp / scale;
-        m.set(3);
-
-        for (int r = 0; r < Math.max(w, h); r += iscale) {
-            for (int i = -iscale; i < w + iscale; i += iscale) {
-                for (int j = -iscale; j < h + iscale; j += iscale) {
-                    int a = i - (w / 2);
-                    int b = j - (h / 2);
-                    if (a * a + b * b <= r * r) {
-                        int tx = (int) (Math.floor((offsetX + i) / iscale) * iscale);
-                        int tz = (int) (Math.floor((offsetZ + j) / iscale) * iscale);
-                        BufferedImage t = getTile(gg, iscale, tx, tz, m);
-
-                        if (t != null) {
-                            int rx = Math.floorMod((int) Math.floor(offsetX), iscale);
-                            int rz = Math.floorMod((int) Math.floor(offsetZ), iscale);
-                            g.drawImage(t, i - rx, j - rz, iscale, iscale, (img, infoflags, x, y, width, height) -> true);
-                        }
-                    }
-                }
-            }
-        }
-
-        p.end();
-
-        for (BlockPosition i : positions.k()) {
-            if (!gg.contains(i)) {
-                positions.remove(i);
-            }
-        }
-
-        hanleFollow();
-        renderOverlays(g);
-
-        if (!isVisible()) {
-            return;
-        }
-
-        if (!getParent().isVisible()) {
-            return;
-        }
-
-        if (!getParent().getParent().isVisible()) {
-            return;
-        }
-
-        J.a(() ->
-        {
-            J.sleep(eco ? 15 : 1);
-            repaint();
-        });
-    }
-
-    private void hanleFollow() {
-        if (follow && player != null) {
-            animateTo(player.getLocation().getX(), player.getLocation().getZ());
-        }
-    }
-
-    private void renderOverlays(Graphics2D g) {
-        renderPlayer(g);
-
-        if (help) {
-            renderOverlayHelp(g);
-        } else if (debug) {
-            renderOverlayDebug(g);
-        }
-
-        renderOverlayLegend(g);
-
-        renderHoverOverlay(g, shift);
-        if (!notifications.isEmpty()) {
-            renderNotification(g);
-        }
-    }
-
-    private void renderOverlayLegend(Graphics2D g) {
-        KList<String> l = new KList<>();
-        l.add("Zoom: " + Form.pc(mscale, 0));
-        l.add("Blocks: " + Form.f((int) mscale * w) + " by " + Form.f((int) mscale * h));
-        l.add("BPP: " + Form.f(mscale, 1));
-        l.add("Render Mode: " + Form.capitalizeWords(currentType.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
-
-        drawCardBR(g, l);
-    }
-
-    private void renderNotification(Graphics2D g) {
-        drawCardCB(g, notifications.k());
-
-        for (String i : notifications.k()) {
-            if (M.ms() > notifications.get(i)) {
-                notifications.remove(i);
-            }
-        }
-    }
-
-    private void renderPlayer(Graphics2D g) {
-        Player b = null;
-
-        for (Player i : world.getPlayers()) {
-            b = i;
-            renderPosition(g, i.getLocation().getX(), i.getLocation().getZ());
-        }
-
-        synchronized (lastEntities) {
-            double dist = Double.MAX_VALUE;
-            LivingEntity h = null;
-
-            for (LivingEntity i : lastEntities) {
-                if (i instanceof Player) {
-                    continue;
-                }
-
-                renderMobPosition(g, i, i.getLocation().getX(), i.getLocation().getZ());
-                if (shift) {
-                    double d = i.getLocation().distanceSquared(new Location(i.getWorld(), getWorldX(hx), i.getLocation().getY(), getWorldZ(hz)));
-
-                    if (d < dist) {
-                        dist = d;
-                        h = i;
-                    }
-                }
-            }
-
-            if (h != null && shift) {
-                g.setColor(Color.red);
-                g.fillRoundRect((int) getScreenX(h.getLocation().getX()) - 10, (int) getScreenZ(h.getLocation().getZ()) - 10, 20, 20, 20, 20);
-                KList<String> k = new KList<>();
-                k.add(Form.capitalizeWords(h.getType().name().toLowerCase(Locale.ROOT).replaceAll("\\Q_\\E", " ")) + h.getEntityId());
-
-                k.add("Pos: " + h.getLocation().getBlockX() + ", " + h.getLocation().getBlockY() + ", " + h.getLocation().getBlockZ());
-                k.add("UUID: " + h.getUniqueId());
-                k.add("HP: " + h.getHealth() + " / " + h.getAttribute(MAX_HEALTH).getValue());
-
-                drawCardTR(g, k);
-            }
-        }
-
-        player = b;
-    }
-
-    private void animateTo(double wx, double wz) {
-        double cx = getWorldX(getWidth() / 2);
-        double cz = getWorldZ(getHeight() / 2);
-        ox += ((wx - cx) / mscale) * scale;
-        oz += ((wz - cz) / mscale) * scale;
-    }
-
-    private void renderPosition(Graphics2D g, double x, double z) {
-        if (texture != null) {
-            g.drawImage(texture, (int) getScreenX(x), (int) getScreenZ(z), 66, 66, (img, infoflags, xx, xy, width, height) -> true);
-        } else {
-            g.setColor(Color.darkGray);
-            g.fillRoundRect((int) getScreenX(x) - 15, (int) getScreenZ(z) - 15, 30, 30, 15, 15);
-            g.setColor(Color.cyan.darker().darker());
-            g.fillRoundRect((int) getScreenX(x) - 10, (int) getScreenZ(z) - 10, 20, 20, 10, 10);
-        }
-    }
-
-    private void renderMobPosition(Graphics2D g, LivingEntity e, double x, double z) {
-        g.setColor(Color.red.darker().darker());
-        g.fillRoundRect((int) getScreenX(x) - 2, (int) getScreenZ(z) - 2, 4, 4, 4, 4);
-    }
-
-    private void renderHoverOverlay(Graphics2D g, boolean detailed) {
-        IrisBiome biome = engine.getComplex().getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz));
-        IrisRegion region = engine.getComplex().getRegionStream().get(getWorldX(hx), getWorldZ(hz));
-        KList<String> l = new KList<>();
-        l.add("Biome: " + biome.getName());
-        l.add("Region: " + region.getName() + "(" + region.getLoadKey() + ")");
-        l.add("Block " + (int) getWorldX(hx) + ", " + (int) getWorldZ(hz));
-        if (detailed) {
-            l.add("Chunk " + ((int) getWorldX(hx) >> 4) + ", " + ((int) getWorldZ(hz) >> 4));
-            l.add("Region " + (((int) getWorldX(hx) >> 4) >> 5) + ", " + (((int) getWorldZ(hz) >> 4) >> 5));
-            l.add("Key: " + biome.getLoadKey());
-            l.add("File: " + biome.getLoadFile());
-        }
-
-        drawCardAt((float) hx, (float) hz, 0, 0, g, l);
-    }
-
-    private void renderOverlayDebug(Graphics2D g) {
-        KList<String> l = new KList<>();
-        l.add("Velocity: " + (int) velocity);
-        l.add("Center Pos: " + Form.f((int) getWorldX(getWidth() / 2)) + ", " + Form.f((int) getWorldZ(getHeight() / 2)));
-        drawCardBL(g, l);
-    }
-
-    private void renderOverlayHelp(Graphics2D g) {
-        KList<String> l = new KList<>();
-        l.add("/ to show this help screen");
-        l.add("R to repaint the screen");
-        l.add("F to follow first player");
-        l.add("+/- to Change Zoom");
-        l.add("\\ to reset zoom to 1");
-        l.add("M to cycle render modes");
-        l.add("P to toggle Tile Quality Mode");
-        l.add("E to toggle Eco FPS Mode");
-
-        int ff = 0;
-        for (RenderType i : RenderType.values()) {
-            ff++;
-            l.add(ff + " to view " + Form.capitalizeWords(i.name().toLowerCase().replaceAll("\\Q_\\E", " ")));
-        }
-
-        l.add("Shift for additional biome details (at cursor)");
-        l.add("CTRL + Click to teleport to location");
-        l.add("ALT + Click to open biome in VSCode");
-        drawCardTL(g, l);
-    }
-
-    private void drawCardTL(Graphics2D g, KList<String> text) {
-        drawCardAt(0, 0, 0, 0, g, text);
-    }
-
-    private void drawCardBR(Graphics2D g, KList<String> text) {
-        drawCardAt(getWidth(), getHeight(), 1, 1, g, text);
-    }
-
-    private void drawCardBL(Graphics2D g, KList<String> text) {
-        drawCardAt(0, getHeight(), 0, 1, g, text);
-    }
-
-    private void drawCardTR(Graphics2D g, KList<String> text) {
-        drawCardAt(getWidth(), 0, 1, 0, g, text);
-    }
-
-    private void open() {
-        IrisComplex complex = engine.getComplex();
-        File r = null;
-        switch (currentType) {
-            case BIOME, LAYER_LOAD, DECORATOR_LOAD, OBJECT_LOAD, HEIGHT ->
-                    r = complex.getTrueBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
-            case BIOME_LAND -> r = complex.getLandBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
-            case BIOME_SEA -> r = complex.getSeaBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
-            case REGION -> r = complex.getRegionStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
-            case CAVE_LAND -> r = complex.getCaveBiomeStream().get(getWorldX(hx), getWorldZ(hz)).openInVSCode();
-        }
-
-        notify("Opening " + r.getPath() + " in VSCode");
-    }
-
-    private void teleport() {
-        J.s(() -> {
-            if (player != null) {
-                int xx = (int) getWorldX(hx);
-                int zz = (int) getWorldZ(hz);
-                int h = engine.getComplex().getRoundedHeighteightStream().get(xx, zz);
-                player.teleport(new Location(player.getWorld(), xx, h, zz));
-                notify("Teleporting to " + xx + ", " + h + ", " + zz);
-            } else {
-                notify("No player in world, can't teleport.");
-            }
-        });
-    }
-
-    private void drawCardCB(Graphics2D g, KList<String> text) {
-        drawCardAt(getWidth() / 2, getHeight(), 0.5, 1, g, text);
-    }
-
-    private void drawCardCT(Graphics2D g, KList<String> text) {
-        drawCardAt(getWidth() / 2, 0, 0.5, 0, g, text);
-    }
-
-    private void drawCardAt(float x, float y, double pushX, double pushZ, Graphics2D g, KList<String> text) {
-        g.setFont(new Font("Hevetica", Font.BOLD, 16));
-        int h = 0;
-        int w = 0;
-
-        for (String i : text) {
-            h += g.getFontMetrics().getHeight();
-            w = Math.max(w, g.getFontMetrics().stringWidth(i));
-        }
-
-        w += 28;
-        h += 14;
-
-        int cw = (int) ((w + 26) * pushX);
-        int ch = (int) ((h + 26) * pushZ);
-
-        g.setColor(Color.darkGray);
-        g.fillRect((int) x + 7 + 2 - cw, (int) y + 12 + 2 - ch, w + 7, h); // Shadow
-        g.setColor(Color.gray);
-        g.fillRect((int) x + 7 + 1 - cw, (int) y + 12 + 1 - ch, w + 7, h); // Shadow
-        g.setColor(Color.white);
-        g.fillRect((int) x + 7 - cw, (int) y + 12 - ch, w + 7, h);
-
-        g.setColor(Color.black);
-        int m = 0;
-        for (String i : text) {
-            g.drawString(i, x + 14 - cw, y + 14 - ch + (++m * g.getFontMetrics().getHeight()));
-        }
-    }
-
-    public void mouseWheelMoved(MouseWheelEvent e) {
-        int notches = e.getWheelRotation();
-        if (e.isControlDown()) {
-            return;
-        }
-
-        double m0 = mscale;
-        double m1 = m0 + ((0.25 * m0) * notches);
-        m1 = Math.max(m1, 0.00001);
-        if (m1 == m0) {
-            return;
-        }
-
-        positions.clear();
-        fastpositions.clear();
-
-        Point p = e.getPoint();
-        double sx = p.getX();
-        double sz = p.getY();
-
-        double newOxp = scale * ((m0 / m1) * (sx + (oxp / scale)) - sx);
-        double newOzp = scale * ((m0 / m1) * (sz + (ozp / scale)) - sz);
-
-        mscale = m1;
-        oxp = newOxp;
-        ozp = newOzp;
-        ox = oxp;
-        oz = ozp;
-    }
-
-    @Override
-    public void mouseClicked(MouseEvent e) {
-        if (control) {
-            teleport();
-        } else if (alt) {
-            open();
-        }
-    }
-
-    @Override
-    public void mousePressed(MouseEvent e) {
-
-    }
-
-    @Override
-    public void mouseReleased(MouseEvent e) {
-
-    }
-
-    @Override
-    public void mouseEntered(MouseEvent e) {
-
-    }
-
-    @Override
-    public void mouseExited(MouseEvent e) {
-
-    }
-}

core/src/main/java/com/volmit/iris/core/gui/components/IrisRenderer.java

@@ -1,85 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.gui.components;
-
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.object.IrisBiomeGeneratorLink;
-import com.volmit.iris.util.interpolation.IrisInterpolation;
-
-import java.awt.*;
-import java.awt.image.BufferedImage;
-import java.util.function.BiFunction;
-
-public class IrisRenderer {
-    private final Engine renderer;
-
-    public IrisRenderer(Engine renderer) {
-        this.renderer = renderer;
-    }
-
-    public BufferedImage render(double sx, double sz, double size, int resolution, RenderType currentType) {
-        BufferedImage image = new BufferedImage(resolution, resolution, BufferedImage.TYPE_INT_RGB);
-        BiFunction<Double, Double, Integer> colorFunction = (d, dx) -> Color.black.getRGB();
-
-        switch (currentType) {
-            case BIOME, DECORATOR_LOAD, OBJECT_LOAD, LAYER_LOAD ->
-                    colorFunction = (x, z) -> renderer.getComplex().getTrueBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
-            case BIOME_LAND ->
-                    colorFunction = (x, z) -> renderer.getComplex().getLandBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
-            case BIOME_SEA ->
-                    colorFunction = (x, z) -> renderer.getComplex().getSeaBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
-            case REGION ->
-                    colorFunction = (x, z) -> renderer.getComplex().getRegionStream().get(x, z).getColor(renderer.getComplex(), currentType).getRGB();
-            case CAVE_LAND ->
-                    colorFunction = (x, z) -> renderer.getComplex().getCaveBiomeStream().get(x, z).getColor(renderer, currentType).getRGB();
-            case HEIGHT ->
-                    colorFunction = (x, z) -> Color.getHSBColor(renderer.getComplex().getHeightStream().get(x, z).floatValue(), 100, 100).getRGB();
-            case CONTINENT -> colorFunction = (x, z) -> {
-                IrisBiome b = renderer.getBiome((int) Math.round(x), renderer.getMaxHeight() - 1, (int) Math.round(z));
-                IrisBiomeGeneratorLink g = b.getGenerators().get(0);
-                Color c;
-                if (g.getMax() <= 0) {
-                    // Max is below water level, so it is most likely an ocean biome
-                    c = Color.BLUE;
-                } else if (g.getMin() < 0) {
-                    // Min is below water level, but max is not, so it is most likely a shore biome
-                    c = Color.YELLOW;
-                } else {
-                    // Both min and max are above water level, so it is most likely a land biome
-                    c = Color.GREEN;
-                }
-                return c.getRGB();
-            };
-        }
-
-        double x, z;
-        int i, j;
-        for (i = 0; i < resolution; i++) {
-            x = IrisInterpolation.lerp(sx, sx + size, (double) i / (double) (resolution));
-
-            for (j = 0; j < resolution; j++) {
-                z = IrisInterpolation.lerp(sz, sz + size, (double) j / (double) (resolution));
-                image.setRGB(i, j, colorFunction.apply(x, z));
-            }
-        }
-
-        return image;
-    }
-}

core/src/main/java/com/volmit/iris/core/gui/components/RenderType.java

@@ -1,23 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.gui.components;
-
-public enum RenderType {
-    BIOME, BIOME_LAND, BIOME_SEA, REGION, CAVE_LAND, HEIGHT, OBJECT_LOAD, DECORATOR_LOAD, CONTINENT, LAYER_LOAD
-}

core/src/main/java/com/volmit/iris/core/gui/components/Renderer.java

@@ -1,26 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.gui.components;
-
-import java.awt.*;
-
-@FunctionalInterface
-public interface Renderer {
-    Color draw(double x, double z);
-}

core/src/main/java/com/volmit/iris/core/gui/components/TileRender.java

@@ -1,31 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.gui.components;
-
-import lombok.Builder;
-import lombok.Data;
-
-import java.awt.image.BufferedImage;
-
-@Builder
-@Data
-public class TileRender {
-    private BufferedImage image;
-    private int quality;
-}

core/src/main/java/com/volmit/iris/core/link/CustomItemsDataProvider.java

@@ -1,102 +0,0 @@
-//package com.volmit.iris.core.link;
-//
-//import com.jojodmo.customitems.api.CustomItemsAPI;
-//import com.jojodmo.customitems.item.custom.CustomItem;
-//import com.jojodmo.customitems.item.custom.block.CustomMushroomBlock;
-//import com.jojodmo.customitems.version.SafeMaterial;
-//import com.volmit.iris.util.collection.KList;
-//import com.volmit.iris.util.reflect.WrappedField;
-//import com.volmit.iris.util.reflect.WrappedReturningMethod;
-//import org.bukkit.block.BlockFace;
-//import org.bukkit.block.data.BlockData;
-//import org.bukkit.block.data.MultipleFacing;
-//import org.bukkit.inventory.ItemStack;
-//
-//import java.util.Map;
-//import java.util.MissingResourceException;
-//
-//public class CustomItemsDataProvider extends ExternalDataProvider {
-//
-//    private static final String FIELD_FACES = "faces";
-//    private static final String METHOD_GET_MATERIAL = "getMaterial";
-//
-//    private WrappedField<CustomMushroomBlock, Map<Integer, boolean[]>> mushroomFaces;
-//    private WrappedReturningMethod<CustomMushroomBlock, SafeMaterial> mushroomMaterial;
-//
-//    public CustomItemsDataProvider() {
-//        super("CustomItems");
-//    }
-//
-//    @Override
-//    public void init() {
-//        this.mushroomFaces = new WrappedField<>(CustomMushroomBlock.class, FIELD_FACES);
-//        this.mushroomMaterial = new WrappedReturningMethod<>(CustomMushroomBlock.class, METHOD_GET_MATERIAL);
-//    }
-//
-//    @Override
-//    public BlockData getBlockData(Identifier blockId) throws MissingResourceException {
-//        CustomItem item = CustomItem.get(blockId.key());
-//        if(item == null) {
-//            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-//        } else if(item.getBlockTexture().isSpawner()) {
-//            throw new MissingResourceException("Iris does not yet support SpawnerBlocks from CustomItems.", blockId.namespace(), blockId.key());
-//        } else if(item.getBlockTexture() != null && item.getBlockTexture().isValid()) {
-//            throw new MissingResourceException("Tried to fetch BlockData for a CustomItem that is not placeable!", blockId.namespace(), blockId.key());
-//        }
-//        return getMushroomData(item);
-//    }
-//
-//    @Override
-//    public ItemStack getItemStack(Identifier itemId) throws MissingResourceException {
-//        ItemStack stack = CustomItemsAPI.getCustomItem(itemId.key());
-//        if(stack == null) {
-//            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-//        }
-//        return stack;
-//    }
-//
-//    @Override
-//    public Identifier[] getBlockTypes() {
-//        KList<Identifier> names = new KList<>();
-//        for (String name : CustomItemsAPI.listBlockCustomItemIDs()) {
-//            try {
-//                Identifier key = new Identifier("cui", name);
-//                if (getItemStack(key) != null)
-//                    names.add(key);
-//            } catch (MissingResourceException ignored) { }
-//        }
-//
-//        return names.toArray(new Identifier[0]);
-//    }
-//
-//    @Override
-//    public Identifier[] getItemTypes() {
-//        KList<Identifier> names = new KList<>();
-//        for (String name : CustomItemsAPI.listCustomItemIDs()) {
-//            try {
-//                Identifier key = new Identifier("cui", name);
-//                if (getItemStack(key) != null)
-//                    names.add(key);
-//            } catch (MissingResourceException ignored) { }
-//        }
-//
-//        return names.toArray(new Identifier[0]);
-//    }
-//
-//    @Override
-//    public boolean isValidProvider(Identifier key, boolean isItem) {
-//        return key.namespace().equalsIgnoreCase("cui");
-//    }
-//
-//    private BlockData getMushroomData(CustomItem item) {
-//        MultipleFacing data = (MultipleFacing)mushroomMaterial.invoke(item.getBlockTexture().getMushroomId()).parseMaterial().createBlockData();
-//        boolean[] values = mushroomFaces.get().get(item.getBlockTexture().getMushroomId());
-//        data.setFace(BlockFace.DOWN, values[0]);
-//        data.setFace(BlockFace.EAST, values[1]);
-//        data.setFace(BlockFace.NORTH, values[2]);
-//        data.setFace(BlockFace.SOUTH, values[3]);
-//        data.setFace(BlockFace.UP, values[4]);
-//        data.setFace(BlockFace.WEST, values[5]);
-//        return data;
-//    }
-//}

core/src/main/java/com/volmit/iris/core/link/ExternalDataProvider.java

@@ -1,170 +0,0 @@
-package com.volmit.iris.core.link;
-
-import com.volmit.iris.core.link.data.DataType;
-import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.nms.container.BlockProperty;
-import com.volmit.iris.core.nms.container.Pair;
-import com.volmit.iris.engine.data.cache.Cache;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.IrisCustomData;
-import com.volmit.iris.util.math.RNG;
-import lombok.Getter;
-import lombok.NonNull;
-import lombok.RequiredArgsConstructor;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.block.Block;
-import org.bukkit.block.BlockFace;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.entity.Entity;
-import org.bukkit.event.Listener;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.plugin.Plugin;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Arrays;
-import java.util.Collection;
-import java.util.List;
-import java.util.MissingResourceException;
-
-@Getter
-@RequiredArgsConstructor
-public abstract class ExternalDataProvider implements Listener {
-
-    @NonNull
-    private final String pluginId;
-
-    @Nullable
-    public Plugin getPlugin() {
-        return Bukkit.getPluginManager().getPlugin(pluginId);
-    }
-
-    public boolean isReady() {
-        return getPlugin() != null && getPlugin().isEnabled();
-    }
-
-    public abstract void init();
-
-    /**
-     * @see ExternalDataProvider#getBlockData(Identifier, KMap)
-     */
-    @NotNull
-    public BlockData getBlockData(@NotNull Identifier blockId) throws MissingResourceException {
-        return getBlockData(blockId, new KMap<>());
-    }
-
-    /**
-     * This method returns a {@link BlockData} corresponding to the blockID
-     * it is used in any place Iris accepts {@link BlockData}
-     *
-     * @param blockId The id of the block to get
-     * @param state The state of the block to get
-     * @return Corresponding {@link BlockData} to the blockId
-     *         may return {@link IrisCustomData} for blocks that need a world for placement
-     * @throws MissingResourceException when the blockId is invalid
-     */
-    @NotNull
-    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
-        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-    }
-
-    /**
-     * Retrieves a list of all {@link BlockProperty} objects associated with the specified block identifier.
-     *
-     * @param blockId The identifier of the block whose properties are to be retrieved. Must not be null.
-     * @return A list of {@link BlockProperty} objects representing the properties of the block.
-     * @throws MissingResourceException If the specified block identifier is invalid or cannot be found.
-     */
-    @NotNull
-    public List<BlockProperty> getBlockProperties(@NotNull Identifier blockId) throws MissingResourceException {
-        return List.of();
-    }
-
-    /**
-     * @see ExternalDataProvider#getItemStack(Identifier)
-     */
-    @NotNull
-    public ItemStack getItemStack(@NotNull Identifier itemId) throws MissingResourceException {
-        return getItemStack(itemId, new KMap<>());
-    }
-
-    /**
-     * This method returns a {@link ItemStack} corresponding to the itemID
-     * it is used in loot tables
-     *
-     * @param itemId The id of the item to get
-     * @param customNbt Custom nbt to apply to the item
-     * @return Corresponding {@link ItemStack} to the itemId
-     * @throws MissingResourceException when the itemId is invalid
-     */
-    @NotNull
-    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
-        throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-    }
-
-    /**
-     * This method is used for placing blocks that need to use the plugins api
-     * it will only be called when the {@link ExternalDataProvider#getBlockData(Identifier, KMap)} returned a {@link IrisCustomData}
-     *
-     * @param engine The engine of the world the block is being placed in
-     * @param block The block where the block should be placed
-     * @param blockId The blockId to place
-     */
-    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {}
-
-    /**
-     * Spawns a mob in the specified location using the given engine and entity identifier.
-     *
-     * @param location The location in the world where the mob should spawn. Must not be null.
-     * @param entityId The identifier of the mob entity to spawn. Must not be null.
-     * @return The spawned {@link Entity} if successful, or null if the mob could not be spawned.
-     */
-    @Nullable
-    public Entity spawnMob(@NotNull Location location, @NotNull Identifier entityId) throws MissingResourceException {
-        throw new MissingResourceException("Failed to find Entity!", entityId.namespace(), entityId.key());
-    }
-
-    public abstract @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType);
-
-    public abstract boolean isValidProvider(@NotNull Identifier id, DataType dataType);
-
-    protected static Pair<Float, BlockFace> parseYawAndFace(@NotNull Engine engine, @NotNull Block block, @NotNull KMap<@NotNull String, @NotNull String> state) {
-        float yaw = 0;
-        BlockFace face = BlockFace.NORTH;
-
-        long seed = engine.getSeedManager().getSeed() + Cache.key(block.getX(), block.getZ()) + block.getY();
-        RNG rng = new RNG(seed);
-        if ("true".equals(state.get("randomYaw"))) {
-            yaw = rng.f(0, 360);
-        } else if (state.containsKey("yaw")) {
-            yaw = Float.parseFloat(state.get("yaw"));
-        }
-        if ("true".equals(state.get("randomFace"))) {
-            BlockFace[] faces = BlockFace.values();
-            face = faces[rng.i(0, faces.length - 1)];
-        } else if (state.containsKey("face")) {
-            face = BlockFace.valueOf(state.get("face").toUpperCase());
-        }
-        if (face == BlockFace.SELF) {
-            face = BlockFace.NORTH;
-        }
-
-        return new Pair<>(yaw, face);
-    }
-
-    protected static List<BlockProperty> YAW_FACE_BIOME_PROPERTIES = List.of(
-            BlockProperty.ofEnum(BiomeColor.class, "matchBiome", null),
-            BlockProperty.ofBoolean("randomYaw", false),
-            BlockProperty.ofFloat("yaw", 0, 0, 360f, false, true),
-            BlockProperty.ofBoolean("randomFace", true),
-            new BlockProperty(
-                    "face",
-                    BlockFace.class,
-                    BlockFace.NORTH,
-                    Arrays.asList(BlockFace.values()).subList(0, BlockFace.values().length - 1),
-                    BlockFace::name
-            )
-    );
-}

core/src/main/java/com/volmit/iris/core/link/Identifier.java

@@ -1,37 +0,0 @@
-package com.volmit.iris.core.link;
-
-import org.bukkit.NamespacedKey;
-
-public record Identifier(String namespace, String key) {
-
-    private static final String DEFAULT_NAMESPACE = "minecraft";
-
-    public static Identifier fromNamespacedKey(NamespacedKey key) {
-        return new Identifier(key.getNamespace(), key.getKey());
-    }
-
-    public static Identifier fromString(String id) {
-        String[] strings = id.split(":", 2);
-        if (strings.length == 1) {
-            return new Identifier(DEFAULT_NAMESPACE, strings[0]);
-        } else {
-            return new Identifier(strings[0], strings[1]);
-        }
-    }
-
-    @Override
-    public String toString() {
-        return namespace + ":" + key;
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj instanceof Identifier i) {
-            return i.namespace().equals(this.namespace) && i.key().equals(this.key);
-        } else if (obj instanceof NamespacedKey i) {
-            return i.getNamespace().equals(this.namespace) && i.getKey().equals(this.key);
-        } else {
-            return false;
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/link/IrisPapiExpansion.java

@@ -1,116 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.link;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.engine.platform.PlatformChunkGenerator;
-import me.clip.placeholderapi.expansion.PlaceholderExpansion;
-import org.bukkit.Location;
-import org.bukkit.OfflinePlayer;
-import org.jetbrains.annotations.NotNull;
-
-// See/update https://app.gitbook.com/@volmitsoftware/s/iris/compatability/papi/
-public class IrisPapiExpansion extends PlaceholderExpansion {
-    @Override
-    public @NotNull String getIdentifier() {
-        return "iris";
-    }
-
-    @Override
-    public @NotNull String getAuthor() {
-        return "Volmit Software";
-    }
-
-    @Override
-    public @NotNull String getVersion() {
-        return Iris.instance.getDescription().getVersion();
-    }
-
-    @Override
-    public boolean persist() {
-        return true;
-    }
-
-    @Override
-    public String onRequest(OfflinePlayer player, String p) {
-        Location l = null;
-        PlatformChunkGenerator a = null;
-
-        if (player.isOnline() && player.getPlayer() != null) {
-            l = player.getPlayer().getLocation().add(0, 2, 0);
-            a = IrisToolbelt.access(l.getWorld());
-        }
-
-        if (p.equalsIgnoreCase("biome_name")) {
-            if (a != null) {
-                return getBiome(a, l).getName();
-            }
-        } else if (p.equalsIgnoreCase("biome_id")) {
-            if (a != null) {
-                return getBiome(a, l).getLoadKey();
-            }
-        } else if (p.equalsIgnoreCase("biome_file")) {
-            if (a != null) {
-                return getBiome(a, l).getLoadFile().getPath();
-            }
-        } else if (p.equalsIgnoreCase("region_name")) {
-            if (a != null) {
-                return a.getEngine().getRegion(l).getName();
-            }
-        } else if (p.equalsIgnoreCase("region_id")) {
-            if (a != null) {
-                return a.getEngine().getRegion(l).getLoadKey();
-            }
-        } else if (p.equalsIgnoreCase("region_file")) {
-            if (a != null) {
-                return a.getEngine().getRegion(l).getLoadFile().getPath();
-            }
-        } else if (p.equalsIgnoreCase("terrain_slope")) {
-            if (a != null) {
-                return (a.getEngine())
-                        .getComplex().getSlopeStream()
-                        .get(l.getX(), l.getZ()) + "";
-            }
-        } else if (p.equalsIgnoreCase("terrain_height")) {
-            if (a != null) {
-                return Math.round(a.getEngine().getHeight(l.getBlockX(), l.getBlockZ())) + "";
-            }
-        } else if (p.equalsIgnoreCase("world_mode")) {
-            if (a != null) {
-                return a.isStudio() ? "Studio" : "Production";
-            }
-        } else if (p.equalsIgnoreCase("world_seed")) {
-            if (a != null) {
-                return a.getEngine().getSeedManager().getSeed() + "";
-            }
-        } else if (p.equalsIgnoreCase("world_speed")) {
-            if (a != null) {
-                return a.getEngine().getGeneratedPerSecond() + "/s";
-            }
-        }
-
-        return null;
-    }
-
-    private IrisBiome getBiome(PlatformChunkGenerator a, Location l) {
-        return a.getEngine().getBiome(l.getBlockX(), l.getBlockY() - l.getWorld().getMinHeight(), l.getBlockZ());
-    }
-}

core/src/main/java/com/volmit/iris/core/link/MultiverseCoreLink.java

@@ -1,77 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.link;
-
-import lombok.SneakyThrows;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.mvplugins.multiverse.core.MultiverseCoreApi;
-import org.mvplugins.multiverse.core.world.MultiverseWorld;
-import org.mvplugins.multiverse.core.world.WorldManager;
-import org.mvplugins.multiverse.core.world.options.ImportWorldOptions;
-
-public class MultiverseCoreLink {
-    private final boolean active;
-
-    public MultiverseCoreLink() {
-        active = Bukkit.getPluginManager().getPlugin("Multiverse-Core") != null;
-    }
-
-    public void removeFromConfig(World world) {
-        removeFromConfig(world.getName());
-    }
-
-    public void removeFromConfig(String world) {
-        if (!active) return;
-        var manager = worldManager();
-        manager.removeWorld(world).onSuccess(manager::saveWorldsConfig);
-    }
-
-    @SneakyThrows
-    public void updateWorld(World bukkitWorld, String pack) {
-        if (!active) return;
-        var generator = "Iris:" + pack;
-        var manager = worldManager();
-        var world = manager.getWorld(bukkitWorld).getOrElse(() -> {
-            var options = ImportWorldOptions.worldName(bukkitWorld.getName())
-                    .generator(generator)
-                    .environment(bukkitWorld.getEnvironment())
-                    .useSpawnAdjust(false);
-            return manager.importWorld(options).get();
-        });
-
-        world.setAutoLoad(false);
-        if (!generator.equals(world.getGenerator())) {
-            var field = MultiverseWorld.class.getDeclaredField("worldConfig");
-            field.setAccessible(true);
-
-            var config = field.get(world);
-            config.getClass()
-                    .getDeclaredMethod("setGenerator", String.class)
-                    .invoke(config, generator);
-        }
-
-        manager.saveWorldsConfig();
-    }
-
-    private WorldManager worldManager() {
-        var api = MultiverseCoreApi.get();
-        return api.getWorldManager();
-    }
-}

core/src/main/java/com/volmit/iris/core/link/WorldEditLink.java

@@ -1,60 +0,0 @@
-package com.volmit.iris.core.link;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.engine.data.cache.AtomicCache;
-import com.volmit.iris.util.data.Cuboid;
-import com.volmit.iris.util.data.KCache;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.entity.Player;
-
-import java.lang.reflect.InvocationTargetException;
-import java.time.Duration;
-import java.util.UUID;
-
-public class WorldEditLink {
-    private static final AtomicCache<Boolean> active = new AtomicCache<>();
-
-    public static Cuboid getSelection(Player p) {
-        if (!hasWorldEdit())
-            return null;
-
-        try {
-            Object instance = Class.forName("com.sk89q.worldedit.WorldEdit").getDeclaredMethod("getInstance").invoke(null);
-            Object sessionManager = instance.getClass().getDeclaredMethod("getSessionManager").invoke(instance);
-            Class<?> bukkitAdapter = Class.forName("com.sk89q.worldedit.bukkit.BukkitAdapter");
-            Object world = bukkitAdapter.getDeclaredMethod("adapt", World.class).invoke(null, p.getWorld());
-            Object player = bukkitAdapter.getDeclaredMethod("adapt", Player.class).invoke(null, p);
-            Object localSession = sessionManager.getClass().getDeclaredMethod("getIfPresent", Class.forName("com.sk89q.worldedit.session.SessionOwner")).invoke(sessionManager, player);
-            if (localSession == null) return null;
-
-            Object region = null;
-            try {
-                region = localSession.getClass().getDeclaredMethod("getSelection", Class.forName("com.sk89q.worldedit.world.World")).invoke(localSession, world);
-            } catch (InvocationTargetException ignored) {}
-            if (region == null) return null;
-
-            Object min = region.getClass().getDeclaredMethod("getMinimumPoint").invoke(region);
-            Object max = region.getClass().getDeclaredMethod("getMaximumPoint").invoke(region);
-            return new Cuboid(p.getWorld(),
-                    (int) min.getClass().getDeclaredMethod("x").invoke(min),
-                    (int) min.getClass().getDeclaredMethod("y").invoke(min),
-                    (int) min.getClass().getDeclaredMethod("z").invoke(min),
-                    (int) min.getClass().getDeclaredMethod("x").invoke(max),
-                    (int) min.getClass().getDeclaredMethod("y").invoke(max),
-                    (int) min.getClass().getDeclaredMethod("z").invoke(max)
-            );
-        } catch (Throwable e) {
-            Iris.error("Could not get selection");
-            e.printStackTrace();
-            Iris.reportError(e);
-            active.reset();
-            active.aquire(() -> false);
-        }
-        return null;
-    }
-
-    public static boolean hasWorldEdit() {
-        return active.aquire(() -> Bukkit.getPluginManager().isPluginEnabled("WorldEdit"));
-    }
-}

core/src/main/java/com/volmit/iris/core/link/data/DataType.java

@@ -1,33 +0,0 @@
-package com.volmit.iris.core.link.data;
-
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-
-import java.util.MissingResourceException;
-import java.util.function.BiPredicate;
-import java.util.function.Predicate;
-
-public enum DataType implements BiPredicate<ExternalDataProvider, Identifier> {
-    ITEM,
-    BLOCK,
-    ENTITY;
-
-    @Override
-    public boolean test(ExternalDataProvider dataProvider, Identifier identifier) {
-        if (!dataProvider.isValidProvider(identifier, this)) return false;
-        try {
-            switch (this) {
-                case ITEM -> dataProvider.getItemStack(identifier);
-                case BLOCK -> dataProvider.getBlockData(identifier);
-                case ENTITY -> {}
-            }
-            return true;
-        } catch (MissingResourceException e) {
-            return false;
-        }
-    }
-
-    public Predicate<Identifier> asPredicate(ExternalDataProvider dataProvider) {
-        return i -> test(dataProvider, i);
-    }
-}

core/src/main/java/com/volmit/iris/core/link/data/EcoItemsDataProvider.java

@@ -1,61 +0,0 @@
-package com.volmit.iris.core.link.data;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.reflect.WrappedField;
-import com.willfp.ecoitems.items.EcoItem;
-import com.willfp.ecoitems.items.EcoItems;
-import org.bukkit.NamespacedKey;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.MissingResourceException;
-
-public class EcoItemsDataProvider extends ExternalDataProvider {
-    private WrappedField<EcoItem, ItemStack> itemStack;
-    private WrappedField<EcoItem, NamespacedKey> id;
-
-    public EcoItemsDataProvider() {
-        super("EcoItems");
-    }
-
-    @Override
-    public void init() {
-        Iris.info("Setting up EcoItems Link...");
-        itemStack = new WrappedField<>(EcoItem.class, "_itemStack");
-        if (this.itemStack.hasFailed()) {
-            Iris.error("Failed to set up EcoItems Link: Unable to fetch ItemStack field!");
-        }
-        id = new WrappedField<>(EcoItem.class, "id");
-        if (this.id.hasFailed()) {
-            Iris.error("Failed to set up EcoItems Link: Unable to fetch id field!");
-        }
-    }
-
-    @NotNull
-    @Override
-    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
-        EcoItem item = EcoItems.INSTANCE.getByID(itemId.key());
-        if (item == null) throw new MissingResourceException("Failed to find Item!", itemId.namespace(), itemId.key());
-        return itemStack.get(item).clone();
-    }
-
-    @Override
-    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
-        if (dataType != DataType.ITEM) return List.of();
-        return EcoItems.INSTANCE.values()
-                .stream()
-                .map(x -> Identifier.fromNamespacedKey(id.get(x)))
-                .filter(dataType.asPredicate(this))
-                .toList();
-    }
-
-    @Override
-    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
-        return id.namespace().equalsIgnoreCase("ecoitems") && dataType == DataType.ITEM;
-    }
-}

core/src/main/java/com/volmit/iris/core/link/data/ExecutableItemsDataProvider.java

@@ -1,49 +0,0 @@
-package com.volmit.iris.core.link.data;
-
-import com.ssomar.score.api.executableitems.ExecutableItemsAPI;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.util.collection.KMap;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.MissingResourceException;
-import java.util.Optional;
-
-public class ExecutableItemsDataProvider extends ExternalDataProvider {
-    public ExecutableItemsDataProvider() {
-        super("ExecutableItems");
-    }
-
-    @Override
-    public void init() {
-        Iris.info("Setting up ExecutableItems Link...");
-    }
-
-    @NotNull
-    @Override
-    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
-        return ExecutableItemsAPI.getExecutableItemsManager().getExecutableItem(itemId.key())
-                .map(item -> item.buildItem(1, Optional.empty()))
-                .orElseThrow(() -> new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key()));
-    }
-
-    @Override
-    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
-        if (dataType != DataType.ITEM) return List.of();
-        return ExecutableItemsAPI.getExecutableItemsManager()
-                .getExecutableItemIdsList()
-                .stream()
-                .map(name -> new Identifier("executable_items", name))
-                .filter(dataType.asPredicate(this))
-                .toList();
-    }
-
-    @Override
-    public boolean isValidProvider(@NotNull Identifier key, DataType dataType) {
-        return key.namespace().equalsIgnoreCase("executable_items") && dataType == DataType.ITEM;
-    }
-}

core/src/main/java/com/volmit/iris/core/link/data/HMCLeavesDataProvider.java

@@ -1,126 +0,0 @@
-package com.volmit.iris.core.link.data;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.core.service.ExternalDataSVC;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.IrisCustomData;
-import com.volmit.iris.util.reflect.WrappedField;
-import com.volmit.iris.util.reflect.WrappedReturningMethod;
-import org.bukkit.Bukkit;
-import org.bukkit.Location;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.block.data.type.Leaves;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.Map;
-import java.util.MissingResourceException;
-import java.util.function.Supplier;
-
-public class HMCLeavesDataProvider extends ExternalDataProvider {
-	private Object apiInstance;
-	private WrappedReturningMethod<Object, Material> worldBlockType;
-	private WrappedReturningMethod<Object, Boolean> setCustomBlock;
-	private Map<String, Object> blockDataMap = Map.of();
-	private Map<String, Supplier<ItemStack>> itemDataField = Map.of();
-
-	public HMCLeavesDataProvider() {
-		super("HMCLeaves");
-	}
-
-	@Override
-	public String getPluginId() {
-		return "HMCLeaves";
-	}
-
-	@Override
-	public void init() {
-		try {
-			worldBlockType = new WrappedReturningMethod<>((Class<Object>) Class.forName("io.github.fisher2911.hmcleaves.data.BlockData"), "worldBlockType");
-			apiInstance = getApiInstance(Class.forName("io.github.fisher2911.hmcleaves.api.HMCLeavesAPI"));
-			setCustomBlock = new WrappedReturningMethod<>((Class<Object>) apiInstance.getClass(), "setCustomBlock", Location.class, String.class, boolean.class);
-			Object config = getLeavesConfig(apiInstance.getClass());
-			blockDataMap = getMap(config, "blockDataMap");
-			itemDataField = getMap(config, "itemSupplierMap");
-		} catch (Throwable e) {
-			Iris.error("Failed to initialize HMCLeavesDataProvider: " + e.getMessage());
-		}
-	}
-
-	@NotNull
-	@Override
-	public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
-		Object o = blockDataMap.get(blockId.key());
-		if (o == null)
-			throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-		Material material = worldBlockType.invoke(o, new Object[0]);
-		if (material == null)
-			throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-		BlockData blockData = Bukkit.createBlockData(material);
-		if (IrisSettings.get().getGenerator().preventLeafDecay && blockData instanceof Leaves leaves)
-			leaves.setPersistent(true);
-		return IrisCustomData.of(blockData, ExternalDataSVC.buildState(blockId, state));
-	}
-
-	@NotNull
-	@Override
-	public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
-		if (!itemDataField.containsKey(itemId.key()))
-			throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-		return itemDataField.get(itemId.key()).get();
-	}
-
-	@Override
-	public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
-		var pair = ExternalDataSVC.parseState(blockId);
-		blockId = pair.getA();
-		Boolean result = setCustomBlock.invoke(apiInstance, new Object[]{block.getLocation(), blockId.key(), false});
-		if (result == null || !result)
-			Iris.warn("Failed to set custom block! " + blockId.key() + " " + block.getX() + " " + block.getY() + " " + block.getZ());
-		else if (IrisSettings.get().getGenerator().preventLeafDecay) {
-			BlockData blockData = block.getBlockData();
-			if (blockData instanceof Leaves leaves)
-				leaves.setPersistent(true);
-		}
-	}
-
-	@Override
-	public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
-		if (dataType == DataType.ENTITY) return List.of();
-		return (dataType == DataType.BLOCK ? blockDataMap.keySet() : itemDataField.keySet())
-				.stream()
-				.map(x -> new Identifier("hmcleaves", x))
-				.filter(dataType.asPredicate(this))
-				.toList();
-	}
-
-	@Override
-	public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
-		if (dataType == DataType.ENTITY) return false;
-		return (dataType == DataType.ITEM ? itemDataField.keySet() : blockDataMap.keySet()).contains(id.key());
-	}
-
-	private <C, T> Map<String, T> getMap(C config, String name) {
-		WrappedField<C, Map<String, T>> field = new WrappedField<>((Class<C>) config.getClass(), name);
-		return field.get(config);
-	}
-
-	private <A> A getApiInstance(Class<A> apiClass) {
-		WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
-		return instance.invoke();
-	}
-
-	private <A, C> C getLeavesConfig(Class<A> apiClass) {
-		WrappedReturningMethod<A, A> instance = new WrappedReturningMethod<>(apiClass, "getInstance");
-		WrappedField<A, C> config = new WrappedField<>(apiClass, "config");
-		return config.get(instance.invoke());
-	}
-}

core/src/main/java/com/volmit/iris/core/link/data/ItemAdderDataProvider.java

@@ -1,107 +0,0 @@
-package com.volmit.iris.core.link.data;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.data.IrisCustomData;
-import dev.lone.itemsadder.api.CustomBlock;
-import dev.lone.itemsadder.api.CustomStack;
-import dev.lone.itemsadder.api.Events.ItemsAdderLoadDataEvent;
-import org.bukkit.block.Block;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.event.EventHandler;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.MissingResourceException;
-import java.util.stream.Collectors;
-
-public class ItemAdderDataProvider extends ExternalDataProvider {
-
-    private final KSet<String> itemNamespaces = new KSet<>();
-    private final KSet<String> blockNamespaces = new KSet<>();
-
-    public ItemAdderDataProvider() {
-        super("ItemsAdder");
-    }
-
-    @Override
-    public void init() {
-        updateNamespaces();
-    }
-
-    @EventHandler
-    public void onLoadData(ItemsAdderLoadDataEvent event) {
-        updateNamespaces();
-    }
-
-    @NotNull
-    @Override
-    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
-        CustomBlock block = CustomBlock.getInstance(blockId.toString());
-        if (block == null) {
-            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-        }
-        return IrisCustomData.of(block.getBaseBlockData(), blockId);
-    }
-
-    @NotNull
-    @Override
-    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
-        CustomStack stack = CustomStack.getInstance(itemId.toString());
-        if (stack == null) {
-            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        }
-        return stack.getItemStack();
-    }
-
-    @Override
-    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
-        CustomBlock custom;
-        if ((custom = CustomBlock.place(blockId.toString(), block.getLocation())) == null)
-            return;
-        block.setBlockData(custom.getBaseBlockData(), false);
-    }
-
-    @Override
-    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
-        return switch (dataType) {
-            case ENTITY -> List.of();
-            case ITEM -> CustomStack.getNamespacedIdsInRegistry()
-                    .stream()
-                    .map(Identifier::fromString)
-                    .toList();
-            case BLOCK -> CustomBlock.getNamespacedIdsInRegistry()
-                    .stream()
-                    .map(Identifier::fromString)
-                    .toList();
-        };
-    }
-
-    private void updateNamespaces() {
-        try {
-            updateNamespaces(DataType.ITEM);
-            updateNamespaces(DataType.BLOCK);
-        } catch (Throwable e) {
-            Iris.warn("Failed to update ItemAdder namespaces: " + e.getMessage());
-        }
-    }
-
-    private void updateNamespaces(DataType dataType) {
-        var namespaces = getTypes(dataType).stream().map(Identifier::namespace).collect(Collectors.toSet());
-        var currentNamespaces = dataType == DataType.ITEM ? itemNamespaces : blockNamespaces;
-        currentNamespaces.removeIf(n -> !namespaces.contains(n));
-        currentNamespaces.addAll(namespaces);
-    }
-
-    @Override
-    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
-        if (dataType == DataType.ENTITY) return false;
-        return dataType == DataType.ITEM ? itemNamespaces.contains(id.namespace()) : blockNamespaces.contains(id.namespace());
-    }
-}

core/src/main/java/com/volmit/iris/core/link/data/KGeneratorsDataProvider.java

@@ -1,74 +0,0 @@
-package com.volmit.iris.core.link.data;
-
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.core.service.ExternalDataSVC;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
-import me.kryniowesegryderiusz.kgenerators.Main;
-import me.kryniowesegryderiusz.kgenerators.api.KGeneratorsAPI;
-import me.kryniowesegryderiusz.kgenerators.generators.locations.objects.GeneratorLocation;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.MissingResourceException;
-
-public class KGeneratorsDataProvider extends ExternalDataProvider {
-    public KGeneratorsDataProvider() {
-        super("KGenerators");
-    }
-
-    @Override
-    public void init() {
-
-    }
-
-    @Override
-    public @NotNull BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
-        if (Main.getGenerators().get(blockId.key()) == null) throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-        return IrisCustomData.of(Material.STRUCTURE_VOID.createBlockData(), ExternalDataSVC.buildState(blockId, state));
-    }
-
-    @Override
-    public @NotNull ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
-        var gen = Main.getGenerators().get(itemId.key());
-        if (gen == null) throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        return gen.getGeneratorItem();
-    }
-
-    @Override
-    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
-        if (block.getType() != Material.STRUCTURE_VOID) return;
-        var existing = KGeneratorsAPI.getLoadedGeneratorLocation(block.getLocation());
-        if (existing != null) return;
-        block.setBlockData(B.getAir(), false);
-        var gen = Main.getGenerators().get(blockId.key());
-        if (gen == null) return;
-        var loc = new GeneratorLocation(-1, gen, block.getLocation(), Main.getPlacedGenerators().getChunkInfo(block.getChunk()), null, null);
-        Main.getDatabases().getDb().saveGenerator(loc);
-        Main.getPlacedGenerators().addLoaded(loc);
-        Main.getSchedules().schedule(loc, true);
-    }
-
-    @Override
-    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
-        if (dataType == DataType.ENTITY) return List.of();
-        return Main.getGenerators().getAll().stream()
-                .map(gen -> new Identifier("kgenerators", gen.getId()))
-                .filter(dataType.asPredicate(this))
-                .toList();
-    }
-
-    @Override
-    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
-        if (dataType == DataType.ENTITY) return false;
-        return "kgenerators".equalsIgnoreCase(id.namespace());
-    }
-}

core/src/main/java/com/volmit/iris/core/link/data/MMOItemsDataProvider.java

@@ -1,125 +0,0 @@
-package com.volmit.iris.core.link.data;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.scheduling.J;
-import net.Indyuce.mmoitems.MMOItems;
-import net.Indyuce.mmoitems.api.ItemTier;
-import net.Indyuce.mmoitems.api.block.CustomBlock;
-import org.bukkit.Bukkit;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.MissingResourceException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.ExecutionException;
-import java.util.function.Supplier;
-
-public class MMOItemsDataProvider extends ExternalDataProvider {
-
-    public MMOItemsDataProvider() {
-        super("MMOItems");
-    }
-
-    @Override
-    public void init() {
-        Iris.info("Setting up MMOItems Link...");
-    }
-
-    @NotNull
-    @Override
-    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
-        int id = -1;
-        try {
-            id = Integer.parseInt(blockId.key());
-        } catch (NumberFormatException ignored) {}
-        CustomBlock block = api().getCustomBlocks().getBlock(id);
-        if (block == null) throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-        return block.getState().getBlockData();
-    }
-
-    @NotNull
-    @Override
-    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
-        String[] parts = itemId.namespace().split("_", 2);
-        if (parts.length != 2)
-            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        CompletableFuture<ItemStack> future = new CompletableFuture<>();
-        Runnable run = () -> {
-            try {
-                var type = api().getTypes().get(parts[1]);
-                int level = -1;
-                ItemTier tier = null;
-
-                if (customNbt != null) {
-                    level = (int) customNbt.getOrDefault("level", -1);
-                    tier = api().getTiers().get(String.valueOf(customNbt.get("tier")));
-                }
-
-                ItemStack itemStack;
-                if (type == null) {
-                    future.complete(null);
-                    return;
-                }
-
-                if (level != -1 && tier != null) {
-                    itemStack = api().getItem(type, itemId.key(), level, tier);
-                } else {
-                    itemStack = api().getItem(type, itemId.key());
-                }
-                future.complete(itemStack);
-            } catch (Throwable e) {
-                future.completeExceptionally(e);
-            }
-        };
-        if (Bukkit.isPrimaryThread()) run.run();
-        else J.s(run);
-        ItemStack item = null;
-        try {
-            item = future.get();
-        } catch (InterruptedException | ExecutionException ignored) {}
-        if (item == null)
-            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        return item;
-    }
-
-    @Override
-    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
-        return switch (dataType) {
-            case ENTITY -> List.of();
-            case BLOCK -> api().getCustomBlocks().getBlockIds().stream().map(id -> new Identifier("mmoitems", String.valueOf(id)))
-                    .filter(dataType.asPredicate(this))
-                    .toList();
-            case ITEM -> {
-                Supplier<Collection<Identifier>> supplier = () -> api().getTypes()
-                        .getAll()
-                        .stream()
-                        .flatMap(type -> api()
-                                .getTemplates()
-                                .getTemplateNames(type)
-                                .stream()
-                                .map(name -> new Identifier("mmoitems_" + type.getId(), name)))
-                        .filter(dataType.asPredicate(this))
-                        .toList();
-
-                if (Bukkit.isPrimaryThread()) yield supplier.get();
-                else yield J.sfut(supplier).join();
-            }
-        };
-    }
-
-    @Override
-    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
-        if (dataType == DataType.ENTITY) return false;
-        return dataType == DataType.ITEM ? id.namespace().split("_", 2).length == 2 : id.namespace().equals("mmoitems");
-    }
-
-    private MMOItems api() {
-        return MMOItems.plugin;
-    }
-}

core/src/main/java/com/volmit/iris/core/link/data/MythicCrucibleDataProvider.java

@@ -1,144 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.link.data;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.nms.container.BlockProperty;
-import com.volmit.iris.core.service.ExternalDataSVC;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
-import io.lumine.mythic.bukkit.BukkitAdapter;
-import io.lumine.mythic.bukkit.utils.serialize.Chroma;
-import io.lumine.mythiccrucible.MythicCrucible;
-import io.lumine.mythiccrucible.items.CrucibleItem;
-import io.lumine.mythiccrucible.items.ItemManager;
-import io.lumine.mythiccrucible.items.blocks.CustomBlockItemContext;
-import io.lumine.mythiccrucible.items.furniture.FurnitureItemContext;
-import org.bukkit.block.Block;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.inventory.ItemStack;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.MissingResourceException;
-import java.util.Optional;
-
-public class MythicCrucibleDataProvider extends ExternalDataProvider {
-
-    private ItemManager itemManager;
-
-    public MythicCrucibleDataProvider() {
-        super("MythicCrucible");
-    }
-
-    @Override
-    public void init() {
-        Iris.info("Setting up MythicCrucible Link...");
-        try {
-            this.itemManager = MythicCrucible.inst().getItemManager();
-        } catch (Exception e) {
-            Iris.error("Failed to set up MythicCrucible Link: Unable to fetch MythicCrucible instance!");
-        }
-    }
-
-    @NotNull
-    @Override
-    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
-        CrucibleItem crucibleItem = this.itemManager.getItem(blockId.key())
-                .orElseThrow(() -> new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key()));
-        CustomBlockItemContext blockItemContext = crucibleItem.getBlockData();
-        FurnitureItemContext furnitureItemContext = crucibleItem.getFurnitureData();
-        if (furnitureItemContext != null) {
-            return IrisCustomData.of(B.getAir(), ExternalDataSVC.buildState(blockId, state));
-        } else if (blockItemContext != null) {
-            return blockItemContext.getBlockData();
-        }
-        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-    }
-
-    @Override
-    public @NotNull List<BlockProperty> getBlockProperties(@NotNull Identifier blockId) throws MissingResourceException {
-        CrucibleItem crucibleItem = this.itemManager.getItem(blockId.key())
-                .orElseThrow(() -> new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key()));
-
-        if (crucibleItem.getFurnitureData() != null) {
-            return YAW_FACE_BIOME_PROPERTIES;
-        } else if (crucibleItem.getBlockData() != null) {
-            return List.of();
-        }
-        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-    }
-
-    @NotNull
-    @Override
-    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
-        Optional<CrucibleItem> opt = this.itemManager.getItem(itemId.key());
-        return BukkitAdapter.adapt(opt.orElseThrow(() ->
-                new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key()))
-                .getMythicItem()
-                .generateItemStack(1));
-    }
-
-    @Override
-    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
-        return itemManager.getItems()
-                .stream()
-                .map(i -> new Identifier("crucible", i.getInternalName()))
-                .filter(dataType.asPredicate(this))
-                .toList();
-    }
-
-    @Override
-    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
-        var parsedState = ExternalDataSVC.parseState(blockId);
-        var state = parsedState.getB();
-        blockId = parsedState.getA();
-
-        Optional<CrucibleItem> item = itemManager.getItem(blockId.key());
-        if (item.isEmpty()) return;
-        FurnitureItemContext furniture = item.get().getFurnitureData();
-        if (furniture == null) return;
-
-        var pair = parseYawAndFace(engine, block, state);
-        BiomeColor type = null;
-        Chroma color = null;
-        try {
-            type = BiomeColor.valueOf(state.get("matchBiome").toUpperCase());
-        } catch (NullPointerException | IllegalArgumentException ignored) {}
-        if (type != null) {
-            var biomeColor = INMS.get().getBiomeColor(block.getLocation(), type);
-            if (biomeColor == null) return;
-            color = Chroma.of(biomeColor.getRGB());
-        }
-        furniture.place(block, pair.getB(), pair.getA(), color);
-    }
-
-    @Override
-    public boolean isValidProvider(@NotNull Identifier key, DataType dataType) {
-        if (dataType == DataType.ENTITY) return false;
-        return key.namespace().equalsIgnoreCase("crucible");
-    }
-}

core/src/main/java/com/volmit/iris/core/link/data/MythicMobsDataProvider.java

@@ -1,130 +0,0 @@
-package com.volmit.iris.core.link.data;
-
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import io.lumine.mythic.api.adapters.AbstractLocation;
-import io.lumine.mythic.api.config.MythicLineConfig;
-import io.lumine.mythic.api.mobs.entities.SpawnReason;
-import io.lumine.mythic.api.skills.conditions.ILocationCondition;
-import io.lumine.mythic.bukkit.BukkitAdapter;
-import io.lumine.mythic.bukkit.MythicBukkit;
-import io.lumine.mythic.bukkit.adapters.BukkitWorld;
-import io.lumine.mythic.bukkit.events.MythicConditionLoadEvent;
-import io.lumine.mythic.core.mobs.ActiveMob;
-import io.lumine.mythic.core.mobs.MobStack;
-import io.lumine.mythic.core.skills.SkillCondition;
-import io.lumine.mythic.core.utils.annotations.MythicCondition;
-import io.lumine.mythic.core.utils.annotations.MythicField;
-import org.bukkit.Location;
-import org.bukkit.entity.Entity;
-import org.bukkit.event.EventHandler;
-import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.*;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.stream.Stream;
-
-public class MythicMobsDataProvider extends ExternalDataProvider {
-    public MythicMobsDataProvider() {
-        super("MythicMobs");
-    }
-
-    @Override
-    public void init() {
-    }
-
-    @Override
-    public @Nullable Entity spawnMob(@NotNull Location location, @NotNull Identifier entityId) throws MissingResourceException {
-        var mm = spawnMob(BukkitAdapter.adapt(location), entityId);
-        return mm == null ? null : mm.getEntity().getBukkitEntity();
-    }
-
-    private ActiveMob spawnMob(AbstractLocation location, Identifier entityId) throws MissingResourceException {
-        var manager = MythicBukkit.inst().getMobManager();
-        var mm = manager.getMythicMob(entityId.key()).orElse(null);
-        if (mm == null) {
-            var stack = manager.getMythicMobStack(entityId.key());
-            if (stack == null) throw new MissingResourceException("Failed to find Mob!", entityId.namespace(), entityId.key());
-            return stack.spawn(location, 1d, SpawnReason.OTHER, null);
-        }
-        return mm.spawn(location, 1d, SpawnReason.OTHER, null, null);
-    }
-
-    @Override
-    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
-        if (dataType != DataType.ENTITY) return List.of();
-        var manager = MythicBukkit.inst().getMobManager();
-        return Stream.concat(manager.getMobNames().stream(),
-                        manager.getMobStacks()
-                                .stream()
-                                .map(MobStack::getName)
-                )
-                .distinct()
-                .map(name -> new Identifier("mythicmobs", name))
-                .toList();
-    }
-
-    @Override
-    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
-        return id.namespace().equalsIgnoreCase("mythicmobs") && dataType == DataType.ENTITY;
-    }
-
-    @EventHandler
-    public void on(MythicConditionLoadEvent event) {
-        switch (event.getConditionName()) {
-            case "irisbiome" -> event.register(new IrisBiomeCondition(event.getConditionName(), event.getConfig()));
-            case "irisregion" -> event.register(new IrisRegionCondition(event.getConditionName(), event.getConfig()));
-        }
-    }
-
-    @MythicCondition(author = "CrazyDev22", name = "irisbiome", description = "Tests if the target is within the given list of biomes")
-    public static class IrisBiomeCondition extends SkillCondition implements ILocationCondition {
-        @MythicField(name = "biome", aliases = {"b"}, description = "A list of biomes to check")
-        private Set<String> biomes = ConcurrentHashMap.newKeySet();
-        @MythicField(name = "surface", aliases = {"s"}, description = "If the biome check should only be performed on the surface")
-        private boolean surface;
-
-        public IrisBiomeCondition(String line, MythicLineConfig mlc) {
-            super(line);
-            String b = mlc.getString(new String[]{"biome", "b"}, "");
-            biomes.addAll(Arrays.asList(b.split(",")));
-            surface = mlc.getBoolean(new String[]{"surface", "s"}, false);
-        }
-
-        @Override
-        public boolean check(AbstractLocation target) {
-            var access = IrisToolbelt.access(((BukkitWorld) target.getWorld()).getBukkitWorld());
-            if (access == null) return false;
-            var engine = access.getEngine();
-            if (engine == null) return false;
-            var biome = surface ?
-                    engine.getSurfaceBiome(target.getBlockX(), target.getBlockZ()) :
-                    engine.getBiomeOrMantle(target.getBlockX(), target.getBlockY() - engine.getMinHeight(), target.getBlockZ());
-            return biomes.contains(biome.getLoadKey());
-        }
-    }
-
-    @MythicCondition(author = "CrazyDev22", name = "irisregion", description = "Tests if the target is within the given list of biomes")
-    public static class IrisRegionCondition extends SkillCondition implements ILocationCondition {
-        @MythicField(name = "region", aliases = {"r"}, description = "A list of regions to check")
-        private Set<String> regions = ConcurrentHashMap.newKeySet();
-
-        public IrisRegionCondition(String line, MythicLineConfig mlc) {
-            super(line);
-            String b = mlc.getString(new String[]{"region", "r"}, "");
-            regions.addAll(Arrays.asList(b.split(",")));
-        }
-
-        @Override
-        public boolean check(AbstractLocation target) {
-            var access = IrisToolbelt.access(((BukkitWorld) target.getWorld()).getBukkitWorld());
-            if (access == null) return false;
-            var engine = access.getEngine();
-            if (engine == null) return false;
-            var region = engine.getRegion(target.getBlockX(), target.getBlockZ());
-            return regions.contains(region.getLoadKey());
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/link/data/NexoDataProvider.java

@@ -1,140 +0,0 @@
-package com.volmit.iris.core.link.data;
-
-import com.nexomc.nexo.api.NexoBlocks;
-import com.nexomc.nexo.api.NexoFurniture;
-import com.nexomc.nexo.api.NexoItems;
-import com.nexomc.nexo.items.ItemBuilder;
-import com.volmit.iris.core.link.ExternalDataProvider;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.nms.container.BlockProperty;
-import com.volmit.iris.core.service.ExternalDataSVC;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.data.B;
-import com.volmit.iris.util.data.IrisCustomData;
-import org.bukkit.Color;
-import org.bukkit.block.Block;
-import org.bukkit.block.data.BlockData;
-import org.bukkit.entity.ItemDisplay;
-import org.bukkit.inventory.ItemStack;
-import org.bukkit.inventory.meta.LeatherArmorMeta;
-import org.bukkit.inventory.meta.MapMeta;
-import org.bukkit.inventory.meta.PotionMeta;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.Collection;
-import java.util.List;
-import java.util.MissingResourceException;
-
-public class NexoDataProvider extends ExternalDataProvider {
-    public NexoDataProvider() {
-        super("Nexo");
-    }
-
-    @Override
-    public void init() {
-    }
-
-    @NotNull
-    @Override
-    public BlockData getBlockData(@NotNull Identifier blockId, @NotNull KMap<String, String> state) throws MissingResourceException {
-        if (!NexoItems.exists(blockId.key())) {
-            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-        }
-
-        Identifier blockState = ExternalDataSVC.buildState(blockId, state);
-        if (NexoBlocks.isCustomBlock(blockId.key())) {
-            BlockData data = NexoBlocks.blockData(blockId.key());
-            if (data == null)
-                throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-            return IrisCustomData.of(data, blockState);
-        } else if (NexoFurniture.isFurniture(blockId.key())) {
-            return IrisCustomData.of(B.getAir(), blockState);
-        }
-
-        throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-    }
-
-    @Override
-    public @NotNull List<BlockProperty> getBlockProperties(@NotNull Identifier blockId) throws MissingResourceException {
-        if (!NexoItems.exists(blockId.key())) {
-            throw new MissingResourceException("Failed to find BlockData!", blockId.namespace(), blockId.key());
-        }
-
-        return NexoFurniture.isFurniture(blockId.key()) ? YAW_FACE_BIOME_PROPERTIES : List.of();
-    }
-
-    @NotNull
-    @Override
-    public ItemStack getItemStack(@NotNull Identifier itemId, @NotNull KMap<String, Object> customNbt) throws MissingResourceException {
-        ItemBuilder builder = NexoItems.itemFromId(itemId.key());
-        if (builder == null) {
-            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        }
-        try {
-            return builder.build();
-        } catch (Exception e) {
-            e.printStackTrace();
-            throw new MissingResourceException("Failed to find ItemData!", itemId.namespace(), itemId.key());
-        }
-    }
-
-    @Override
-    public void processUpdate(@NotNull Engine engine, @NotNull Block block, @NotNull Identifier blockId) {
-        var statePair = ExternalDataSVC.parseState(blockId);
-        var state = statePair.getB();
-        blockId = statePair.getA();
-
-        if (NexoBlocks.isCustomBlock(blockId.key())) {
-            NexoBlocks.place(blockId.key(), block.getLocation());
-            return;
-        }
-
-        if (!NexoFurniture.isFurniture(blockId.key()))
-            return;
-
-        var pair = parseYawAndFace(engine, block, state);
-        ItemDisplay display = NexoFurniture.place(blockId.key(), block.getLocation(), pair.getA(), pair.getB());
-        if (display == null) return;
-        ItemStack itemStack = display.getItemStack();
-        if (itemStack == null) return;
-
-        BiomeColor type = null;
-        try {
-            type = BiomeColor.valueOf(state.get("matchBiome").toUpperCase());
-        } catch (NullPointerException | IllegalArgumentException ignored) {}
-
-        if (type != null) {
-            var biomeColor = INMS.get().getBiomeColor(block.getLocation(), type);
-            if (biomeColor == null) return;
-            var potionColor = Color.fromARGB(biomeColor.getAlpha(), biomeColor.getRed(), biomeColor.getGreen(), biomeColor.getBlue());
-            var meta = itemStack.getItemMeta();
-            switch (meta) {
-                case LeatherArmorMeta armor -> armor.setColor(potionColor);
-                case PotionMeta potion -> potion.setColor(potionColor);
-                case MapMeta map -> map.setColor(potionColor);
-                case null, default -> {}
-            }
-            itemStack.setItemMeta(meta);
-        }
-        display.setItemStack(itemStack);
-    }
-
-    @Override
-    public @NotNull Collection<@NotNull Identifier> getTypes(@NotNull DataType dataType) {
-        if (dataType == DataType.ENTITY) return List.of();
-        return NexoItems.itemNames()
-                .stream()
-                .map(i -> new Identifier("nexo", i))
-                .filter(dataType.asPredicate(this))
-                .toList();
-    }
-
-    @Override
-    public boolean isValidProvider(@NotNull Identifier id, DataType dataType) {
-        if (dataType == DataType.ENTITY) return false;
-        return "nexo".equalsIgnoreCase(id.namespace());
-    }
-}

core/src/main/java/com/volmit/iris/core/loader/ImageResourceLoader.java

@@ -1,166 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.loader;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.engine.object.IrisImage;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.data.KCache;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-
-import javax.imageio.ImageIO;
-import java.awt.image.BufferedImage;
-import java.io.File;
-import java.util.Set;
-
-public class ImageResourceLoader extends ResourceLoader<IrisImage> {
-    public ImageResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
-        super(root, idm, folderName, resourceTypeName, IrisImage.class);
-        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getObjectLoaderCacheSize());
-    }
-
-    public boolean supportsSchemas() {
-        return false;
-    }
-
-    public long getSize() {
-        return loadCache.getSize();
-    }
-
-    public long getTotalStorage() {
-        return getSize();
-    }
-
-    protected IrisImage loadFile(File j, String name) {
-        try {
-            PrecisionStopwatch p = PrecisionStopwatch.start();
-            BufferedImage bu = ImageIO.read(j);
-            IrisImage img = new IrisImage(bu);
-            img.setLoadFile(j);
-            img.setLoader(manager);
-            img.setLoadKey(name);
-            logLoad(j, img);
-            tlt.addAndGet(p.getMilliseconds());
-            return img;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
-            return null;
-        }
-    }
-
-    void getPNGFiles(File directory, Set<String> m) {
-        for (File file : directory.listFiles()) {
-            if (file.isFile() && file.getName().endsWith(".png")) {
-                m.add(file.getName().replaceAll("\\Q.png\\E", ""));
-            } else if (file.isDirectory()) {
-                getPNGFiles(file, m);
-            }
-        }
-    }
-
-
-    public String[] getPossibleKeys() {
-        if (possibleKeys != null) {
-            return possibleKeys;
-        }
-
-        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
-        KSet<String> m = new KSet<>();
-
-
-        for (File i : getFolders()) {
-            getPNGFiles(i, m);
-        }
-
-//        for (File i : getFolders()) {
-//            for (File j : i.listFiles()) {
-//                if (j.isFile() && j.getName().endsWith(".png")) {
-//                    m.add(j.getName().replaceAll("\\Q.png\\E", ""));
-//                } else if (j.isDirectory()) {
-//                    for (File k : j.listFiles()) {
-//                        if (k.isFile() && k.getName().endsWith(".png")) {
-//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.png\\E", ""));
-//                        } else if (k.isDirectory()) {
-//                            for (File l : k.listFiles()) {
-//                                if (l.isFile() && l.getName().endsWith(".png")) {
-//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.png\\E", ""));
-//                                }
-//                            }
-//                        }
-//                    }
-//                }
-//            }
-//        }
-
-        KList<String> v = new KList<>(m);
-        possibleKeys = v.toArray(new String[0]);
-        return possibleKeys;
-    }
-
-    public File findFile(String name) {
-        for (File i : getFolders(name)) {
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
-                    return j;
-                }
-            }
-
-            File file = new File(i, name + ".png");
-
-            if (file.exists()) {
-                return file;
-            }
-        }
-
-        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
-
-        return null;
-    }
-
-    public IrisImage load(String name) {
-        return load(name, true);
-    }
-
-    private IrisImage loadRaw(String name) {
-        for (File i : getFolders(name)) {
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".png") && j.getName().split("\\Q.\\E")[0].equals(name)) {
-                    return loadFile(j, name);
-                }
-            }
-
-            File file = new File(i, name + ".png");
-
-            if (file.exists()) {
-                return loadFile(file, name);
-            }
-        }
-
-        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
-
-        return null;
-    }
-
-    public IrisImage load(String name, boolean warn) {
-        return loadCache.get(name);
-    }
-}

core/src/main/java/com/volmit/iris/core/loader/IrisData.java

@@ -1,593 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.loader;
-
-import com.google.gson.*;
-import com.google.gson.reflect.TypeToken;
-import com.google.gson.stream.JsonReader;
-import com.google.gson.stream.JsonToken;
-import com.google.gson.stream.JsonWriter;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.scripting.environment.PackEnvironment;
-import com.volmit.iris.engine.data.cache.AtomicCache;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.*;
-import com.volmit.iris.engine.object.annotations.Snippet;
-import com.volmit.iris.engine.object.matter.IrisMatterObject;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.context.IrisContext;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.mantle.flag.MantleFlagAdapter;
-import com.volmit.iris.util.mantle.flag.MantleFlag;
-import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.parallel.BurstExecutor;
-import com.volmit.iris.util.parallel.MultiBurst;
-import com.volmit.iris.util.reflect.KeyedType;
-import com.volmit.iris.util.scheduling.ChronoLatch;
-import com.volmit.iris.util.scheduling.J;
-import lombok.Data;
-import org.jetbrains.annotations.Nullable;
-
-import java.io.File;
-import java.io.FileReader;
-import java.io.IOException;
-import java.nio.file.Files;
-import java.nio.file.Path;
-import java.util.*;
-
-@Data
-public class IrisData implements ExclusionStrategy, TypeAdapterFactory {
-    private static final KMap<File, IrisData> dataLoaders = new KMap<>();
-    private final File dataFolder;
-    private final int id;
-    private boolean closed = false;
-    private PackEnvironment environment;
-    private ResourceLoader<IrisBiome> biomeLoader;
-    private ResourceLoader<IrisLootTable> lootLoader;
-    private ResourceLoader<IrisRegion> regionLoader;
-    private ResourceLoader<IrisDimension> dimensionLoader;
-    private ResourceLoader<IrisGenerator> generatorLoader;
-    private ResourceLoader<IrisJigsawPiece> jigsawPieceLoader;
-    private ResourceLoader<IrisJigsawPool> jigsawPoolLoader;
-    private ResourceLoader<IrisJigsawStructure> jigsawStructureLoader;
-    private ResourceLoader<IrisEntity> entityLoader;
-    private ResourceLoader<IrisMarker> markerLoader;
-    private ResourceLoader<IrisSpawner> spawnerLoader;
-    private ResourceLoader<IrisMod> modLoader;
-    private ResourceLoader<IrisBlockData> blockLoader;
-    private ResourceLoader<IrisExpression> expressionLoader;
-    private ResourceLoader<IrisObject> objectLoader;
-    private ResourceLoader<IrisMatterObject> matterLoader;
-    private ResourceLoader<IrisImage> imageLoader;
-    private ResourceLoader<IrisScript> scriptLoader;
-    private ResourceLoader<IrisCave> caveLoader;
-    private ResourceLoader<IrisRavine> ravineLoader;
-    private ResourceLoader<IrisMatterObject> matterObjectLoader;
-    private KMap<String, KList<String>> possibleSnippets;
-    private Gson gson;
-    private Gson snippetLoader;
-    private GsonBuilder builder;
-    private KMap<Class<? extends IrisRegistrant>, ResourceLoader<? extends IrisRegistrant>> loaders = new KMap<>();
-    private Engine engine;
-
-    private IrisData(File dataFolder) {
-        this.engine = null;
-        this.dataFolder = dataFolder;
-        this.id = RNG.r.imax();
-        hotloaded();
-    }
-
-    public static IrisData get(File dataFolder) {
-        return dataLoaders.computeIfAbsent(dataFolder, IrisData::new);
-    }
-
-    public static Optional<IrisData> getLoaded(File dataFolder) {
-        return Optional.ofNullable(dataLoaders.get(dataFolder));
-    }
-
-    public static void dereference() {
-        dataLoaders.v().forEach(IrisData::cleanupEngine);
-    }
-
-    public static int cacheSize() {
-        int m = 0;
-        for (IrisData i : dataLoaders.values()) {
-            for (ResourceLoader<?> j : i.getLoaders().values()) {
-                m += j.getLoadCache().getSize();
-            }
-        }
-
-        return m;
-    }
-
-    private static void printData(ResourceLoader<?> rl) {
-        Iris.warn("  " + rl.getResourceTypeName() + " @ /" + rl.getFolderName() + ": Cache=" + rl.getLoadCache().getSize() + " Folders=" + rl.getFolders().size());
-    }
-
-    public static IrisObject loadAnyObject(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisObject.class, key, nearest);
-    }
-
-    public static IrisMatterObject loadAnyMatter(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisMatterObject.class, key, nearest);
-    }
-
-    public static IrisBiome loadAnyBiome(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisBiome.class, key, nearest);
-    }
-
-    public static IrisExpression loadAnyExpression(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisExpression.class, key, nearest);
-    }
-
-    public static IrisMod loadAnyMod(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisMod.class, key, nearest);
-    }
-
-    public static IrisJigsawPiece loadAnyJigsawPiece(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisJigsawPiece.class, key, nearest);
-    }
-
-    public static IrisJigsawPool loadAnyJigsawPool(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisJigsawPool.class, key, nearest);
-    }
-
-    public static IrisEntity loadAnyEntity(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisEntity.class, key, nearest);
-    }
-
-    public static IrisLootTable loadAnyLootTable(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisLootTable.class, key, nearest);
-    }
-
-    public static IrisBlockData loadAnyBlock(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisBlockData.class, key, nearest);
-    }
-
-    public static IrisSpawner loadAnySpaner(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisSpawner.class, key, nearest);
-    }
-
-    public static IrisScript loadAnyScript(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisScript.class, key, nearest);
-    }
-
-    public static IrisRavine loadAnyRavine(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisRavine.class, key, nearest);
-    }
-
-    public static IrisRegion loadAnyRegion(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisRegion.class, key, nearest);
-    }
-
-    public static IrisMarker loadAnyMarker(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisMarker.class, key, nearest);
-    }
-
-    public static IrisCave loadAnyCave(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisCave.class, key, nearest);
-    }
-
-    public static IrisImage loadAnyImage(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisImage.class, key, nearest);
-    }
-
-    public static IrisDimension loadAnyDimension(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisDimension.class, key, nearest);
-    }
-
-    public static IrisJigsawStructure loadAnyJigsawStructure(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisJigsawStructure.class, key, nearest);
-    }
-
-    public static IrisGenerator loadAnyGenerator(String key, @Nullable IrisData nearest) {
-        return loadAny(IrisGenerator.class, key, nearest);
-    }
-
-    public static <T extends IrisRegistrant> T loadAny(Class<T> type, String key, @Nullable IrisData nearest) {
-        try {
-            if (nearest != null) {
-                T t = nearest.load(type, key, false);
-                if (t != null) {
-                    return t;
-                }
-            }
-
-            for (File i : Objects.requireNonNull(Iris.instance.getDataFolder("packs").listFiles())) {
-                if (i.isDirectory()) {
-                    IrisData dm = get(i);
-                    if (dm == nearest) continue;
-                    T t = dm.load(type, key, false);
-
-                    if (t != null) {
-                        return t;
-                    }
-                }
-            }
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-
-        return null;
-    }
-
-    public <T extends IrisRegistrant> T load(Class<T> type, String key, boolean warn) {
-        var loader = getLoader(type);
-        if (loader == null) return null;
-        return loader.load(key, warn);
-    }
-
-    @SuppressWarnings("unchecked")
-    public <T extends IrisRegistrant> ResourceLoader<T> getLoader(Class<T> type) {
-        return (ResourceLoader<T>) loaders.get(type);
-    }
-
-    public ResourceLoader<?> getTypedLoaderFor(File f) {
-        String[] k = f.getPath().split("\\Q" + File.separator + "\\E");
-
-        for (String i : k) {
-            for (ResourceLoader<?> j : loaders.values()) {
-                if (j.getFolderName().equals(i)) {
-                    return j;
-                }
-            }
-        }
-
-        return null;
-    }
-
-    public void cleanupEngine() {
-        if (engine != null && engine.isClosed()) {
-            engine = null;
-            Iris.debug("Dereferenced Data<Engine> " + getId() + " " + getDataFolder());
-        }
-    }
-
-    public void preprocessObject(IrisRegistrant t) {
-        try {
-            IrisContext ctx = IrisContext.get();
-            Engine engine = this.engine;
-
-            if (engine == null && ctx != null && ctx.getEngine() != null) {
-                engine = ctx.getEngine();
-            }
-
-            if (engine == null && t.getPreprocessors().isNotEmpty()) {
-                Iris.error("Failed to preprocess object " + t.getLoadKey() + " because there is no engine context here. (See stack below)");
-                try {
-                    throw new RuntimeException();
-                } catch (Throwable ex) {
-                    ex.printStackTrace();
-                }
-            }
-
-            if (engine == null) return;
-            var global = engine.getDimension().getPreProcessors(t.getFolderName());
-            var local = t.getPreprocessors();
-            if ((global != null && global.isNotEmpty()) || local.isNotEmpty()) {
-                synchronized (this) {
-                    if (global != null) {
-                        for (String i : global) {
-                            engine.getExecution().preprocessObject(i, t);
-                            Iris.debug("Loader<" + C.GREEN + t.getTypeName() + C.LIGHT_PURPLE + "> iprocess " + C.YELLOW + t.getLoadKey() + C.LIGHT_PURPLE + " in <rainbow>" + i);
-                        }
-                    }
-
-                    for (String i : local) {
-                        engine.getExecution().preprocessObject(i, t);
-                        Iris.debug("Loader<" + C.GREEN + t.getTypeName() + C.LIGHT_PURPLE + "> iprocess " + C.YELLOW + t.getLoadKey() + C.LIGHT_PURPLE + " in <rainbow>" + i);
-                    }
-                }
-            }
-        } catch (Throwable e) {
-            Iris.error("Failed to preprocess object!");
-            e.printStackTrace();
-        }
-    }
-
-    public void close() {
-        closed = true;
-        dump();
-        dataLoaders.remove(dataFolder);
-    }
-
-    public IrisData copy() {
-        return IrisData.get(dataFolder);
-    }
-
-    private <T extends IrisRegistrant> ResourceLoader<T> registerLoader(Class<T> registrant) {
-        try {
-            IrisRegistrant rr = registrant.getConstructor().newInstance();
-            ResourceLoader<T> r = null;
-            if (registrant.equals(IrisObject.class)) {
-                r = (ResourceLoader<T>) new ObjectResourceLoader(dataFolder, this, rr.getFolderName(),
-                        rr.getTypeName());
-            } else if (registrant.equals(IrisMatterObject.class)) {
-                r = (ResourceLoader<T>) new MatterObjectResourceLoader(dataFolder, this, rr.getFolderName(),
-                        rr.getTypeName());
-            } else if (registrant.equals(IrisScript.class)) {
-                r = (ResourceLoader<T>) new ScriptResourceLoader(dataFolder, this, rr.getFolderName(),
-                        rr.getTypeName());
-            } else if (registrant.equals(IrisImage.class)) {
-                r = (ResourceLoader<T>) new ImageResourceLoader(dataFolder, this, rr.getFolderName(),
-                        rr.getTypeName());
-            } else {
-                J.attempt(() -> registrant.getConstructor().newInstance().registerTypeAdapters(builder));
-                r = new ResourceLoader<>(dataFolder, this, rr.getFolderName(), rr.getTypeName(), registrant);
-            }
-
-            loaders.put(registrant, r);
-
-            return r;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-            Iris.error("Failed to create loader! " + registrant.getCanonicalName());
-        }
-
-        return null;
-    }
-
-    public synchronized void hotloaded() {
-        closed = false;
-        possibleSnippets = new KMap<>();
-        builder = new GsonBuilder()
-                .addDeserializationExclusionStrategy(this)
-                .addSerializationExclusionStrategy(this)
-                .setLenient()
-                .registerTypeAdapterFactory(this)
-                .registerTypeAdapter(MantleFlag.class, new MantleFlagAdapter())
-                .setPrettyPrinting();
-        loaders.clear();
-        File packs = dataFolder;
-        packs.mkdirs();
-        this.lootLoader = registerLoader(IrisLootTable.class);
-        this.spawnerLoader = registerLoader(IrisSpawner.class);
-        this.entityLoader = registerLoader(IrisEntity.class);
-        this.regionLoader = registerLoader(IrisRegion.class);
-        this.biomeLoader = registerLoader(IrisBiome.class);
-        this.modLoader = registerLoader(IrisMod.class);
-        this.dimensionLoader = registerLoader(IrisDimension.class);
-        this.jigsawPoolLoader = registerLoader(IrisJigsawPool.class);
-        this.jigsawStructureLoader = registerLoader(IrisJigsawStructure.class);
-        this.jigsawPieceLoader = registerLoader(IrisJigsawPiece.class);
-        this.generatorLoader = registerLoader(IrisGenerator.class);
-        this.caveLoader = registerLoader(IrisCave.class);
-        this.markerLoader = registerLoader(IrisMarker.class);
-        this.ravineLoader = registerLoader(IrisRavine.class);
-        this.blockLoader = registerLoader(IrisBlockData.class);
-        this.expressionLoader = registerLoader(IrisExpression.class);
-        this.objectLoader = registerLoader(IrisObject.class);
-        this.imageLoader = registerLoader(IrisImage.class);
-        this.scriptLoader = registerLoader(IrisScript.class);
-        this.matterObjectLoader = registerLoader(IrisMatterObject.class);
-        this.environment = PackEnvironment.create(this);
-        builder.registerTypeAdapterFactory(KeyedType::createTypeAdapter);
-
-        gson = builder.create();
-        dimensionLoader.streamAll()
-                .map(IrisDimension::getDataScripts)
-                .flatMap(KList::stream)
-                .forEach(environment::execute);
-
-        if (engine != null) {
-            engine.hotload();
-        }
-    }
-
-    public void dump() {
-        for (ResourceLoader<?> i : loaders.values()) {
-            i.clearCache();
-        }
-    }
-
-    public void clearLists() {
-        for (ResourceLoader<?> i : loaders.values()) {
-            i.clearList();
-        }
-        possibleSnippets.clear();
-    }
-
-    public Set<Class<?>> resolveSnippets() {
-        var result = new HashSet<Class<?>>();
-        var processed = new HashSet<Class<?>>();
-        var excluder = gson.excluder();
-
-        var queue = new LinkedList<Class<?>>(loaders.keySet());
-        while (!queue.isEmpty()) {
-            var type = queue.poll();
-            if (excluder.excludeClass(type, false) || !processed.add(type))
-                continue;
-            if (type.isAnnotationPresent(Snippet.class))
-                result.add(type);
-
-            try {
-                for (var field : type.getDeclaredFields()) {
-                    if (excluder.excludeField(field, false))
-                        continue;
-
-                    queue.add(field.getType());
-                }
-            } catch (Throwable ignored) {
-            }
-        }
-
-        return result;
-    }
-
-    public String toLoadKey(File f) {
-        if (f.getPath().startsWith(getDataFolder().getPath())) {
-            String[] full = f.getPath().split("\\Q" + File.separator + "\\E");
-            String[] df = getDataFolder().getPath().split("\\Q" + File.separator + "\\E");
-            StringBuilder g = new StringBuilder();
-            boolean m = true;
-            for (int i = 0; i < full.length; i++) {
-                if (i >= df.length) {
-                    if (m) {
-                        m = false;
-                        continue;
-                    }
-
-                    g.append("/").append(full[i]);
-                }
-            }
-
-            return g.substring(1).split("\\Q.\\E")[0];
-        } else {
-            Iris.error("Forign file from loader " + f.getPath() + " (loader realm: " + getDataFolder().getPath() + ")");
-        }
-
-        Iris.error("Failed to load " + f.getPath() + " (loader realm: " + getDataFolder().getPath() + ")");
-
-        return null;
-    }
-
-    @Override
-    public boolean shouldSkipField(FieldAttributes f) {
-        return false;
-    }
-
-    @Override
-    public boolean shouldSkipClass(Class<?> c) {
-        if (c.equals(AtomicCache.class)) {
-            return true;
-        } else return c.equals(ChronoLatch.class);
-    }
-
-    @Override
-    public <T> TypeAdapter<T> create(Gson gson, TypeToken<T> typeToken) {
-        if (!typeToken.getRawType().isAnnotationPresent(Snippet.class)) {
-            return null;
-        }
-
-        String snippetType = typeToken.getRawType().getDeclaredAnnotation(Snippet.class).value();
-        String snippedBase = "snippet/" + snippetType + "/";
-
-        return new TypeAdapter<>() {
-            @Override
-            public void write(JsonWriter jsonWriter, T t) throws IOException {
-                gson.getDelegateAdapter(IrisData.this, typeToken).write(jsonWriter, t);
-            }
-
-            @Override
-            public T read(JsonReader reader) throws IOException {
-                TypeAdapter<T> adapter = gson.getDelegateAdapter(IrisData.this, typeToken);
-
-                if (reader.peek().equals(JsonToken.STRING)) {
-                    String r = reader.nextString();
-                    if (!r.startsWith("snippet/"))
-                        return null;
-                    if (!r.startsWith(snippedBase))
-                        r = snippedBase + r.substring(8);
-
-                    File f = new File(getDataFolder(), r + ".json");
-                    if (f.exists()) {
-                        try (JsonReader snippetReader = new JsonReader(new FileReader(f))){
-                            return adapter.read(snippetReader);
-                        } catch (Throwable e) {
-                            Iris.error("Couldn't read snippet " + r + " in " + reader.getPath() + " (" + e.getMessage() + ")");
-                        }
-                    } else {
-                        Iris.error("Couldn't find snippet " + r + " in " + reader.getPath());
-                    }
-
-                    return null;
-                }
-
-                try {
-                    return adapter.read(reader);
-                } catch (Throwable e) {
-                    Iris.error("Failed to read " + typeToken.getRawType().getCanonicalName() + "... faking objects a little to load the file at least.");
-                    Iris.reportError(e);
-                    try {
-                        return (T) typeToken.getRawType().getConstructor().newInstance();
-                    } catch (Throwable ignored) {
-
-                    }
-                }
-                return null;
-            }
-        };
-    }
-
-    public KList<String> getPossibleSnippets(String f) {
-        return possibleSnippets.computeIfAbsent(f, (k) -> {
-            KList<String> l = new KList<>();
-
-            File snippetFolder = new File(getDataFolder(), "snippet/" + f);
-            if (!snippetFolder.exists()) return l;
-
-            String absPath = snippetFolder.getAbsolutePath();
-            try (var stream = Files.walk(snippetFolder.toPath())) {
-                stream.filter(Files::isRegularFile)
-                        .map(Path::toAbsolutePath)
-                        .map(Path::toString)
-                        .filter(s -> s.endsWith(".json"))
-                        .map(s -> s.substring(absPath.length() + 1))
-                        .map(s -> s.replace("\\", "/"))
-                        .map(s -> s.split("\\Q.\\E")[0])
-                        .forEach(s -> l.add("snippet/" + s));
-            } catch (Throwable e) {
-                e.printStackTrace();
-            }
-
-            return l;
-        });
-    }
-
-    public boolean isClosed() {
-        return closed;
-    }
-
-    public void savePrefetch(Engine engine) {
-        BurstExecutor b = MultiBurst.ioBurst.burst(loaders.size());
-
-        for (ResourceLoader<?> i : loaders.values()) {
-            b.queue(() -> {
-                try {
-                    i.saveFirstAccess(engine);
-                } catch (IOException e) {
-                    throw new RuntimeException(e);
-                }
-            });
-        }
-
-        b.complete();
-        Iris.info("Saved Prefetch Cache to speed up future world startups");
-    }
-
-    public void loadPrefetch(Engine engine) {
-        BurstExecutor b = MultiBurst.ioBurst.burst(loaders.size());
-
-        for (ResourceLoader<?> i : loaders.values()) {
-            b.queue(() -> {
-                try {
-                    i.loadFirstAccess(engine);
-                } catch (IOException e) {
-                    throw new RuntimeException(e);
-                }
-            });
-        }
-
-        b.complete();
-        Iris.info("Loaded Prefetch Cache to reduce generation disk use.");
-    }
-}

core/src/main/java/com/volmit/iris/core/loader/IrisRegistrant.java

@@ -1,69 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.loader;
-
-import com.google.gson.GsonBuilder;
-import com.volmit.iris.Iris;
-import com.volmit.iris.engine.object.IrisScript;
-import com.volmit.iris.engine.object.annotations.ArrayType;
-import com.volmit.iris.engine.object.annotations.Desc;
-import com.volmit.iris.engine.object.annotations.RegistryListResource;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.json.JSONObject;
-import com.volmit.iris.util.plugin.VolmitSender;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-
-import java.awt.*;
-import java.io.File;
-
-@Data
-public abstract class IrisRegistrant {
-    @Desc("Preprocess this object in-memory when it's loaded, run scripts using the variable 'object' and modify properties about this object before it's used.\nFile extension: .proc.kts")
-    @RegistryListResource(IrisScript.class)
-    @ArrayType(min = 1, type = String.class)
-    private KList<String> preprocessors = new KList<>();
-
-    @EqualsAndHashCode.Exclude
-    private transient IrisData loader;
-
-    private transient String loadKey;
-
-    private transient File loadFile;
-
-    public abstract String getFolderName();
-
-    public abstract String getTypeName();
-
-    public void registerTypeAdapters(GsonBuilder builder) {
-
-    }
-
-    public File openInVSCode() {
-        try {
-            Desktop.getDesktop().open(getLoadFile());
-        } catch (Throwable e) {
-            Iris.reportError(e);
-        }
-
-        return getLoadFile();
-    }
-
-    public abstract void scanForErrors(JSONObject p, VolmitSender sender);
-}

core/src/main/java/com/volmit/iris/core/loader/MatterObjectResourceLoader.java

@@ -1,176 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.loader;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.engine.object.matter.IrisMatterObject;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.data.KCache;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-
-import java.io.File;
-
-public class MatterObjectResourceLoader extends ResourceLoader<IrisMatterObject> {
-    private String[] possibleKeys;
-
-    public MatterObjectResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
-        super(root, idm, folderName, resourceTypeName, IrisMatterObject.class);
-        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getObjectLoaderCacheSize());
-    }
-
-    public boolean supportsSchemas() {
-        return false;
-    }
-
-    public long getSize() {
-        return loadCache.getSize();
-    }
-
-    public long getTotalStorage() {
-        return getSize();
-    }
-
-    protected IrisMatterObject loadFile(File j, String name) {
-        try {
-            PrecisionStopwatch p = PrecisionStopwatch.start();
-            IrisMatterObject t = IrisMatterObject.from(j);
-            t.setLoadKey(name);
-            t.setLoader(manager);
-            t.setLoadFile(j);
-            logLoad(j, t);
-            tlt.addAndGet(p.getMilliseconds());
-            return t;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
-            return null;
-        }
-    }
-
-    private void findMatFiles(File dir, KSet<String> m) {
-        for (File file : dir.listFiles()) {
-            if (file.isFile() && file.getName().endsWith(".mat")) {
-                m.add(file.getName().replaceAll("\\Q.mat\\E", ""));
-            } else if (file.isDirectory()) {
-                findMatFiles(file, m);
-            }
-        }
-    }
-
-    public String[] getPossibleKeys() {
-        if (possibleKeys != null) {
-            return possibleKeys;
-        }
-
-        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
-        KSet<String> m = new KSet<>();
-
-        for (File folder : getFolders()) {
-            findMatFiles(folder, m);
-        }
-
-        KList<String> v = new KList<>(m);
-        possibleKeys = v.toArray(new String[0]);
-        return possibleKeys;
-    }
-
-
-//    public String[] getPossibleKeys() {
-//        if (possibleKeys != null) {
-//            return possibleKeys;
-//        }
-//
-//        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
-//        KSet<String> m = new KSet<>();
-//
-//        for (File i : getFolders()) {
-//            for (File j : i.listFiles()) {
-//                if (j.isFile() && j.getName().endsWith(".mat")) {
-//                    m.add(j.getName().replaceAll("\\Q.mat\\E", ""));
-//                } else if (j.isDirectory()) {
-//                    for (File k : j.listFiles()) {
-//                        if (k.isFile() && k.getName().endsWith(".mat")) {
-//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.mat\\E", ""));
-//                        } else if (k.isDirectory()) {
-//                            for (File l : k.listFiles()) {
-//                                if (l.isFile() && l.getName().endsWith(".mat")) {
-//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.mat\\E", ""));
-//                                }
-//                            }
-//                        }
-//                    }
-//                }
-//            }
-//        }
-//
-//        KList<String> v = new KList<>(m);
-//        possibleKeys = v.toArray(new String[0]);
-//        return possibleKeys;
-//    }
-
-    public File findFile(String name) {
-        for (File i : getFolders(name)) {
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".mat") && j.getName().split("\\Q.\\E")[0].equals(name)) {
-                    return j;
-                }
-            }
-
-            File file = new File(i, name + ".mat");
-
-            if (file.exists()) {
-                return file;
-            }
-        }
-
-        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
-
-        return null;
-    }
-
-    public IrisMatterObject load(String name) {
-        return load(name, true);
-    }
-
-    private IrisMatterObject loadRaw(String name) {
-        for (File i : getFolders(name)) {
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".mat") && j.getName().split("\\Q.\\E")[0].equals(name)) {
-                    return loadFile(j, name);
-                }
-            }
-
-            File file = new File(i, name + ".mat");
-
-            if (file.exists()) {
-                return loadFile(file, name);
-            }
-        }
-
-        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
-
-        return null;
-    }
-
-    public IrisMatterObject load(String name, boolean warn) {
-        return loadCache.get(name);
-    }
-}

core/src/main/java/com/volmit/iris/core/loader/ObjectResourceLoader.java

@@ -1,140 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.loader;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.engine.object.IrisObject;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.data.KCache;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-
-import java.io.File;
-
-public class ObjectResourceLoader extends ResourceLoader<IrisObject> {
-    public ObjectResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
-        super(root, idm, folderName, resourceTypeName, IrisObject.class);
-        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getObjectLoaderCacheSize());
-    }
-
-    public boolean supportsSchemas() {
-        return false;
-    }
-
-    public long getSize() {
-        return loadCache.getSize();
-    }
-
-    public long getTotalStorage() {
-        return getSize();
-    }
-
-    protected IrisObject loadFile(File j, String name) {
-        try {
-            PrecisionStopwatch p = PrecisionStopwatch.start();
-            IrisObject t = new IrisObject(0, 0, 0);
-            t.setLoadKey(name);
-            t.setLoader(manager);
-            t.setLoadFile(j);
-            t.read(j);
-            logLoad(j, t);
-            tlt.addAndGet(p.getMilliseconds());
-            return t;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
-            return null;
-        }
-    }
-
-    public String[] getPossibleKeys() {
-        if (possibleKeys != null) {
-            return possibleKeys;
-        }
-        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
-        KSet<String> m = new KSet<>();
-        for (File i : getFolders()) {
-            m.addAll(getFiles(i, ".iob", true));
-        }
-        possibleKeys = m.toArray(new String[0]);
-        return possibleKeys;
-    }
-
-    private KList<String> getFiles(File dir, String ext, boolean skipDirName) {
-        KList<String> paths = new KList<>();
-        String name = skipDirName ? "" : dir.getName() + "/";
-        for (File f : dir.listFiles()) {
-            if (f.isFile() && f.getName().endsWith(ext)) {
-                paths.add(name + f.getName().replaceAll("\\Q" + ext + "\\E", ""));
-            } else if (f.isDirectory()) {
-                getFiles(f, ext, false).forEach(e -> paths.add(name + e));
-            }
-        }
-        return paths;
-    }
-
-    public File findFile(String name) {
-        for (File i : getFolders(name)) {
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
-                    return j;
-                }
-            }
-
-            File file = new File(i, name + ".iob");
-
-            if (file.exists()) {
-                return file;
-            }
-        }
-
-        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
-
-        return null;
-    }
-
-    public IrisObject load(String name) {
-        return load(name, true);
-    }
-
-    private IrisObject loadRaw(String name) {
-        for (File i : getFolders(name)) {
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".iob") && j.getName().split("\\Q.\\E")[0].equals(name)) {
-                    return loadFile(j, name);
-                }
-            }
-
-            File file = new File(i, name + ".iob");
-
-            if (file.exists()) {
-                return loadFile(file, name);
-            }
-        }
-
-        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
-
-        return null;
-    }
-
-    public IrisObject load(String name, boolean warn) {
-        return loadCache.get(name);
-    }
-}

core/src/main/java/com/volmit/iris/core/loader/ResourceLoader.java

@@ -1,482 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.loader;
-
-import com.google.common.util.concurrent.AtomicDouble;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.project.SchemaBuilder;
-import com.volmit.iris.core.service.PreservationSVC;
-import com.volmit.iris.engine.data.cache.AtomicCache;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.framework.MeteredCache;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KSet;
-import com.volmit.iris.util.data.KCache;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.io.CustomOutputStream;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.json.JSONArray;
-import com.volmit.iris.util.json.JSONObject;
-import com.volmit.iris.util.parallel.BurstExecutor;
-import com.volmit.iris.util.parallel.MultiBurst;
-import com.volmit.iris.util.scheduling.ChronoLatch;
-import com.volmit.iris.util.scheduling.J;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import lombok.Data;
-import lombok.EqualsAndHashCode;
-import lombok.ToString;
-
-import java.io.*;
-import java.util.Arrays;
-import java.util.HashSet;
-import java.util.Locale;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.function.Consumer;
-import java.util.function.Predicate;
-import java.util.stream.Stream;
-import java.util.zip.GZIPInputStream;
-import java.util.zip.GZIPOutputStream;
-
-@Data
-@EqualsAndHashCode(exclude = "manager")
-@ToString(exclude = "manager")
-public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
-    public static final AtomicDouble tlt = new AtomicDouble(0);
-    private static final int CACHE_SIZE = 100000;
-    protected final AtomicCache<KList<File>> folderCache;
-    protected KSet<String> firstAccess;
-    protected File root;
-    protected String folderName;
-    protected String resourceTypeName;
-    protected KCache<String, T> loadCache;
-    protected Class<? extends T> objectClass;
-    protected String cname;
-    protected String[] possibleKeys = null;
-    protected IrisData manager;
-    protected AtomicInteger loads;
-    protected ChronoLatch sec;
-
-    public ResourceLoader(File root, IrisData manager, String folderName, String resourceTypeName, Class<? extends T> objectClass) {
-        this.manager = manager;
-        firstAccess = new KSet<>();
-        folderCache = new AtomicCache<>();
-        sec = new ChronoLatch(5000);
-        loads = new AtomicInteger();
-        this.objectClass = objectClass;
-        cname = objectClass.getCanonicalName();
-        this.resourceTypeName = resourceTypeName;
-        this.root = root;
-        this.folderName = folderName;
-        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getResourceLoaderCacheSize());
-        Iris.debug("Loader<" + C.GREEN + resourceTypeName + C.LIGHT_PURPLE + "> created in " + C.RED + "IDM/" + manager.getId() + C.LIGHT_PURPLE + " on " + C.GRAY + manager.getDataFolder().getPath());
-        Iris.service(PreservationSVC.class).registerCache(this);
-    }
-
-    public JSONObject buildSchema() {
-        Iris.debug("Building Schema " + objectClass.getSimpleName() + " " + root.getPath());
-        JSONObject o = new JSONObject();
-        KList<String> fm = new KList<>();
-
-        for (int g = 1; g < 8; g++) {
-            fm.add("/" + folderName + Form.repeat("/*", g) + ".json");
-        }
-
-        o.put("fileMatch", new JSONArray(fm.toArray()));
-        o.put("url", "./.iris/schema/" + getFolderName() + "-schema.json");
-        File a = new File(getManager().getDataFolder(), ".iris/schema/" + getFolderName() + "-schema.json");
-        J.attemptAsync(() -> IO.writeAll(a, new SchemaBuilder(objectClass, manager).construct().toString(4)));
-
-        return o;
-    }
-
-    public File findFile(String name) {
-        for (File i : getFolders(name)) {
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
-                    return j;
-                }
-            }
-
-            File file = new File(i, name + ".json");
-
-            if (file.exists()) {
-                return file;
-            }
-        }
-
-        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
-
-        return null;
-    }
-
-    public void logLoad(File path, T t) {
-        loads.getAndIncrement();
-
-        if (loads.get() == 1) {
-            sec.flip();
-        }
-
-        if (sec.flip()) {
-            J.a(() -> {
-                Iris.verbose("Loaded " + C.WHITE + loads.get() + " " + resourceTypeName + (loads.get() == 1 ? "" : "s") + C.GRAY + " (" + Form.f(getLoadCache().getSize()) + " " + resourceTypeName + (loadCache.getSize() == 1 ? "" : "s") + " Loaded)");
-                loads.set(0);
-            });
-        }
-
-        Iris.debug("Loader<" + C.GREEN + resourceTypeName + C.LIGHT_PURPLE + "> iload " + C.YELLOW + t.getLoadKey() + C.LIGHT_PURPLE + " in " + C.GRAY + t.getLoadFile().getPath() + C.LIGHT_PURPLE + " TLT: " + C.RED + Form.duration(tlt.get(), 2));
-    }
-
-    public void failLoad(File path, Throwable e) {
-        J.a(() -> Iris.warn("Couldn't Load " + resourceTypeName + " file: " + path.getPath() + ": " + e.getMessage()));
-    }
-
-    private KList<File> matchAllFiles(File root, Predicate<File> f) {
-        KList<File> fx = new KList<>();
-        matchFiles(root, fx, f);
-        return fx;
-    }
-
-    private void matchFiles(File at, KList<File> files, Predicate<File> f) {
-        if (at.isDirectory()) {
-            for (File i : at.listFiles()) {
-                matchFiles(i, files, f);
-            }
-        } else {
-            if (f.test(at)) {
-                files.add(at);
-            }
-        }
-    }
-
-    public String[] getPossibleKeys() {
-        if (possibleKeys != null) {
-            return possibleKeys;
-        }
-
-        KList<File> files = getFolders();
-
-        if (files == null) {
-            possibleKeys = new String[0];
-            return possibleKeys;
-        }
-
-        HashSet<String> m = new HashSet<>();
-        for (File i : files) {
-            for (File j : matchAllFiles(i, (f) -> f.getName().endsWith(".json"))) {
-                m.add(i.toURI().relativize(j.toURI()).getPath().replaceAll("\\Q.json\\E", ""));
-            }
-        }
-
-        KList<String> v = new KList<>(m);
-        possibleKeys = v.toArray(new String[0]);
-        return possibleKeys;
-    }
-
-    public long count() {
-        return loadCache.getSize();
-    }
-
-    protected T loadFile(File j, String name) {
-        try {
-            PrecisionStopwatch p = PrecisionStopwatch.start();
-            T t = getManager().getGson()
-                    .fromJson(preprocess(new JSONObject(IO.readAll(j))).toString(0), objectClass);
-            t.setLoadKey(name);
-            t.setLoadFile(j);
-            t.setLoader(manager);
-            getManager().preprocessObject(t);
-            logLoad(j, t);
-            tlt.addAndGet(p.getMilliseconds());
-            return t;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            failLoad(j, e);
-            return null;
-        }
-    }
-
-    protected JSONObject preprocess(JSONObject j) {
-        return j;
-    }
-
-    public Stream<T> streamAll() {
-        return streamAll(Arrays.stream(getPossibleKeys()));
-    }
-
-    public Stream<T> streamAll(Stream<String> s) {
-        return s.map(this::load);
-    }
-
-    public KList<T> loadAll(KList<String> s) {
-        KList<T> m = new KList<>();
-
-        for (String i : s) {
-            T t = load(i);
-
-            if (t != null) {
-                m.add(t);
-            }
-        }
-
-        return m;
-    }
-
-    public KList<T> loadAllParallel(KList<String> s) {
-        KList<T> m = new KList<>();
-        BurstExecutor burst = MultiBurst.ioBurst.burst(s.size());
-
-        for (String i : s) {
-            burst.queue(() -> {
-                T t = load(i);
-                if (t == null)
-                    return;
-
-                synchronized (m) {
-                    m.add(t);
-                }
-            });
-        }
-
-        burst.complete();
-        return m;
-    }
-
-    public KList<T> loadAll(KList<String> s, Consumer<T> postLoad) {
-        KList<T> m = new KList<>();
-
-        for (String i : s) {
-            T t = load(i);
-
-            if (t != null) {
-                m.add(t);
-                postLoad.accept(t);
-            }
-        }
-
-        return m;
-    }
-
-    public KList<T> loadAll(String[] s) {
-        KList<T> m = new KList<>();
-
-        for (String i : s) {
-            T t = load(i);
-
-            if (t != null) {
-                m.add(t);
-            }
-        }
-
-        return m;
-    }
-
-    public T load(String name) {
-        return load(name, true);
-    }
-
-    private T loadRaw(String name) {
-        for (File i : getFolders(name)) {
-            //noinspection ConstantConditions
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(name)) {
-                    return loadFile(j, name);
-                }
-            }
-
-            File file = new File(i, name + ".json");
-
-            if (file.exists()) {
-                return loadFile(file, name);
-            }
-        }
-
-        return null;
-    }
-
-    public T load(String name, boolean warn) {
-        if (name == null) {
-            return null;
-        }
-
-        if (name.trim().isEmpty()) {
-            return null;
-        }
-
-        var set = firstAccess;
-        if (set != null) firstAccess.add(name);
-        return loadCache.get(name);
-    }
-
-    public void loadFirstAccess(Engine engine) throws IOException {
-        String id = "DIM" + Math.abs(engine.getSeedManager().getSeed() + engine.getDimension().getVersion() + engine.getDimension().getLoadKey().hashCode());
-        File file = Iris.instance.getDataFile("prefetch/" + id + "/" + Math.abs(getFolderName().hashCode()) + ".ipfch");
-
-        if (!file.exists()) {
-            return;
-        }
-
-        FileInputStream fin = new FileInputStream(file);
-        GZIPInputStream gzi = new GZIPInputStream(fin);
-        DataInputStream din = new DataInputStream(gzi);
-        int m = din.readInt();
-        KList<String> s = new KList<>();
-
-        for (int i = 0; i < m; i++) {
-            s.add(din.readUTF());
-        }
-
-        din.close();
-        Iris.info("Loading " + s.size() + " prefetch " + getFolderName());
-        firstAccess = null;
-        loadAllParallel(s);
-    }
-
-    public void saveFirstAccess(Engine engine) throws IOException {
-        if (firstAccess == null) return;
-        String id = "DIM" + Math.abs(engine.getSeedManager().getSeed() + engine.getDimension().getVersion() + engine.getDimension().getLoadKey().hashCode());
-        File file = Iris.instance.getDataFile("prefetch/" + id + "/" + Math.abs(getFolderName().hashCode()) + ".ipfch");
-        file.getParentFile().mkdirs();
-        FileOutputStream fos = new FileOutputStream(file);
-        GZIPOutputStream gzo = new CustomOutputStream(fos, 9);
-        DataOutputStream dos = new DataOutputStream(gzo);
-        var set = firstAccess;
-        firstAccess = null;
-        dos.writeInt(set.size());
-
-        for (String i : set) {
-            dos.writeUTF(i);
-        }
-
-        dos.flush();
-        dos.close();
-    }
-
-    public KList<File> getFolders() {
-        return folderCache.aquire(() -> {
-            KList<File> fc = new KList<>();
-
-            File[] files = root.listFiles();
-            if (files == null) {
-                throw new IllegalStateException("Failed to list files in " + root);
-            }
-
-            for (File i : files) {
-                if (i.isDirectory()) {
-                    if (i.getName().equals(folderName)) {
-                        fc.add(i);
-                        break;
-                    }
-                }
-            }
-            return fc;
-        });
-    }
-
-    public KList<File> getFolders(String rc) {
-        KList<File> folders = getFolders().copy();
-
-        if (rc.contains(":")) {
-            for (File i : folders.copy()) {
-                if (!rc.startsWith(i.getName() + ":")) {
-                    folders.remove(i);
-                }
-            }
-        }
-
-        return folders;
-    }
-
-    public void clearCache() {
-        possibleKeys = null;
-        loadCache.invalidate();
-        folderCache.reset();
-    }
-
-    public File fileFor(T b) {
-        for (File i : getFolders()) {
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".json") && j.getName().split("\\Q.\\E")[0].equals(b.getLoadKey())) {
-                    return j;
-                }
-            }
-
-            File file = new File(i, b.getLoadKey() + ".json");
-
-            if (file.exists()) {
-                return file;
-            }
-        }
-
-        return null;
-    }
-
-    public boolean isLoaded(String next) {
-        return loadCache.contains(next);
-    }
-
-    public void clearList() {
-        folderCache.reset();
-        possibleKeys = null;
-    }
-
-    public KList<String> getPossibleKeys(String arg) {
-        KList<String> f = new KList<>();
-
-        for (String i : getPossibleKeys()) {
-            if (i.equalsIgnoreCase(arg) || i.toLowerCase(Locale.ROOT).startsWith(arg.toLowerCase(Locale.ROOT)) || i.toLowerCase(Locale.ROOT).contains(arg.toLowerCase(Locale.ROOT)) || arg.toLowerCase(Locale.ROOT).contains(i.toLowerCase(Locale.ROOT))) {
-                f.add(i);
-            }
-        }
-
-        return f;
-    }
-
-    public boolean supportsSchemas() {
-        return true;
-    }
-
-    public void clean() {
-
-    }
-
-    public long getSize() {
-        return loadCache.getSize();
-    }
-
-    @Override
-    public KCache<?, ?> getRawCache() {
-        return loadCache;
-    }
-
-    @Override
-    public long getMaxSize() {
-        return loadCache.getMaxSize();
-    }
-
-    @Override
-    public boolean isClosed() {
-        return getManager().isClosed();
-    }
-
-    public long getTotalStorage() {
-        return getSize();
-    }
-}

core/src/main/java/com/volmit/iris/core/loader/ScriptResourceLoader.java

@@ -1,170 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.loader;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.engine.object.IrisScript;
-import com.volmit.iris.util.data.KCache;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-
-import java.io.File;
-import java.util.HashSet;
-import java.util.Set;
-
-public class ScriptResourceLoader extends ResourceLoader<IrisScript> {
-    public ScriptResourceLoader(File root, IrisData idm, String folderName, String resourceTypeName) {
-        super(root, idm, folderName, resourceTypeName, IrisScript.class);
-        loadCache = new KCache<>(this::loadRaw, IrisSettings.get().getPerformance().getScriptLoaderCacheSize());
-    }
-
-    public boolean supportsSchemas() {
-        return false;
-    }
-
-    public long getSize() {
-        return loadCache.getSize();
-    }
-
-    protected IrisScript loadFile(File j, String name) {
-        try {
-            PrecisionStopwatch p = PrecisionStopwatch.start();
-            IrisScript t = new IrisScript(IO.readAll(j));
-            t.setLoadKey(name);
-            t.setLoader(manager);
-            t.setLoadFile(j);
-            logLoad(j, t);
-            tlt.addAndGet(p.getMilliseconds());
-            return t;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            Iris.warn("Couldn't read " + resourceTypeName + " file: " + j.getPath() + ": " + e.getMessage());
-            return null;
-        }
-    }
-
-
-    public String[] getPossibleKeys() {
-        if (possibleKeys != null) {
-            return possibleKeys;
-        }
-
-        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
-        Set<String> keys = new HashSet<>();
-
-        for (File i : getFolders()) {
-            if (i.isDirectory()) {
-                keys.addAll(getKeysInDirectory(i));
-            }
-        }
-
-        possibleKeys = keys.toArray(new String[0]);
-        return possibleKeys;
-    }
-
-    private Set<String> getKeysInDirectory(File directory) {
-        Set<String> keys = new HashSet<>();
-        for (File file : directory.listFiles()) {
-            if (file.isFile() && file.getName().endsWith(".kts")) {
-                keys.add(file.getName().replaceAll("\\Q.kts\\E", ""));
-            } else if (file.isDirectory()) {
-                keys.addAll(getKeysInDirectory(file));
-            }
-        }
-        return keys;
-    }
-
-//    public String[] getPossibleKeys() {
-//        if (possibleKeys != null) {
-//            return possibleKeys;
-//        }
-//
-//        Iris.debug("Building " + resourceTypeName + " Possibility Lists");
-//        KSet<String> m = new KSet<>();
-//
-//        for (File i : getFolders()) {
-//            for (File j : i.listFiles()) {
-//                if (j.isFile() && j.getName().endsWith(".js")) {
-//                    m.add(j.getName().replaceAll("\\Q.js\\E", ""));
-//                } else if (j.isDirectory()) {
-//                    for (File k : j.listFiles()) {
-//                        if (k.isFile() && k.getName().endsWith(".js")) {
-//                            m.add(j.getName() + "/" + k.getName().replaceAll("\\Q.js\\E", ""));
-//                        } else if (k.isDirectory()) {
-//                            for (File l : k.listFiles()) {
-//                                if (l.isFile() && l.getName().endsWith(".js")) {
-//                                    m.add(j.getName() + "/" + k.getName() + "/" + l.getName().replaceAll("\\Q.js\\E", ""));
-//                                }
-//                            }
-//                        }
-//                    }
-//                }
-//            }
-//        }
-//
-//        KList<String> v = new KList<>(m);
-//        possibleKeys = v.toArray(new String[0]);
-//        return possibleKeys;
-//    }
-
-    public File findFile(String name) {
-        for (File i : getFolders(name)) {
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".kts") && j.getName().split("\\Q.\\E")[0].equals(name)) {
-                    return j;
-                }
-            }
-
-            File file = new File(i, name + ".kts");
-
-            if (file.exists()) {
-                return file;
-            }
-        }
-
-        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
-
-        return null;
-    }
-
-    private IrisScript loadRaw(String name) {
-        for (File i : getFolders(name)) {
-            for (File j : i.listFiles()) {
-                if (j.isFile() && j.getName().endsWith(".kts") && j.getName().split("\\Q.\\E")[0].equals(name)) {
-                    return loadFile(j, name);
-                }
-            }
-
-            File file = new File(i, name + ".kts");
-
-            if (file.exists()) {
-                return loadFile(file, name);
-            }
-        }
-
-        Iris.warn("Couldn't find " + resourceTypeName + ": " + name);
-
-        return null;
-    }
-
-    public IrisScript load(String name, boolean warn) {
-        return loadCache.get(name);
-    }
-}

core/src/main/java/com/volmit/iris/core/nms/BiomeBaseInjector.java

@@ -1,28 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.nms;
-
-@FunctionalInterface
-public interface BiomeBaseInjector {
-    default void setBiome(int x, int z, Object biomeBase) {
-        setBiome(x, 0, z, biomeBase);
-    }
-
-    void setBiome(int x, int y, int z, Object biomeBase);
-}

core/src/main/java/com/volmit/iris/core/nms/INMS.java

@@ -1,128 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.nms;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.nms.v1X.NMSBinding1X;
-import org.bukkit.Bukkit;
-
-import java.util.List;
-
-public class INMS {
-    private static final Version CURRENT = Boolean.getBoolean("iris.no-version-limit") ?
-            new Version(Integer.MAX_VALUE, Integer.MAX_VALUE, null) :
-            new Version(21, 10, null);
-
-    private static final List<Version> REVISION = List.of(
-            new Version(21, 9, "v1_21_R6"),
-            new Version(21, 6, "v1_21_R5"),
-            new Version(21, 5, "v1_21_R4"),
-            new Version(21, 4, "v1_21_R3"),
-            new Version(21, 2, "v1_21_R2"),
-            new Version(21, 0, "v1_21_R1"),
-            new Version(20, 5, "v1_20_R4")
-    );
-
-    private static final List<Version> PACKS = List.of(
-            new Version(21, 5, "31100"),
-            new Version(21, 4, "31020"),
-            new Version(21, 2, "31000"),
-            new Version(20, 1, "3910")
-    );
-
-    //@done
-    private static final INMSBinding binding = bind();
-    public static final String OVERWORLD_TAG = getTag(PACKS, "3910");
-
-    public static INMSBinding get() {
-        return binding;
-    }
-
-    public static String getNMSTag() {
-        if (IrisSettings.get().getGeneral().isDisableNMS()) {
-            return "BUKKIT";
-        }
-
-        try {
-            String name = Bukkit.getServer().getClass().getCanonicalName();
-            if (name.equals("org.bukkit.craftbukkit.CraftServer")) {
-                return getTag(REVISION, "BUKKIT");
-            } else {
-                return name.split("\\Q.\\E")[3];
-            }
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            Iris.error("Failed to determine server nms version!");
-            e.printStackTrace();
-        }
-
-        return "BUKKIT";
-    }
-
-    private static INMSBinding bind() {
-        String code = getNMSTag();
-        Iris.info("Locating NMS Binding for " + code);
-
-        try {
-            Class<?> clazz = Class.forName("com.volmit.iris.core.nms."+code+".NMSBinding");
-            try {
-                Object b = clazz.getConstructor().newInstance();
-                if (b instanceof INMSBinding binding) {
-                    Iris.info("Craftbukkit " + code + " <-> " + b.getClass().getSimpleName() + " Successfully Bound");
-                    return binding;
-                }
-            } catch (Throwable e) {
-                Iris.reportError(e);
-                e.printStackTrace();
-            }
-        } catch (ClassNotFoundException|NoClassDefFoundError classNotFoundException) {}
-
-        Iris.info("Craftbukkit " + code + " <-> " + NMSBinding1X.class.getSimpleName() + " Successfully Bound");
-        Iris.warn("Note: Some features of Iris may not work the same since you are on an unsupported version of Minecraft.");
-        Iris.warn("Note: If this is a new version, expect an update soon.");
-
-        return new NMSBinding1X();
-    }
-
-    private static String getTag(List<Version> versions, String def) {
-        var version = Bukkit.getServer().getBukkitVersion().split("-")[0].split("\\.", 3);
-        int major = 0;
-        int minor = 0;
-
-        if (version.length > 2) {
-            major = Integer.parseInt(version[1]);
-            minor = Integer.parseInt(version[2]);
-        } else if (version.length == 2) {
-            major = Integer.parseInt(version[1]);
-        }
-        if (CURRENT.major < major || CURRENT.minor < minor) {
-            return versions.getFirst().tag;
-        }
-
-        for (var p : versions) {
-            if (p.major > major || p.minor > minor)
-                continue;
-            return p.tag;
-        }
-        return def;
-    }
-
-    private record Version(int major, int minor, String tag) {}
-}

core/src/main/java/com/volmit/iris/core/nms/INMSBinding.java

@@ -1,147 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.nms;
-
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.core.nms.container.AutoClosing;
-import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.nms.container.BlockProperty;
-import com.volmit.iris.core.nms.container.Pair;
-import com.volmit.iris.core.nms.container.StructurePlacement;
-import com.volmit.iris.core.nms.datapack.DataVersion;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.platform.PlatformChunkGenerator;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.mantle.Mantle;
-import com.volmit.iris.util.math.Vector3d;
-import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
-import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
-import com.volmit.iris.util.nbt.tag.CompoundTag;
-import org.bukkit.*;
-import org.bukkit.block.Biome;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.event.entity.CreatureSpawnEvent;
-import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.inventory.ItemStack;
-
-import java.awt.Color;
-import java.util.List;
-
-public interface INMSBinding {
-    boolean hasTile(Material material);
-
-    boolean hasTile(Location l);
-
-    KMap<String, Object> serializeTile(Location location);
-
-    void deserializeTile(KMap<String, Object> s, Location newPosition);
-
-    CompoundTag serializeEntity(Entity location);
-
-    Entity deserializeEntity(CompoundTag s, Location newPosition);
-
-    boolean supportsCustomHeight();
-
-    Object getBiomeBaseFromId(int id);
-
-    int getMinHeight(World world);
-
-    boolean supportsCustomBiomes();
-
-    int getTrueBiomeBaseId(Object biomeBase);
-
-    Object getTrueBiomeBase(Location location);
-
-    String getTrueBiomeBaseKey(Location location);
-
-    Object getCustomBiomeBaseFor(String mckey);
-
-    Object getCustomBiomeBaseHolderFor(String mckey);
-
-    int getBiomeBaseIdForKey(String key);
-
-    String getKeyForBiomeBase(Object biomeBase);
-
-    Object getBiomeBase(World world, Biome biome);
-
-    Object getBiomeBase(Object registry, Biome biome);
-
-    KList<Biome> getBiomes();
-
-    boolean isBukkit();
-
-    int getBiomeId(Biome biome);
-
-    MCABiomeContainer newBiomeContainer(int min, int max, int[] data);
-
-    MCABiomeContainer newBiomeContainer(int min, int max);
-
-    default World createWorld(WorldCreator c) {
-        if (c.generator() instanceof PlatformChunkGenerator gen
-                && missingDimensionTypes(gen.getTarget().getDimension().getDimensionTypeKey()))
-            throw new IllegalStateException("Missing dimension types to create world");
-        return c.createWorld();
-    }
-
-    int countCustomBiomes();
-
-    void forceBiomeInto(int x, int y, int z, Object somethingVeryDirty, ChunkGenerator.BiomeGrid chunk);
-
-    default boolean supportsDataPacks() {
-        return false;
-    }
-
-    MCAPaletteAccess createPalette();
-
-    void injectBiomesFromMantle(Chunk e, Mantle mantle);
-
-    ItemStack applyCustomNbt(ItemStack itemStack, KMap<String, Object> customNbt) throws IllegalArgumentException;
-
-    void inject(long seed, Engine engine, World world) throws NoSuchFieldException, IllegalAccessException;
-
-    Vector3d getBoundingbox(org.bukkit.entity.EntityType entity);
-    
-    Entity spawnEntity(Location location, EntityType type, CreatureSpawnEvent.SpawnReason reason);
-
-    Color getBiomeColor(Location location, BiomeColor type);
-
-    default DataVersion getDataVersion() {
-        return DataVersion.V1192;
-    }
-
-    default int getSpawnChunkCount(World world) {
-        return 441;
-    }
-
-    KList<String> getStructureKeys();
-
-    boolean missingDimensionTypes(String... keys);
-
-    default boolean injectBukkit() {
-        return true;
-    }
-
-    KMap<Material, List<BlockProperty>> getBlockProperties();
-
-    void placeStructures(Chunk chunk);
-
-    KMap<Identifier, StructurePlacement> collectStructures();
-}

core/src/main/java/com/volmit/iris/core/nms/container/AutoClosing.java

@@ -1,39 +0,0 @@
-package com.volmit.iris.core.nms.container;
-
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.function.NastyRunnable;
-import lombok.AllArgsConstructor;
-
-import java.util.concurrent.atomic.AtomicBoolean;
-
-@AllArgsConstructor
-public class AutoClosing implements AutoCloseable {
-    private static final KMap<Thread, AutoClosing> CONTEXTS = new KMap<>();
-    private final AtomicBoolean closed = new AtomicBoolean();
-    private final NastyRunnable action;
-
-    @Override
-    public void close() {
-        if (closed.getAndSet(true)) return;
-        try {
-            removeContext();
-            action.run();
-        } catch (Throwable e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    public void storeContext() {
-        CONTEXTS.put(Thread.currentThread(), this);
-    }
-
-    public void removeContext() {
-        CONTEXTS.values().removeIf(c -> c == this);
-    }
-
-    public static void closeContext() {
-        AutoClosing closing = CONTEXTS.remove(Thread.currentThread());
-        if (closing == null) return;
-        closing.close();
-    }
-}

core/src/main/java/com/volmit/iris/core/nms/container/BiomeColor.java

@@ -1,10 +0,0 @@
-package com.volmit.iris.core.nms.container;
-
-public enum BiomeColor {
-    FOG,
-    WATER,
-    WATER_FOG,
-    SKY,
-    FOLIAGE,
-    GRASS
-}

core/src/main/java/com/volmit/iris/core/nms/container/BlockPos.java

@@ -1,14 +0,0 @@
-package com.volmit.iris.core.nms.container;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class BlockPos {
-    private int x;
-    private int y;
-    private int z;
-}

core/src/main/java/com/volmit/iris/core/nms/container/BlockProperty.java

@@ -1,154 +0,0 @@
-package com.volmit.iris.core.nms.container;
-
-import com.volmit.iris.util.json.JSONArray;
-import com.volmit.iris.util.json.JSONObject;
-import org.jetbrains.annotations.NotNull;
-
-import java.util.*;
-import java.util.function.Function;
-
-public class BlockProperty {
-    private static final Set<Class<?>> NATIVES = Set.of(Byte.class, Short.class, Integer.class, Long.class, Float.class, Double.class, Boolean.class, String.class);
-    private final String name;
-    private final Class<?> type;
-
-    private final Object defaultValue;
-    private final Set<Object> values;
-    private final Function<Object, String> nameFunction;
-    private final Function<Object, Object> jsonFunction;
-
-    public  <T extends Comparable<T>> BlockProperty(
-            String name,
-            Class<T> type,
-            T defaultValue,
-            Collection<T> values,
-            Function<T, String> nameFunction
-    ) {
-        this.name = name;
-        this.type = type;
-        this.defaultValue = defaultValue;
-        this.values = Collections.unmodifiableSet(new TreeSet<>(values));
-        this.nameFunction = (Function<Object, String>) (Object) nameFunction;
-        jsonFunction = NATIVES.contains(type) ? Function.identity() : this.nameFunction::apply;
-    }
-
-    public static <T extends Enum<T>> BlockProperty ofEnum(Class<T> type, String name, T defaultValue) {
-        return new BlockProperty(
-                name,
-                type,
-                defaultValue,
-                Arrays.asList(type.getEnumConstants()),
-                val -> val == null ? "null" : val.name()
-        );
-    }
-
-    public static BlockProperty ofFloat(String name, float defaultValue, float min, float max, boolean exclusiveMin, boolean exclusiveMax) {
-        return new BoundedDouble(
-                name,
-                defaultValue,
-                min,
-                max,
-                exclusiveMin,
-                exclusiveMax,
-                (f) -> String.format("%.2f", f)
-        );
-    }
-
-    public static BlockProperty ofBoolean(String name, boolean defaultValue) {
-        return new BlockProperty(
-                name,
-                Boolean.class,
-                defaultValue,
-                List.of(true, false),
-                (b) -> b ? "true" : "false"
-        );
-    }
-
-    @Override
-    public @NotNull String toString() {
-        return name + "=" + nameFunction.apply(defaultValue) + " [" + String.join(",", names()) + "]";
-    }
-
-    public String name() {
-        return name;
-    }
-
-    public String defaultValue() {
-        return nameFunction.apply(defaultValue);
-    }
-
-    public List<String> names() {
-        return values.stream().map(nameFunction).toList();
-    }
-
-    public Object defaultValueAsJson() {
-        return jsonFunction.apply(defaultValue);
-    }
-
-    public JSONArray valuesAsJson() {
-        return new JSONArray(values.stream().map(jsonFunction).toList());
-    }
-
-    public JSONObject buildJson() {
-        var json = new JSONObject();
-        json.put("type", jsonType());
-        json.put("default", defaultValueAsJson());
-        if (!values.isEmpty()) json.put("enum", valuesAsJson());
-        return json;
-    }
-
-    public String jsonType() {
-        if (type == Boolean.class)
-            return "boolean";
-        if (type == Byte.class || type == Short.class || type == Integer.class || type == Long.class)
-            return "integer";
-        if (type == Float.class || type == Double.class)
-            return "number";
-        return "string";
-    }
-
-    @Override
-    public boolean equals(Object obj) {
-        if (obj == this) return true;
-        if (obj == null || obj.getClass() != this.getClass()) return false;
-        var that = (BlockProperty) obj;
-        return Objects.equals(this.name, that.name) &&
-                Objects.equals(this.values, that.values) &&
-                Objects.equals(this.type, that.type);
-    }
-
-    @Override
-    public int hashCode() {
-        return Objects.hash(name, values, type);
-    }
-
-    private static class BoundedDouble extends BlockProperty {
-        private final double min, max;
-        private final boolean exclusiveMin, exclusiveMax;
-
-        public BoundedDouble(
-                String name,
-                double defaultValue,
-                double min,
-                double max,
-                boolean exclusiveMin,
-                boolean exclusiveMax,
-                Function<Double, String> nameFunction
-        ) {
-            super(name, Double.class, defaultValue, List.of(), nameFunction);
-            this.min = min;
-            this.max = max;
-            this.exclusiveMin = exclusiveMin;
-            this.exclusiveMax = exclusiveMax;
-        }
-
-        @Override
-        public JSONObject buildJson() {
-            return super.buildJson()
-                    .put("minimum", min)
-                    .put("maximum", max)
-                    .put("exclusiveMinimum", exclusiveMin)
-                    .put("exclusiveMaximum", exclusiveMax);
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/nms/container/Pair.java

@@ -1,13 +0,0 @@
-package com.volmit.iris.core.nms.container;
-
-import lombok.AllArgsConstructor;
-import lombok.Data;
-import lombok.NoArgsConstructor;
-
-@Data
-@AllArgsConstructor
-@NoArgsConstructor
-public class Pair<A, B> {
-    private A a;
-    private B b;
-}

core/src/main/java/com/volmit/iris/core/nms/container/StructurePlacement.java

@@ -1,77 +0,0 @@
-package com.volmit.iris.core.nms.container;
-
-import com.google.gson.JsonObject;
-import com.volmit.iris.engine.object.IrisJigsawStructurePlacement.SpreadType;
-import lombok.*;
-import lombok.experimental.Accessors;
-import lombok.experimental.SuperBuilder;
-import org.apache.commons.math3.fraction.Fraction;
-
-import java.util.List;
-
-@Data
-@SuperBuilder
-@Accessors(fluent = true, chain = true)
-public abstract class StructurePlacement {
-    private final int salt;
-    private final float frequency;
-    private final List<Structure> structures;
-
-    public abstract JsonObject toJson(String structure);
-
-    protected JsonObject createBase(String structure) {
-        JsonObject object = new JsonObject();
-        object.addProperty("structure", structure);
-        object.addProperty("salt", salt);
-        return object;
-    }
-
-    public int frequencyToSpacing() {
-        var frac = new Fraction(Math.max(Math.min(frequency, 1), 0.000000001f));
-        return (int) Math.round(Math.sqrt((double) frac.getDenominator() / frac.getNumerator()));
-    }
-
-    @Getter
-    @Accessors(chain = true, fluent = true)
-    @EqualsAndHashCode(callSuper = true)
-    @SuperBuilder
-    public static class RandomSpread extends StructurePlacement {
-        private final int spacing;
-        private final int separation;
-        private final SpreadType spreadType;
-
-        @Override
-        public JsonObject toJson(String structure) {
-            JsonObject object = createBase(structure);
-            object.addProperty("spacing", Math.max(spacing, frequencyToSpacing()));
-            object.addProperty("separation", separation);
-            object.addProperty("spreadType", spreadType.name());
-            return object;
-        }
-    }
-
-    @Getter
-    @EqualsAndHashCode(callSuper = true)
-    @SuperBuilder
-    public static class ConcentricRings extends StructurePlacement {
-        private final int distance;
-        private final int spread;
-        private final int count;
-
-        @Override
-        public JsonObject toJson(String structure) {
-            return null;
-        }
-    }
-
-    public record Structure(
-            int weight,
-            String key,
-            List<String> tags
-    ) {
-
-        public boolean isValid() {
-            return weight > 0 && key != null;
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/nms/datapack/DataVersion.java

@@ -1,43 +0,0 @@
-package com.volmit.iris.core.nms.datapack;
-
-import com.volmit.iris.core.nms.INMS;
-import com.volmit.iris.core.nms.datapack.v1192.DataFixerV1192;
-import com.volmit.iris.core.nms.datapack.v1206.DataFixerV1206;
-import com.volmit.iris.core.nms.datapack.v1213.DataFixerV1213;
-import com.volmit.iris.util.collection.KMap;
-import lombok.AccessLevel;
-import lombok.Getter;
-
-import java.util.function.Supplier;
-
-//https://minecraft.wiki/w/Pack_format
-@Getter
-public enum DataVersion {
-    UNSUPPORTED("0.0.0", 0, () -> null),
-    V1192("1.19.2", 10, DataFixerV1192::new),
-    V1205("1.20.6", 41, DataFixerV1206::new),
-    V1213("1.21.3", 57, DataFixerV1213::new);
-    private static final KMap<DataVersion, IDataFixer> cache = new KMap<>();
-    @Getter(AccessLevel.NONE)
-    private final Supplier<IDataFixer> constructor;
-    private final String version;
-    private final int packFormat;
-
-    DataVersion(String version, int packFormat, Supplier<IDataFixer> constructor) {
-        this.constructor = constructor;
-        this.packFormat = packFormat;
-        this.version = version;
-    }
-
-    public IDataFixer get() {
-        return cache.computeIfAbsent(this, k -> constructor.get());
-    }
-
-    public static IDataFixer getDefault() {
-        return INMS.get().getDataVersion().get();
-    }
-
-    public static DataVersion getLatest() {
-        return values()[values().length - 1];
-    }
-}

core/src/main/java/com/volmit/iris/core/nms/datapack/IDataFixer.java

@@ -1,31 +0,0 @@
-package com.volmit.iris.core.nms.datapack;
-
-import com.volmit.iris.engine.object.IrisBiomeCustom;
-import com.volmit.iris.engine.object.IrisDimensionTypeOptions;
-import com.volmit.iris.util.json.JSONObject;
-import org.jetbrains.annotations.Nullable;
-
-public interface IDataFixer {
-    default JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
-        return json;
-    }
-
-    JSONObject resolve(Dimension dimension, @Nullable IrisDimensionTypeOptions options);
-
-    void fixDimension(Dimension dimension, JSONObject json);
-
-    default JSONObject createDimension(Dimension base, int minY, int height, int logicalHeight, @Nullable IrisDimensionTypeOptions options) {
-        JSONObject obj = resolve(base, options);
-        obj.put("min_y", minY);
-        obj.put("height", height);
-        obj.put("logical_height", logicalHeight);
-        fixDimension(base, obj);
-        return obj;
-    }
-
-    enum Dimension {
-        OVERWORLD,
-        NETHER,
-        END
-    }
-}

core/src/main/java/com/volmit/iris/core/nms/datapack/v1192/DataFixerV1192.java

@@ -1,104 +0,0 @@
-package com.volmit.iris.core.nms.datapack.v1192;
-
-import com.volmit.iris.core.nms.datapack.IDataFixer;
-import com.volmit.iris.engine.object.IrisDimensionTypeOptions;
-import com.volmit.iris.util.json.JSONObject;
-import org.jetbrains.annotations.Nullable;
-
-import java.util.Map;
-
-import static com.volmit.iris.engine.object.IrisDimensionTypeOptions.TriState.*;
-
-public class DataFixerV1192 implements IDataFixer {
-    private static final Map<Dimension, IrisDimensionTypeOptions> OPTIONS = Map.of(
-            Dimension.OVERWORLD, new IrisDimensionTypeOptions(
-                    FALSE,
-                    TRUE,
-                    FALSE,
-                    FALSE,
-                    TRUE,
-                    TRUE,
-                    TRUE,
-                    FALSE,
-                    1d,
-                    0f,
-                    null,
-                    192,
-                    0),
-            Dimension.NETHER, new IrisDimensionTypeOptions(
-                    TRUE,
-                    FALSE,
-                    TRUE,
-                    TRUE,
-                    FALSE,
-                    FALSE,
-                    FALSE,
-                    TRUE,
-                    8d,
-                    0.1f,
-                    18000L,
-                    null,
-                    15),
-            Dimension.END, new IrisDimensionTypeOptions(
-                    FALSE,
-                    FALSE,
-                    FALSE,
-                    FALSE,
-                    FALSE,
-                    TRUE,
-                    FALSE,
-                    FALSE,
-                    1d,
-                    0f,
-                    6000L,
-                    null,
-                    0)
-    );
-
-    private static final Map<Dimension, String> DIMENSIONS = Map.of(
-            Dimension.OVERWORLD, """
-            {
-              "effects": "minecraft:overworld",
-              "infiniburn": "#minecraft:infiniburn_overworld",
-              "monster_spawn_light_level": {
-                "type": "minecraft:uniform",
-                "value": {
-                  "max_inclusive": 7,
-                  "min_inclusive": 0
-                }
-              }
-            }""",
-            Dimension.NETHER, """
-            {
-              "effects": "minecraft:the_nether",
-              "infiniburn": "#minecraft:infiniburn_nether",
-              "monster_spawn_light_level": 7,
-            }""",
-            Dimension.END, """
-            {
-              "effects": "minecraft:the_end",
-              "infiniburn": "#minecraft:infiniburn_end",
-              "monster_spawn_light_level": {
-                "type": "minecraft:uniform",
-                "value": {
-                  "max_inclusive": 7,
-                  "min_inclusive": 0
-                }
-              }
-            }"""
-    );
-
-    @Override
-    public JSONObject resolve(Dimension dimension, @Nullable IrisDimensionTypeOptions options) {
-        return options == null ? OPTIONS.get(dimension).toJson() : options.resolve(OPTIONS.get(dimension)).toJson();
-    }
-
-    @Override
-    public void fixDimension(Dimension dimension, JSONObject json) {
-        var missing = new JSONObject(DIMENSIONS.get(dimension));
-        for (String key : missing.keySet()) {
-            if (json.has(key)) continue;
-            json.put(key, missing.get(key));
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/nms/datapack/v1206/DataFixerV1206.java

@@ -1,56 +0,0 @@
-package com.volmit.iris.core.nms.datapack.v1206;
-
-import com.volmit.iris.core.nms.datapack.v1192.DataFixerV1192;
-import com.volmit.iris.engine.object.IrisBiomeCustom;
-import com.volmit.iris.engine.object.IrisBiomeCustomSpawn;
-import com.volmit.iris.engine.object.IrisBiomeCustomSpawnType;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.json.JSONArray;
-import com.volmit.iris.util.json.JSONObject;
-
-import java.util.Locale;
-
-public class DataFixerV1206 extends DataFixerV1192 {
-    @Override
-    public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
-        int spawnRarity = biome.getSpawnRarity();
-        if (spawnRarity > 0) {
-            json.put("creature_spawn_probability", Math.min(spawnRarity/20d, 0.9999999));
-        } else {
-            json.remove("creature_spawn_probability");
-        }
-
-        var spawns = biome.getSpawns();
-        if (spawns != null && spawns.isNotEmpty()) {
-            JSONObject spawners = new JSONObject();
-            KMap<IrisBiomeCustomSpawnType, JSONArray> groups = new KMap<>();
-
-            for (IrisBiomeCustomSpawn i : spawns) {
-                JSONArray g = groups.computeIfAbsent(i.getGroup(), (k) -> new JSONArray());
-                JSONObject o = new JSONObject();
-                o.put("type", i.getType().getKey());
-                o.put("weight", i.getWeight());
-                o.put("minCount", i.getMinCount());
-                o.put("maxCount", i.getMaxCount());
-                g.put(o);
-            }
-
-            for (IrisBiomeCustomSpawnType i : groups.k()) {
-                spawners.put(i.name().toLowerCase(Locale.ROOT), groups.get(i));
-            }
-
-            json.put("spawners", spawners);
-        }
-        return json;
-    }
-
-    @Override
-    public void fixDimension(Dimension dimension, JSONObject json) {
-        super.fixDimension(dimension, json);
-        if (!(json.get("monster_spawn_light_level") instanceof JSONObject lightLevel))
-            return;
-        var value = (JSONObject) lightLevel.remove("value");
-        lightLevel.put("max_inclusive", value.get("max_inclusive"));
-        lightLevel.put("min_inclusive", value.get("min_inclusive"));
-    }
-}

core/src/main/java/com/volmit/iris/core/nms/datapack/v1213/DataFixerV1213.java

@@ -1,16 +0,0 @@
-package com.volmit.iris.core.nms.datapack.v1213;
-
-import com.volmit.iris.core.nms.datapack.v1206.DataFixerV1206;
-import com.volmit.iris.engine.object.IrisBiomeCustom;
-import com.volmit.iris.util.json.JSONArray;
-import com.volmit.iris.util.json.JSONObject;
-
-public class DataFixerV1213 extends DataFixerV1206 {
-
-    @Override
-    public JSONObject fixCustomBiome(IrisBiomeCustom biome, JSONObject json) {
-        json = super.fixCustomBiome(biome, json);
-        json.put("carvers", new JSONArray());
-        return json;
-    }
-}

core/src/main/java/com/volmit/iris/core/nms/v1X/NMSBinding1X.java

@@ -1,279 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.nms.v1X;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.link.Identifier;
-import com.volmit.iris.core.nms.INMSBinding;
-import com.volmit.iris.core.nms.container.BiomeColor;
-import com.volmit.iris.core.nms.container.BlockProperty;
-import com.volmit.iris.core.nms.datapack.DataVersion;
-import com.volmit.iris.core.nms.container.Pair;
-import com.volmit.iris.core.nms.container.StructurePlacement;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.collection.KMap;
-import com.volmit.iris.util.mantle.Mantle;
-import com.volmit.iris.util.math.Vector3d;
-import com.volmit.iris.util.nbt.mca.palette.MCABiomeContainer;
-import com.volmit.iris.util.nbt.mca.palette.MCAPaletteAccess;
-import com.volmit.iris.util.nbt.tag.CompoundTag;
-import org.bukkit.*;
-import org.bukkit.block.Biome;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.EntityType;
-import org.bukkit.event.entity.CreatureSpawnEvent;
-import org.bukkit.generator.ChunkGenerator;
-import org.bukkit.generator.structure.Structure;
-import org.bukkit.inventory.ItemStack;
-
-import java.awt.Color;
-import java.util.List;
-import java.util.stream.StreamSupport;
-
-public class NMSBinding1X implements INMSBinding {
-    private static final boolean supportsCustomHeight = testCustomHeight();
-
-    @SuppressWarnings("ConstantConditions")
-    private static boolean testCustomHeight() {
-        try {
-            if (World.class.getDeclaredMethod("getMaxHeight") != null && World.class.getDeclaredMethod("getMinHeight") != null)
-                ;
-            {
-                return true;
-            }
-        } catch (Throwable ignored) {
-
-        }
-
-        return false;
-    }
-
-    @Override
-    public boolean hasTile(Material material) {
-        return false;
-    }
-
-    @Override
-    public boolean hasTile(Location l) {
-        return false;
-    }
-
-    @Override
-    public KMap<String, Object> serializeTile(Location location) {
-        return null;
-    }
-
-    @Override
-    public void deserializeTile(KMap<String, Object> s, Location newPosition) {
-
-    }
-
-
-    @Override
-    public void injectBiomesFromMantle(Chunk e, Mantle mantle) {
-
-    }
-
-    @Override
-    public ItemStack applyCustomNbt(ItemStack itemStack, KMap<String, Object> customNbt) throws IllegalArgumentException {
-        return itemStack;
-    }
-
-    @Override
-    public void inject(long seed, Engine engine, World world) throws NoSuchFieldException, IllegalAccessException {
-
-    }
-
-    public Vector3d getBoundingbox() {
-        return null;
-    }
-
-    @Override
-    public Entity spawnEntity(Location location, EntityType type, CreatureSpawnEvent.SpawnReason reason) {
-        return location.getWorld().spawnEntity(location, type);
-    }
-
-    @Override
-    public Color getBiomeColor(Location location, BiomeColor type) {
-        return Color.GREEN;
-    }
-
-    @Override
-    public KList<String> getStructureKeys() {
-        var list = StreamSupport.stream(Registry.STRUCTURE.spliterator(), false)
-                .map(Structure::getKey)
-                .map(NamespacedKey::toString)
-                .toList();
-        return new KList<>(list);
-    }
-
-    @Override
-    public boolean missingDimensionTypes(String... keys) {
-        return false;
-    }
-
-    @Override
-    public KMap<Material, List<BlockProperty>> getBlockProperties() {
-        KMap<Material, List<BlockProperty>> map = new KMap<>();
-        for (Material m : Material.values()) {
-            if (m.isBlock()) map.put(m, List.of());
-        }
-        return map;
-    }
-
-    @Override
-    public void placeStructures(Chunk chunk) {
-
-    }
-
-    @Override
-    public KMap<Identifier, StructurePlacement> collectStructures() {
-        return new KMap<>();
-    }
-
-    @Override
-    public CompoundTag serializeEntity(Entity location) {
-        return null;
-    }
-
-    @Override
-    public Entity deserializeEntity(CompoundTag s, Location newPosition) {
-        return null;
-    }
-
-    @Override
-    public boolean supportsCustomHeight() {
-        return supportsCustomHeight;
-    }
-
-    @Override
-    public Object getBiomeBaseFromId(int id) {
-        return null;
-    }
-
-    @Override
-    public int getMinHeight(World world) {
-        return supportsCustomHeight ? world.getMinHeight() : 0;
-    }
-
-    @Override
-    public boolean supportsCustomBiomes() {
-        return false;
-    }
-
-    @Override
-    public int getTrueBiomeBaseId(Object biomeBase) {
-        return 0;
-    }
-
-    @Override
-    public Object getTrueBiomeBase(Location location) {
-        return null;
-    }
-
-    @Override
-    public String getTrueBiomeBaseKey(Location location) {
-        return null;
-    }
-
-    @Override
-    public Object getCustomBiomeBaseFor(String mckey) {
-        return null;
-    }
-
-    @Override
-    public Object getCustomBiomeBaseHolderFor(String mckey) {
-        return null;
-    }
-
-    @Override
-    public int getBiomeBaseIdForKey(String key) {
-        return 0;
-    }
-
-    @Override
-    public String getKeyForBiomeBase(Object biomeBase) {
-        return null;
-    }
-
-    public Object getBiomeBase(World world, Biome biome) {
-        return null;
-    }
-
-    @Override
-    public Object getBiomeBase(Object registry, Biome biome) {
-        return null;
-    }
-
-    @Override
-    public KList<Biome> getBiomes() {
-        return new KList<>(Biome.values()).qdel(Biome.CUSTOM);
-    }
-
-    @Override
-    public boolean isBukkit() {
-        return true;
-    }
-
-    @Override
-    public DataVersion getDataVersion() {
-        return DataVersion.UNSUPPORTED;
-    }
-
-    @Override
-    public int getBiomeId(Biome biome) {
-        return biome.ordinal();
-    }
-
-    @Override
-    public MCABiomeContainer newBiomeContainer(int min, int max) {
-        Iris.error("Cannot use the custom biome data! Iris is incapable of using MCA generation on this version of minecraft!");
-
-        return null;
-    }
-
-    @Override
-    public MCABiomeContainer newBiomeContainer(int min, int max, int[] v) {
-        Iris.error("Cannot use the custom biome data! Iris is incapable of using MCA generation on this version of minecraft!");
-
-        return null;
-    }
-
-    @Override
-    public int countCustomBiomes() {
-        return 0;
-    }
-
-    @Override
-    public void forceBiomeInto(int x, int y, int z, Object somethingVeryDirty, ChunkGenerator.BiomeGrid chunk) {
-
-    }
-
-    @Override
-    public Vector3d getBoundingbox(org.bukkit.entity.EntityType entity) {
-      return null;
-    }
-
-    @Override
-    public MCAPaletteAccess createPalette() {
-        Iris.error("Cannot use the global data palette! Iris is incapable of using MCA generation on this version of minecraft!");
-        return null;
-    }
-}

core/src/main/java/com/volmit/iris/core/pack/IrisPack.java

@@ -1,384 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.pack;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.loader.IrisData;
-import com.volmit.iris.core.loader.ResourceLoader;
-import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.engine.object.IrisDimension;
-import com.volmit.iris.engine.object.IrisWorld;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.exceptions.IrisException;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.json.JSONArray;
-import com.volmit.iris.util.json.JSONObject;
-import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.PrecisionStopwatch;
-import lombok.Data;
-import org.bukkit.World;
-import org.zeroturnaround.zip.commons.FileUtils;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.MalformedURLException;
-import java.util.concurrent.CompletableFuture;
-import java.util.concurrent.Future;
-
-/**
- * Represents an Iris pack that exists
- */
-@Data
-public class IrisPack {
-    private final File folder;
-    private final IrisData data;
-
-    /**
-     * Create an iris pack backed by a data folder
-     * the data folder is assumed to be in the Iris/packs/NAME folder
-     *
-     * @param name the name
-     */
-    public IrisPack(String name) {
-        this(packsPack(name));
-    }
-
-    /**
-     * Create an iris pack backed by a data folder
-     *
-     * @param folder the folder of the pack. Must be a directory
-     */
-    public IrisPack(File folder) {
-        this.folder = folder;
-
-        if (!folder.exists()) {
-            throw new RuntimeException("Cannot open Pack " + folder.getPath() + " (directory doesnt exist)");
-        }
-
-        if (!folder.isDirectory()) {
-            throw new RuntimeException("Cannot open Pack " + folder.getPath() + " (not a directory)");
-        }
-
-        this.data = IrisData.get(folder);
-    }
-
-    /**
-     * Create a new pack from the input url
-     *
-     * @param sender the sender
-     * @param url    the url, or name, or really anything see IrisPackRepository.from(String)
-     * @return the iris pack
-     * @throws IrisException fails
-     */
-    public static Future<IrisPack> from(VolmitSender sender, String url) throws IrisException {
-        IrisPackRepository repo = IrisPackRepository.from(url);
-        if (repo == null) {
-            throw new IrisException("Null Repo");
-        }
-
-        try {
-            return from(sender, repo);
-        } catch (MalformedURLException e) {
-            throw new IrisException("Malformed URL " + e.getMessage());
-        }
-    }
-
-    /**
-     * Create a pack from a repo
-     *
-     * @param sender the sender
-     * @param repo   the repo
-     * @return the pack
-     * @throws MalformedURLException shit happens
-     */
-    public static Future<IrisPack> from(VolmitSender sender, IrisPackRepository repo) throws MalformedURLException {
-        CompletableFuture<IrisPack> pack = new CompletableFuture<>();
-        repo.install(sender, () -> {
-            pack.complete(new IrisPack(repo.getRepo()));
-        });
-        return pack;
-    }
-
-    /**
-     * Create a blank pack with a given name
-     *
-     * @param name the name of the pack
-     * @return the pack
-     * @throws IrisException if the pack already exists or another error
-     */
-    public static IrisPack blank(String name) throws IrisException {
-        File f = packsPack(name);
-
-        if (f.exists()) {
-            throw new IrisException("Already exists");
-        }
-
-        File fd = new File(f, "dimensions/" + name + ".json");
-        fd.getParentFile().mkdirs();
-        try {
-            IO.writeAll(fd, "{\n" +
-                    "    \"name\": \"" + Form.capitalize(name) + "\",\n" +
-                    "    \"version\": 1\n" +
-                    "}\n");
-        } catch (IOException e) {
-            throw new IrisException(e.getMessage(), e);
-        }
-
-        IrisPack pack = new IrisPack(f);
-        pack.updateWorkspace();
-        return pack;
-    }
-
-    /**
-     * Get a packs pack folder for a name. Such that overworld would resolve as Iris/packs/overworld
-     *
-     * @param name the name
-     * @return the file path
-     */
-    public static File packsPack(String name) {
-        return Iris.instance.getDataFolderNoCreate(StudioSVC.WORKSPACE_NAME, name);
-    }
-
-    private static KList<File> collectFiles(File f, String fileExtension) {
-        KList<File> l = new KList<>();
-
-        if (f.isDirectory()) {
-            for (File i : f.listFiles()) {
-                l.addAll(collectFiles(i, fileExtension));
-            }
-        } else if (f.getName().endsWith("." + fileExtension)) {
-            l.add(f);
-        }
-
-        return l;
-    }
-
-    /**
-     * Delete this pack. This invalidates this pack and you should
-     * probably no longer use this instance after deleting this pack
-     */
-    public void delete() {
-        IO.delete(folder);
-        folder.delete();
-    }
-
-    /**
-     * Get the name of this pack
-     *
-     * @return the pack name
-     */
-    public String getName() {
-        return folder.getName();
-    }
-
-    /**
-     * Get the file path of the workspace file
-     *
-     * @return the workspace file path
-     */
-    public File getWorkspaceFile() {
-        return new File(getFolder(), getName() + ".code-workspace");
-    }
-
-    /**
-     * Update the workspace file
-     *
-     * @return true if it was updated
-     */
-    public boolean updateWorkspace() {
-        getFolder().mkdirs();
-        File ws = getWorkspaceFile();
-
-        try {
-            PrecisionStopwatch p = PrecisionStopwatch.start();
-            Iris.debug("Building Workspace: " + ws.getPath());
-            JSONObject j = generateWorkspaceConfig();
-            IO.writeAll(ws, j.toString(4));
-            p.end();
-            Iris.debug("Building Workspace: " + ws.getPath() + " took " + Form.duration(p.getMilliseconds(), 2));
-            return true;
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            Iris.warn("Pack invalid: " + ws.getAbsolutePath() + " Re-creating. You may loose some vs-code workspace settings! But not your actual project!");
-            ws.delete();
-            try {
-                IO.writeAll(ws, generateWorkspaceConfig());
-            } catch (IOException e1) {
-                Iris.reportError(e1);
-                e1.printStackTrace();
-            }
-        }
-
-        return false;
-    }
-
-    /**
-     * Install this pack into a world
-     *
-     * @param world the world to install into (world/iris/pack)
-     * @return the installed pack
-     */
-    public IrisPack install(World world) throws IrisException {
-        return install(new File(world.getWorldFolder(), "iris/pack"));
-    }
-
-    /**
-     * Install this pack into a world
-     *
-     * @param world the world to install into (world/iris/pack)
-     * @return the installed pack
-     */
-    public IrisPack install(IrisWorld world) throws IrisException {
-        return install(new File(world.worldFolder(), "iris/pack"));
-    }
-
-    /**
-     * Install this pack into a world
-     *
-     * @param folder the folder to install this pack into
-     * @return the installed pack
-     */
-    public IrisPack install(File folder) throws IrisException {
-        if (folder.exists()) {
-            throw new IrisException("Cannot install new pack because the folder " + folder.getName() + " already exists!");
-        }
-
-        folder.mkdirs();
-
-        try {
-            FileUtils.copyDirectory(getFolder(), folder);
-        } catch (IOException e) {
-            Iris.reportError(e);
-        }
-
-        return new IrisPack(folder);
-    }
-
-    /**
-     * Create a new pack using this pack as a template. The new pack will be renamed & have a renamed dimension
-     * to match it.
-     *
-     * @param newName the new pack name
-     * @return the new IrisPack
-     */
-    public IrisPack install(String newName) throws IrisException {
-        File newPack = packsPack(newName);
-
-        if (newPack.exists()) {
-            throw new IrisException("Cannot install new pack because the folder " + newName + " already exists!");
-        }
-
-        try {
-            FileUtils.copyDirectory(getFolder(), newPack);
-        } catch (IOException e) {
-            Iris.reportError(e);
-        }
-
-        IrisData data = IrisData.get(newPack);
-        IrisDimension dim = data.getDimensionLoader().load(getDimensionKey());
-        data.dump();
-        File from = dim.getLoadFile();
-        File to = new File(from.getParentFile(), newName + ".json");
-        try {
-            FileUtils.moveFile(from, to);
-            new File(newPack, getWorkspaceFile().getName()).delete();
-        } catch (Throwable e) {
-            throw new IrisException(e);
-        }
-
-        IrisPack pack = new IrisPack(newPack);
-        pack.updateWorkspace();
-
-        return pack;
-    }
-
-    /**
-     * The dimension's assumed loadkey
-     *
-     * @return getName()
-     */
-    public String getDimensionKey() {
-        return getName();
-    }
-
-    /**
-     * Get the main dimension object
-     *
-     * @return the dimension (folder name as dim key)
-     */
-    public IrisDimension getDimension() {
-        return getData().getDimensionLoader().load(getDimensionKey());
-    }
-
-    /**
-     * Find all files in this pack with the given extension
-     *
-     * @param fileExtension the extension
-     * @return the list of files
-     */
-    public KList<File> collectFiles(String fileExtension) {
-        return collectFiles(getFolder(), fileExtension);
-    }
-
-    private JSONObject generateWorkspaceConfig() {
-        JSONObject ws = new JSONObject();
-        JSONArray folders = new JSONArray();
-        JSONObject folder = new JSONObject();
-        folder.put("path", ".");
-        folders.put(folder);
-        ws.put("folders", folders);
-        JSONObject settings = new JSONObject();
-        settings.put("workbench.colorTheme", "Monokai");
-        settings.put("workbench.preferredDarkColorTheme", "Solarized Dark");
-        settings.put("workbench.tips.enabled", false);
-        settings.put("workbench.tree.indent", 24);
-        settings.put("files.autoSave", "onFocusChange");
-        JSONObject jc = new JSONObject();
-        jc.put("editor.autoIndent", "brackets");
-        jc.put("editor.acceptSuggestionOnEnter", "smart");
-        jc.put("editor.cursorSmoothCaretAnimation", true);
-        jc.put("editor.dragAndDrop", false);
-        jc.put("files.trimTrailingWhitespace", true);
-        jc.put("diffEditor.ignoreTrimWhitespace", true);
-        jc.put("files.trimFinalNewlines", true);
-        jc.put("editor.suggest.showKeywords", false);
-        jc.put("editor.suggest.showSnippets", false);
-        jc.put("editor.suggest.showWords", false);
-        JSONObject st = new JSONObject();
-        st.put("strings", true);
-        jc.put("editor.quickSuggestions", st);
-        jc.put("editor.suggest.insertMode", "replace");
-        settings.put("[json]", jc);
-        settings.put("json.maxItemsComputed", 30000);
-        JSONArray schemas = new JSONArray();
-        IrisData dm = IrisData.get(getFolder());
-
-        for (ResourceLoader<?> r : dm.getLoaders().v()) {
-            if (r.supportsSchemas()) {
-                schemas.put(r.buildSchema());
-            }
-        }
-
-        settings.put("json.schemas", schemas);
-        ws.put("settings", settings);
-
-        return ws;
-    }
-}

core/src/main/java/com/volmit/iris/core/pack/IrisPackRepository.java

@@ -1,132 +0,0 @@
-/*
- * Iris is a World Generator for Minecraft Bukkit Servers
- * Copyright (c) 2022 Arcane Arts (Volmit Software)
- *
- * 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/>.
- */
-
-package com.volmit.iris.core.pack;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.service.StudioSVC;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.plugin.VolmitSender;
-import com.volmit.iris.util.scheduling.jobs.DownloadJob;
-import com.volmit.iris.util.scheduling.jobs.JobCollection;
-import com.volmit.iris.util.scheduling.jobs.SingleJob;
-import lombok.Builder;
-import lombok.Data;
-import org.zeroturnaround.zip.ZipUtil;
-import org.zeroturnaround.zip.commons.FileUtils;
-
-import java.io.File;
-import java.io.IOException;
-import java.net.MalformedURLException;
-import java.util.UUID;
-
-@Data
-@Builder
-public class IrisPackRepository {
-    @Builder.Default
-    private String user = "IrisDimensions";
-
-    @Builder.Default
-    private String repo = "overworld";
-
-    @Builder.Default
-    private String branch = "master";
-
-    @Builder.Default
-    private String tag = "";
-
-    /**
-     *
-     */
-    public static IrisPackRepository from(String g) {
-        // https://github.com/IrisDimensions/overworld
-        if (g.startsWith("https://github.com/")) {
-            String sub = g.split("\\Qgithub.com/\\E")[1];
-            IrisPackRepository r = IrisPackRepository.builder()
-                    .user(sub.split("\\Q/\\E")[0])
-                    .repo(sub.split("\\Q/\\E")[1]).build();
-
-            if (g.contains("/tree/")) {
-                r.setBranch(g.split("/tree/")[1]);
-            }
-
-            return r;
-        } else if (g.contains("/")) {
-            String[] f = g.split("\\Q/\\E");
-
-            if (f.length == 1) {
-                return from(g);
-            } else if (f.length == 2) {
-                return IrisPackRepository.builder()
-                        .user(f[0])
-                        .repo(f[1])
-                        .build();
-            } else if (f.length >= 3) {
-                IrisPackRepository r = IrisPackRepository.builder()
-                        .user(f[0])
-                        .repo(f[1])
-                        .build();
-
-                if (f[2].startsWith("#")) {
-                    r.setTag(f[2].substring(1));
-                } else {
-                    r.setBranch(f[2]);
-                }
-
-                return r;
-            }
-        } else {
-            return IrisPackRepository.builder()
-                    .user("IrisDimensions")
-                    .repo(g)
-                    .branch(g.equals("overworld") ? "stable" : "master")
-                    .build();
-        }
-
-        return null;
-    }
-
-    public String toURL() {
-        if (!tag.trim().isEmpty()) {
-            return "https://codeload.github.com/" + user + "/" + repo + "/zip/refs/tags/" + tag;
-        }
-
-        return "https://codeload.github.com/" + user + "/" + repo + "/zip/refs/heads/" + branch;
-    }
-
-    public void install(VolmitSender sender, Runnable whenComplete) throws MalformedURLException {
-        File pack = Iris.instance.getDataFolderNoCreate(StudioSVC.WORKSPACE_NAME, getRepo());
-
-        if (!pack.exists()) {
-            File dl = new File(Iris.getTemp(), "dltk-" + UUID.randomUUID() + ".zip");
-            File work = new File(Iris.getTemp(), "extk-" + UUID.randomUUID());
-            new JobCollection(Form.capitalize(getRepo()),
-                    new DownloadJob(toURL(), pack),
-                    new SingleJob("Extracting", () -> ZipUtil.unpack(dl, work)),
-                    new SingleJob("Installing", () -> {
-                        try {
-                            FileUtils.copyDirectory(work.listFiles()[0], pack);
-                        } catch (IOException e) {
-                            e.printStackTrace();
-                        }
-                    })).execute(sender, whenComplete);
-        } else {
-            sender.sendMessage("Pack already exists!");
-        }
-    }
-}

core/src/main/java/com/volmit/iris/core/pregenerator/ChunkUpdater.java

@@ -1,320 +0,0 @@
-package com.volmit.iris.core.pregenerator;
-
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.IrisSettings;
-import com.volmit.iris.core.service.PreservationSVC;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.mantle.flag.MantleFlag;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.math.Position2;
-import com.volmit.iris.util.math.RollingSequence;
-import com.volmit.iris.util.plugin.chunk.TicketHolder;
-import com.volmit.iris.util.profile.LoadBalancer;
-import com.volmit.iris.util.scheduling.J;
-import io.papermc.lib.PaperLib;
-import org.bukkit.Bukkit;
-import org.bukkit.Chunk;
-import org.bukkit.World;
-
-import java.io.File;
-
-import java.util.concurrent.*;
-import java.util.concurrent.atomic.AtomicBoolean;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-
-public class ChunkUpdater {
-    private static final String REGION_PATH = "region" + File.separator + "r.";
-    private final AtomicBoolean paused = new AtomicBoolean();
-    private final AtomicBoolean cancelled = new AtomicBoolean();
-    private final TicketHolder holder;
-    private final RollingSequence chunksPerSecond = new RollingSequence(5);
-    private final AtomicInteger totalMaxChunks = new AtomicInteger();
-    private final AtomicInteger chunksProcessed = new AtomicInteger();
-    private final AtomicInteger chunksProcessedLast = new AtomicInteger();
-    private final AtomicInteger chunksUpdated = new AtomicInteger();
-    private final AtomicBoolean serverEmpty = new AtomicBoolean(true);
-    private final AtomicLong lastCpsTime = new AtomicLong(M.ms());
-    private final int maxConcurrency = IrisSettings.get().getUpdater().getMaxConcurrency();
-    private final int coreLimit = (int) Math.max(Runtime.getRuntime().availableProcessors() * IrisSettings.get().getUpdater().getThreadMultiplier(), 1);
-    private final Semaphore semaphore = new Semaphore(maxConcurrency);
-    private final LoadBalancer loadBalancer = new LoadBalancer(semaphore, maxConcurrency, IrisSettings.get().getUpdater().emptyMsRange);
-    private final AtomicLong startTime = new AtomicLong();
-    private final Dimensions dimensions;
-    private final PregenTask task;
-    private final ExecutorService chunkExecutor = IrisSettings.get().getUpdater().isNativeThreads() ? Executors.newFixedThreadPool(coreLimit) : Executors.newVirtualThreadPerTaskExecutor();
-    private final ScheduledExecutorService scheduler  = Executors.newScheduledThreadPool(1);
-    private final CountDownLatch latch;
-    private final Engine engine;
-    private final World world;
-
-    public ChunkUpdater(World world) {
-        this.engine = IrisToolbelt.access(world).getEngine();
-        this.world = world;
-        this.holder = Iris.tickets.getHolder(world);
-        this.dimensions = calculateWorldDimensions(new File(world.getWorldFolder(), "region"));
-        this.task = dimensions.task();
-        this.totalMaxChunks.set(dimensions.count * 1024);
-        this.latch = new CountDownLatch(totalMaxChunks.get());
-    }
-
-    public String getName() {
-        return world.getName();
-    }
-
-    public int getChunks() {
-        return totalMaxChunks.get();
-    }
-
-    public void start() {
-        unloadAndSaveAllChunks();
-        update();
-    }
-
-    public boolean pause() {
-        unloadAndSaveAllChunks();
-        if (paused.get()) {
-            paused.set(false);
-            return false;
-        } else {
-            paused.set(true);
-            return true;
-        }
-    }
-
-    public void stop() {
-        unloadAndSaveAllChunks();
-        cancelled.set(true);
-    }
-
-    private void update() {
-        Iris.info("Updating..");
-        try {
-            startTime.set(System.currentTimeMillis());
-            scheduler.scheduleAtFixedRate(() -> {
-                try {
-                    if (!paused.get()) {
-                        long eta = computeETA();
-                        int processed = chunksProcessed.get();
-                        double last = processed - chunksProcessedLast.getAndSet(processed);
-                        double cps = last / ((M.ms() - lastCpsTime.getAndSet(M.ms())) / 1000d);
-                        chunksPerSecond.put(cps);
-                        double percentage = ((double) processed / (double) totalMaxChunks.get()) * 100;
-                        if (!cancelled.get()) {
-                            Iris.info("Updated: " + Form.f(processed) + " of " + Form.f(totalMaxChunks.get()) + " (%.0f%%) " + Form.f(chunksPerSecond.getAverage()) + "/s, ETA: " + Form.duration(eta,
-                                    2), percentage);
-                        }
-                    }
-                } catch (Exception e) {
-                    Iris.reportError(e);
-                    e.printStackTrace();
-                }
-            }, 0, 3, TimeUnit.SECONDS);
-            scheduler.scheduleAtFixedRate(() -> {
-                boolean empty = Bukkit.getOnlinePlayers().isEmpty();
-                if (serverEmpty.getAndSet(empty) == empty)
-                    return;
-                loadBalancer.setRange(empty ? IrisSettings.get().getUpdater().emptyMsRange : IrisSettings.get().getUpdater().defaultMsRange);
-            }, 0, 10, TimeUnit.SECONDS);
-
-            var t = new Thread(() -> {
-                run();
-                close();
-            }, "Iris Chunk Updater - " + world.getName());
-            t.setPriority(Thread.MAX_PRIORITY);
-            t.start();
-
-            Iris.service(PreservationSVC.class).register(t);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    public void close() {
-        try {
-            loadBalancer.close();
-            semaphore.acquire(256);
-
-            chunkExecutor.shutdown();
-            chunkExecutor.awaitTermination(5, TimeUnit.SECONDS);
-            scheduler.shutdownNow();
-            unloadAndSaveAllChunks();
-        } catch (Exception ignored) {}
-        if (cancelled.get()) {
-            Iris.info("Updated: " + Form.f(chunksUpdated.get()) + " Chunks");
-            Iris.info("Irritated: " + Form.f(chunksProcessed.get()) + " of " + Form.f(totalMaxChunks.get()));
-            Iris.info("Stopped updater.");
-        } else {
-            Iris.info("Processed: " + Form.f(chunksProcessed.get()) + " Chunks");
-            Iris.info("Finished Updating: " + Form.f(chunksUpdated.get()) + " Chunks");
-        }
-    }
-
-    private void run() {
-        task.iterateRegions((rX, rZ) -> {
-            if (cancelled.get())
-                return;
-
-            while (paused.get()) {
-                J.sleep(50);
-            }
-
-            if (rX < dimensions.min.getX() ||
-                    rX > dimensions.max.getX() ||
-                    rZ < dimensions.min.getZ() ||
-                    rZ > dimensions.max.getZ() ||
-                    !new File(world.getWorldFolder(), REGION_PATH + rX + "." + rZ + ".mca").exists()
-            ) return;
-
-            task.iterateChunks(rX, rZ, (x, z) -> {
-                while (paused.get() && !cancelled.get()) {
-                    J.sleep(50);
-                }
-
-                try {
-                    semaphore.acquire();
-                } catch (InterruptedException ignored) {
-                    return;
-                }
-                chunkExecutor.submit(() -> {
-                    try {
-                        if (!cancelled.get())
-                            processChunk(x, z);
-                    } finally {
-                        latch.countDown();
-                        semaphore.release();
-                    }
-                });
-            });
-        });
-    }
-
-    private void processChunk(int x, int z) {
-        if (!loadChunksIfGenerated(x, z)) {
-            chunksProcessed.getAndIncrement();
-            return;
-        }
-
-        var mc = engine.getMantle().getMantle().getChunk(x, z).use();
-        try {
-            Chunk c = world.getChunkAt(x, z);
-            engine.updateChunk(c);
-
-            removeTickets(x, z);
-        } finally {
-            chunksUpdated.incrementAndGet();
-            chunksProcessed.getAndIncrement();
-            mc.release();
-        }
-    }
-
-    private boolean loadChunksIfGenerated(int x, int z) {
-        if (engine.getMantle().getMantle().hasFlag(x, z, MantleFlag.ETCHED))
-            return false;
-
-        for (int dx = -1; dx <= 1; dx++) {
-            for (int dz = -1; dz <= 1; dz++) {
-                if (!PaperLib.isChunkGenerated(world, x + dx, z + dz)) {
-                    return false;
-                }
-            }
-        }
-
-        AtomicBoolean generated = new AtomicBoolean(true);
-        CountDownLatch latch = new CountDownLatch(9);
-        for (int dx = -1; dx <= 1; dx++) {
-            for (int dz = -1; dz <= 1; dz++) {
-                int xx = x + dx;
-                int zz = z + dz;
-                PaperLib.getChunkAtAsync(world, xx, zz, false, true)
-                        .thenAccept(chunk -> {
-                            if (chunk == null || !chunk.isGenerated()) {
-                                latch.countDown();
-                                generated.set(false);
-                                return;
-                            }
-                            holder.addTicket(chunk);
-                            latch.countDown();
-                        });
-            }
-        }
-
-        try {
-            latch.await();
-        } catch (InterruptedException e) {
-            Iris.info("Interrupted while waiting for chunks to load");
-        }
-
-        if (generated.get()) return true;
-        removeTickets(x, z);
-        return false;
-    }
-
-    private void removeTickets(int x, int z) {
-        for (int xx = -1; xx <= 1; xx++) {
-            for (int zz = -1; zz <= 1; zz++) {
-                holder.removeTicket(x + xx, z + zz);
-            }
-        }
-    }
-
-    private void unloadAndSaveAllChunks() {
-        try {
-            J.sfut(() -> {
-                if (world == null) {
-                    Iris.warn("World was null somehow...");
-                    return;
-                }
-
-                world.save();
-            }).get();
-        } catch (Throwable e) {
-            Iris.reportError(e);
-            e.printStackTrace();
-        }
-    }
-
-    private long computeETA() {
-        return (long) (totalMaxChunks.get() > 1024 ? // Generated chunks exceed 1/8th of total?
-                // If yes, use smooth function (which gets more accurate over time since its less sensitive to outliers)
-                ((totalMaxChunks.get() - chunksProcessed.get()) * ((double) (M.ms() - startTime.get()) / (double) chunksProcessed.get())) :
-                // If no, use quick function (which is less accurate over time but responds better to the initial delay)
-                ((totalMaxChunks.get() - chunksProcessed.get()) / chunksPerSecond.getAverage()) * 1000
-        );
-    }
-
-    private Dimensions calculateWorldDimensions(File regionDir) {
-        File[] files = regionDir.listFiles((dir, name) -> name.endsWith(".mca"));
-
-        int minX = Integer.MAX_VALUE;
-        int maxX = Integer.MIN_VALUE;
-        int minZ = Integer.MAX_VALUE;
-        int maxZ = Integer.MIN_VALUE;
-
-        for (File file : files) {
-            String[] parts = file.getName().split("\\.");
-            int x = Integer.parseInt(parts[1]);
-            int z = Integer.parseInt(parts[2]);
-
-            minX = Math.min(minX, x);
-            maxX = Math.max(maxX, x);
-            minZ = Math.min(minZ, z);
-            maxZ = Math.max(maxZ, z);
-        }
-        int oX = minX + ((maxX - minX) / 2);
-        int oZ = minZ + ((maxZ - minZ) / 2);
-
-        int height = maxX - minX + 1;
-        int width = maxZ - minZ + 1;
-
-        return new Dimensions(new Position2(minX, minZ), new Position2(maxX, maxZ), height * width, PregenTask.builder()
-                .radiusZ((int) Math.ceil(width / 2d * 512))
-                .radiusX((int) Math.ceil(height / 2d * 512))
-                .center(new Position2(oX, oZ))
-                .build());
-    }
-
-    private record Dimensions(Position2 min, Position2 max, int count, PregenTask task) { }
-}

core/src/main/java/com/volmit/iris/core/pregenerator/DeepSearchPregenerator.java

@@ -1,274 +0,0 @@
-package com.volmit.iris.core.pregenerator;
-
-import com.google.gson.Gson;
-import com.volmit.iris.Iris;
-import com.volmit.iris.core.tools.IrisToolbelt;
-import com.volmit.iris.engine.framework.Engine;
-import com.volmit.iris.engine.object.IrisBiome;
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.format.C;
-import com.volmit.iris.util.format.Form;
-import com.volmit.iris.util.io.IO;
-import com.volmit.iris.util.math.M;
-import com.volmit.iris.util.math.Position2;
-import com.volmit.iris.util.math.RollingSequence;
-import com.volmit.iris.util.math.Spiraler;
-import com.volmit.iris.util.scheduling.ChronoLatch;
-import com.volmit.iris.util.scheduling.J;
-import lombok.Data;
-import lombok.Getter;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.world.WorldUnloadEvent;
-import org.bukkit.scheduler.BukkitRunnable;
-
-import java.io.File;
-import java.io.FileWriter;
-import java.io.IOException;
-import java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
-import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.concurrent.atomic.AtomicLong;
-import java.util.concurrent.locks.ReentrantLock;
-
-public class DeepSearchPregenerator extends Thread implements Listener {
-    @Getter
-    private static DeepSearchPregenerator instance;
-    private final DeepSearchJob job;
-    private final File destination;
-    private final int maxPosition;
-    private World world;
-    private final ChronoLatch latch;
-    private static AtomicInteger foundChunks;
-    private final AtomicInteger foundLast;
-    private final AtomicInteger foundTotalChunks;
-    private final AtomicLong startTime;
-    private final RollingSequence chunksPerSecond;
-    private final RollingSequence chunksPerMinute;
-    private final AtomicInteger chunkCachePos;
-    private final AtomicInteger chunkCacheSize;
-    private int pos;
-    private final AtomicInteger foundCacheLast;
-    private final AtomicInteger foundCache;
-    private LinkedHashMap<Integer, Position2> chunkCache;
-    private KList<Position2> chunkQueue;
-    private final ReentrantLock cacheLock;
-
-    private static final Map<String, DeepSearchJob> jobs = new HashMap<>();
-
-    public DeepSearchPregenerator(DeepSearchJob job, File destination) {
-        this.job = job;
-        this.chunkCacheSize = new AtomicInteger(); // todo
-        this.chunkCachePos = new AtomicInteger(1000);
-        this.foundCacheLast = new AtomicInteger();
-        this.foundCache = new AtomicInteger();
-        this.cacheLock = new ReentrantLock();
-        this.destination = destination;
-        this.chunkCache = new LinkedHashMap<>();
-        this.maxPosition = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
-        }).count();
-        this.world = Bukkit.getWorld(job.getWorld().getUID());
-        this.chunkQueue = new KList<>();
-        this.latch = new ChronoLatch(3000);
-        this.startTime = new AtomicLong(M.ms());
-        this.chunksPerSecond = new RollingSequence(10);
-        this.chunksPerMinute = new RollingSequence(10);
-        foundChunks = new AtomicInteger(0);
-        this.foundLast = new AtomicInteger(0);
-        this.foundTotalChunks = new AtomicInteger((int) Math.ceil(Math.pow((2.0 * job.getRadiusBlocks()) / 16, 2)));
-
-        this.pos = 0;
-        jobs.put(job.getWorld().getName(), job);
-        DeepSearchPregenerator.instance = this;
-    }
-
-    @EventHandler
-    public void on(WorldUnloadEvent e) {
-        if (e.getWorld().equals(world)) {
-            interrupt();
-        }
-    }
-
-    public void run() {
-        while (!interrupted()) {
-            tick();
-        }
-        try {
-            saveNow();
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-    }
-
-    public void tick() {
-        DeepSearchJob job = jobs.get(world.getName());
-       // chunkCache(); //todo finish this
-        if (latch.flip() && !job.paused) {
-            if (cacheLock.isLocked()) {
-                Iris.info("DeepFinder: Caching: " + chunkCachePos.get() + " Of " + chunkCacheSize.get());
-            } else {
-                long eta = computeETA();
-                save();
-                int secondGenerated = foundChunks.get() - foundLast.get();
-                foundLast.set(foundChunks.get());
-                secondGenerated = secondGenerated / 3;
-                chunksPerSecond.put(secondGenerated);
-                chunksPerMinute.put(secondGenerated * 60);
-                Iris.info("DeepFinder: " + C.IRIS + world.getName() + C.RESET + " Searching: " + Form.f(foundChunks.get()) + " of " + Form.f(foundTotalChunks.get()) + " " + Form.f((int) chunksPerSecond.getAverage()) + "/s ETA: " + Form.duration((double) eta, 2));
-            }
-
-        }
-        if (foundChunks.get() >= foundTotalChunks.get()) {
-            Iris.info("Completed DeepSearch!");
-            interrupt();
-        }
-    }
-
-    private long computeETA() {
-        return (long) ((foundTotalChunks.get() - foundChunks.get()) / chunksPerSecond.getAverage()) * 1000;
-        // todo broken
-    }
-
-    private final ExecutorService executorService = Executors.newSingleThreadExecutor();
-
-    private void queueSystem(Position2 chunk) {
-        if (chunkQueue.isEmpty()) {
-            for (int limit = 512; limit != 0; limit--) {
-                pos = job.getPosition() + 1;
-                chunkQueue.add(getChunk(pos));
-            }
-        } else {
-            //MCAUtil.read();
-
-        }
-
-
-    }
-
-    private void findInChunk(World world, int x, int z) throws IOException {
-        int xx = x * 16;
-        int zz = z * 16;
-        Engine engine = IrisToolbelt.access(world).getEngine();
-        for (int i = 0; i < 16; i++) {
-            for (int j = 0; j < 16; j++) {
-                int height = engine.getHeight(xx + i, zz + j);
-                if (height > 300) {
-                    File found = new File("plugins" + "iris" + "found.txt");
-                    FileWriter writer = new FileWriter(found);
-                    if (!found.exists()) {
-                        found.createNewFile();
-                    }
-                    IrisBiome biome = engine.getBiome(xx, engine.getHeight(), zz);
-                    Iris.info("Found at! " + xx + ", " + zz + "Biome ID: " + biome.getName() + ", ");
-                    writer.write("Biome at: X: " + xx + " Z: " + zz + "Biome ID: " + biome.getName() +  ", ");
-                    return;
-               }
-            }
-        }
-    }
-
-    public Position2 getChunk(int position) {
-        int p = -1;
-        AtomicInteger xx = new AtomicInteger();
-        AtomicInteger zz = new AtomicInteger();
-        Spiraler s = new Spiraler(job.getRadiusBlocks() * 2, job.getRadiusBlocks() * 2, (x, z) -> {
-            xx.set(x);
-            zz.set(z);
-        });
-
-        while (s.hasNext() && p++ < position) {
-            s.next();
-        }
-
-        return new Position2(xx.get(), zz.get());
-    }
-
-    public void save() {
-        J.a(() -> {
-            try {
-                saveNow();
-            } catch (Throwable e) {
-                e.printStackTrace();
-            }
-        });
-    }
-
-    public static void setPausedDeep(World world) {
-        DeepSearchJob job = jobs.get(world.getName());
-        if (isPausedDeep(world)){
-            job.paused = false;
-        } else {
-            job.paused = true;
-        }
-
-        if ( job.paused) {
-            Iris.info(C.BLUE + "DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " Paused");
-        } else {
-            Iris.info(C.BLUE + "DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " Resumed");
-        }
-    }
-
-    public static boolean isPausedDeep(World world) {
-        DeepSearchJob job = jobs.get(world.getName());
-        return job != null && job.isPaused();
-    }
-
-    public void shutdownInstance(World world) throws IOException {
-        Iris.info("DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " Shutting down..");
-        DeepSearchJob job = jobs.get(world.getName());
-        File worldDirectory = new File(Bukkit.getWorldContainer(), world.getName());
-        File deepFile = new File(worldDirectory, "DeepSearch.json");
-
-        if (job == null) {
-            Iris.error("No DeepSearch job found for world: " + world.getName());
-            return;
-        }
-
-        try {
-            if (!job.isPaused()) {
-                job.setPaused(true);
-            }
-            save();
-            jobs.remove(world.getName());
-            new BukkitRunnable() {
-                @Override
-                public void run() {
-                    while (deepFile.exists()){
-                        deepFile.delete();
-                        J.sleep(1000);
-                    }
-                    Iris.info("DeepSearch: " + C.IRIS + world.getName() + C.BLUE + " File deleted and instance closed.");
-                }
-            }.runTaskLater(Iris.instance, 20L);
-        } catch (Exception e) {
-            Iris.error("Failed to shutdown DeepSearch for " + world.getName());
-            e.printStackTrace();
-        } finally {
-            saveNow();
-            interrupt();
-        }
-    }
-
-
-    public void saveNow() throws IOException {
-        IO.writeAll(this.destination, new Gson().toJson(job));
-    }
-
-    @Data
-    @lombok.Builder
-    public static class DeepSearchJob {
-        private World world;
-        @lombok.Builder.Default
-        private int radiusBlocks = 5000;
-        @lombok.Builder.Default
-        private int position = 0;
-        @lombok.Builder.Default
-        boolean paused = false;
-    }
-}
-