commit 7c7ce877bcfa2a784fe2655f2bad8b6412091494 Author: MrPowerGamerBR Date: Wed Feb 24 10:48:15 2021 -0300 new fork who dis - First commit :tada: diff --git a/.github/workflows/sparklypaper.yml b/.github/workflows/sparklypaper.yml new file mode 100644 index 0000000..deb1486 --- /dev/null +++ b/.github/workflows/sparklypaper.yml @@ -0,0 +1,40 @@ +# From Airplane: https://github.com/TECHNOVE/Airplane/blob/master/.github/workflows/airplanelite.yml +# Thanks Airplane! :3 +name: Build main + +on: [push] + +jobs: + build: + runs-on: ubuntu-latest + + strategy: + matrix: + java: [11, 8] + + steps: + - uses: actions/checkout@v2 + + - name: Set up JDK ${{ matrix.java }} + uses: actions/setup-java@v1 + with: + java-version: ${{ matrix.java }} + + - uses: actions/cache@v2 + with: + path: ~/.m2/repository + key: ${{ runner.os }}-maven-${{ hashFiles('**/pom.xml') }} + restore-keys: ${{ runner.os }}-maven- + + - name: Patch SparklyPaper + run: | + git config --global user.email "you@example.com" + git config --global user.name "Your Name" + ./gradlew applyPatches + ./gradlew build + ./gradlew paperclip + + - uses: actions/upload-artifact@v2 + with: + name: SparklyPaper-JDK${{ matrix.java }} + path: launcher-sparklypaper.jar \ No newline at end of file diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..dbc1d0a --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +Airplane-API +Airplane-Server + +last-tuinity +build/ +.gradle/ + +launcher-airplane.jar + +.idea/ \ No newline at end of file diff --git a/.gitmodules b/.gitmodules new file mode 100644 index 0000000..74b1cd8 --- /dev/null +++ b/.gitmodules @@ -0,0 +1,3 @@ +[submodule "Tuinity"] + path = Tuinity + url = https://github.com/Spottedleaf/Tuinity.git diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..2def0e8 --- /dev/null +++ b/LICENSE @@ -0,0 +1,661 @@ + GNU AFFERO GENERAL PUBLIC LICENSE + Version 3, 19 November 2007 + + Copyright (C) 2007 Free Software Foundation, Inc. + Everyone is permitted to copy and distribute verbatim copies + of this license document, but changing it is not allowed. + + Preamble + + The GNU Affero General Public License is a free, copyleft license for +software and other kinds of works, specifically designed to ensure +cooperation with the community in the case of network server software. + + The licenses for most software and other practical works are designed +to take away your freedom to share and change the works. By contrast, +our General Public Licenses are 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. + + 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. + + Developers that use our General Public Licenses protect your rights +with two steps: (1) assert copyright on the software, and (2) offer +you this License which gives you legal permission to copy, distribute +and/or modify the software. + + A secondary benefit of defending all users' freedom is that +improvements made in alternate versions of the program, if they +receive widespread use, become available for other developers to +incorporate. Many developers of free software are heartened and +encouraged by the resulting cooperation. However, in the case of +software used on network servers, this result may fail to come about. +The GNU General Public License permits making a modified version and +letting the public access it on a server without ever releasing its +source code to the public. + + The GNU Affero General Public License is designed specifically to +ensure that, in such cases, the modified source code becomes available +to the community. It requires the operator of a network server to +provide the source code of the modified version running there to the +users of that server. Therefore, public use of a modified version, on +a publicly accessible server, gives the public access to the source +code of the modified version. + + An older license, called the Affero General Public License and +published by Affero, was designed to accomplish similar goals. This is +a different license, not a version of the Affero GPL, but Affero has +released a new version of the Affero GPL which permits relicensing under +this license. + + 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 Affero 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. Remote Network Interaction; Use with the GNU General Public License. + + Notwithstanding any other provision of this License, if you modify the +Program, your modified version must prominently offer all users +interacting with it remotely through a computer network (if your version +supports such interaction) an opportunity to receive the Corresponding +Source of your version by providing access to the Corresponding Source +from a network server at no charge, through some standard or customary +means of facilitating copying of software. This Corresponding Source +shall include the Corresponding Source for any work covered by version 3 +of the GNU General Public License that is incorporated pursuant to the +following paragraph. + + 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 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 work with which it is combined will remain governed by version +3 of the GNU General Public License. + + 14. Revised Versions of this License. + + The Free Software Foundation may publish revised and/or new versions of +the GNU Affero 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 Affero 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 Affero 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 Affero 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. + + + Copyright (C) + + This program is free software: you can redistribute it and/or modify + it under the terms of the GNU Affero 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 Affero General Public License for more details. + + You should have received a copy of the GNU Affero General Public License + along with this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + + If your software can interact with users remotely through a computer +network, you should also make sure that it provides a way for users to +get its source. For example, if your program is a web application, its +interface could display a "Source" link that leads users to an archive +of the code. There are many ways you could offer source, and different +solutions will be better for different programs; see section 13 for the +specific requirements. + + 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 AGPL, see +. \ No newline at end of file diff --git a/README.md b/README.md new file mode 100644 index 0000000..c77fad8 --- /dev/null +++ b/README.md @@ -0,0 +1,4 @@ + +

+ +

\ No newline at end of file diff --git a/SparklyPaper-API b/SparklyPaper-API new file mode 160000 index 0000000..06868d9 --- /dev/null +++ b/SparklyPaper-API @@ -0,0 +1 @@ +Subproject commit 06868d9b303333c8a0903e8ac54214fa844c5dc4 diff --git a/SparklyPaper-Server b/SparklyPaper-Server new file mode 160000 index 0000000..0b206b7 --- /dev/null +++ b/SparklyPaper-Server @@ -0,0 +1 @@ +Subproject commit 0b206b710af2feac86d49deba26cb45d89443626 diff --git a/Tuinity b/Tuinity new file mode 160000 index 0000000..2f298d3 --- /dev/null +++ b/Tuinity @@ -0,0 +1 @@ +Subproject commit 2f298d30e93c9c3cdfcf5cadc44daecc4c9e22c4 diff --git a/build.gradle.kts b/build.gradle.kts new file mode 100644 index 0000000..eab5619 --- /dev/null +++ b/build.gradle.kts @@ -0,0 +1,50 @@ +import xyz.jpenilla.toothpick.gitCmd +import xyz.jpenilla.toothpick.toothpick + +plugins { + `java-library` + id("xyz.jpenilla.toothpick") version "1.0.0-SNAPSHOT" +} + +toothpick { + forkName = "SparklyPaper" + groupId = "net.perfectdreams.sparklypaper" + val versionTag = System.getenv("BUILD_NUMBER") + ?: "\"${gitCmd("rev-parse", "--short", "HEAD").output}\"" + forkVersion = "git-$forkName-$versionTag" + forkUrl = "https://github.com/SparklyPower/SparklyPaper" + + minecraftVersion = "1.16.5" + nmsPackage = "1_16_R3" + nmsRevision = "R0.1-SNAPSHOT" + + upstream = "Tuinity" + upstreamBranch = "origin/master" + + paperclipName = "launcher-sparklypaper" + + server { + project = project(":$forkNameLowercase-server") + patchesDir = rootProject.projectDir.resolve("patches/server") + } + api { + project = project(":$forkNameLowercase-api") + patchesDir = rootProject.projectDir.resolve("patches/api") + } +} + +subprojects { + repositories { + mavenCentral() + maven("https://repo.aikar.co/content/groups/aikar/") + maven("https://nexus.velocitypowered.com/repository/velocity-artifacts-snapshots/") + maven("https://libraries.minecraft.net") + mavenLocal() + } + + java { + sourceCompatibility = JavaVersion.VERSION_1_8 + targetCompatibility = JavaVersion.VERSION_1_8 + withSourcesJar() + } +} diff --git a/gradle.properties b/gradle.properties new file mode 100644 index 0000000..a5950be --- /dev/null +++ b/gradle.properties @@ -0,0 +1,2 @@ +org.gradle.daemon=true +org.gradle.jvmargs=-Xmx2G diff --git a/gradle/wrapper/gradle-wrapper.jar b/gradle/wrapper/gradle-wrapper.jar new file mode 100644 index 0000000..e708b1c Binary files /dev/null and b/gradle/wrapper/gradle-wrapper.jar differ diff --git a/gradle/wrapper/gradle-wrapper.properties b/gradle/wrapper/gradle-wrapper.properties new file mode 100644 index 0000000..da9702f --- /dev/null +++ b/gradle/wrapper/gradle-wrapper.properties @@ -0,0 +1,5 @@ +distributionBase=GRADLE_USER_HOME +distributionPath=wrapper/dists +distributionUrl=https\://services.gradle.org/distributions/gradle-6.8-bin.zip +zipStoreBase=GRADLE_USER_HOME +zipStorePath=wrapper/dists diff --git a/gradlew b/gradlew new file mode 100644 index 0000000..4f906e0 --- /dev/null +++ b/gradlew @@ -0,0 +1,185 @@ +#!/usr/bin/env sh + +# +# Copyright 2015 the original author or authors. +# +# Licensed under the Apache License, Version 2.0 (the "License"); +# you may not use this file except in compliance with the License. +# You may obtain a copy of the License at +# +# https://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, software +# distributed under the License is distributed on an "AS IS" BASIS, +# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +# See the License for the specific language governing permissions and +# limitations under the License. +# + +############################################################################## +## +## Gradle start up script for UN*X +## +############################################################################## + +# Attempt to set APP_HOME +# Resolve links: $0 may be a link +PRG="$0" +# Need this for relative symlinks. +while [ -h "$PRG" ] ; do + ls=`ls -ld "$PRG"` + link=`expr "$ls" : '.*-> \(.*\)$'` + if expr "$link" : '/.*' > /dev/null; then + PRG="$link" + else + PRG=`dirname "$PRG"`"/$link" + fi +done +SAVED="`pwd`" +cd "`dirname \"$PRG\"`/" >/dev/null +APP_HOME="`pwd -P`" +cd "$SAVED" >/dev/null + +APP_NAME="Gradle" +APP_BASE_NAME=`basename "$0"` + +# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"' + +# Use the maximum available, or set MAX_FD != -1 to use that value. +MAX_FD="maximum" + +warn () { + echo "$*" +} + +die () { + echo + echo "$*" + echo + exit 1 +} + +# OS specific support (must be 'true' or 'false'). +cygwin=false +msys=false +darwin=false +nonstop=false +case "`uname`" in + CYGWIN* ) + cygwin=true + ;; + Darwin* ) + darwin=true + ;; + MINGW* ) + msys=true + ;; + NONSTOP* ) + nonstop=true + ;; +esac + +CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar + + +# Determine the Java command to use to start the JVM. +if [ -n "$JAVA_HOME" ] ; then + if [ -x "$JAVA_HOME/jre/sh/java" ] ; then + # IBM's JDK on AIX uses strange locations for the executables + JAVACMD="$JAVA_HOME/jre/sh/java" + else + JAVACMD="$JAVA_HOME/bin/java" + fi + if [ ! -x "$JAVACMD" ] ; then + die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." + fi +else + JAVACMD="java" + which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. + +Please set the JAVA_HOME variable in your environment to match the +location of your Java installation." +fi + +# Increase the maximum file descriptors if we can. +if [ "$cygwin" = "false" -a "$darwin" = "false" -a "$nonstop" = "false" ] ; then + MAX_FD_LIMIT=`ulimit -H -n` + if [ $? -eq 0 ] ; then + if [ "$MAX_FD" = "maximum" -o "$MAX_FD" = "max" ] ; then + MAX_FD="$MAX_FD_LIMIT" + fi + ulimit -n $MAX_FD + if [ $? -ne 0 ] ; then + warn "Could not set maximum file descriptor limit: $MAX_FD" + fi + else + warn "Could not query maximum file descriptor limit: $MAX_FD_LIMIT" + fi +fi + +# For Darwin, add options to specify how the application appears in the dock +if $darwin; then + GRADLE_OPTS="$GRADLE_OPTS \"-Xdock:name=$APP_NAME\" \"-Xdock:icon=$APP_HOME/media/gradle.icns\"" +fi + +# For Cygwin or MSYS, switch paths to Windows format before running java +if [ "$cygwin" = "true" -o "$msys" = "true" ] ; then + APP_HOME=`cygpath --path --mixed "$APP_HOME"` + CLASSPATH=`cygpath --path --mixed "$CLASSPATH"` + + JAVACMD=`cygpath --unix "$JAVACMD"` + + # We build the pattern for arguments to be converted via cygpath + ROOTDIRSRAW=`find -L / -maxdepth 1 -mindepth 1 -type d 2>/dev/null` + SEP="" + for dir in $ROOTDIRSRAW ; do + ROOTDIRS="$ROOTDIRS$SEP$dir" + SEP="|" + done + OURCYGPATTERN="(^($ROOTDIRS))" + # Add a user-defined pattern to the cygpath arguments + if [ "$GRADLE_CYGPATTERN" != "" ] ; then + OURCYGPATTERN="$OURCYGPATTERN|($GRADLE_CYGPATTERN)" + fi + # Now convert the arguments - kludge to limit ourselves to /bin/sh + i=0 + for arg in "$@" ; do + CHECK=`echo "$arg"|egrep -c "$OURCYGPATTERN" -` + CHECK2=`echo "$arg"|egrep -c "^-"` ### Determine if an option + + if [ $CHECK -ne 0 ] && [ $CHECK2 -eq 0 ] ; then ### Added a condition + eval `echo args$i`=`cygpath --path --ignore --mixed "$arg"` + else + eval `echo args$i`="\"$arg\"" + fi + i=`expr $i + 1` + done + case $i in + 0) set -- ;; + 1) set -- "$args0" ;; + 2) set -- "$args0" "$args1" ;; + 3) set -- "$args0" "$args1" "$args2" ;; + 4) set -- "$args0" "$args1" "$args2" "$args3" ;; + 5) set -- "$args0" "$args1" "$args2" "$args3" "$args4" ;; + 6) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" ;; + 7) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" ;; + 8) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" ;; + 9) set -- "$args0" "$args1" "$args2" "$args3" "$args4" "$args5" "$args6" "$args7" "$args8" ;; + esac +fi + +# Escape application args +save () { + for i do printf %s\\n "$i" | sed "s/'/'\\\\''/g;1s/^/'/;\$s/\$/' \\\\/" ; done + echo " " +} +APP_ARGS=`save "$@"` + +# Collect all arguments for the java command, following the shell quoting and substitution rules +eval set -- $DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS "\"-Dorg.gradle.appname=$APP_BASE_NAME\"" -classpath "\"$CLASSPATH\"" org.gradle.wrapper.GradleWrapperMain "$APP_ARGS" + +exec "$JAVACMD" "$@" diff --git a/gradlew.bat b/gradlew.bat new file mode 100644 index 0000000..107acd3 --- /dev/null +++ b/gradlew.bat @@ -0,0 +1,89 @@ +@rem +@rem Copyright 2015 the original author or authors. +@rem +@rem Licensed under the Apache License, Version 2.0 (the "License"); +@rem you may not use this file except in compliance with the License. +@rem You may obtain a copy of the License at +@rem +@rem https://www.apache.org/licenses/LICENSE-2.0 +@rem +@rem Unless required by applicable law or agreed to in writing, software +@rem distributed under the License is distributed on an "AS IS" BASIS, +@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +@rem See the License for the specific language governing permissions and +@rem limitations under the License. +@rem + +@if "%DEBUG%" == "" @echo off +@rem ########################################################################## +@rem +@rem Gradle startup script for Windows +@rem +@rem ########################################################################## + +@rem Set local scope for the variables with windows NT shell +if "%OS%"=="Windows_NT" setlocal + +set DIRNAME=%~dp0 +if "%DIRNAME%" == "" set DIRNAME=. +set APP_BASE_NAME=%~n0 +set APP_HOME=%DIRNAME% + +@rem Resolve any "." and ".." in APP_HOME to make it shorter. +for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi + +@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script. +set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m" + +@rem Find java.exe +if defined JAVA_HOME goto findJavaFromJavaHome + +set JAVA_EXE=java.exe +%JAVA_EXE% -version >NUL 2>&1 +if "%ERRORLEVEL%" == "0" goto execute + +echo. +echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH. +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:findJavaFromJavaHome +set JAVA_HOME=%JAVA_HOME:"=% +set JAVA_EXE=%JAVA_HOME%/bin/java.exe + +if exist "%JAVA_EXE%" goto execute + +echo. +echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME% +echo. +echo Please set the JAVA_HOME variable in your environment to match the +echo location of your Java installation. + +goto fail + +:execute +@rem Setup the command line + +set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar + + +@rem Execute Gradle +"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %* + +:end +@rem End local scope for the variables with windows NT shell +if "%ERRORLEVEL%"=="0" goto mainEnd + +:fail +rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of +rem the _cmd.exe /c_ return code! +if not "" == "%GRADLE_EXIT_CONSOLE%" exit 1 +exit /b 1 + +:mainEnd +if "%OS%"=="Windows_NT" endlocal + +:omega diff --git a/mcdevimports.json b/mcdevimports.json new file mode 100644 index 0000000..291a11e --- /dev/null +++ b/mcdevimports.json @@ -0,0 +1,3 @@ +{ + "nmsImports": [ "PacketPlayOutBlockChange" ] +} \ No newline at end of file diff --git a/patches/api/.gitkeep b/patches/api/.gitkeep new file mode 100644 index 0000000..e69de29 diff --git a/patches/api/0001-new-fork-who-dis-Rebrand-to-SparklyPaper.patch b/patches/api/0001-new-fork-who-dis-Rebrand-to-SparklyPaper.patch new file mode 100644 index 0000000..aa0c78d --- /dev/null +++ b/patches/api/0001-new-fork-who-dis-Rebrand-to-SparklyPaper.patch @@ -0,0 +1,32 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: MrPowerGamerBR +Date: Tue, 23 Feb 2021 10:27:40 -0300 +Subject: [PATCH] new fork who dis - Rebrand to SparklyPaper + + +diff --git a/pom.xml b/pom.xml +index c441d455e2273b63d2cec136872a5025182d75d6..580736a267ea7d65a04dea020dd3c69963eb4d5e 100644 +--- a/pom.xml ++++ b/pom.xml +@@ -3,8 +3,8 @@ + xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd"> + 4.0.0 + +- com.tuinity +- tuinity-parent ++ net.perfectdreams.sparklypaper ++ sparklypaper-parent + dev-SNAPSHOT + ../pom.xml + +@@ -13,8 +13,8 @@ + 1.16.5-R0.1-SNAPSHOT + jar + +- Tuinity-API +- https://github.com/Spottedleaf/Tuinity ++ SparklyPaper-API ++ https://github.com/SparklyPower/SparklyPaper + An enhanced plugin API for Minecraft servers. + + diff --git a/patches/api/0002-Fix-NotePlayEvent.patch b/patches/api/0002-Fix-NotePlayEvent.patch new file mode 100644 index 0000000..3a90c28 --- /dev/null +++ b/patches/api/0002-Fix-NotePlayEvent.patch @@ -0,0 +1,108 @@ +From 502314e373a9e4cf31d1778f63dfaad39b644198 Mon Sep 17 00:00:00 2001 +From: Kieran Wallbanks +Date: Thu, 11 Feb 2021 11:27:24 +0000 +Subject: [PATCH] Fix NotePlayEvent + +--- + src/main/java/org/bukkit/Instrument.java | 29 +++++++++++++++---- + .../org/bukkit/event/block/NotePlayEvent.java | 4 --- + 2 files changed, 24 insertions(+), 9 deletions(-) + +diff --git a/src/main/java/org/bukkit/Instrument.java b/src/main/java/org/bukkit/Instrument.java +index 92194803..82ddb000 100644 +--- a/src/main/java/org/bukkit/Instrument.java ++++ b/src/main/java/org/bukkit/Instrument.java +@@ -3,33 +3,34 @@ package org.bukkit; + import com.google.common.collect.Maps; + import java.util.Map; + import org.jetbrains.annotations.Nullable; ++import org.jetbrains.annotations.NotNull; // Haricot - add constructor for actual state value names + + public enum Instrument { + + /** + * Piano is the standard instrument for a note block. + */ +- PIANO(0x0), ++ PIANO(0x0, "harp"), // Haricot - add constructor for actual state value names + /** + * Bass drum is normally played when a note block is on top of a + * stone-like block. + */ +- BASS_DRUM(0x1), ++ BASS_DRUM(0x1, "basedrum"), // Haricot - add constructor for actual state value names + /** + * Snare drum is normally played when a note block is on top of a sandy + * block. + */ +- SNARE_DRUM(0x2), ++ SNARE_DRUM(0x2, "snare"), // Haricot - add constructor for actual state value names + /** + * Sticks are normally played when a note block is on top of a glass + * block. + */ +- STICKS(0x3), ++ STICKS(0x3, "hat"), // Haricot - add constructor for actual state value names + /** + * Bass guitar is normally played when a note block is on top of a wooden + * block. + */ +- BASS_GUITAR(0x4), ++ BASS_GUITAR(0x4, "bass"), // Haricot - add constructor for actual state value names + /** + * Flute is normally played when a note block is on top of a clay block. + */ +@@ -81,8 +82,26 @@ public enum Instrument { + + private Instrument(final int type) { + this.type = (byte) type; ++ this.value = this.name().toLowerCase(); // Haricot - add constructor for actual state value names + } + ++ // Haricot start - add constructor for actual state value names ++ private final String value; ++ ++ Instrument(final int type, final String value) { ++ this.type = (byte) type; ++ this.value = value; ++ } ++ ++ /** ++ * Gets the name of the instrument, as found in the block state. ++ * @return the name of the instrument ++ */ ++ public @NotNull String getName() { ++ return this.value; ++ } ++ // Haricot end ++ + /** + * @return The type ID of this instrument. + * @deprecated Magic value +diff --git a/src/main/java/org/bukkit/event/block/NotePlayEvent.java b/src/main/java/org/bukkit/event/block/NotePlayEvent.java +index a3887067..676b31f6 100644 +--- a/src/main/java/org/bukkit/event/block/NotePlayEvent.java ++++ b/src/main/java/org/bukkit/event/block/NotePlayEvent.java +@@ -58,9 +58,7 @@ public class NotePlayEvent extends BlockEvent implements Cancellable { + * Overrides the {@link Instrument} to be used. + * + * @param instrument the Instrument. Has no effect if null. +- * @deprecated no effect on newer Minecraft versions + */ +- @Deprecated + public void setInstrument(@NotNull Instrument instrument) { + if (instrument != null) { + this.instrument = instrument; +@@ -71,9 +69,7 @@ public class NotePlayEvent extends BlockEvent implements Cancellable { + * Overrides the {@link Note} to be played. + * + * @param note the Note. Has no effect if null. +- * @deprecated no effect on newer Minecraft versions + */ +- @Deprecated + public void setNote(@NotNull Note note) { + if (note != null) { + this.note = note; +-- +2.25.1 + diff --git a/patches/api/0003-More-note-block-events.patch b/patches/api/0003-More-note-block-events.patch new file mode 100644 index 0000000..8c68724 --- /dev/null +++ b/patches/api/0003-More-note-block-events.patch @@ -0,0 +1,151 @@ +From 10a10970b7e62160a78a4ce2a7a06f73676ba0a6 Mon Sep 17 00:00:00 2001 +From: Kieran Wallbanks +Date: Thu, 11 Feb 2021 13:16:44 +0000 +Subject: [PATCH] More note block events + +--- + .../event/block/NoteBlockPlaceEvent.java | 44 ++++++++++ + .../event/block/NoteBlockUpdateEvent.java | 80 +++++++++++++++++++ + 2 files changed, 124 insertions(+) + create mode 100644 src/main/java/ml/beancraft/haricot/event/block/NoteBlockPlaceEvent.java + create mode 100644 src/main/java/ml/beancraft/haricot/event/block/NoteBlockUpdateEvent.java + +diff --git a/src/main/java/ml/beancraft/haricot/event/block/NoteBlockPlaceEvent.java b/src/main/java/ml/beancraft/haricot/event/block/NoteBlockPlaceEvent.java +new file mode 100644 +index 00000000..2a22bb7c +--- /dev/null ++++ b/src/main/java/ml/beancraft/haricot/event/block/NoteBlockPlaceEvent.java +@@ -0,0 +1,44 @@ ++package ml.beancraft.haricot.event.block; ++ ++import org.bukkit.block.Block; ++import org.bukkit.block.data.type.NoteBlock; ++import org.bukkit.event.HandlerList; ++import org.bukkit.event.block.BlockEvent; ++import org.bukkit.inventory.ItemStack; ++import org.jetbrains.annotations.NotNull; ++ ++public class NoteBlockPlaceEvent extends BlockEvent { ++ private static final HandlerList handlers = new HandlerList(); ++ ++ private final ItemStack itemInHand; ++ private NoteBlock data; ++ ++ public NoteBlockPlaceEvent(@NotNull Block block, @NotNull NoteBlock data, @NotNull ItemStack itemInHand) { ++ super(block); ++ this.data = data; ++ this.itemInHand = itemInHand; ++ } ++ ++ public @NotNull ItemStack getItemInHand() { ++ return itemInHand; ++ } ++ ++ public @NotNull NoteBlock getData() { ++ return data; ++ } ++ ++ public void setData(@NotNull NoteBlock data) { ++ this.data = data; ++ } ++ ++ @NotNull ++ @Override ++ public HandlerList getHandlers() { ++ return handlers; ++ } ++ ++ @NotNull ++ public static HandlerList getHandlerList() { ++ return handlers; ++ } ++} +diff --git a/src/main/java/ml/beancraft/haricot/event/block/NoteBlockUpdateEvent.java b/src/main/java/ml/beancraft/haricot/event/block/NoteBlockUpdateEvent.java +new file mode 100644 +index 00000000..c1d8b37c +--- /dev/null ++++ b/src/main/java/ml/beancraft/haricot/event/block/NoteBlockUpdateEvent.java +@@ -0,0 +1,80 @@ ++package ml.beancraft.haricot.event.block; ++ ++import org.apache.commons.lang.Validate; ++import org.bukkit.block.Block; ++import org.bukkit.block.data.type.NoteBlock; ++import org.bukkit.event.Cancellable; ++import org.bukkit.event.HandlerList; ++import org.bukkit.event.block.BlockEvent; ++import org.jetbrains.annotations.NotNull; ++ ++/** ++ * Called when the data of a note block changes. Note that this may not be called for ++ * every note block update and might be called multiple times for one cause. ++ */ ++public class NoteBlockUpdateEvent extends BlockEvent implements Cancellable { ++ private static final HandlerList handlers = new HandlerList(); ++ ++ private final NoteBlock oldData; ++ private NoteBlock newData; ++ private boolean cancelled; ++ ++ /** ++ * Constructs a new note block update event. ++ * @param theBlock the block that is being updated ++ * @param oldData the data the block had before the update ++ * @param newData the data this block is going to have after the update ++ */ ++ public NoteBlockUpdateEvent(@NotNull Block theBlock, @NotNull NoteBlock oldData, @NotNull NoteBlock newData) { ++ super(theBlock); ++ this.oldData = oldData; ++ this.newData = newData; ++ this.cancelled = false; ++ } ++ ++ /** ++ * Gets the data of the note block before the update. ++ * @return the data ++ */ ++ public @NotNull NoteBlock getOldData() { ++ return this.oldData; ++ } ++ ++ /** ++ * Gets the data that the note block will have after this event. ++ * @return the data ++ */ ++ public @NotNull NoteBlock getNewData() { ++ return this.newData; ++ } ++ ++ /** ++ * Sets the data that the note block will have after this event. ++ * @param data the data ++ */ ++ public void setNewData(@NotNull NoteBlock data) { ++ Validate.notNull(data, "Data cannot be null"); ++ this.newData = data; ++ } ++ ++ @Override ++ public boolean isCancelled() { ++ return cancelled; ++ } ++ ++ @Override ++ public void setCancelled(boolean cancel) { ++ this.cancelled = cancel; ++ } ++ ++ @NotNull ++ @Override ++ public HandlerList getHandlers() { ++ return handlers; ++ } ++ ++ @NotNull ++ public static HandlerList getHandlerList() { ++ return handlers; ++ } ++} +-- +2.25.1 + diff --git a/patches/server/0001-new-fork-who-dis-Rebrand-to-SparklyPaper.patch b/patches/server/0001-new-fork-who-dis-Rebrand-to-SparklyPaper.patch new file mode 100644 index 0000000..fa6b4b5 --- /dev/null +++ b/patches/server/0001-new-fork-who-dis-Rebrand-to-SparklyPaper.patch @@ -0,0 +1,108 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: MrPowerGamerBR +Date: Mon, 22 Feb 2021 17:44:11 -0300 +Subject: [PATCH] new fork who dis - Rebrand to SparklyPaper + + +diff --git a/pom.xml b/pom.xml +index e83e4241a56fe131a75fe21cc1518992c089da2c..ef6d6019a5782d42ea6cd73f76e01f4e985771de 100644 +--- a/pom.xml ++++ b/pom.xml +@@ -1,11 +1,11 @@ + + 4.0.0 +- tuinity ++ sparklypaper + jar + 1.16.5-R0.1-SNAPSHOT +- Tuinity-Server +- https://github.com/Spottedleaf/Tuinity ++ SparklyPaper-Server ++ https://github.com/SparklyPower/SparklyPaper + + + +@@ -19,8 +19,8 @@ + + + +- com.tuinity +- tuinity-parent ++ net.perfectdreams.sparklypaper ++ sparklypaper-parent + dev-SNAPSHOT + ../pom.xml + +@@ -183,7 +183,7 @@ + + + +- tuinity-${minecraft.version} ++ sparklypaper-${minecraft.version} + install + + +@@ -191,7 +191,7 @@ + gitdescribe-maven-plugin + 1.3 + +- git-Tuinity- ++ git-SparklyPaper- + .. + + +diff --git a/src/main/java/com/destroystokyo/paper/PaperVersionFetcher.java b/src/main/java/com/destroystokyo/paper/PaperVersionFetcher.java +index 255bbd6e48b95c70fad02ba692c64c7579496827..bbe8902b6ace3c2bd9eb49192d9cd855e0a88565 100644 +--- a/src/main/java/com/destroystokyo/paper/PaperVersionFetcher.java ++++ b/src/main/java/com/destroystokyo/paper/PaperVersionFetcher.java +@@ -24,8 +24,8 @@ public class PaperVersionFetcher implements VersionFetcher { + @Nonnull + @Override + public String getVersionMessage(@Nonnull String serverVersion) { +- String[] parts = serverVersion.substring("git-Tuinity-".length()).split("[-\\s]"); // Tuinity +- String updateMessage = getUpdateStatusMessage("Spottedleaf/Tuinity", GITHUB_BRANCH_NAME, parts[0]); // Tuinity ++ String[] parts = serverVersion.substring("git-SparklyPaper-".length()).split("[-\\s]"); // SparklyPaper // Tuinity ++ String updateMessage = getUpdateStatusMessage("SparklyPower/SparklyPaper", GITHUB_BRANCH_NAME, parts[0]); // SparklyPaper // Tuinity + String history = getHistory(); + + return history != null ? history + "\n" + updateMessage : updateMessage; +diff --git a/src/main/java/net/minecraft/server/MinecraftServer.java b/src/main/java/net/minecraft/server/MinecraftServer.java +index 1768554b00ea0b7a57ebbed1f0bc5d8fd6f02f76..c08b6bfc2861d5ee227424ec5950b9a4d8ba3e5c 100644 +--- a/src/main/java/net/minecraft/server/MinecraftServer.java ++++ b/src/main/java/net/minecraft/server/MinecraftServer.java +@@ -1513,7 +1513,7 @@ public abstract class MinecraftServer extends IAsyncTaskHandlerReentrant // Spigot - Spigot > // CraftBukkit - cb > vanilla! ++ return "SparklyPaper"; // SparklyPaper // Tuinity //Paper - Paper > // Spigot - Spigot > // CraftBukkit - cb > vanilla! + } + + public CrashReport b(CrashReport crashreport) { +diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java +index 44524e08bed8897e43e408b6f179bf798fed9b62..0272750bfb233fd3f2ae6a734f539a84a2dd5cb5 100644 +--- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java ++++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java +@@ -231,7 +231,7 @@ import javax.annotation.Nullable; // Paper + import javax.annotation.Nonnull; // Paper + + public final class CraftServer implements Server { +- private final String serverName = "Tuinity"; // Paper // Tuinity ++ private final String serverName = "SparklyPaper"; // SparklyPaper // Paper // Tuinity + private final String serverVersion; + private final String bukkitVersion = Versioning.getBukkitVersion(); + private final Logger logger = Logger.getLogger("Minecraft"); +diff --git a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java +index 001b1e5197eaa51bfff9031aa6c69876c9a47960..a299350e03e805bf3ad155ee5380895a4c0e8b14 100644 +--- a/src/main/java/org/bukkit/craftbukkit/util/Versioning.java ++++ b/src/main/java/org/bukkit/craftbukkit/util/Versioning.java +@@ -11,7 +11,7 @@ public final class Versioning { + public static String getBukkitVersion() { + String result = "Unknown-Version"; + +- InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/com.tuinity/tuinity-api/pom.properties"); // Tuinity ++ InputStream stream = Bukkit.class.getClassLoader().getResourceAsStream("META-INF/maven/net.perfectdreams.sparklypaper/sparklypaper-api/pom.properties"); // SparklyPaper // Tuinity + Properties properties = new Properties(); + + if (stream != null) { diff --git a/patches/server/0004-Fix-NotePlayEvent.patch b/patches/server/0004-Fix-NotePlayEvent.patch new file mode 100644 index 0000000..01439f9 --- /dev/null +++ b/patches/server/0004-Fix-NotePlayEvent.patch @@ -0,0 +1,54 @@ +From 742fb14262501f071993273011de76a2dabb28b5 Mon Sep 17 00:00:00 2001 +From: Kieran Wallbanks +Date: Thu, 11 Feb 2021 11:31:38 +0000 +Subject: [PATCH] Fix NotePlayEvent + +--- + .../java/net/minecraft/server/BlockNote.java | 22 ++++++++++++------- + 1 file changed, 14 insertions(+), 8 deletions(-) + +diff --git a/src/main/java/net/minecraft/server/BlockNote.java b/src/main/java/net/minecraft/server/BlockNote.java +index df69d00d3..7111ba9c2 100644 +--- a/src/main/java/net/minecraft/server/BlockNote.java ++++ b/src/main/java/net/minecraft/server/BlockNote.java +@@ -39,10 +39,9 @@ public class BlockNote extends Block { + private void play(World world, BlockPosition blockposition, IBlockData data) { // CraftBukkit + if (world.getType(blockposition.up()).isAir()) { + // CraftBukkit start +- org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, blockposition, data.get(BlockNote.INSTRUMENT), data.get(BlockNote.NOTE)); +- if (!event.isCancelled()) { +- world.playBlockAction(blockposition, this, 0, 0); +- } ++ // Haricot start - move NotePlayEvent call to fix instrument/note changes ++ world.playBlockAction(blockposition, this, 0, 0); ++ // Haricot end + // CraftBukkit end + } + +@@ -71,12 +70,19 @@ public class BlockNote extends Block { + + @Override + public boolean a(IBlockData iblockdata, World world, BlockPosition blockposition, int i, int j) { +- int k = (Integer) iblockdata.get(BlockNote.NOTE); ++ // Haricot start - move NotePlayEvent call to fix instrument/note changes ++ org.bukkit.event.block.NotePlayEvent event = org.bukkit.craftbukkit.event.CraftEventFactory.callNotePlayEvent(world, blockposition, iblockdata.get(BlockNote.INSTRUMENT), iblockdata.get(BlockNote.NOTE)); ++ ++ int k = event.getNote().getId(); + float f = (float) Math.pow(2.0D, (double) (k - 12) / 12.0D); + +- world.playSound((EntityHuman) null, blockposition, ((BlockPropertyInstrument) iblockdata.get(BlockNote.INSTRUMENT)).b(), SoundCategory.RECORDS, 3.0F, f); +- world.addParticle(Particles.NOTE, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 1.2D, (double) blockposition.getZ() + 0.5D, (double) k / 24.0D, 0.0D, 0.0D); +- return true; ++ if (!event.isCancelled()) { ++ world.playSound((EntityHuman) null, blockposition, BlockPropertyInstrument.valueOf(event.getInstrument().getName().toUpperCase()).b(), SoundCategory.RECORDS, 3.0F, f); ++ world.addParticle(Particles.NOTE, (double) blockposition.getX() + 0.5D, (double) blockposition.getY() + 1.2D, (double) blockposition.getZ() + 0.5D, (double) k / 24.0D, 0.0D, 0.0D); ++ return true; ++ } ++ return false; ++ // Haricot end + } + + @Override +-- +2.25.1 + diff --git a/patches/server/0005-More-note-block-events.patch b/patches/server/0005-More-note-block-events.patch new file mode 100644 index 0000000..a048d60 --- /dev/null +++ b/patches/server/0005-More-note-block-events.patch @@ -0,0 +1,110 @@ +From 50416a2ef110abe02e86b83bddc08464b8addb81 Mon Sep 17 00:00:00 2001 +From: Kieran Wallbanks +Date: Thu, 11 Feb 2021 13:17:03 +0000 +Subject: [PATCH] More note block events + +--- + .../java/net/minecraft/server/BlockNote.java | 63 ++++++++++++++++--- + 1 file changed, 56 insertions(+), 7 deletions(-) + +diff --git a/src/main/java/net/minecraft/server/BlockNote.java b/src/main/java/net/minecraft/server/BlockNote.java +index 7111ba9c2..f8261543d 100644 +--- a/src/main/java/net/minecraft/server/BlockNote.java ++++ b/src/main/java/net/minecraft/server/BlockNote.java +@@ -1,5 +1,12 @@ + package net.minecraft.server; + ++// Haricot start ++import ml.beancraft.haricot.event.block.NoteBlockPlaceEvent; ++import ml.beancraft.haricot.event.block.NoteBlockUpdateEvent; ++import org.bukkit.craftbukkit.block.CraftBlock; ++import org.bukkit.craftbukkit.block.impl.CraftNote; ++// Haricot end ++ + public class BlockNote extends Block { + + public static final BlockStateEnum INSTRUMENT = BlockProperties.aI; +@@ -13,12 +20,32 @@ public class BlockNote extends Block { + + @Override + public IBlockData getPlacedState(BlockActionContext blockactioncontext) { +- return (IBlockData) this.getBlockData().set(BlockNote.INSTRUMENT, BlockPropertyInstrument.a(blockactioncontext.getWorld().getType(blockactioncontext.getClickPosition().down()))); ++ // Haricot start - note block api ++ NoteBlockPlaceEvent event = new NoteBlockPlaceEvent(new CraftBlock(blockactioncontext.getWorld(), blockactioncontext.getClickPosition()), ++ new CraftNote(this.blockStateList.getBlockData()), blockactioncontext.getItemStack().asBukkitMirror()); ++ event.callEvent(); ++ ++ return this.getBlockData().set(INSTRUMENT, BlockPropertyInstrument.valueOf(event.getData().getInstrument().getName().toUpperCase())) ++ .set(NOTE, (int) event.getData().getNote().getId()) ++ .set(POWERED, event.getData().isPowered()); ++ // Haricot end + } + + @Override + public IBlockData updateState(IBlockData iblockdata, EnumDirection enumdirection, IBlockData iblockdata1, GeneratorAccess generatoraccess, BlockPosition blockposition, BlockPosition blockposition1) { +- return enumdirection == EnumDirection.DOWN ? (IBlockData) iblockdata.set(BlockNote.INSTRUMENT, BlockPropertyInstrument.a(iblockdata1)) : super.updateState(iblockdata, enumdirection, iblockdata1, generatoraccess, blockposition, blockposition1); ++ // Haricot start - note block api ++ NoteBlockUpdateEvent event = new NoteBlockUpdateEvent(new CraftBlock(generatoraccess, blockposition), new CraftNote(iblockdata), ++ new CraftNote(enumdirection == EnumDirection.DOWN ? iblockdata.set(BlockNote.INSTRUMENT, BlockPropertyInstrument.a(iblockdata1)) : iblockdata)); ++ event.callEvent(); ++ ++ if (!event.isCancelled()) { ++ return iblockdata.set(INSTRUMENT, BlockPropertyInstrument.valueOf(event.getNewData().getInstrument().getName().toUpperCase())) ++ .set(NOTE, (int) event.getNewData().getNote().getId()) ++ .set(POWERED, event.getNewData().isPowered()); ++ } else { ++ return iblockdata; ++ } ++ // Haricot end + } + + @Override +@@ -31,7 +58,18 @@ public class BlockNote extends Block { + iblockdata = world.getType(blockposition); // CraftBukkit - SPIGOT-5617: update in case changed in event + } + +- world.setTypeAndData(blockposition, (IBlockData) iblockdata.set(BlockNote.POWERED, flag1), 3); ++ // Haricot start - note block api ++ NoteBlockUpdateEvent event = new NoteBlockUpdateEvent(new CraftBlock(world, blockposition), new CraftNote(iblockdata), ++ new CraftNote(iblockdata.set(BlockNote.POWERED, flag1))); ++ event.callEvent(); ++ ++ if (!event.isCancelled()) { ++ world.setTypeAndData(blockposition, iblockdata ++ .set(INSTRUMENT, BlockPropertyInstrument.valueOf(event.getNewData().getInstrument().getName().toUpperCase())) ++ .set(NOTE, (int) event.getNewData().getNote().getId()) ++ .set(POWERED, event.getNewData().isPowered()), 3); ++ } ++ // Haricot end + } + + } +@@ -52,10 +90,21 @@ public class BlockNote extends Block { + if (world.isClientSide) { + return EnumInteractionResult.SUCCESS; + } else { +- iblockdata = (IBlockData) iblockdata.a((IBlockState) BlockNote.NOTE); +- world.setTypeAndData(blockposition, iblockdata, 3); +- this.play(world, blockposition, iblockdata); // CraftBukkit +- entityhuman.a(StatisticList.TUNE_NOTEBLOCK); ++ // Haricot start - note block api ++ NoteBlockUpdateEvent event = new NoteBlockUpdateEvent(new CraftBlock(world, blockposition), new CraftNote(iblockdata), ++ new CraftNote(iblockdata.a(NOTE))); ++ event.callEvent(); ++ ++ if (!event.isCancelled()) { ++ IBlockData newData = iblockdata ++ .set(INSTRUMENT, BlockPropertyInstrument.valueOf(event.getNewData().getInstrument().getName().toUpperCase())) ++ .set(NOTE, (int) event.getNewData().getNote().getId()) ++ .set(POWERED, event.getNewData().isPowered()); ++ world.setTypeAndData(blockposition, newData, 3); ++ this.play(world, blockposition, newData); ++ entityhuman.a(StatisticList.TUNE_NOTEBLOCK); ++ } ++ // Haricot end + return EnumInteractionResult.CONSUME; + } + } +-- +2.25.1 + diff --git a/patches/server/0005-Remove-streams.patch b/patches/server/0005-Remove-streams.patch new file mode 100644 index 0000000..c6d5d82 --- /dev/null +++ b/patches/server/0005-Remove-streams.patch @@ -0,0 +1,57 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Sat, 23 Jan 2021 16:42:24 -0600 +Subject: [PATCH] Remove streams + +Airplane +Copyright (C) 2020 Technove LLC + +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 . + +diff --git a/src/main/java/net/minecraft/server/BehaviorBetterJob.java b/src/main/java/net/minecraft/server/BehaviorBetterJob.java +index 19f8cf4384ff7a1515ad33a5f573ea0061bab93d..e6507a9bef705e1496497ad6b58a546348a0779e 100644 +--- a/src/main/java/net/minecraft/server/BehaviorBetterJob.java ++++ b/src/main/java/net/minecraft/server/BehaviorBetterJob.java +@@ -14,11 +14,31 @@ public class BehaviorBetterJob extends Behavior { + protected void a(WorldServer worldserver, EntityVillager entityvillager, long i) { + GlobalPos globalpos = (GlobalPos) entityvillager.getBehaviorController().getMemory(MemoryModuleType.JOB_SITE).get(); + ++ // Airplane start - remove stream ++ /* + worldserver.y().c(globalpos.getBlockPosition()).ifPresent((villageplacetype) -> { + BehaviorUtil.a(entityvillager, (entityvillager1) -> { + return this.a(globalpos, villageplacetype, entityvillager1); + }).reduce(entityvillager, BehaviorBetterJob::a); + }); ++ */ ++ java.util.Optional optVillagePlaceType = worldserver.y().c(globalpos.getBlockPosition()); ++ if (optVillagePlaceType.isPresent()) { ++ VillagePlaceType villageplacetype = optVillagePlaceType.get(); ++ java.util.Optional> optList = entityvillager.getBehaviorController().getMemory(MemoryModuleType.MOBS); ++ if (optList.isPresent()) { ++ EntityVillager previous = entityvillager; ++ for (EntityLiving entityliving : optList.get()) { ++ if (entityliving instanceof EntityVillager && entityliving != entityvillager && entityliving.isAlive()) { ++ EntityVillager entityvillager1 = (EntityVillager) entityliving; ++ if (this.a(globalpos, villageplacetype, entityvillager1)) { ++ previous = a(previous, entityvillager1); ++ } ++ } ++ } ++ } ++ } ++ // Airplane end + } + + private static EntityVillager a(EntityVillager entityvillager, EntityVillager entityvillager1) { diff --git a/patches/server/0006-Strip-raytracing-for-EntityLiving-hasLineOfSight.patch b/patches/server/0006-Strip-raytracing-for-EntityLiving-hasLineOfSight.patch new file mode 100644 index 0000000..82127f7 --- /dev/null +++ b/patches/server/0006-Strip-raytracing-for-EntityLiving-hasLineOfSight.patch @@ -0,0 +1,185 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Sat, 31 Oct 2020 18:43:02 -0500 +Subject: [PATCH] Strip raytracing for EntityLiving#hasLineOfSight + +The IBlockAccess#rayTrace method is very wasteful in both allocations, +and in logic. While EntityLiving#hasLineOfSight provides static +parameters for collisions with blocks and fluids, the method still does +a lot of dynamic checks for both of these, which result in extra work. +As well, since the fluid collision option is set to NONE, the entire +fluid collision system is completely unneeded, yet used anyways. + +Airplane +Copyright (C) 2020 Technove LLC + +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 . + +diff --git a/src/main/java/net/minecraft/server/EntityLiving.java b/src/main/java/net/minecraft/server/EntityLiving.java +index 87b66c284208f12e9e7cd1c9950ada8d0fbf26a5..5a717085e16fcb08bcc350463bc9dacedb7bac07 100644 +--- a/src/main/java/net/minecraft/server/EntityLiving.java ++++ b/src/main/java/net/minecraft/server/EntityLiving.java +@@ -3007,7 +3007,7 @@ public abstract class EntityLiving extends Entity { + Vec3D vec3d = new Vec3D(this.locX(), this.getHeadY(), this.locZ()); + Vec3D vec3d1 = new Vec3D(entity.locX(), entity.getHeadY(), entity.locZ()); + +- return this.world.rayTrace(new RayTrace(vec3d, vec3d1, RayTrace.BlockCollisionOption.COLLIDER, RayTrace.FluidCollisionOption.NONE, this)).getType() == MovingObjectPosition.EnumMovingObjectType.MISS; ++ return this.world.rayTraceDirect(vec3d, vec3d1, VoxelShapeCollision.a(this)) == MovingObjectPosition.EnumMovingObjectType.MISS; // Airplane - use direct method + } + + @Override +diff --git a/src/main/java/net/minecraft/server/IBlockAccess.java b/src/main/java/net/minecraft/server/IBlockAccess.java +index 5c3eb4fc7e5aec2ad8d0050673fc8f4d2bff6a71..15f20132d5777c5e0162aa91e6e968e1e8b1cc2d 100644 +--- a/src/main/java/net/minecraft/server/IBlockAccess.java ++++ b/src/main/java/net/minecraft/server/IBlockAccess.java +@@ -44,6 +44,15 @@ public interface IBlockAccess { + return BlockPosition.a(axisalignedbb).map(this::getType); + } + ++ // Airplane start - broken down variant of below rayTraceBlock, used by World#rayTraceDirect ++ default MovingObjectPosition.EnumMovingObjectType rayTraceBlockDirect(Vec3D vec3d, Vec3D vec3d1, BlockPosition blockposition, IBlockData iblockdata, VoxelShapeCollision voxelshapecoll) { ++ VoxelShape voxelshape = RayTrace.BlockCollisionOption.COLLIDER.get(iblockdata, this, blockposition, voxelshapecoll); ++ MovingObjectPositionBlock movingobjectpositionblock = this.rayTrace(vec3d, vec3d1, blockposition, voxelshape, iblockdata); ++ ++ return movingobjectpositionblock == null ? null : movingobjectpositionblock.getType(); ++ } ++ // Airplane end ++ + // CraftBukkit start - moved block handling into separate method for use by Block#rayTrace + default MovingObjectPositionBlock rayTraceBlock(RayTrace raytrace1, BlockPosition blockposition) { + // Paper start - Prevent raytrace from loading chunks +diff --git a/src/main/java/net/minecraft/server/MathHelper.java b/src/main/java/net/minecraft/server/MathHelper.java +index 2e7721a650c5a351b3584665bd236f92ef577761..b3c2b461b2a654a9e37a57f2f62b3ba8b5bb1634 100644 +--- a/src/main/java/net/minecraft/server/MathHelper.java ++++ b/src/main/java/net/minecraft/server/MathHelper.java +@@ -238,6 +238,7 @@ public class MathHelper { + return f - (float) d(f); + } + ++ public static double getDecimals(double num) { return h(num); } // Airplane + public static double h(double d0) { + return d0 - (double) d(d0); + } +@@ -416,6 +417,7 @@ public class MathHelper { + return f1 + f * (f2 - f1); + } + ++ public static double linearInterpolation(double value1, double value2, double amount) { return d(value1, value2, amount); } // Airplane - OBFHELPER + public static double d(double d0, double d1, double d2) { + return d1 + d0 * (d2 - d1); + } +@@ -432,6 +434,7 @@ public class MathHelper { + return d0 * d0 * d0 * (d0 * (d0 * 6.0D - 15.0D) + 10.0D); + } + ++ public static int sign(double num) { return k(num); } // Airplane - OBFHELPER + public static int k(double d0) { + return d0 == 0.0D ? 0 : (d0 > 0.0D ? 1 : -1); + } +diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java +index 970c1be5477a01ab9c6d79e84c519e22775564ff..50cb45883a2e815bdbf5c1522a8ddbcb124561b3 100644 +--- a/src/main/java/net/minecraft/server/World.java ++++ b/src/main/java/net/minecraft/server/World.java +@@ -318,6 +318,91 @@ public abstract class World implements GeneratorAccess, AutoCloseable { + return null; + } + ++ // Airplane start - broken down method of raytracing for EntityLiving#hasLineOfSight, replaces IBlockAccess#rayTrace(RayTrace) ++ protected MovingObjectPosition.EnumMovingObjectType rayTraceDirect(Vec3D vec3d, Vec3D vec3d1, VoxelShapeCollision voxelshapecoll) { ++ // most of this code comes from IBlockAccess#a(RayTrace, BiFunction, Function), but removes the needless functions ++ if (vec3d.equals(vec3d1)) { ++ return MovingObjectPosition.EnumMovingObjectType.MISS; ++ } ++ ++ double endX = MathHelper.linearInterpolation(-1.0E-7D, vec3d1.x, vec3d.x); ++ double endY = MathHelper.linearInterpolation(-1.0E-7D, vec3d1.y, vec3d.y); ++ double endZ = MathHelper.linearInterpolation(-1.0E-7D, vec3d1.z, vec3d.z); ++ ++ double startX = MathHelper.linearInterpolation(-1.0E-7D, vec3d.x, vec3d1.x); ++ double startY = MathHelper.linearInterpolation(-1.0E-7D, vec3d.y, vec3d1.y); ++ double startZ = MathHelper.linearInterpolation(-1.0E-7D, vec3d.z, vec3d1.z); ++ ++ int currentX = MathHelper.floor(startX); ++ int currentY = MathHelper.floor(startY); ++ int currentZ = MathHelper.floor(startZ); ++ ++ BlockPosition.MutableBlockPosition currentBlock = new BlockPosition.MutableBlockPosition(currentX, currentY, currentZ); ++ ++ Chunk chunk = this.getChunkIfLoaded(currentBlock); ++ if (chunk == null) { ++ return MovingObjectPosition.EnumMovingObjectType.MISS; ++ } ++ ++ MovingObjectPosition.EnumMovingObjectType initialCheck = this.rayTraceBlockDirect(vec3d, vec3d1, currentBlock, chunk.getType(currentBlock), voxelshapecoll); ++ ++ if (initialCheck != null) { ++ return initialCheck; ++ } ++ ++ double diffX = endX - startX; ++ double diffY = endY - startY; ++ double diffZ = endZ - startZ; ++ ++ int xDirection = MathHelper.sign(diffX); ++ int yDirection = MathHelper.sign(diffY); ++ int zDirection = MathHelper.sign(diffZ); ++ ++ double normalizedX = xDirection == 0 ? Double.MAX_VALUE : (double) xDirection / diffX; ++ double normalizedY = yDirection == 0 ? Double.MAX_VALUE : (double) yDirection / diffY; ++ double normalizedZ = zDirection == 0 ? Double.MAX_VALUE : (double) zDirection / diffZ; ++ ++ double normalizedXDirection = normalizedX * (xDirection > 0 ? 1.0D - MathHelper.getDecimals(startX) : MathHelper.getDecimals(startX)); ++ double normalizedYDirection = normalizedY * (yDirection > 0 ? 1.0D - MathHelper.getDecimals(startY) : MathHelper.getDecimals(startY)); ++ double normalizedZDirection = normalizedZ * (zDirection > 0 ? 1.0D - MathHelper.getDecimals(startZ) : MathHelper.getDecimals(startZ)); ++ ++ MovingObjectPosition.EnumMovingObjectType result; ++ ++ do { ++ if (normalizedXDirection > 1.0D && normalizedYDirection > 1.0D && normalizedZDirection > 1.0D) { ++ return MovingObjectPosition.EnumMovingObjectType.MISS; ++ } ++ ++ if (normalizedXDirection < normalizedYDirection) { ++ if (normalizedXDirection < normalizedZDirection) { ++ currentX += xDirection; ++ normalizedXDirection += normalizedX; ++ } else { ++ currentZ += zDirection; ++ normalizedZDirection += normalizedZ; ++ } ++ } else if (normalizedYDirection < normalizedZDirection) { ++ currentY += yDirection; ++ normalizedYDirection += normalizedY; ++ } else { ++ currentZ += zDirection; ++ normalizedZDirection += normalizedZ; ++ } ++ ++ currentBlock.setValues(currentX, currentY, currentZ); ++ if (chunk.getPos().x != currentBlock.getX() >> 4 || chunk.getPos().z != currentBlock.getZ() >> 4) { ++ chunk = this.getChunkIfLoaded(currentBlock); ++ if (chunk == null) { ++ return MovingObjectPosition.EnumMovingObjectType.MISS; ++ } ++ } ++ result = this.rayTraceBlockDirect(vec3d, vec3d1, currentBlock, chunk.getType(currentBlock), voxelshapecoll); ++ } while (result == null); ++ ++ return result; ++ } ++ // Airplane end ++ + public static boolean isValidLocation(BlockPosition blockposition) { + return blockposition.isValidLocation(); // Paper - use better/optimized check + } diff --git a/patches/server/0007-Simpler-ShapelessRecipes-comparison-for-Vanilla.patch b/patches/server/0007-Simpler-ShapelessRecipes-comparison-for-Vanilla.patch new file mode 100644 index 0000000..84278dc --- /dev/null +++ b/patches/server/0007-Simpler-ShapelessRecipes-comparison-for-Vanilla.patch @@ -0,0 +1,87 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Sat, 31 Oct 2020 18:51:38 -0500 +Subject: [PATCH] Simpler ShapelessRecipes comparison for Vanilla + +Paper added a fancy sorting comparison due to Bukkit recipes breaking +the vanilla one, however this is far more advanced than what you need +for all the vanilla recipes. + +Airplane +Copyright (C) 2020 Technove LLC + +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 . + +diff --git a/src/main/java/net/minecraft/server/ShapelessRecipes.java b/src/main/java/net/minecraft/server/ShapelessRecipes.java +index 61d88dbaa1f5c543be610ce0914b2c89d8ad40ee..11fbbe86978055ece0cb47eee531093e59f61dcf 100644 +--- a/src/main/java/net/minecraft/server/ShapelessRecipes.java ++++ b/src/main/java/net/minecraft/server/ShapelessRecipes.java +@@ -17,8 +17,16 @@ public class ShapelessRecipes implements RecipeCrafting { + private final String group; + private final ItemStack result; + private final NonNullList ingredients; ++ private final boolean isBukkit; // Airplane + ++ // Airplane start - add isBukkit constructor param + public ShapelessRecipes(MinecraftKey minecraftkey, String s, ItemStack itemstack, NonNullList nonnulllist) { ++ this(minecraftkey, s, itemstack, nonnulllist, false); ++ } ++ ++ public ShapelessRecipes(MinecraftKey minecraftkey, String s, ItemStack itemstack, NonNullList nonnulllist, boolean isBukkit) { ++ this.isBukkit = isBukkit; ++ // Airplane end + this.key = minecraftkey; + this.group = s; + this.result = itemstack; +@@ -60,6 +68,28 @@ public class ShapelessRecipes implements RecipeCrafting { + } + + public boolean a(InventoryCrafting inventorycrafting, World world) { ++ // Airplane start ++ if (!this.isBukkit) { ++ java.util.List ingredients = com.google.common.collect.Lists.newArrayList(this.ingredients.toArray(new RecipeItemStack[0])); ++ ++ inventory: for (int index = 0; index < inventorycrafting.getSize(); index++) { ++ ItemStack itemStack = inventorycrafting.getItem(index); ++ ++ if (!itemStack.isEmpty()) { ++ for (int i = 0; i < ingredients.size(); i++) { ++ if (ingredients.get(i).test(itemStack)) { ++ ingredients.remove(i); ++ continue inventory; ++ } ++ } ++ return false; ++ } ++ } ++ ++ return ingredients.isEmpty(); ++ } ++ // Airplane end ++ + AutoRecipeStackManager autorecipestackmanager = new AutoRecipeStackManager(); + int i = 0; + +diff --git a/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java b/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java +index 4aba511fe8078164bf1467b39645dd9bf6a931e7..56b781e438f0cf1c12dd55eb37356601e47de47f 100644 +--- a/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java ++++ b/src/main/java/org/bukkit/craftbukkit/inventory/CraftShapelessRecipe.java +@@ -44,6 +44,6 @@ public class CraftShapelessRecipe extends ShapelessRecipe implements CraftRecipe + data.set(i, toNMS(ingred.get(i), true)); + } + +- MinecraftServer.getServer().getCraftingManager().addRecipe(new ShapelessRecipes(CraftNamespacedKey.toMinecraft(this.getKey()), this.getGroup(), CraftItemStack.asNMSCopy(this.getResult()), data)); ++ MinecraftServer.getServer().getCraftingManager().addRecipe(new ShapelessRecipes(CraftNamespacedKey.toMinecraft(this.getKey()), this.getGroup(), CraftItemStack.asNMSCopy(this.getResult()), data, true)); // Airplane + } + } diff --git a/patches/server/0009-Swap-priority-of-checks-in-chunk-ticking.patch b/patches/server/0009-Swap-priority-of-checks-in-chunk-ticking.patch new file mode 100644 index 0000000..adacae3 --- /dev/null +++ b/patches/server/0009-Swap-priority-of-checks-in-chunk-ticking.patch @@ -0,0 +1,37 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Sun, 1 Nov 2020 16:59:08 -0600 +Subject: [PATCH] Swap priority of checks in chunk ticking + +World.V showed up a lot in lag spikes for some reason, although I wonder +if it's just Spark getting JVM safe points. + +Airplane +Copyright (C) 2020 Technove LLC + +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 . + +diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java/net/minecraft/server/WorldServer.java +index d2b50cdc43c737d9fdfdcd7838de24cbca2017e4..a60fc548982e2ddfabd924ce9026762d23071038 100644 +--- a/src/main/java/net/minecraft/server/WorldServer.java ++++ b/src/main/java/net/minecraft/server/WorldServer.java +@@ -1094,7 +1094,7 @@ public class WorldServer extends World implements GeneratorAccessSeed { + gameprofilerfiller.enter("thunder"); + final BlockPosition.MutableBlockPosition blockposition = this.chunkTickMutablePosition; // Paper - use mutable to reduce allocation rate, final to force compile fail on change + +- if (!this.paperConfig.disableThunder && flag && this.W() && this.random.nextInt(100000) == 0) { // Paper - Disable thunder ++ if (!this.paperConfig.disableThunder && flag && this.random.nextInt(100000) == 0 && this.W()) { // Paper - Disable thunder // Airplane - check this.W last + blockposition.setValues(this.a(this.a(j, 0, k, 15))); // Paper + if (this.isRainingAt(blockposition)) { + DifficultyDamageScaler difficultydamagescaler = this.getDamageScaler(blockposition); diff --git a/patches/server/0010-Reduce-projectile-chunk-loading.patch b/patches/server/0010-Reduce-projectile-chunk-loading.patch new file mode 100644 index 0000000..0b2d7d3 --- /dev/null +++ b/patches/server/0010-Reduce-projectile-chunk-loading.patch @@ -0,0 +1,63 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Sun, 13 Dec 2020 17:52:35 -0600 +Subject: [PATCH] Reduce projectile chunk loading + +Airplane +Copyright (C) 2020 Technove LLC + +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 . + +diff --git a/src/main/java/net/minecraft/server/EntityProjectile.java b/src/main/java/net/minecraft/server/EntityProjectile.java +index d85a19905efab7189e461a61becb6ca2b8c50803..4b3d5731a18177c74f02eef91820720104145d1c 100644 +--- a/src/main/java/net/minecraft/server/EntityProjectile.java ++++ b/src/main/java/net/minecraft/server/EntityProjectile.java +@@ -85,6 +85,37 @@ public abstract class EntityProjectile extends IProjectile { + this.setPosition(d0, d1, d2); + } + ++ private static int loadedThisTick = 0; ++ private static int loadedTick; ++ ++ private int buffered = 0; ++ ++ // Airplane start ++ @Override ++ public void setPosition(double d0, double d1, double d2) { ++ if (loadedTick != MinecraftServer.currentTick) { ++ loadedTick = MinecraftServer.currentTick; ++ loadedThisTick = 0; ++ } ++ int previousX = MathHelper.floor(this.locX()) >> 4, previousZ = MathHelper.floor(this.locZ()) >> 4; ++ int newX = MathHelper.floor(d0) >> 4, newZ = MathHelper.floor(d2) >> 4; ++ if (previousX != newX || previousZ != newZ) { ++ boolean isLoaded = this.world.isChunkLoaded(newX, newZ); ++ if (!isLoaded) { ++ if (loadedThisTick > 10) { // Airplane 10 = max chunks to load from projectiles in a tick todo config ++ if (++buffered > 20) { // Airplane 20 = max chunks a single projectile loads overall todo config ++ this.die(); ++ } ++ return; ++ } ++ loadedThisTick++; ++ } ++ buffered = 0; ++ } ++ super.setPosition(d0, d1, d2); ++ } ++ // Airplane end ++ + protected float k() { + return 0.03F; + } diff --git a/patches/server/0011-Only-check-for-spooky-season-once-an-hour.patch b/patches/server/0011-Only-check-for-spooky-season-once-an-hour.patch new file mode 100644 index 0000000..a1456f9 --- /dev/null +++ b/patches/server/0011-Only-check-for-spooky-season-once-an-hour.patch @@ -0,0 +1,49 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Sun, 13 Dec 2020 17:53:08 -0600 +Subject: [PATCH] Only check for spooky season once an hour + +Airplane +Copyright (C) 2020 Technove LLC + +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 . + +diff --git a/src/main/java/net/minecraft/server/EntityBat.java b/src/main/java/net/minecraft/server/EntityBat.java +index 0a59e02d762a096cb3de62e0f8105cc5a5fab8d4..66aa5009550bcb215536a1ca98334771db193fcb 100644 +--- a/src/main/java/net/minecraft/server/EntityBat.java ++++ b/src/main/java/net/minecraft/server/EntityBat.java +@@ -221,13 +221,22 @@ public class EntityBat extends EntityAmbient { + } + } + ++ // Airplane start - only check for spooky season once an hour ++ private static boolean isSpookySeason = false; ++ private static final int ONE_HOUR = 20 * 60 * 60; ++ private static int lastSpookyCheck = -ONE_HOUR; + private static boolean eJ() { ++ if (MinecraftServer.currentTick - lastSpookyCheck > ONE_HOUR) { + LocalDate localdate = LocalDate.now(); + int i = localdate.get(ChronoField.DAY_OF_MONTH); + int j = localdate.get(ChronoField.MONTH_OF_YEAR); ++ isSpookySeason = j == 10 && i >= 20 || j == 11 && i <= 3; ++ lastSpookyCheck = MinecraftServer.currentTick; ++ } + +- return j == 10 && i >= 20 || j == 11 && i <= 3; ++ return isSpookySeason; + } ++ // Airplane end + + @Override + protected float b(EntityPose entitypose, EntitySize entitysize) { diff --git a/patches/server/0012-Optimize-random-calls-in-chunk-ticking.patch b/patches/server/0012-Optimize-random-calls-in-chunk-ticking.patch new file mode 100644 index 0000000..aa2f5d2 --- /dev/null +++ b/patches/server/0012-Optimize-random-calls-in-chunk-ticking.patch @@ -0,0 +1,109 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Thu, 7 Jan 2021 11:49:36 -0600 +Subject: [PATCH] Optimize random calls in chunk ticking + +Especially at over 30,000 chunks these random calls are fairly heavy. We +use a different method here for checking lightning, and for checking +ice. + +Lighting: Each chunk now keeps an int of how many ticks until the +lightning should strike. This int is a random number from 0 to 100000 * 2, +the multiplication is required to keep the probability the same. + +Ice and snow: We just generate a single random number 0-16 and increment +it, while checking if it's 0 for the current chunk. + +Depending on configuration for things that tick in a chunk, this is a +5-10% improvement. + +Airplane +Copyright (C) 2020 Technove LLC + +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 . + +diff --git a/src/main/java/net/minecraft/server/Chunk.java b/src/main/java/net/minecraft/server/Chunk.java +index 8fda4702764e80dae93ef9c0eb53abc198642ab1..0924f6b484468f3cf3c2d405101c0158c12d69e6 100644 +--- a/src/main/java/net/minecraft/server/Chunk.java ++++ b/src/main/java/net/minecraft/server/Chunk.java +@@ -53,6 +53,18 @@ public class Chunk implements IChunkAccess { + private final ChunkCoordIntPair loc; public final long coordinateKey; public final int locX; public final int locZ; // Paper - cache coordinate key + private volatile boolean x; + ++ // Airplane start - instead of using a random every time the chunk is ticked, define when lightning strikes preemptively ++ private int lightningTick; ++ // shouldDoLightning compiles down to 29 bytes, which with the default of 35 byte inlining should guarantee an inline ++ public final boolean shouldDoLightning(java.util.Random random) { ++ if (this.lightningTick-- <= 0) { ++ this.lightningTick = random.nextInt(100000) << 1; ++ return true; ++ } ++ return false; ++ } ++ // Airplane end ++ + public Chunk(World world, ChunkCoordIntPair chunkcoordintpair, BiomeStorage biomestorage) { + this(world, chunkcoordintpair, biomestorage, ChunkConverter.a, TickListEmpty.b(), TickListEmpty.b(), 0L, (ChunkSection[]) null, (Consumer) null); + } +@@ -287,6 +299,7 @@ public class Chunk implements IChunkAccess { + // CraftBukkit start + this.bukkitChunk = new org.bukkit.craftbukkit.CraftChunk(this); + this.entitySlicesManager = new com.tuinity.tuinity.world.ChunkEntitySlices(this.world, this.loc.x, this.loc.z, 0, 15); // TODO update for 1.17 // Tuinity ++ this.lightningTick = this.world.random.nextInt(100000) << 1; // Airplane - initialize lightning tick + } + + public org.bukkit.Chunk bukkitChunk; +diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java +index 18270d44185b0ec41b9b6e1d2135e7aae3b33261..e8a6bc2654e840395fee70d79695c5a395a4fc1b 100644 +--- a/src/main/java/net/minecraft/server/ChunkProviderServer.java ++++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java +@@ -973,6 +973,7 @@ public class ChunkProviderServer extends IChunkProvider { + } + // Paper end - optimize isOutisdeRange + this.world.getMethodProfiler().enter("pollingChunks"); ++ this.world.resetIceAndSnowTick(); // Airplane - reset ice & snow tick random + int k = this.world.getGameRules().getInt(GameRules.RANDOM_TICK_SPEED); + boolean flag2 = world.ticksPerAnimalSpawns != 0L && worlddata.getTime() % world.ticksPerAnimalSpawns == 0L; // CraftBukkit + +diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java/net/minecraft/server/WorldServer.java +index a60fc548982e2ddfabd924ce9026762d23071038..c0b6bd8f01214346c17d819d5d870689900d7719 100644 +--- a/src/main/java/net/minecraft/server/WorldServer.java ++++ b/src/main/java/net/minecraft/server/WorldServer.java +@@ -1084,6 +1084,8 @@ public class WorldServer extends World implements GeneratorAccessSeed { + private final com.destroystokyo.paper.util.math.ThreadUnsafeRandom randomTickRandom = new com.destroystokyo.paper.util.math.ThreadUnsafeRandom(); + // Paper end + ++ private int currentIceAndSnowTick = 0; protected void resetIceAndSnowTick() { this.currentIceAndSnowTick = this.randomTickRandom.nextInt(16); } // Airplane ++ + public void a(Chunk chunk, int i) { final int randomTickSpeed = i; // Paper + ChunkCoordIntPair chunkcoordintpair = chunk.getPos(); + boolean flag = this.isRaining(); +@@ -1094,7 +1096,7 @@ public class WorldServer extends World implements GeneratorAccessSeed { + gameprofilerfiller.enter("thunder"); + final BlockPosition.MutableBlockPosition blockposition = this.chunkTickMutablePosition; // Paper - use mutable to reduce allocation rate, final to force compile fail on change + +- if (!this.paperConfig.disableThunder && flag && this.random.nextInt(100000) == 0 && this.W()) { // Paper - Disable thunder // Airplane - check this.W last ++ if (!this.paperConfig.disableThunder && flag && chunk.shouldDoLightning(this.random) && this.W()) { // Paper - Disable thunder // Airplane - check this.W last // Airplane - replace random with shouldDoLighting + blockposition.setValues(this.a(this.a(j, 0, k, 15))); // Paper + if (this.isRainingAt(blockposition)) { + DifficultyDamageScaler difficultydamagescaler = this.getDamageScaler(blockposition); +@@ -1118,7 +1120,7 @@ public class WorldServer extends World implements GeneratorAccessSeed { + } + + gameprofilerfiller.exitEnter("iceandsnow"); +- if (!this.paperConfig.disableIceAndSnow && this.randomTickRandom.nextInt(16) == 0) { // Paper - Disable ice and snow // Paper - optimise random ticking ++ if (!this.paperConfig.disableIceAndSnow && (this.currentIceAndSnowTick++ & 15) == 0) { // Paper - Disable ice and snow // Paper - optimise random ticking // Airplane - optimize further random ticking + // Paper start - optimise chunk ticking + this.getRandomBlockPosition(j, 0, k, 15, blockposition); + int normalY = chunk.getHighestBlockY(HeightMap.Type.MOTION_BLOCKING, blockposition.getX() & 15, blockposition.getZ() & 15); diff --git a/patches/server/0013-Don-t-get-entity-equipment-if-not-needed.patch b/patches/server/0013-Don-t-get-entity-equipment-if-not-needed.patch new file mode 100644 index 0000000..f5d6da6 --- /dev/null +++ b/patches/server/0013-Don-t-get-entity-equipment-if-not-needed.patch @@ -0,0 +1,42 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Fri, 15 Jan 2021 20:08:54 -0600 +Subject: [PATCH] Don't get entity equipment if not needed + +Airplane +Copyright (C) 2020 Technove LLC + +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 . + +diff --git a/src/main/java/net/minecraft/server/EntityLiving.java b/src/main/java/net/minecraft/server/EntityLiving.java +index 5a717085e16fcb08bcc350463bc9dacedb7bac07..c8b5d56bd58aaf91a89a6ebdb90e87f0d1bd9e29 100644 +--- a/src/main/java/net/minecraft/server/EntityLiving.java ++++ b/src/main/java/net/minecraft/server/EntityLiving.java +@@ -815,11 +815,13 @@ public abstract class EntityLiving extends Entity { + } + + if (entity != null) { +- ItemStack itemstack = this.getEquipment(EnumItemSlot.HEAD); +- Item item = itemstack.getItem(); ++ // Airplane start - don't get equipment if not needed ++ //ItemStack itemstack = this.getEquipment(EnumItemSlot.HEAD); ++ //Item item = itemstack.getItem(); + EntityTypes entitytypes = entity.getEntityType(); + +- if (entitytypes == EntityTypes.SKELETON && item == Items.SKELETON_SKULL || entitytypes == EntityTypes.ZOMBIE && item == Items.ZOMBIE_HEAD || entitytypes == EntityTypes.CREEPER && item == Items.CREEPER_HEAD) { ++ if (entitytypes == EntityTypes.SKELETON && this.getEquipment(EnumItemSlot.HEAD).getItem() == Items.SKELETON_SKULL || entitytypes == EntityTypes.ZOMBIE && this.getEquipment(EnumItemSlot.HEAD).getItem() == Items.ZOMBIE_HEAD || entitytypes == EntityTypes.CREEPER && this.getEquipment(EnumItemSlot.HEAD).getItem() == Items.CREEPER_HEAD) { ++ // Airplane end + d0 *= 0.5D; + } + } diff --git a/patches/server/0015-Reduce-allocs-improve-perf-of-StructureManager.patch b/patches/server/0015-Reduce-allocs-improve-perf-of-StructureManager.patch new file mode 100644 index 0000000..c697efd --- /dev/null +++ b/patches/server/0015-Reduce-allocs-improve-perf-of-StructureManager.patch @@ -0,0 +1,76 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Thu, 4 Feb 2021 23:24:20 -0600 +Subject: [PATCH] Reduce allocs & improve perf of StructureManager + +Focuses on two methods, getStructureStarts & getFeatureStarts. For +getStructureStarts, it inlines getFeatureStarts so it doesn't have to +calculate an entire list when it returns early. As well, it uses a +LongIterator in order to not allocate longs for each position. + +diff --git a/src/main/java/net/minecraft/server/StructureManager.java b/src/main/java/net/minecraft/server/StructureManager.java +index 2598ae3710d46c2cfd2be5d6be2a56e59ceef6ea..fd1f1e2d7e4be227697f534bdc6d9c52ceeeda4b 100644 +--- a/src/main/java/net/minecraft/server/StructureManager.java ++++ b/src/main/java/net/minecraft/server/StructureManager.java +@@ -5,6 +5,11 @@ import it.unimi.dsi.fastutil.objects.ObjectArrayList; // Paper + import java.util.stream.Stream; + import javax.annotation.Nullable; + ++// Airplane start ++import it.unimi.dsi.fastutil.longs.LongIterator; ++import it.unimi.dsi.fastutil.longs.LongSet; ++// Airplane end ++ + public class StructureManager { + + private final GeneratorAccess a; public GeneratorAccess getLevel() { return a; } // Paper - OBFHELPER +@@ -41,13 +46,15 @@ public class StructureManager { + public java.util.List> getFeatureStarts(SectionPosition sectionPosition, StructureGenerator structureGenerator, IWorldReader world) { + // Tuinity end - add world parameter + java.util.List> list = new ObjectArrayList<>(); +- for (Long curLong: (world == null ? getLevel() : world).getChunkAt(sectionPosition.a(), sectionPosition.c(), ChunkStatus.STRUCTURE_REFERENCES).b(structureGenerator)) { // Tuinity - fix deadlock on world gen - chunk can be unloaded while generating, so we should be using the generator's regionlimitedaccess so we always get the chunk +- SectionPosition sectionPosition1 = SectionPosition.a(new ChunkCoordIntPair(curLong), 0); ++ // Airplane start - skip allocating Longs ++ (world == null ? getLevel() : world).getChunkAt(sectionPosition.a(), sectionPosition.c(), ChunkStatus.STRUCTURE_REFERENCES).b(structureGenerator).forEach((java.util.function.LongConsumer) curLong -> { ++ SectionPosition sectionPosition1 = SectionPosition.a(ChunkCoordIntPair.getX(curLong), 0, ChunkCoordIntPair.getZ(curLong)); // don't allocate ChunkCoordIntPair + StructureStart structurestart = a(sectionPosition1, structureGenerator, getLevel().getChunkAt(sectionPosition1.a(), sectionPosition1.c(), ChunkStatus.STRUCTURE_STARTS)); + if (structurestart != null && structurestart.e()) { + list.add(structurestart); + } +- } ++ }); ++ // Airplane end + return list; + } + // Paper end +@@ -75,7 +82,18 @@ public class StructureManager { + } + public StructureStart getStructureStarts(BlockPosition blockposition, boolean flag, StructureGenerator structuregenerator, IWorldReader world) { + // Paper start - remove structure streams +- for (StructureStart structurestart : getFeatureStarts(SectionPosition.a(blockposition), structuregenerator, world)) { // Tuinity end - add world parameter ++ // Airplane start - inline getFeatureStarts to skip creating the list ++ SectionPosition sectionPosition = SectionPosition.a(blockposition); ++ ++ // use iterator here instead of forEach like in getFeatureStarts so we can return early ++ LongSet longSet = (world == null ? getLevel() : world).getChunkAt(sectionPosition.a(), sectionPosition.c(), ChunkStatus.STRUCTURE_REFERENCES).b(structuregenerator); ++ LongIterator iterator = longSet.iterator(); ++ while (iterator.hasNext()) { ++ long curLong = iterator.nextLong(); ++ SectionPosition sectionPosition1 = SectionPosition.a(ChunkCoordIntPair.getX(curLong), 0, ChunkCoordIntPair.getZ(curLong)); // don't allocate ChunkCoordIntPair ++ StructureStart structurestart = a(sectionPosition1, structuregenerator, getLevel().getChunkAt(sectionPosition1.a(), sectionPosition1.c(), ChunkStatus.STRUCTURE_STARTS)); ++ if (structurestart != null && structurestart.e()) { ++ + if (structurestart.c().b(blockposition)) { + if (!flag) { + return structurestart; +@@ -86,7 +104,10 @@ public class StructureManager { + } + } + } ++ ++ } + } ++ // Airplane end + return StructureStart.a; + // Paper end + } diff --git a/patches/server/0016-Cache-palette-array.patch b/patches/server/0016-Cache-palette-array.patch new file mode 100644 index 0000000..8872553 --- /dev/null +++ b/patches/server/0016-Cache-palette-array.patch @@ -0,0 +1,60 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Thu, 4 Feb 2021 23:28:46 -0600 +Subject: [PATCH] Cache palette array + +The reasoning for reusing it in ChunkRegionLoader is because ThreadLocal +lookups are fairly expensive, and if we put it in DataPaletteBlock the +ThreadLocal lookup would happen 18 times. + +diff --git a/src/main/java/net/minecraft/server/ChunkRegionLoader.java b/src/main/java/net/minecraft/server/ChunkRegionLoader.java +index 076d6c1e1cc049dd312ecb30518e7b25fc2d7371..68538ae94806d5980cd531e61fa52a01a5cc8997 100644 +--- a/src/main/java/net/minecraft/server/ChunkRegionLoader.java ++++ b/src/main/java/net/minecraft/server/ChunkRegionLoader.java +@@ -424,6 +424,7 @@ public class ChunkRegionLoader { + public static NBTTagCompound saveChunk(WorldServer worldserver, IChunkAccess ichunkaccess) { + return saveChunk(worldserver, ichunkaccess, null); + } ++ private static final ThreadLocal paletteArray = ThreadLocal.withInitial(() -> new int[4096]); // Airplane + public static NBTTagCompound saveChunk(WorldServer worldserver, IChunkAccess ichunkaccess, AsyncSaveData asyncsavedata) { + // Paper end + // Tuinity start - rewrite light impl +@@ -454,6 +455,7 @@ public class ChunkRegionLoader { + + NBTTagCompound nbttagcompound2; + ++ int[] aint = paletteArray.get(); // Airplane - use cached + for (int i = -1; i < 17; ++i) { // Paper - conflict on loop parameter change + int finalI = i; // CraftBukkit - decompile errors + ChunkSection chunksection = (ChunkSection) Arrays.stream(achunksection).filter((chunksection1) -> { +@@ -474,7 +476,7 @@ public class ChunkRegionLoader { + nbttagcompound2 = new NBTTagCompound(); + nbttagcompound2.setByte("Y", (byte) (i & 255)); + if (chunksection != Chunk.a) { +- chunksection.getBlocks().a(nbttagcompound2, "Palette", "BlockStates"); ++ chunksection.getBlocks().a(nbttagcompound2, "Palette", "BlockStates", aint); // Airplane + } + + if (nibblearray != null && !nibblearray.c()) { +diff --git a/src/main/java/net/minecraft/server/DataPaletteBlock.java b/src/main/java/net/minecraft/server/DataPaletteBlock.java +index 73163b417af7e522a4509bf9c1ab56d6499be622..2855a2757c35afc5751a7ca6f3a12cc27c24bf96 100644 +--- a/src/main/java/net/minecraft/server/DataPaletteBlock.java ++++ b/src/main/java/net/minecraft/server/DataPaletteBlock.java +@@ -226,12 +226,16 @@ public class DataPaletteBlock implements DataPaletteExpandable { + this.b(); + } + ++ // Airplane start - add parameter for reusing aint + public synchronized void a(NBTTagCompound nbttagcompound, String s, String s1) { // Paper - synchronize ++ a(nbttagcompound, s, s1, new int[4096]); ++ } ++ public synchronized void a(NBTTagCompound nbttagcompound, String s, String s1, int[] aint) { // Paper - synchronize // Airplane end + this.a(); + DataPaletteHash datapalettehash = new DataPaletteHash<>(this.d, this.i, this.c, this.e, this.f); + T t0 = this.g; + int i = datapalettehash.a(this.g); +- int[] aint = new int[4096]; ++ //int[] aint = new int[4096]; // Airplane - use parameter + + for (int j = 0; j < 4096; ++j) { + T t1 = this.a(j); diff --git a/patches/server/0017-Reduce-chunk-loading-lookups.patch b/patches/server/0017-Reduce-chunk-loading-lookups.patch new file mode 100644 index 0000000..9081921 --- /dev/null +++ b/patches/server/0017-Reduce-chunk-loading-lookups.patch @@ -0,0 +1,47 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Thu, 4 Feb 2021 23:33:52 -0600 +Subject: [PATCH] Reduce chunk loading & lookups + + +diff --git a/src/main/java/net/minecraft/server/EntityEnderman.java b/src/main/java/net/minecraft/server/EntityEnderman.java +index f53525eb32a6096ae24fd23756b2169d5d39e9d4..a192400f0ea4517c56c473d39e4bd04396b4eb72 100644 +--- a/src/main/java/net/minecraft/server/EntityEnderman.java ++++ b/src/main/java/net/minecraft/server/EntityEnderman.java +@@ -260,11 +260,18 @@ public class EntityEnderman extends EntityMonster implements IEntityAngerable { + private boolean p(double d0, double d1, double d2) { + BlockPosition.MutableBlockPosition blockposition_mutableblockposition = new BlockPosition.MutableBlockPosition(d0, d1, d2); + +- while (blockposition_mutableblockposition.getY() > 0 && !this.world.getType(blockposition_mutableblockposition).getMaterial().isSolid()) { ++ // Airplane start - single chunk lookup ++ Chunk chunk = this.world.getChunkIfLoaded(blockposition_mutableblockposition); ++ if (chunk == null) { ++ return false; ++ } ++ ++ while (blockposition_mutableblockposition.getY() > 0 && !chunk.getType(blockposition_mutableblockposition).getMaterial().isSolid()) { // use chunk lookup + blockposition_mutableblockposition.c(EnumDirection.DOWN); + } + +- IBlockData iblockdata = this.world.getType(blockposition_mutableblockposition); ++ IBlockData iblockdata = chunk.getType(blockposition_mutableblockposition); // use chunk lookup ++ // Airplane end + boolean flag = iblockdata.getMaterial().isSolid(); + boolean flag1 = iblockdata.getFluid().a((Tag) TagsFluid.WATER); + +diff --git a/src/main/java/net/minecraft/server/SpawnerCreature.java b/src/main/java/net/minecraft/server/SpawnerCreature.java +index a77b1d61b9dcb0a2a27d7e50357eaf44c99a661e..3406ffde3c56d9c35ec18a76af8fb258d4131417 100644 +--- a/src/main/java/net/minecraft/server/SpawnerCreature.java ++++ b/src/main/java/net/minecraft/server/SpawnerCreature.java +@@ -372,7 +372,10 @@ public final class SpawnerCreature { + } + + private static List a(WorldServer worldserver, StructureManager structuremanager, ChunkGenerator chunkgenerator, EnumCreatureType enumcreaturetype, BlockPosition blockposition, @Nullable BiomeBase biomebase) { +- return enumcreaturetype == EnumCreatureType.MONSTER && worldserver.getType(blockposition.down()).getBlock() == Blocks.NETHER_BRICKS && structuremanager.a(blockposition, false, StructureGenerator.FORTRESS).e() ? StructureGenerator.FORTRESS.c() : chunkgenerator.getMobsFor(biomebase != null ? biomebase : worldserver.getBiome(blockposition), structuremanager, enumcreaturetype, blockposition); ++ // Airplane start - single chunk lookup ++ Chunk chunk; ++ return enumcreaturetype == EnumCreatureType.MONSTER && (chunk = worldserver.getChunkIfLoaded(blockposition)) != null && chunk.getType(blockposition.down()).getBlock() == Blocks.NETHER_BRICKS && structuremanager.a(blockposition, false, StructureGenerator.FORTRESS).e() ? StructureGenerator.FORTRESS.c() : chunkgenerator.getMobsFor(biomebase != null ? biomebase : worldserver.getBiome(blockposition), structuremanager, enumcreaturetype, blockposition); ++ // Airplane end + } + + private static BlockPosition getRandomPosition(World world, Chunk chunk) { diff --git a/patches/server/0018-Reduce-memory-allocations.patch b/patches/server/0018-Reduce-memory-allocations.patch new file mode 100644 index 0000000..a289083 --- /dev/null +++ b/patches/server/0018-Reduce-memory-allocations.patch @@ -0,0 +1,209 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Tue, 9 Feb 2021 19:05:58 -0600 +Subject: [PATCH] Reduce memory allocations + + +diff --git a/src/main/java/net/minecraft/server/BlockDirtSnowSpreadable.java b/src/main/java/net/minecraft/server/BlockDirtSnowSpreadable.java +index 7b29d47dfdef7611db58068af285f76d92a9f12a..6c5d96853d47850b81ce85e56a516c554819ef25 100644 +--- a/src/main/java/net/minecraft/server/BlockDirtSnowSpreadable.java ++++ b/src/main/java/net/minecraft/server/BlockDirtSnowSpreadable.java +@@ -43,8 +43,14 @@ public abstract class BlockDirtSnowSpreadable extends BlockDirtSnow { + if (worldserver.getLightLevel(blockposition.up()) >= 9) { + IBlockData iblockdata1 = this.getBlockData(); + ++ // Airplane start - use mutable position ++ BlockPosition.MutableBlockPosition blockposition1 = new BlockPosition.MutableBlockPosition(); + for (int i = 0; i < 4; ++i) { ++ blockposition1.setValues(blockposition).addValues(random.nextInt(3) - 1, random.nextInt(5) - 3, random.nextInt(3) - 1); ++ /* + BlockPosition blockposition1 = blockposition.b(random.nextInt(3) - 1, random.nextInt(5) - 3, random.nextInt(3) - 1); ++ */ ++ // Airplane end + + if (worldserver.getType(blockposition1).a(Blocks.DIRT) && c(iblockdata1, (IWorldReader) worldserver, blockposition1)) { + org.bukkit.craftbukkit.event.CraftEventFactory.handleBlockSpreadEvent(worldserver, blockposition, blockposition1, (IBlockData) iblockdata1.set(BlockDirtSnowSpreadable.a, worldserver.getType(blockposition1.up()).a(Blocks.SNOW))); // CraftBukkit +diff --git a/src/main/java/net/minecraft/server/BlockPosition.java b/src/main/java/net/minecraft/server/BlockPosition.java +index 2291135eaef64c403183724cb6e413cd7e472672..72ee5fe0ca25844cbcd8f1bbbbd6a7f8ced24bc4 100644 +--- a/src/main/java/net/minecraft/server/BlockPosition.java ++++ b/src/main/java/net/minecraft/server/BlockPosition.java +@@ -432,6 +432,14 @@ public class BlockPosition extends BaseBlockPosition { + public BlockPosition b(int i, int j, int k) { + return super.b(i, j, k).immutableCopy(); + } ++ // Airplane start - version of b that doesn't copy ++ public BlockPosition addValues(int x, int y, int z) { ++ ((BaseBlockPosition)this).a += x; ++ ((BaseBlockPosition)this).b += y; ++ ((BaseBlockPosition)this).e += z; ++ return this; ++ } ++ // Airplane end + + @Override + public BlockPosition shift(EnumDirection enumdirection, int i) { +diff --git a/src/main/java/net/minecraft/server/EntityTypes.java b/src/main/java/net/minecraft/server/EntityTypes.java +index bf914dc5ee7f2d4a324b6711ea273f5581ec84ad..1d23d6ede74bfa142e75ffcd84d75cde47270510 100644 +--- a/src/main/java/net/minecraft/server/EntityTypes.java ++++ b/src/main/java/net/minecraft/server/EntityTypes.java +@@ -139,6 +139,8 @@ public class EntityTypes { + private MinecraftKey bq; + private final EntitySize br; + ++ public java.util.function.Supplier getEntityName = () -> IRegistry.ENTITY_TYPE.getKey(this).toString(); // Airplane - create lambda ones ++ + private static EntityTypes a(String s, EntityTypes.Builder entitytypes_builder) { // CraftBukkit - decompile error + return (EntityTypes) IRegistry.a((IRegistry) IRegistry.ENTITY_TYPE, s, (Object) entitytypes_builder.a(s)); + } +diff --git a/src/main/java/net/minecraft/server/PlayerChunkMap.java b/src/main/java/net/minecraft/server/PlayerChunkMap.java +index 61570ab947b5a153a4c2bcb5a09344f060e6052d..121deda90227cb0416d6642607b24093df2baa80 100644 +--- a/src/main/java/net/minecraft/server/PlayerChunkMap.java ++++ b/src/main/java/net/minecraft/server/PlayerChunkMap.java +@@ -641,7 +641,9 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d { + return d2 * d2 + d3 * d3; + } + +- private static int b(ChunkCoordIntPair chunkcoordintpair, EntityPlayer entityplayer, boolean flag) { ++ // Airplane start - create copy that accepts x/z instead of allocating pair ++ private static int b(ChunkCoordIntPair chunkcoordintpair, EntityPlayer entityplayer, boolean flag) { return someDistanceCalculation(chunkcoordintpair.x, chunkcoordintpair.z, entityplayer, flag); } ++ private static int someDistanceCalculation(int x, int z, EntityPlayer entityplayer, boolean flag) { + int i; + int j; + +@@ -655,12 +657,16 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d { + j = MathHelper.floor(entityplayer.locZ() / 16.0D); + } + +- return a(chunkcoordintpair, i, j); ++ return someOtherDistanceCalculation(x, z, i, j); ++ // Airplane end + } + +- private static int a(ChunkCoordIntPair chunkcoordintpair, int i, int j) { +- int k = chunkcoordintpair.x - i; +- int l = chunkcoordintpair.z - j; ++ // Airplane start - create copy that accepts x/z instead of allocating pair ++ private static int a(ChunkCoordIntPair chunkcoordintpair, int i, int j) { return someOtherDistanceCalculation(chunkcoordintpair.x, chunkcoordintpair.z, i, j); } ++ private static int someOtherDistanceCalculation(int x, int z, int i, int j) { ++ int k = x - i; ++ int l = z - j; ++ // Airplane end + + return Math.max(Math.abs(k), Math.abs(l)); + } +@@ -2499,11 +2505,17 @@ Sections go from 0..16. Now whenever a section is not empty, it can potentially + boolean flag1 = this.tracker.attachedToPlayer; + + if (!flag1) { ++ // Airplane start - use int/longs instead of ChunkCoordIntPair ++ /* + ChunkCoordIntPair chunkcoordintpair = new ChunkCoordIntPair(this.tracker.chunkX, this.tracker.chunkZ); +- PlayerChunk playerchunk = PlayerChunkMap.this.getVisibleChunk(chunkcoordintpair.pair()); ++ */ ++ int x = this.tracker.chunkX, z = this.tracker.chunkZ; ++ long chunkcoordintpair = ChunkCoordIntPair.pair(x, z); ++ PlayerChunk playerchunk = PlayerChunkMap.this.getVisibleChunk(chunkcoordintpair); + + if (playerchunk != null && playerchunk.getSendingChunk() != null) { // Paper - no-tick view distance +- flag1 = PlayerChunkMap.b(chunkcoordintpair, entityplayer, false) <= PlayerChunkMap.this.viewDistance; ++ flag1 = PlayerChunkMap.someDistanceCalculation(x, z, entityplayer, false) <= PlayerChunkMap.this.viewDistance; ++ // Airplane end + } + } + +@@ -2533,8 +2545,10 @@ Sections go from 0..16. Now whenever a section is not empty, it can potentially + } + + private int b() { ++ // Airplane start ++ int i = this.trackingDistance; // move out of if statement ++ if (!this.tracker.passengers.isEmpty()) { + Collection collection = this.tracker.getAllPassengers(); +- int i = this.trackingDistance; + Iterator iterator = collection.iterator(); + + while (iterator.hasNext()) { +@@ -2546,6 +2560,8 @@ Sections go from 0..16. Now whenever a section is not empty, it can potentially + i = j; + } + } ++ } ++ // Airplane end + + return this.a(i); + } +diff --git a/src/main/java/net/minecraft/server/World.java b/src/main/java/net/minecraft/server/World.java +index 50cb45883a2e815bdbf5c1522a8ddbcb124561b3..3c968c6133c42c3690fe554d5993d237de82c162 100644 +--- a/src/main/java/net/minecraft/server/World.java ++++ b/src/main/java/net/minecraft/server/World.java +@@ -1041,19 +1041,19 @@ public abstract class World implements GeneratorAccess, AutoCloseable { + + public void a(Consumer consumer, Entity entity) { + try { +- consumer.accept(entity); ++ consumer.accept(entity); // Airplane - error on change + } catch (Throwable throwable) { + if (throwable instanceof ThreadDeath) throw throwable; // Paper + // Paper start - Prevent tile entity and entity crashes + String msg = "Entity threw exception at " + entity.world.getWorld().getName() + ":" + entity.locX() + "," + entity.locY() + "," + entity.locZ(); + System.err.println(msg); + throwable.printStackTrace(); +- getServer().getPluginManager().callEvent(new ServerExceptionEvent(new ServerInternalException(msg, throwable))); ++ getServer().getPluginManager().callEvent(new ServerExceptionEvent(new ServerInternalException(msg, throwable))); // Airplane - error on change + entity.dead = true; + return; + // Paper end + } +- MinecraftServer.getServer().executeMidTickTasks(); // Tuinity - execute chunk tasks mid tick ++ MinecraftServer.getServer().executeMidTickTasks(); // Tuinity - execute chunk tasks mid tick // Airplane - error on change + } + // Paper start - Prevent armor stands from doing entity lookups + @Override +diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java/net/minecraft/server/WorldServer.java +index c0b6bd8f01214346c17d819d5d870689900d7719..bccc599d2ba76d2b92e57a8d29e661dc974439a5 100644 +--- a/src/main/java/net/minecraft/server/WorldServer.java ++++ b/src/main/java/net/minecraft/server/WorldServer.java +@@ -992,7 +992,28 @@ public class WorldServer extends World implements GeneratorAccessSeed { + + gameprofilerfiller.enter("tick"); + if (!entity.dead && !(entity instanceof EntityComplexPart)) { ++ // Airplane start - inline this.a to prevent creation of lambda ++ /* + this.a(this::entityJoinedWorld, entity); ++ */ ++ boolean doMidTick = false; // usually there's a returns in the catch, so treat it like that ++ try { ++ this.entityJoinedWorld(entity); ++ doMidTick = true; ++ } catch (Throwable throwable) { ++ if (throwable instanceof ThreadDeath) throw throwable; // Paper ++ // Paper start - Prevent tile entity and entity crashes ++ String msg = "Entity threw exception at " + entity.world.getWorld().getName() + ":" + entity.locX() + "," + entity.locY() + "," + entity.locZ(); ++ System.err.println(msg); ++ throwable.printStackTrace(); ++ getServer().getPluginManager().callEvent(new com.destroystokyo.paper.event.server.ServerExceptionEvent(new com.destroystokyo.paper.exception.ServerInternalException(msg, throwable))); ++ entity.dead = true; ++ // Paper end ++ } ++ if (doMidTick) { ++ MinecraftServer.getServer().executeMidTickTasks(); // Tuinity - execute chunk tasks mid tick ++ } ++ // Airplane end + } + + gameprofilerfiller.exit(); +@@ -1330,9 +1351,14 @@ public class WorldServer extends World implements GeneratorAccessSeed { + ++entity.ticksLived; + GameProfilerFiller gameprofilerfiller = this.getMethodProfiler(); + ++ // Airplane start - create debug lambda once, todo do we even WANT the method profiler? ++ /* + gameprofilerfiller.a(() -> { + return IRegistry.ENTITY_TYPE.getKey(entity.getEntityType()).toString(); + }); ++ */ ++ gameprofilerfiller.a(entity.getEntityType().getEntityName); ++ // Airplane end + gameprofilerfiller.c("tickNonPassenger"); + if (isActive) { // Paper - EAR 2 + TimingHistory.activatedEntityTicks++; // Paper diff --git a/patches/server/0019-Skip-POI-finding-if-stuck-in-vehicle.patch b/patches/server/0019-Skip-POI-finding-if-stuck-in-vehicle.patch new file mode 100644 index 0000000..2e241ef --- /dev/null +++ b/patches/server/0019-Skip-POI-finding-if-stuck-in-vehicle.patch @@ -0,0 +1,23 @@ +From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 +From: Paul Sauve +Date: Thu, 18 Feb 2021 13:13:27 -0600 +Subject: [PATCH] Skip POI finding if stuck in vehicle + + +diff --git a/src/main/java/net/minecraft/server/BehaviorFindPosition.java b/src/main/java/net/minecraft/server/BehaviorFindPosition.java +index 8d445e9c0875db6cf45e4d8bcfce7cd3d5094d94..bc13f865689058a3c94ee41b8efb4dce5874004b 100644 +--- a/src/main/java/net/minecraft/server/BehaviorFindPosition.java ++++ b/src/main/java/net/minecraft/server/BehaviorFindPosition.java +@@ -45,6 +45,12 @@ public class BehaviorFindPosition extends Behavior { + } + + protected boolean a(WorldServer worldserver, EntityCreature entitycreature) { ++ // Airplane start - don't calculate POI if they're trapped in a vehicle ++ Entity vehicle = entitycreature.getVehicle(); ++ if (vehicle instanceof EntityBoat || vehicle instanceof EntityMinecartRideable) { ++ return false; ++ } ++ // Airplane end + if (this.d && entitycreature.isBaby()) { + return false; + } else if (this.f == 0L) { diff --git a/settings.gradle.kts b/settings.gradle.kts new file mode 100644 index 0000000..d641e94 --- /dev/null +++ b/settings.gradle.kts @@ -0,0 +1,28 @@ +import java.util.Locale + +pluginManagement { + repositories { + mavenCentral() + jcenter() + maven("https://repo.jpenilla.xyz/snapshots") + } +} + +val forkName = "SparklyPaper" +val forkNameLowercase = forkName.toLowerCase(Locale.ENGLISH) + +rootProject.name = forkNameLowercase + +setupSubproject("$forkNameLowercase-api") { + projectDir = File("$forkName-API") + buildFileName = "../subprojects/api.gradle.kts" +} +setupSubproject("$forkNameLowercase-server") { + projectDir = File("$forkName-Server") + buildFileName = "../subprojects/server.gradle.kts" +} + +inline fun setupSubproject(name: String, block: ProjectDescriptor.() -> Unit) { + include(name) + project(":$name").apply(block) +} diff --git a/subprojects/api.gradle.kts b/subprojects/api.gradle.kts new file mode 100644 index 0000000..2578822 --- /dev/null +++ b/subprojects/api.gradle.kts @@ -0,0 +1,14 @@ +import xyz.jpenilla.toothpick.loadDependencies +import xyz.jpenilla.toothpick.loadRepositories + +repositories { + loadRepositories(project) +} + +dependencies { + loadDependencies(project) +} + +java { + withJavadocJar() +} diff --git a/subprojects/server.gradle.kts b/subprojects/server.gradle.kts new file mode 100644 index 0000000..4527104 --- /dev/null +++ b/subprojects/server.gradle.kts @@ -0,0 +1,10 @@ +import xyz.jpenilla.toothpick.loadDependencies +import xyz.jpenilla.toothpick.loadRepositories + +repositories { + loadRepositories(project) +} + +dependencies { + loadDependencies(project) +}