Merge remote-tracking branch 'origin/master'

* Updated minecraft internals to adapt to 1.20.5/1.20.6 (tested on paper experimental builds)
* Adapt to further breaking changes introduced by paper
* Updated custom payload wrapper for 1.20.5/1.20.6

.github/ISSUE_TEMPLATE/bug_report.md

@@ -1,7 +1,7 @@
 ---
 name: Bug report
-about: Report a bug to help us fix
-title: "[BUG REPORT]"
+about: Report bugs to help us improve our software.
+title: ""
 labels: bug
 assignees: ''
 
@@ -10,11 +10,21 @@ assignees: ''
 **Describe the bug**
 A clear and concise description of what the bug is.
 
-**To Reproduce**
+**Software brand**
+Please let us know what software you are using.
+Eg. Spigot 1.18.2, Paper 1.18.2, Tuinity 1.18.2, Pufferfish 1.18.2, etc...
+Make sure to mention the version of the software.
+
+**Plugins**
+Please give us a list of your plugins. Sometimes we run into incompatibilities. Having an overview of the plugins on your server can really help identify the problem quicker.
+Eg. ViaVersion, ProtocolLib, HolographicDisplays
+You may also provide a screenshot.
+
+**How To Reproduce**
 Steps to reproduce the behavior:
 *Example:*
-1. Login on the 1.16.4 minecraft client.
-2. Join the server while it is still starting up.
+1. Join with the 1.18.2 vanilla minecraft client.
+2. Spam
 3. ....
 4. See error
 
@@ -24,18 +34,5 @@ A clear and concise description of what you expected to happen.
 **Screenshots**
 If applicable, add screenshots to help explain your problem.
 
-**About your server (please complete the following information):**
- - Spigot: [eg. Paper or Tuinity]
-    We only accept reports that are reproducible
-    on one of the supported spigots.
- 
-- Server Version: [eg. 1.16.4]
-    Feel free to report bugs for versions newer than 1.7.10, even if we
-    don’t support them yet, but be aware that we might have already
-    found the bug and fixed it in a dev build, just before you reported it.
-    Please don’t get frustrated in such cases.
-
-- Plugins List if possible: [eg. ViaVersion, ProtocolLib, HolographicDisplays]
-
 **Additional context**
 Add any other context about the problem here.

.github/workflows/gradle-publish.yml

@@ -0,0 +1,33 @@
+# This workflow will build a package using Gradle and then publish it to GitHub packages when a release is created
+# For more information see: https://github.com/actions/setup-java/blob/main/docs/advanced-usage.md#Publishing-using-gradle
+
+name: Gradle Package
+
+on: [ push, pull_request ]
+
+jobs:
+  build:
+
+    runs-on: ubuntu-latest
+    permissions:
+      contents: read
+      packages: write
+
+    steps:
+    - uses: actions/checkout@v2
+    - name: Set up JDK 8
+      uses: actions/setup-java@v2
+      with:
+        java-version: '8'
+        distribution: 'adopt'
+        server-id: github # Value of the distributionManagement/repository/id field of the pom.xml
+        settings-path: ${{ github.workspace }} # location for the settings.xml file
+
+    - name: Build with Gradle
+      run: gradle :clean :build
+
+    - name: Upload build artifacts
+      uses: actions/upload-artifact@v1
+      with:
+        name: packetevents-dev-build.jar
+        path: build/libs

.gitignore

@@ -110,4 +110,8 @@ dependency-reduced-pom.xml
 buildNumber.properties
 .mvn/timing.properties
 # https://github.com/takari/maven-wrapper#usage-without-binary-jar
-.mvn/wrapper/maven-wrapper.jar
+.mvn/wrapper/maven-wrapper.jar
+/src/main/resources/
+/.gradle/
+/.idea/
+/build/

LICENSE

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

README.md

@@ -1,82 +1,23 @@
 # packetevents
 
-Some tasks require you to work at the packet level.
-It is very common for people to write their own packet system and event manager.
-PacketEvents is here to save you a ton of work.
-We provide high level packet-wrappers.
-The PacketEvents API focuses on providing you easy to use packet-wrappers supporting 1.7.10 spigots up to the current latest version!
-This API even comes with two event systems.
-The first one (currently deprecated) is extremely similar to Bukkit's event system making it really easy to use for
-experienced Bukkit plugin developers.
-The second one (recommended) prioritizes performance.
-PacketEvents listens to its community. 
-Many users love shading the API into their plugin, so that their customers won't need to
-download the API as an external dependency.
-We have gone out of our way to support multiple plugins shading the API (resulting in duplicate PacketEvents APIs)
-and they all work together.
-
-### Resources
-* [Website](https://packetevents.github.io)
-* [SpigotMC](https://www.spigotmc.org/resources/packetevents-api.80279/)
-* [JavaDoc](https://retrooper.github.io/packetevents)
-
-### Licensing
-[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)\
-PacketEvents is licensed under the MIT License.
-We intentionally selected this license compared to stricter options.\
-[Summary of the license](https://tldrlegal.com/license/mit-license)
-
-### Contributing
-[![Contributor Covenant](https://img.shields.io/badge/Contributor%20Covenant-v2.0%20adopted-ff69b4.svg)](CONTRIBUTOR_CODE_OF_CONDUCT.md)\
-PacketEvents is an open source project.
-We appreciate contributions.
-It is amazing that you want to take an extra step to contribute a change to the API that will
-hopefully benefit the majority of users.
-Before taking this step, please read the Contributor Code Of Conduct. (click on the badge above)
-Please also read [this](CONTRIBUTING.md) if you consider contributing.
-Our discord server has a role for contributors.\
-[Learn more about it in our discord server](https://discord.me/packetevents)
-
-### Forking
-We also appreciate forks.
-It is always great news to us knowing someone is building their own API off of the PacketEvents API.
-If you are developing a feature that is only going to benefit you and not the majority of the community,
-please do not contribute!
-Make a fork instead!
-Our discord server has a discord role for forkers.\
-[Learn more about it in our discord server](https://discord.me/packetevents)
-
-### Compilation
-PacketEvents is built with Maven and all past releases have always used maven.
-The majority of users (currently) in the Bukkit community use Maven.
-It should be easier for most people to contribute if we use Maven too.
-Just because PacketEvents is built with Maven doesn't mean you can't use other dependency managers to use the API.
-
-### Setup
-You can either use the API with a dependency manager(like Maven or Gradle), depend on a pre-built build or compile it yourself with the source code.
-We recommend using a dependency manager.
-#### 1. Using a dependency manager
+[![](https://img.shields.io/badge/License-GPLv3-yellow.svg)](https://github.com/retrooper/packetevents/blob/master/LICENSE)
 [![](https://jitpack.io/v/retrooper/packetevents.svg)](https://jitpack.io/#retrooper/packetevents)
 
-#### 2. Using as an external pre-built dependency.
-* Download the [latest build from SpigotMC](https://www.spigotmc.org/resources/packetevents-api.80279/)
-* Add PacketEvents as a depend or soft-depend to your plugin.yml like this:
-```yml
-depend: [packetevents]
-```
-Your customers are now required to download this external pre-built dependency on their minecraft server.\
-It is an API and a Bukkit plugin at the same time.
-The version of the pre-built dependency is recommended to be the same as the version
-of the API you used in your plugin incase there have been API changes.
+PacketEvents is a powerful packet library. Our packet wrappers are efficient and easy to use. We support many protocol versions. (1.8+)
 
-#### 3. Compiling source code.
-When compiling the source code yourself, you are required to use Maven. (unless you switch yourself)\
-We currently do not have a guide showing you how to do this, but it should be self explanatory if you know what you are doing.
+### Resources
+* [SpigotMC](https://www.spigotmc.org/resources/packetevents-api.80279/)
+* [JavaDoc](https://packetevents.github.io/javadocs)
+* [Discord](https://discord.me/packetevents)
 
-### Author
-PacketEvents was started by retrooper.
-This API was initially for his private anti-cheat he was developing just to test around with.
-He has quit anti-cheat development and is now prioritizing this API and a few other private projects.
-PacketEvents now has a handfull of contributors improving the API.
-Share the API, donate, contribute, fork.
-Thanks. 
+### Setup
+[Learn more](https://github.com/retrooper/packetevents/wiki/1.-Setup)
+
+### Sponsorships
+[![](https://www.ej-technologies.com/images/product_banners/jprofiler_small.png)](https://www.ej-technologies.com/products/jprofiler/overview.html)
+
+### Statistics
+PacketEvents collects statistics anonymously using bStats. It helps give us an overview of what platforms use our project. If you really don't like, you can turn it off.
+
+### Credit
+PacketEvents uses an injector that is extremely similar to ViaVersion's injector. I have included license and copyright holder notice in the files taken from ViaVersion. Thank you ViaVersion.

SUMMARY.md

@@ -0,0 +1,4 @@
+# Table of contents
+
+* [Initial page](README.md)
+

build.gradle

@@ -0,0 +1,79 @@
+plugins {
+    id 'java'
+    id 'maven-publish'
+}
+
+//gradle myJavadocs
+task myJavadocs(type: Javadoc) {
+    source = sourceSets.main.allJava
+    File projectDir = getProjectDir()
+    File javadocsDir = new File(projectDir.getParentFile().getAbsolutePath() + "/docs");
+    javadocsDir.mkdirs()
+    setDestinationDir(javadocsDir)
+}
+
+repositories {
+    mavenLocal()
+    maven {
+        url = uri('https://hub.spigotmc.org/nexus/content/repositories/snapshots/')
+    }
+
+    maven {
+        url 'https://papermc.io/repo/repository/maven-public/'
+    }
+
+    maven {
+        url 'https://repo.opencollab.dev/maven-snapshots/'
+    }
+
+    maven {
+        url 'https://repo.opencollab.dev/maven-releases/'
+    }
+
+    maven {
+        url = uri('https://jitpack.io/')
+    }
+
+    maven {
+        url = uri('https://repo.viaversion.com/')
+    }
+
+    maven {
+        url = uri('https://oss.sonatype.org/content/repositories/releases/')
+    }
+
+    maven {
+        url = uri('https://repo.maven.apache.org/maven2/')
+    }
+    mavenCentral()
+}
+
+dependencies {
+    implementation 'org.jetbrains:annotations:23.0.0'
+
+    compileOnly 'org.spigotmc:spigot-api:1.17-R0.1-SNAPSHOT'
+    compileOnly 'com.destroystokyo.paper:paper-api:1.16.5-R0.1-SNAPSHOT'
+    compileOnly 'com.viaversion:viaversion-api:4.0.1'
+    compileOnly 'com.github.ProtocolSupport:ProtocolSupport:3d24efeda6'
+
+    compileOnly group: 'com.github.azbh111', name: 'craftbukkit-1.14.3', version: 'R'
+    compileOnly group: 'com.github.azbh111', name: 'craftbukkit-1.8.8', version: 'R'
+    compileOnly group: 'com.github.azbh111', name: 'craftbukkit-1.7.10', version: 'R'
+}
+
+group = 'io.github.retrooper'
+version = '1.8.4'
+description = 'packetevents'
+java.sourceCompatibility = JavaVersion.VERSION_1_8
+java.targetCompatibility = JavaVersion.VERSION_1_8
+publishing {
+    publications {
+        maven(MavenPublication) {
+            from(components.java)
+        }
+    }
+}
+
+tasks.withType(JavaCompile) {
+    options.encoding = 'UTF-8'
+}

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -0,0 +1,169 @@
+#!/usr/bin/env sh
+
+##############################################################################
+##
+##  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" "$@"

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

pom.xml

@@ -1,178 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xmlns="http://maven.apache.org/POM/4.0.0"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
-    <modelVersion>4.0.0</modelVersion>
-
-    <groupId>io.github.retrooper</groupId>
-    <artifactId>packetevents</artifactId>
-    <version>1.8-pre-10</version>
-    <build>
-        <plugins>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>3.2.4</version>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
-                            <minimizeJar>true</minimizeJar>
-                            <createDependencyReducedPom>false</createDependencyReducedPom>
-                            <createTestSourcesJar>false</createTestSourcesJar>
-                            <shadedArtifactAttached>false</shadedArtifactAttached>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <configuration>
-                    <source>8</source>
-                    <target>8</target>
-                </configuration>
-            </plugin>
-            <!--
-             <plugin>
-                 <groupId>org.apache.maven.plugins</groupId>
-                 <artifactId>maven-javadoc-plugin</artifactId>
-                 <executions>
-                     <execution>
-                         <id>attach-javadocs</id>
-                         <goals>
-                             <goal>jar</goal>
-                         </goals>
-                     </execution>
-                 </executions>
-             </plugin>
-             -->
-        </plugins>
-        <resources>
-            <resource>
-                <directory>src/main/resources</directory>
-                <filtering>true</filtering>
-            </resource>
-        </resources>
-    </build>
-    <packaging>jar</packaging>
-    <name>packetevents</name>
-
-    <properties>
-        <java.version>1.8</java.version>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-
-    <repositories>
-        <repository>
-            <id>spigot-repo</id>
-            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
-        </repository>
-        <repository>
-            <id>jitpack.io</id>
-            <url>https://jitpack.io</url>
-        </repository>
-        <repository>
-            <id>funkemunky-releases</id>
-            <url>https://nexus.funkemunky.cc/content/repositories/releases/</url>
-        </repository>
-        <repository>
-            <id>viaversion-repo</id>
-            <url>https://repo.viaversion.com</url>
-        </repository>
-        <repository>
-            <id>sonotype</id>
-            <url>https://oss.sonatype.org/content/repositories/releases/</url>
-        </repository>
-    </repositories>
-
-
-    <dependencies>
-        <dependency>
-            <groupId>org.jetbrains</groupId>
-            <artifactId>annotations</artifactId>
-            <version>20.1.0</version>
-            <scope>compile</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.github.spigot</groupId>
-            <artifactId>1.16.2</artifactId>
-            <version>1.16.2</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.github.spigot</groupId>
-            <artifactId>1.13.2</artifactId>
-            <version>1.13.2</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.github.spigot</groupId>
-            <artifactId>1.13</artifactId>
-            <version>1.13</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.github.spigot</groupId>
-            <artifactId>1.12.2</artifactId>
-            <version>1.12.2</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.github.spigot</groupId>
-            <artifactId>1.9.4</artifactId>
-            <version>1.9.4</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.github.spigot</groupId>
-            <artifactId>1.9</artifactId>
-            <version>1.9</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.github.spigot</groupId>
-            <artifactId>1.8.8</artifactId>
-            <version>1.8.8</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.github.spigot</groupId>
-            <artifactId>1.7.10</artifactId>
-            <version>1.7.10</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>us.myles</groupId>
-            <artifactId>viaversion</artifactId>
-            <version>3.2.0</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>com.github.ProtocolSupport</groupId>
-            <artifactId>ProtocolSupport</artifactId>
-            <version>3d24efeda6</version>
-            <scope>provided</scope>
-        </dependency>
-
-        <dependency>
-            <groupId>org.spigotmc</groupId>
-            <artifactId>spigot-api</artifactId>
-            <version>1.8.8-R0.1-SNAPSHOT</version>
-            <scope>provided</scope>
-        </dependency>
-    </dependencies>
-</project>

settings.gradle

@@ -0,0 +1,5 @@
+/*
+ * This file was generated by the Gradle 'init' task.
+ */
+
+rootProject.name = 'packetevents'

src/main/java/io/github/retrooper/packetevents/PacketEvents.java

@@ -1,29 +1,24 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents;
 
+import io.github.retrooper.packetevents.bstats.Metrics;
 import io.github.retrooper.packetevents.event.impl.PostPlayerInjectEvent;
 import io.github.retrooper.packetevents.event.manager.EventManager;
 import io.github.retrooper.packetevents.event.manager.PEEventManager;
@@ -32,49 +27,51 @@ import io.github.retrooper.packetevents.injector.GlobalChannelInjector;
 import io.github.retrooper.packetevents.packettype.PacketType;
 import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.packetwrappers.play.out.entityequipment.WrappedPacketOutEntityEquipment;
 import io.github.retrooper.packetevents.processor.BukkitEventProcessorInternal;
 import io.github.retrooper.packetevents.processor.PacketProcessorInternal;
 import io.github.retrooper.packetevents.settings.PacketEventsSettings;
 import io.github.retrooper.packetevents.updatechecker.UpdateChecker;
 import io.github.retrooper.packetevents.utils.entityfinder.EntityFinderUtils;
+import io.github.retrooper.packetevents.utils.guava.GuavaUtils;
 import io.github.retrooper.packetevents.utils.netty.bytebuf.ByteBufUtil;
 import io.github.retrooper.packetevents.utils.netty.bytebuf.ByteBufUtil_7;
 import io.github.retrooper.packetevents.utils.netty.bytebuf.ByteBufUtil_8;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
 import io.github.retrooper.packetevents.utils.player.PlayerUtils;
-import io.github.retrooper.packetevents.utils.reflection.Reflection;
 import io.github.retrooper.packetevents.utils.server.ServerUtils;
 import io.github.retrooper.packetevents.utils.server.ServerVersion;
 import io.github.retrooper.packetevents.utils.version.PEVersion;
 import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.Listener;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.ServicePriority;
-import org.spigotmc.SpigotConfig;
+import org.bukkit.plugin.java.JavaPlugin;
 
-import java.lang.reflect.Field;
 import java.util.concurrent.ExecutorService;
 import java.util.concurrent.atomic.AtomicBoolean;
 
 public final class PacketEvents implements Listener, EventManager {
-    public static String handlerName;
-    //TODO finish unfinished wrappers
     private static PacketEvents instance;
     private static Plugin plugin;
-    private final PEVersion version = new PEVersion(1, 7, 9, 10);
+    private final PEVersion version = new PEVersion(1, 8, 4);
     private final EventManager eventManager = new PEEventManager();
     private final PlayerUtils playerUtils = new PlayerUtils();
     private final ServerUtils serverUtils = new ServerUtils();
-    private final UpdateChecker updateChecker = new UpdateChecker();
-    public final PacketProcessorInternal packetProcessorInternal = new PacketProcessorInternal();
-    public final BukkitEventProcessorInternal bukkitEventProcessorInternal = new BukkitEventProcessorInternal();
-    public final GlobalChannelInjector injector = new GlobalChannelInjector();
-    private volatile boolean loading, loaded;
-    private final AtomicBoolean injectorReady = new AtomicBoolean(false);
-    private boolean initialized, initializing, terminating;
+    private final PacketProcessorInternal packetProcessorInternal = new PacketProcessorInternal();
+    private final BukkitEventProcessorInternal bukkitEventProcessorInternal = new BukkitEventProcessorInternal();
+    private final GlobalChannelInjector injector = new GlobalChannelInjector();
+    private final AtomicBoolean injectorReady = new AtomicBoolean();
+    private String handlerName;
     private PacketEventsSettings settings = new PacketEventsSettings();
     private ByteBufUtil byteBufUtil;
+    private UpdateChecker updateChecker;
+    private volatile boolean loading, loaded;
+    private boolean initialized, initializing, terminating;
+    private boolean lateBind = false;
 
     public static PacketEvents create(final Plugin plugin) {
         if (Bukkit.isPrimaryThread()) {
@@ -106,23 +103,20 @@ public final class PacketEvents implements Listener, EventManager {
 
     @Deprecated
     public static PacketEvents getAPI() {
-        return get();
+        return instance;
     }
 
 
     public void load() {
         if (!loaded && !loading) {
             loading = true;
+            //Resolve server version and cache
             ServerVersion version = ServerVersion.getVersion();
             WrappedPacket.version = version;
             NMSUtils.version = version;
             EntityFinderUtils.version = version;
             handlerName = "pe-" + plugin.getName();
             try {
-                Field lateBindField = Reflection.getField(SpigotConfig.class, "lateBind");
-                if (lateBindField != null && lateBindField.getBoolean(null)) {
-                    throw new IllegalStateException("Please disable late-bind in your Spigot config, late-bind is not supported!");
-                }
                 NMSUtils.load();
 
                 PacketTypeClasses.load();
@@ -130,19 +124,34 @@ public final class PacketEvents implements Listener, EventManager {
                 PacketType.load();
 
                 EntityFinderUtils.load();
+
+                getServerUtils().entityCache = GuavaUtils.makeMap();
+
+                if (version.isNewerThanOrEquals(ServerVersion.v_1_9)) {
+                    for (WrappedPacketOutEntityEquipment.EquipmentSlot slot : WrappedPacketOutEntityEquipment.EquipmentSlot.values()) {
+                        slot.id = (byte) slot.ordinal();
+                    }
+                } else {
+                    WrappedPacketOutEntityEquipment.EquipmentSlot.MAINHAND.id = 0;
+                    WrappedPacketOutEntityEquipment.EquipmentSlot.OFFHAND.id = -1; //Invalid
+                    WrappedPacketOutEntityEquipment.EquipmentSlot.BOOTS.id = 1;
+                    WrappedPacketOutEntityEquipment.EquipmentSlot.LEGGINGS.id = 2;
+                    WrappedPacketOutEntityEquipment.EquipmentSlot.CHESTPLATE.id = 3;
+                    WrappedPacketOutEntityEquipment.EquipmentSlot.HELMET.id = 4;
+                }
             } catch (Exception ex) {
                 loading = false;
                 throw new PacketEventsLoadFailureException(ex);
             }
 
             byteBufUtil = NMSUtils.legacyNettyImportMode ? new ByteBufUtil_7() : new ByteBufUtil_8();
-
+            updateChecker = new UpdateChecker();
             if (!injectorReady.get()) {
                 injector.load();
-                try {
+                lateBind = !injector.isBound();
+                //If late-bind is enabled, we will inject a bit later.
+                if (!lateBind) {
                     injector.inject();
-                } catch (Exception ex) {
-                    ex.printStackTrace();
                 }
                 injectorReady.set(true);
             }
@@ -152,10 +161,12 @@ public final class PacketEvents implements Listener, EventManager {
         }
     }
 
+    @Deprecated
     public void loadAsyncNewThread() {
         new Thread(this::load).start();
     }
 
+    @Deprecated
     public void loadAsync(ExecutorService executorService) {
         executorService.execute(this::load);
     }
@@ -180,19 +191,38 @@ public final class PacketEvents implements Listener, EventManager {
                 handleUpdateCheck();
             }
 
-            //We may not continue until the injector has been initialized!
-            while (!injectorReady.get()) {
-                ;
+            if (settings.isbStatsEnabled()) {
+                Metrics metrics = new Metrics((JavaPlugin) getPlugin(), 11327);
+                //Just to have an idea what versions of packetevents people use
+                metrics.addCustomChart(new Metrics.SimplePie("packetevents_version", () -> {
+                    return getVersion().toString();
+                }));
             }
 
-            Bukkit.getPluginManager().registerEvents(bukkitEventProcessorInternal, plugin);
-            for (final Player p : Bukkit.getOnlinePlayers()) {
-                try {
-                    injector.injectPlayer(p);
-                    PacketEvents.get().getEventManager().callEvent(new PostPlayerInjectEvent(p, false));
-                } catch (Exception ex) {
-                    p.kickPlayer("Failed to inject... Please rejoin!");
+            //We must wait for the injector to initialize.
+
+            //Wait for the injector to be ready.
+            while (!injectorReady.get()) {
+            }
+
+            Runnable postInjectTask = () -> {
+                Bukkit.getPluginManager().registerEvents(bukkitEventProcessorInternal, plugin);
+                for (final Player p : Bukkit.getOnlinePlayers()) {
+                    try {
+                        injector.injectPlayer(p);
+                        getEventManager().callEvent(new PostPlayerInjectEvent(p, false));
+                    } catch (Exception ex) {
+                        p.kickPlayer("Failed to inject... Please rejoin!");
+                    }
                 }
+            };
+
+            if (lateBind) {
+                //If late-bind is enabled, we still need to inject (after all plugins enabled).
+                Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, injector::inject);
+                Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, postInjectTask);
+            } else {
+                postInjectTask.run();
             }
 
             initialized = true;
@@ -212,11 +242,13 @@ public final class PacketEvents implements Listener, EventManager {
 
     public void terminate() {
         if (initialized && !terminating) {
+            //Eject all players
             for (Player p : Bukkit.getOnlinePlayers()) {
                 injector.ejectPlayer(p);
             }
+            //Eject the injector if needed
             injector.eject();
-
+            //Unregister all our listeners
             getEventManager().unregisterAllListeners();
             initialized = false;
             terminating = false;
@@ -262,11 +294,18 @@ public final class PacketEvents implements Listener, EventManager {
         return plugin;
     }
 
-    /**
-     * Get the PacketEvents settings.
-     *
-     * @return Configure some settings for the API
-     */
+    public GlobalChannelInjector getInjector() {
+        return injector;
+    }
+
+    public PacketProcessorInternal getInternalPacketProcessor() {
+        return packetProcessorInternal;
+    }
+
+    public String getHandlerName() {
+        return handlerName;
+    }
+
     public PacketEventsSettings getSettings() {
         return settings;
     }
@@ -296,34 +335,37 @@ public final class PacketEvents implements Listener, EventManager {
     }
 
     private void handleUpdateCheck() {
+        if (updateChecker == null) {
+            updateChecker = new UpdateChecker();
+        }
         Thread thread = new Thread(() -> {
-            PacketEvents.get().getPlugin().getLogger().info("[PacketEvents] Checking for an update, please wait...");
+            getPlugin().getLogger().info("[packetevents] Checking for an update, please wait...");
             UpdateChecker.UpdateCheckerStatus status = updateChecker.checkForUpdate();
             int seconds = 5;
-            for (int i = 0; i < 5; i++) {
-                if (status == UpdateChecker.UpdateCheckerStatus.FAILED) {
-                    PacketEvents.get().getPlugin().getLogger().severe("[PacketEvents] Checking for an update again in " + seconds + " seconds...");
-                    try {
-                        Thread.sleep(seconds * 1000L);
-                    } catch (InterruptedException e) {
-                        e.printStackTrace();
-                    }
+            int retryCount = 5;
+            for (int i = 0; i < retryCount; i++) {
+                if (status != UpdateChecker.UpdateCheckerStatus.FAILED) {
+                    break;
+                }
+                getPlugin().getLogger().severe("[packetevents] Checking for an update again in " + seconds + " seconds...");
+                try {
+                    Thread.sleep(seconds * 1000L);
+                } catch (InterruptedException e) {
+                    e.printStackTrace();
+                }
 
-                    seconds *= 2;
+                seconds *= 2;
 
-                    status = updateChecker.checkForUpdate();
+                status = updateChecker.checkForUpdate();
 
-                    if (i == 4) {
-                        PacketEvents.get().getPlugin().getLogger().severe("[PacketEvents] PacketEvents failed to check for an update. No longer retrying.");
-                        break;
-                    }
-                } else {
+                if (i == (retryCount - 1)) {
+                    getPlugin().getLogger().severe("[packetevents] PacketEvents failed to check for an update. No longer retrying.");
                     break;
                 }
 
             }
 
-        }, "PacketEvents-update-check-thread");
+        }, "packetevents-update-check-thread");
         thread.start();
     }
 

src/main/java/io/github/retrooper/packetevents/PacketEventsPlugin.java

@@ -1,57 +1,112 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents;
 
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
+import io.github.retrooper.packetevents.event.impl.PacketConfigReceiveEvent;
 import io.github.retrooper.packetevents.event.impl.PacketPlayReceiveEvent;
+import io.github.retrooper.packetevents.event.impl.PacketPlaySendEvent;
 import io.github.retrooper.packetevents.packettype.PacketType;
+import io.github.retrooper.packetevents.packetwrappers.play.in.blockdig.WrappedPacketInBlockDig;
+import io.github.retrooper.packetevents.packetwrappers.play.in.custompayload.WrappedPacketInCustomPayload;
+import io.github.retrooper.packetevents.packetwrappers.play.in.entityaction.WrappedPacketInEntityAction;
+import io.github.retrooper.packetevents.packetwrappers.play.in.flying.WrappedPacketInFlying;
+import io.github.retrooper.packetevents.packetwrappers.play.in.useentity.WrappedPacketInUseEntity;
+import io.github.retrooper.packetevents.packetwrappers.play.out.entity.WrappedPacketOutEntity;
+import io.github.retrooper.packetevents.packetwrappers.play.out.entityeffect.WrappedPacketOutEntityEffect;
+import io.github.retrooper.packetevents.packetwrappers.play.out.entityvelocity.WrappedPacketOutEntityVelocity;
+import io.github.retrooper.packetevents.packetwrappers.play.out.setslot.WrappedPacketOutSetSlot;
 import io.github.retrooper.packetevents.settings.PacketEventsSettings;
-import io.github.retrooper.packetevents.utils.gameprofile.WrappedGameProfile;
-import io.github.retrooper.packetevents.utils.gameprofile.WrappedProperty;
+import io.github.retrooper.packetevents.utils.server.ServerVersion;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.java.JavaPlugin;
 
-import javax.net.ssl.HttpsURLConnection;
-import java.io.BufferedReader;
-import java.io.InputStreamReader;
-import java.net.URL;
-import java.util.UUID;
+import java.nio.charset.StandardCharsets;
 
 public class PacketEventsPlugin extends JavaPlugin {
     @Override
     public void onLoad() {
-        //Return value of create is your PacketEvents instance.
-        PacketEvents instance = PacketEvents.create(this);
-        PacketEventsSettings settings = instance.getSettings();
-        settings.compatInjector(false);
-        settings.checkForUpdates(false);
-        instance.loadAsyncNewThread();
+        PacketEventsSettings settings = PacketEvents.create(this).getSettings();
+        settings
+                .fallbackServerVersion(ServerVersion.getLatest())
+                .checkForUpdates(true)
+                .bStats(true);
+        PacketEvents.get().loadAsyncNewThread();
+        //You can do something here as it is loading
     }
 
     @Override
     public void onEnable() {
-        //Other way to access your instance...
+        /*PacketEvents.get().getEventManager().registerListener(new PacketListenerAbstract() {
+            @Override
+            public void onPacketPlayReceive(PacketPlayReceiveEvent event) {
+                if (event.getPacketId() == PacketType.Play.Client.USE_ENTITY) {
+                    System.out.println("Yes");
+                    WrappedPacketInUseEntity ue = new WrappedPacketInUseEntity(event.getNMSPacket());
+                    event.getPlayer().sendMessage("action: " + ue.getAction());
+                    event.getPlayer().sendMessage("target: " + ue.getTarget());
+                    ItemStack stack = new ItemStack(Material.STICK);
+                    WrappedPacketOutSetSlot setSlot = new WrappedPacketOutSetSlot(0, 37, stack);
+                    PacketEvents.get().getPlayerUtils().sendPacket(event.getPlayer(), setSlot);
+                } else if (event.getPacketId() == PacketType.Play.Client.CUSTOM_PAYLOAD) {
+                    WrappedPacketInCustomPayload cp = new WrappedPacketInCustomPayload(event.getNMSPacket());
+                    String name = cp.getChannelName();
+                    System.out.println("name play: " + name);
+                    System.out.println("Data: " + ((new String(cp.getData(), StandardCharsets.UTF_8))));
+                }
+                else if (event.getPacketId() == PacketType.Play.Client.ENTITY_ACTION) {
+                    WrappedPacketInEntityAction ea = new WrappedPacketInEntityAction(event.getNMSPacket());
+                    event.getPlayer().sendMessage("EA: " + ea.getAction());
+                } else if (PacketType.Play.Client.BLOCK_DIG == event.getPacketId()) {
+                    WrappedPacketInBlockDig bd = new WrappedPacketInBlockDig(event.getNMSPacket());
+                    event.getPlayer().sendMessage("bd: " + bd.getDigType());
+                }
+                else if (PacketType.Play.Client.Util.isInstanceOfFlying(event.getPacketId())) {
+                    WrappedPacketInFlying f = new WrappedPacketInFlying(event.getNMSPacket());
+                    System.out.println("flying: " + f.getPosition().toString() + ", pitch and yaw: " + f.getPitch() + ", " + f.getYaw());
+                }
+            }
+
+            @Override
+            public void onPacketConfigReceive(PacketConfigReceiveEvent event) {
+                if (event.getPacketId() == PacketType.Play.Client.CUSTOM_PAYLOAD) {
+                    WrappedPacketInCustomPayload cp = new WrappedPacketInCustomPayload(event.getNMSPacket());
+                    String name = cp.getChannelName();
+                    System.out.println("name: " + name);
+                    System.out.println("Data: " + ((new String(cp.getData(), StandardCharsets.UTF_8))));
+                }
+            }
+
+            @Override
+            public void onPacketPlaySend(PacketPlaySendEvent event) {
+                if (PacketType.Play.Server.Util.isInstanceOfEntity(event.getPacketId())) {
+                    WrappedPacketOutEntity entity = new WrappedPacketOutEntity(event.getNMSPacket());
+                } else if (event.getPacketId() == PacketType.Play.Server.ENTITY_EFFECT) {
+                    WrappedPacketOutEntityEffect eff = new WrappedPacketOutEntityEffect(event.getNMSPacket());
+                    //TODO Broken on 1.20.5 eff.setEffectId(eff.getEffectId());
+                    System.out.println("eff: " + eff.getEffectId() + ", ampl: " + eff.getAmplifier() + ", dur:" + eff.getDuration());
+                } else if (event.getPacketId() == PacketType.Play.Server.ENTITY_VELOCITY) {
+                    WrappedPacketOutEntityVelocity ev = new WrappedPacketOutEntityVelocity(event.getNMSPacket());
+                }
+            }
+        });*/
         PacketEvents.get().init();
     }
 

src/main/java/io/github/retrooper/packetevents/bstats/Metrics.java

@@ -0,0 +1,860 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.bstats;
+
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.file.YamlConfiguration;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.Plugin;
+import org.bukkit.plugin.java.JavaPlugin;
+
+import javax.net.ssl.HttpsURLConnection;
+import java.io.*;
+import java.lang.reflect.Method;
+import java.net.URL;
+import java.nio.charset.StandardCharsets;
+import java.util.*;
+import java.util.concurrent.Callable;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.TimeUnit;
+import java.util.function.BiConsumer;
+import java.util.function.Consumer;
+import java.util.function.Supplier;
+import java.util.logging.Level;
+import java.util.stream.Collectors;
+import java.util.zip.GZIPOutputStream;
+
+public class Metrics {
+
+    private final Plugin plugin;
+
+    private final MetricsBase metricsBase;
+
+    /**
+     * Creates a new Metrics instance.
+     *
+     * @param plugin    Your plugin instance.
+     * @param serviceId The id of the service. It can be found at <a
+     *                  href="https://bstats.org/what-is-my-plugin-id">What is my plugin id?</a>
+     */
+    public Metrics(JavaPlugin plugin, int serviceId) {
+        this.plugin = plugin;
+        // Get the config file
+        File bStatsFolder = new File(plugin.getDataFolder().getParentFile(), "bStats");
+        File configFile = new File(bStatsFolder, "config.yml");
+        YamlConfiguration config = YamlConfiguration.loadConfiguration(configFile);
+        if (!config.isSet("serverUuid")) {
+            config.addDefault("enabled", true);
+            config.addDefault("serverUuid", UUID.randomUUID().toString());
+            config.addDefault("logFailedRequests", false);
+            config.addDefault("logSentData", false);
+            config.addDefault("logResponseStatusText", false);
+            // Inform the server owners about bStats
+            config
+                    .options()
+                    .header(
+                            "bStats (https://bStats.org) collects some basic information for plugin authors, like how\n"
+                                    + "many people use their plugin and their total player count. It's recommended to keep bStats\n"
+                                    + "enabled, but if you're not comfortable with this, you can turn this setting off. There is no\n"
+                                    + "performance penalty associated with having metrics enabled, and data sent to bStats is fully\n"
+                                    + "anonymous.")
+                    .copyDefaults(true);
+            try {
+                config.save(configFile);
+            } catch (IOException ignored) {
+            }
+        }
+        // Load the data
+        boolean enabled = config.getBoolean("enabled", true);
+        String serverUUID = config.getString("serverUuid");
+        boolean logErrors = config.getBoolean("logFailedRequests", false);
+        boolean logSentData = config.getBoolean("logSentData", false);
+        boolean logResponseStatusText = config.getBoolean("logResponseStatusText", false);
+        metricsBase =
+                new MetricsBase(
+                        "bukkit",
+                        serverUUID,
+                        serviceId,
+                        enabled,
+                        this::appendPlatformData,
+                        this::appendServiceData,
+                        submitDataTask -> Bukkit.getScheduler().runTask(plugin, submitDataTask),
+                        plugin::isEnabled,
+                        (message, error) -> this.plugin.getLogger().log(Level.WARNING, message, error),
+                        (message) -> this.plugin.getLogger().log(Level.INFO, message),
+                        logErrors,
+                        logSentData,
+                        logResponseStatusText);
+    }
+
+    /**
+     * Adds a custom chart.
+     *
+     * @param chart The chart to add.
+     */
+    public void addCustomChart(CustomChart chart) {
+        metricsBase.addCustomChart(chart);
+    }
+
+    private void appendPlatformData(JsonObjectBuilder builder) {
+        builder.appendField("playerAmount", getPlayerAmount());
+        builder.appendField("onlineMode", Bukkit.getOnlineMode() ? 1 : 0);
+        builder.appendField("bukkitVersion", Bukkit.getVersion());
+        builder.appendField("bukkitName", Bukkit.getName());
+        builder.appendField("javaVersion", System.getProperty("java.version"));
+        builder.appendField("osName", System.getProperty("os.name"));
+        builder.appendField("osArch", System.getProperty("os.arch"));
+        builder.appendField("osVersion", System.getProperty("os.version"));
+        builder.appendField("coreCount", Runtime.getRuntime().availableProcessors());
+    }
+
+    private void appendServiceData(JsonObjectBuilder builder) {
+        builder.appendField("pluginVersion", plugin.getDescription().getVersion());
+    }
+
+    private int getPlayerAmount() {
+        try {
+            // Around MC 1.8 the return type was changed from an array to a collection,
+            // This fixes java.lang.NoSuchMethodError:
+            // org.bukkit.Bukkit.getOnlinePlayers()Ljava/util/Collection;
+            Method onlinePlayersMethod = Class.forName("org.bukkit.Server").getMethod("getOnlinePlayers");
+            return onlinePlayersMethod.getReturnType().equals(Collection.class)
+                    ? ((Collection<?>) onlinePlayersMethod.invoke(Bukkit.getServer())).size()
+                    : ((Player[]) onlinePlayersMethod.invoke(Bukkit.getServer())).length;
+        } catch (Exception e) {
+            // Just use the new method if the reflection failed
+            return Bukkit.getOnlinePlayers().size();
+        }
+    }
+
+    public static class MetricsBase {
+
+        /**
+         * The version of the Metrics class.
+         */
+        public static final String METRICS_VERSION = "2.2.1";
+
+        private static final ScheduledExecutorService scheduler =
+                Executors.newScheduledThreadPool(1, task -> new Thread(task, "bStats-Metrics"));
+
+        private static final String REPORT_URL = "https://bStats.org/api/v2/data/%s";
+
+        private final String platform;
+
+        private final String serverUuid;
+
+        private final int serviceId;
+
+        private final Consumer<JsonObjectBuilder> appendPlatformDataConsumer;
+
+        private final Consumer<JsonObjectBuilder> appendServiceDataConsumer;
+
+        private final Consumer<Runnable> submitTaskConsumer;
+
+        private final Supplier<Boolean> checkServiceEnabledSupplier;
+
+        private final BiConsumer<String, Throwable> errorLogger;
+
+        private final Consumer<String> infoLogger;
+
+        private final boolean logErrors;
+
+        private final boolean logSentData;
+
+        private final boolean logResponseStatusText;
+
+        private final Set<CustomChart> customCharts = new HashSet<>();
+
+        private final boolean enabled;
+
+        /**
+         * Creates a new MetricsBase class instance.
+         *
+         * @param platform                    The platform of the service.
+         * @param serviceId                   The id of the service.
+         * @param serverUuid                  The server uuid.
+         * @param enabled                     Whether or not data sending is enabled.
+         * @param appendPlatformDataConsumer  A consumer that receives a {@code JsonObjectBuilder} and
+         *                                    appends all platform-specific data.
+         * @param appendServiceDataConsumer   A consumer that receives a {@code JsonObjectBuilder} and
+         *                                    appends all service-specific data.
+         * @param submitTaskConsumer          A consumer that takes a runnable with the submit task. This can be
+         *                                    used to delegate the data collection to a another thread to prevent errors caused by
+         *                                    concurrency. Can be {@code null}.
+         * @param checkServiceEnabledSupplier A supplier to check if the service is still enabled.
+         * @param errorLogger                 A consumer that accepts log message and an error.
+         * @param infoLogger                  A consumer that accepts info log messages.
+         * @param logErrors                   Whether or not errors should be logged.
+         * @param logSentData                 Whether or not the sent data should be logged.
+         * @param logResponseStatusText       Whether or not the response status text should be logged.
+         */
+        public MetricsBase(
+                String platform,
+                String serverUuid,
+                int serviceId,
+                boolean enabled,
+                Consumer<JsonObjectBuilder> appendPlatformDataConsumer,
+                Consumer<JsonObjectBuilder> appendServiceDataConsumer,
+                Consumer<Runnable> submitTaskConsumer,
+                Supplier<Boolean> checkServiceEnabledSupplier,
+                BiConsumer<String, Throwable> errorLogger,
+                Consumer<String> infoLogger,
+                boolean logErrors,
+                boolean logSentData,
+                boolean logResponseStatusText) {
+            this.platform = platform;
+            this.serverUuid = serverUuid;
+            this.serviceId = serviceId;
+            this.enabled = enabled;
+            this.appendPlatformDataConsumer = appendPlatformDataConsumer;
+            this.appendServiceDataConsumer = appendServiceDataConsumer;
+            this.submitTaskConsumer = submitTaskConsumer;
+            this.checkServiceEnabledSupplier = checkServiceEnabledSupplier;
+            this.errorLogger = errorLogger;
+            this.infoLogger = infoLogger;
+            this.logErrors = logErrors;
+            this.logSentData = logSentData;
+            this.logResponseStatusText = logResponseStatusText;
+            checkRelocation();
+            if (enabled) {
+                startSubmitting();
+            }
+        }
+
+        /**
+         * Gzips the given string.
+         *
+         * @param str The string to gzip.
+         * @return The gzipped string.
+         */
+        private static byte[] compress(final String str) throws IOException {
+            if (str == null) {
+                return null;
+            }
+            ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
+            try (GZIPOutputStream gzip = new GZIPOutputStream(outputStream)) {
+                gzip.write(str.getBytes(StandardCharsets.UTF_8));
+            }
+            return outputStream.toByteArray();
+        }
+
+        public void addCustomChart(CustomChart chart) {
+            this.customCharts.add(chart);
+        }
+
+        private void startSubmitting() {
+            final Runnable submitTask =
+                    () -> {
+                        if (!enabled || !checkServiceEnabledSupplier.get()) {
+                            // Submitting data or service is disabled
+                            scheduler.shutdown();
+                            return;
+                        }
+                        if (submitTaskConsumer != null) {
+                            submitTaskConsumer.accept(this::submitData);
+                        } else {
+                            this.submitData();
+                        }
+                    };
+            // Many servers tend to restart at a fixed time at xx:00 which causes an uneven distribution
+            // of requests on the
+            // bStats backend. To circumvent this problem, we introduce some randomness into the initial
+            // and second delay.
+            // WARNING: You must not modify and part of this Metrics class, including the submit delay or
+            // frequency!
+            // WARNING: Modifying this code will get your plugin banned on bStats. Just don't do it!
+            long initialDelay = (long) (1000 * 60 * (3 + Math.random() * 3));
+            long secondDelay = (long) (1000 * 60 * (Math.random() * 30));
+            scheduler.schedule(submitTask, initialDelay, TimeUnit.MILLISECONDS);
+            scheduler.scheduleAtFixedRate(
+                    submitTask, initialDelay + secondDelay, 1000 * 60 * 30, TimeUnit.MILLISECONDS);
+        }
+
+        private void submitData() {
+            final JsonObjectBuilder baseJsonBuilder = new JsonObjectBuilder();
+            appendPlatformDataConsumer.accept(baseJsonBuilder);
+            final JsonObjectBuilder serviceJsonBuilder = new JsonObjectBuilder();
+            appendServiceDataConsumer.accept(serviceJsonBuilder);
+            JsonObjectBuilder.JsonObject[] chartData =
+                    customCharts.stream()
+                            .map(customChart -> customChart.getRequestJsonObject(errorLogger, logErrors))
+                            .filter(Objects::nonNull)
+                            .toArray(JsonObjectBuilder.JsonObject[]::new);
+            serviceJsonBuilder.appendField("id", serviceId);
+            serviceJsonBuilder.appendField("customCharts", chartData);
+            baseJsonBuilder.appendField("service", serviceJsonBuilder.build());
+            baseJsonBuilder.appendField("serverUUID", serverUuid);
+            baseJsonBuilder.appendField("metricsVersion", METRICS_VERSION);
+            JsonObjectBuilder.JsonObject data = baseJsonBuilder.build();
+            scheduler.execute(
+                    () -> {
+                        try {
+                            // Send the data
+                            sendData(data);
+                        } catch (Exception e) {
+                            // Something went wrong! :(
+                            if (logErrors) {
+                                errorLogger.accept("Could not submit bStats metrics data", e);
+                            }
+                        }
+                    });
+        }
+
+        private void sendData(JsonObjectBuilder.JsonObject data) throws Exception {
+            if (logSentData) {
+                infoLogger.accept("Sent bStats metrics data: " + data.toString());
+            }
+            String url = String.format(REPORT_URL, platform);
+            HttpsURLConnection connection = (HttpsURLConnection) new URL(url).openConnection();
+            // Compress the data to save bandwidth
+            byte[] compressedData = compress(data.toString());
+            connection.setRequestMethod("POST");
+            connection.addRequestProperty("Accept", "application/json");
+            connection.addRequestProperty("Connection", "close");
+            connection.addRequestProperty("Content-Encoding", "gzip");
+            connection.addRequestProperty("Content-Length", String.valueOf(compressedData.length));
+            connection.setRequestProperty("Content-Type", "application/json");
+            connection.setRequestProperty("User-Agent", "Metrics-Service/1");
+            connection.setDoOutput(true);
+            try (DataOutputStream outputStream = new DataOutputStream(connection.getOutputStream())) {
+                outputStream.write(compressedData);
+            }
+            StringBuilder builder = new StringBuilder();
+            try (BufferedReader bufferedReader =
+                         new BufferedReader(new InputStreamReader(connection.getInputStream()))) {
+                String line;
+                while ((line = bufferedReader.readLine()) != null) {
+                    builder.append(line);
+                }
+            }
+            if (logResponseStatusText) {
+                infoLogger.accept("Sent data to bStats and received response: " + builder);
+            }
+        }
+
+        /**
+         * Checks that the class was properly relocated.
+         */
+        private void checkRelocation() {
+            // You can use the property to disable the check in your test environment
+            if (System.getProperty("bstats.relocatecheck") == null
+                    || !System.getProperty("bstats.relocatecheck").equals("false")) {
+                // Maven's Relocate is clever and changes strings, too. So we have to use this little
+                // "trick" ... :D
+                final String defaultPackage =
+                        new String(new byte[]{'o', 'r', 'g', '.', 'b', 's', 't', 'a', 't', 's'});
+                final String examplePackage =
+                        new String(new byte[]{'y', 'o', 'u', 'r', '.', 'p', 'a', 'c', 'k', 'a', 'g', 'e'});
+                // We want to make sure no one just copy & pastes the example and uses the wrong package
+                // names
+                if (MetricsBase.class.getPackage().getName().startsWith(defaultPackage)
+                        || MetricsBase.class.getPackage().getName().startsWith(examplePackage)) {
+                    throw new IllegalStateException("bStats Metrics class has not been relocated correctly!");
+                }
+            }
+        }
+    }
+
+    public static class AdvancedBarChart extends CustomChart {
+
+        private final Callable<Map<String, int[]>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId  The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public AdvancedBarChart(String chartId, Callable<Map<String, int[]>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, int[]> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, int[]> entry : map.entrySet()) {
+                if (entry.getValue().length == 0) {
+                    // Skip this invalid
+                    continue;
+                }
+                allSkipped = false;
+                valuesBuilder.appendField(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class SimpleBarChart extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId  The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SimpleBarChart(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                valuesBuilder.appendField(entry.getKey(), new int[]{entry.getValue()});
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class MultiLineChart extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId  The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public MultiLineChart(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                if (entry.getValue() == 0) {
+                    // Skip this invalid
+                    continue;
+                }
+                allSkipped = false;
+                valuesBuilder.appendField(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public static class AdvancedPie extends CustomChart {
+
+        private final Callable<Map<String, Integer>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId  The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public AdvancedPie(String chartId, Callable<Map<String, Integer>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Integer> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean allSkipped = true;
+            for (Map.Entry<String, Integer> entry : map.entrySet()) {
+                if (entry.getValue() == 0) {
+                    // Skip this invalid
+                    continue;
+                }
+                allSkipped = false;
+                valuesBuilder.appendField(entry.getKey(), entry.getValue());
+            }
+            if (allSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    public abstract static class CustomChart {
+
+        private final String chartId;
+
+        protected CustomChart(String chartId) {
+            if (chartId == null) {
+                throw new IllegalArgumentException("chartId must not be null");
+            }
+            this.chartId = chartId;
+        }
+
+        public JsonObjectBuilder.JsonObject getRequestJsonObject(
+                BiConsumer<String, Throwable> errorLogger, boolean logErrors) {
+            JsonObjectBuilder builder = new JsonObjectBuilder();
+            builder.appendField("chartId", chartId);
+            try {
+                JsonObjectBuilder.JsonObject data = getChartData();
+                if (data == null) {
+                    // If the data is null we don't send the chart.
+                    return null;
+                }
+                builder.appendField("data", data);
+            } catch (Throwable t) {
+                if (logErrors) {
+                    errorLogger.accept("Failed to get data for custom chart with id " + chartId, t);
+                }
+                return null;
+            }
+            return builder.build();
+        }
+
+        protected abstract JsonObjectBuilder.JsonObject getChartData() throws Exception;
+    }
+
+    public static class SingleLineChart extends CustomChart {
+
+        private final Callable<Integer> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId  The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SingleLineChart(String chartId, Callable<Integer> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            int value = callable.call();
+            if (value == 0) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("value", value).build();
+        }
+    }
+
+    public static class SimplePie extends CustomChart {
+
+        private final Callable<String> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId  The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public SimplePie(String chartId, Callable<String> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        protected JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            String value = callable.call();
+            if (value == null || value.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("value", value).build();
+        }
+    }
+
+    public static class DrilldownPie extends CustomChart {
+
+        private final Callable<Map<String, Map<String, Integer>>> callable;
+
+        /**
+         * Class constructor.
+         *
+         * @param chartId  The id of the chart.
+         * @param callable The callable which is used to request the chart data.
+         */
+        public DrilldownPie(String chartId, Callable<Map<String, Map<String, Integer>>> callable) {
+            super(chartId);
+            this.callable = callable;
+        }
+
+        @Override
+        public JsonObjectBuilder.JsonObject getChartData() throws Exception {
+            JsonObjectBuilder valuesBuilder = new JsonObjectBuilder();
+            Map<String, Map<String, Integer>> map = callable.call();
+            if (map == null || map.isEmpty()) {
+                // Null = skip the chart
+                return null;
+            }
+            boolean reallyAllSkipped = true;
+            for (Map.Entry<String, Map<String, Integer>> entryValues : map.entrySet()) {
+                JsonObjectBuilder valueBuilder = new JsonObjectBuilder();
+                boolean allSkipped = true;
+                for (Map.Entry<String, Integer> valueEntry : map.get(entryValues.getKey()).entrySet()) {
+                    valueBuilder.appendField(valueEntry.getKey(), valueEntry.getValue());
+                    allSkipped = false;
+                }
+                if (!allSkipped) {
+                    reallyAllSkipped = false;
+                    valuesBuilder.appendField(entryValues.getKey(), valueBuilder.build());
+                }
+            }
+            if (reallyAllSkipped) {
+                // Null = skip the chart
+                return null;
+            }
+            return new JsonObjectBuilder().appendField("values", valuesBuilder.build()).build();
+        }
+    }
+
+    /**
+     * An extremely simple JSON builder.
+     *
+     * <p>While this class is neither feature-rich nor the most performant one, it's sufficient enough
+     * for its use-case.
+     */
+    public static class JsonObjectBuilder {
+
+        private StringBuilder builder = new StringBuilder();
+
+        private boolean hasAtLeastOneField = false;
+
+        public JsonObjectBuilder() {
+            builder.append("{");
+        }
+
+        /**
+         * Escapes the given string like stated in https://www.ietf.org/rfc/rfc4627.txt.
+         *
+         * <p>This method escapes only the necessary characters '"', '\'. and '\u0000' - '\u001F'.
+         * Compact escapes are not used (e.g., '\n' is escaped as "\u000a" and not as "\n").
+         *
+         * @param value The value to escape.
+         * @return The escaped value.
+         */
+        private static String escape(String value) {
+            final StringBuilder builder = new StringBuilder();
+            for (int i = 0; i < value.length(); i++) {
+                char c = value.charAt(i);
+                if (c == '"') {
+                    builder.append("\\\"");
+                } else if (c == '\\') {
+                    builder.append("\\\\");
+                } else if (c <= '\u000F') {
+                    builder.append("\\u000").append(Integer.toHexString(c));
+                } else if (c <= '\u001F') {
+                    builder.append("\\u00").append(Integer.toHexString(c));
+                } else {
+                    builder.append(c);
+                }
+            }
+            return builder.toString();
+        }
+
+        /**
+         * Appends a null field to the JSON.
+         *
+         * @param key The key of the field.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendNull(String key) {
+            appendFieldUnescaped(key, "null");
+            return this;
+        }
+
+        /**
+         * Appends a string field to the JSON.
+         *
+         * @param key   The key of the field.
+         * @param value The value of the field.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, String value) {
+            if (value == null) {
+                throw new IllegalArgumentException("JSON value must not be null");
+            }
+            appendFieldUnescaped(key, "\"" + escape(value) + "\"");
+            return this;
+        }
+
+        /**
+         * Appends an integer field to the JSON.
+         *
+         * @param key   The key of the field.
+         * @param value The value of the field.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, int value) {
+            appendFieldUnescaped(key, String.valueOf(value));
+            return this;
+        }
+
+        /**
+         * Appends an object to the JSON.
+         *
+         * @param key    The key of the field.
+         * @param object The object.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, JsonObject object) {
+            if (object == null) {
+                throw new IllegalArgumentException("JSON object must not be null");
+            }
+            appendFieldUnescaped(key, object.toString());
+            return this;
+        }
+
+        /**
+         * Appends a string array to the JSON.
+         *
+         * @param key    The key of the field.
+         * @param values The string array.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, String[] values) {
+            if (values == null) {
+                throw new IllegalArgumentException("JSON values must not be null");
+            }
+            String escapedValues =
+                    Arrays.stream(values)
+                            .map(value -> "\"" + escape(value) + "\"")
+                            .collect(Collectors.joining(","));
+            appendFieldUnescaped(key, "[" + escapedValues + "]");
+            return this;
+        }
+
+        /**
+         * Appends an integer array to the JSON.
+         *
+         * @param key    The key of the field.
+         * @param values The integer array.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, int[] values) {
+            if (values == null) {
+                throw new IllegalArgumentException("JSON values must not be null");
+            }
+            String escapedValues =
+                    Arrays.stream(values).mapToObj(String::valueOf).collect(Collectors.joining(","));
+            appendFieldUnescaped(key, "[" + escapedValues + "]");
+            return this;
+        }
+
+        /**
+         * Appends an object array to the JSON.
+         *
+         * @param key    The key of the field.
+         * @param values The integer array.
+         * @return A reference to this object.
+         */
+        public JsonObjectBuilder appendField(String key, JsonObject[] values) {
+            if (values == null) {
+                throw new IllegalArgumentException("JSON values must not be null");
+            }
+            String escapedValues =
+                    Arrays.stream(values).map(JsonObject::toString).collect(Collectors.joining(","));
+            appendFieldUnescaped(key, "[" + escapedValues + "]");
+            return this;
+        }
+
+        /**
+         * Appends a field to the object.
+         *
+         * @param key          The key of the field.
+         * @param escapedValue The escaped value of the field.
+         */
+        private void appendFieldUnescaped(String key, String escapedValue) {
+            if (builder == null) {
+                throw new IllegalStateException("JSON has already been built");
+            }
+            if (key == null) {
+                throw new IllegalArgumentException("JSON key must not be null");
+            }
+            if (hasAtLeastOneField) {
+                builder.append(",");
+            }
+            builder.append("\"").append(escape(key)).append("\":").append(escapedValue);
+            hasAtLeastOneField = true;
+        }
+
+        /**
+         * Builds the JSON string and invalidates this builder.
+         *
+         * @return The built JSON string.
+         */
+        public JsonObject build() {
+            if (builder == null) {
+                throw new IllegalStateException("JSON has already been built");
+            }
+            JsonObject object = new JsonObject(builder.append("}").toString());
+            builder = null;
+            return object;
+        }
+
+        /**
+         * A super simple representation of a JSON object.
+         *
+         * <p>This class only exists to make methods of the {@link JsonObjectBuilder} type-safe and not
+         * allow a raw string inputs for methods like {@link JsonObjectBuilder#appendField(String,
+         * JsonObject)}.
+         */
+        public static class JsonObject {
+
+            private final String value;
+
+            private JsonObject(String value) {
+                this.value = value;
+            }
+
+            @Override
+            public String toString() {
+                return value;
+            }
+        }
+    }
+}

src/main/java/io/github/retrooper/packetevents/event/PacketEvent.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event;
@@ -55,7 +49,7 @@ public abstract class PacketEvent implements CallableEvent {
         this.timestamp = timestamp;
     }
 
-    public void callPacketEventExternal(final PacketListenerDynamic listener) {
+    public void callPacketEventExternal(final PacketListenerAbstract listener) {
         listener.onPacketEventExternal(this);
     }
 

src/main/java/io/github/retrooper/packetevents/event/PacketListener.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event;
@@ -29,7 +23,7 @@ package io.github.retrooper.packetevents.event;
  * Implement this interface in your listener if you are using the legacy event system.
  *
  * @author retrooper
- * @see PacketListenerDynamic
+ * @see PacketListenerAbstract
  * @since 1.2.6
  * @deprecated There is a new and better listener for the new event system.
  */

src/main/java/io/github/retrooper/packetevents/event/PacketListenerAbstract.java

@@ -0,0 +1,207 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.event;
+
+import io.github.retrooper.packetevents.event.impl.*;
+import io.github.retrooper.packetevents.event.priority.PacketEventPriority;
+import io.github.retrooper.packetevents.utils.immutableset.ImmutableSetCustom;
+
+/**
+ * Abstract packet listener.
+ *
+ * @author retrooper
+ * @since 1.8
+ */
+public abstract class PacketListenerAbstract {
+    private final PacketListenerPriority priority;
+    public ImmutableSetCustom<Byte> serverSidedStatusAllowance;
+    public ImmutableSetCustom<Byte> serverSidedLoginAllowance;
+    public ImmutableSetCustom<Byte> serverSidedPlayAllowance;
+
+    public ImmutableSetCustom<Byte> clientSidedStatusAllowance;
+    public ImmutableSetCustom<Byte> clientSidedHandshakeAllowance;
+    public ImmutableSetCustom<Byte> clientSidedLoginAllowance;
+    public ImmutableSetCustom<Byte> clientSidedPlayAllowance;
+
+    @Deprecated
+    public PacketListenerAbstract(final PacketEventPriority priority) {
+        this(PacketListenerPriority.getById(priority.getPriorityValue()));
+    }
+
+    public PacketListenerAbstract(PacketListenerPriority priority) {
+        this.priority = priority;
+        this.serverSidedStatusAllowance = null;
+        this.serverSidedLoginAllowance = null;
+        this.serverSidedPlayAllowance = null;
+
+        this.clientSidedStatusAllowance = null;
+        this.clientSidedHandshakeAllowance = null;
+        this.clientSidedLoginAllowance = null;
+        this.clientSidedPlayAllowance = null;
+    }
+
+
+    public PacketListenerAbstract() {
+        this(PacketListenerPriority.NORMAL);
+    }
+
+    public PacketListenerPriority getPriority() {
+        return priority;
+    }
+
+    public void onPacketStatusReceive(PacketStatusReceiveEvent event) {
+    }
+
+    public void onPacketStatusSend(PacketStatusSendEvent event) {
+    }
+
+    public void onPacketHandshakeReceive(PacketHandshakeReceiveEvent event) {
+    }
+
+    public void onPacketLoginReceive(PacketLoginReceiveEvent event) {
+    }
+
+    public void onPacketLoginSend(PacketLoginSendEvent event) {
+    }
+
+    public void onPacketConfigReceive(PacketConfigReceiveEvent event) {
+    }
+
+    public void onPacketConfigSend(PacketConfigSendEvent event) {
+    }
+
+    public void onPacketPlayReceive(PacketPlayReceiveEvent event) {
+    }
+
+    public void onPacketPlaySend(PacketPlaySendEvent event) {
+    }
+
+    public void onPostPacketPlayReceive(PostPacketPlayReceiveEvent event) {
+    }
+
+    public void onPostPacketPlaySend(PostPacketPlaySendEvent event) {
+    }
+
+    public void onPostPlayerInject(PostPlayerInjectEvent event) {
+    }
+
+    public void onPlayerInject(PlayerInjectEvent event) {
+    }
+
+    public void onPlayerEject(PlayerEjectEvent event) {
+    }
+
+    public void onPacketEventExternal(PacketEvent event) {
+    }
+
+    public final void addServerSidedStatusFilter(Byte... statusPacketIDs) {
+        if (this.serverSidedStatusAllowance == null) {
+            this.serverSidedStatusAllowance = new ImmutableSetCustom<>(statusPacketIDs);
+        } else {
+            this.serverSidedStatusAllowance.addAll(statusPacketIDs);
+        }
+    }
+
+    public final void addServerSidedLoginFilter(Byte... loginPacketIDs) {
+        if (this.serverSidedLoginAllowance == null) {
+            this.serverSidedLoginAllowance = new ImmutableSetCustom<>(loginPacketIDs);
+        } else {
+            this.serverSidedLoginAllowance.addAll(loginPacketIDs);
+        }
+    }
+
+    public final void addServerSidedPlayFilter(Byte... playPacketIDs) {
+        if (this.serverSidedPlayAllowance == null) {
+            this.serverSidedPlayAllowance = new ImmutableSetCustom<>(playPacketIDs);
+        } else {
+            this.serverSidedPlayAllowance.addAll(playPacketIDs);
+        }
+    }
+
+    public final void addClientSidedStatusFilter(Byte... statusPacketIDs) {
+        if (this.clientSidedStatusAllowance == null) {
+            this.clientSidedStatusAllowance = new ImmutableSetCustom<>(statusPacketIDs);
+        } else {
+            this.clientSidedStatusAllowance.addAll(statusPacketIDs);
+        }
+    }
+
+    public final void addClientSidedHandshakeFilter(Byte... handshakePacketIDs) {
+        if (this.clientSidedHandshakeAllowance == null) {
+            this.clientSidedHandshakeAllowance = new ImmutableSetCustom<>(handshakePacketIDs);
+        } else {
+            this.clientSidedHandshakeAllowance.addAll(handshakePacketIDs);
+        }
+    }
+
+    public final void addClientSidedLoginFilter(Byte... loginPacketIDs) {
+        if (this.clientSidedLoginAllowance == null) {
+            this.clientSidedLoginAllowance = new ImmutableSetCustom<>(loginPacketIDs);
+        } else {
+            this.clientSidedLoginAllowance.addAll(loginPacketIDs);
+        }
+    }
+
+    public final void addClientSidedPlayFilter(Byte... playPacketIDs) {
+        if (this.clientSidedPlayAllowance == null) {
+            this.clientSidedPlayAllowance = new ImmutableSetCustom<>(playPacketIDs);
+        } else {
+            this.clientSidedPlayAllowance.addAll(playPacketIDs);
+        }
+    }
+
+    public final void filterAll() {
+        filterServerSidedStatus();
+        filterServerSidedLogin();
+        filterServerSidedPlay();
+
+        filterClientSidedStatus();
+        filterClientSidedHandshake();
+        filterClientSidedLogin();
+        filterClientSidedPlay();
+    }
+
+    public final void filterServerSidedStatus() {
+        this.serverSidedStatusAllowance = new ImmutableSetCustom<>();
+    }
+
+    public final void filterServerSidedLogin() {
+        this.serverSidedLoginAllowance = new ImmutableSetCustom<>();
+    }
+
+    public final void filterServerSidedPlay() {
+        this.serverSidedPlayAllowance = new ImmutableSetCustom<>();
+    }
+
+    public final void filterClientSidedStatus() {
+        this.clientSidedStatusAllowance = new ImmutableSetCustom<>();
+    }
+
+    public final void filterClientSidedHandshake() {
+        this.clientSidedHandshakeAllowance = new ImmutableSetCustom<>();
+    }
+
+    public final void filterClientSidedLogin() {
+        this.clientSidedLoginAllowance = new ImmutableSetCustom<>();
+    }
+
+    public final void filterClientSidedPlay() {
+        this.clientSidedPlayAllowance = new ImmutableSetCustom<>();
+    }
+}

src/main/java/io/github/retrooper/packetevents/event/PacketListenerDynamic.java

@@ -1,204 +1,45 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event;
 
-import io.github.retrooper.packetevents.event.impl.*;
 import io.github.retrooper.packetevents.event.priority.PacketEventPriority;
-import io.github.retrooper.packetevents.utils.immutableset.ImmutableSetCustom;
 
 /**
- * Dynamic packet event listener.
- * Implement whatever event method you need.
- * Nothing will happen if you don't implement an event method.
+ * Deprecated abstract PacketListener.
+ * Please use {@link PacketListenerAbstract}, but this class will still work for a bit.
  *
  * @author retrooper
  * @since 1.7.7
  */
-public abstract class PacketListenerDynamic {
-    private final PacketEventPriority priority;
-    public ImmutableSetCustom<Byte> serverSidedStatusAllowance;
-    public ImmutableSetCustom<Byte> serverSidedLoginAllowance;
-    public ImmutableSetCustom<Byte> serverSidedPlayAllowance;
-
-    public ImmutableSetCustom<Byte> clientSidedStatusAllowance;
-    public ImmutableSetCustom<Byte> clientSidedHandshakeAllowance;
-    public ImmutableSetCustom<Byte> clientSidedLoginAllowance;
-    public ImmutableSetCustom<Byte> clientSidedPlayAllowance;
-
+@Deprecated
+public abstract class PacketListenerDynamic extends PacketListenerAbstract {
+    @Deprecated
     public PacketListenerDynamic(final PacketEventPriority priority) {
-        this.priority = priority;
-        this.serverSidedStatusAllowance = null;
-        this.serverSidedLoginAllowance = null;
-        this.serverSidedPlayAllowance = null;
+        super(priority);
+    }
 
-        this.clientSidedStatusAllowance = null;
-        this.clientSidedHandshakeAllowance = null;
-        this.clientSidedLoginAllowance = null;
-        this.clientSidedPlayAllowance = null;
+    public PacketListenerDynamic(PacketListenerPriority priority) {
+        super(priority);
     }
 
 
     public PacketListenerDynamic() {
-        this(PacketEventPriority.NORMAL);
-    }
-
-    public final PacketEventPriority getPriority() {
-        return priority;
-    }
-
-    public final void addServerSidedStatusFilter(Byte... statusPacketIDs) {
-        if (this.serverSidedStatusAllowance == null) {
-            this.serverSidedStatusAllowance = new ImmutableSetCustom<>(statusPacketIDs);
-        } else {
-            this.serverSidedStatusAllowance.addAll(statusPacketIDs);
-        }
-    }
-
-    public final void addServerSidedLoginFilter(Byte... loginPacketIDs) {
-        if (this.serverSidedLoginAllowance == null) {
-            this.serverSidedLoginAllowance = new ImmutableSetCustom<>(loginPacketIDs);
-        } else {
-            this.serverSidedLoginAllowance.addAll(loginPacketIDs);
-        }
-    }
-
-    public final void addServerSidedPlayFilter(Byte... playPacketIDs) {
-        if (this.serverSidedPlayAllowance == null) {
-            this.serverSidedPlayAllowance = new ImmutableSetCustom<>(playPacketIDs);
-        } else {
-            this.serverSidedPlayAllowance.addAll(playPacketIDs);
-        }
-    }
-
-    public final void addClientSidedStatusFilter(Byte... statusPacketIDs) {
-        if (this.clientSidedStatusAllowance == null) {
-            this.clientSidedStatusAllowance = new ImmutableSetCustom<>(statusPacketIDs);
-        } else {
-            this.clientSidedStatusAllowance.addAll(statusPacketIDs);
-        }
-    }
-
-    public final void addClientSidedHandshakeFilter(Byte... handshakePacketIDs) {
-        if (this.clientSidedHandshakeAllowance == null) {
-            this.clientSidedHandshakeAllowance = new ImmutableSetCustom<>(handshakePacketIDs);
-        } else {
-            this.clientSidedHandshakeAllowance.addAll(handshakePacketIDs);
-        }
-    }
-
-    public final void addClientSidedLoginFilter(Byte... loginPacketIDs) {
-        if (this.clientSidedLoginAllowance == null) {
-            this.clientSidedLoginAllowance = new ImmutableSetCustom<>(loginPacketIDs);
-        } else {
-            this.clientSidedLoginAllowance.addAll(loginPacketIDs);
-        }
-    }
-
-    public final void addClientSidedPlayFilter(Byte... playPacketIDs) {
-        if (this.clientSidedPlayAllowance == null) {
-            this.clientSidedPlayAllowance = new ImmutableSetCustom<>(playPacketIDs);
-        } else {
-            this.clientSidedPlayAllowance.addAll(playPacketIDs);
-        }
-    }
-
-    public final void filterAll() {
-        filterServerSidedStatus();
-        filterServerSidedLogin();
-        filterServerSidedPlay();
-
-        filterClientSidedStatus();
-        filterClientSidedHandshake();
-        filterClientSidedLogin();
-        filterClientSidedPlay();
-    }
-
-    public final void filterServerSidedStatus() {
-        this.serverSidedStatusAllowance = new ImmutableSetCustom<>();
-    }
-
-    public final void filterServerSidedLogin() {
-        this.serverSidedLoginAllowance = new ImmutableSetCustom<>();
-    }
-
-    public final void filterServerSidedPlay() {
-        this.serverSidedPlayAllowance = new ImmutableSetCustom<>();
-    }
-
-    public final void filterClientSidedStatus() {
-        this.clientSidedStatusAllowance = new ImmutableSetCustom<>();
-    }
-
-    public final void filterClientSidedHandshake() {
-        this.clientSidedHandshakeAllowance = new ImmutableSetCustom<>();
-    }
-
-    public final void filterClientSidedLogin() {
-        this.clientSidedLoginAllowance = new ImmutableSetCustom<>();
-    }
-
-    public final void filterClientSidedPlay() {
-        this.clientSidedPlayAllowance = new ImmutableSetCustom<>();
-    }
-
-    public void onPacketStatusReceive(PacketStatusReceiveEvent event) {
-    }
-
-    public void onPacketStatusSend(PacketStatusSendEvent event) {
-    }
-
-    public void onPacketHandshakeReceive(PacketHandshakeReceiveEvent event) {
-    }
-
-    public void onPacketLoginReceive(PacketLoginReceiveEvent event) {
-    }
-
-    public void onPacketLoginSend(PacketLoginSendEvent event) {
-    }
-
-    public void onPacketPlayReceive(PacketPlayReceiveEvent event) {
-    }
-
-    public void onPacketPlaySend(PacketPlaySendEvent event) {
-    }
-
-    public void onPostPacketPlayReceive(PostPacketPlayReceiveEvent event) {
-    }
-
-    public void onPostPacketPlaySend(PostPacketPlaySendEvent event) {
-    }
-
-    public void onPostPlayerInject(PostPlayerInjectEvent event) {
-    }
-
-    public void onPlayerInject(PlayerInjectEvent event) {
-    }
-
-    public void onPlayerEject(PlayerEjectEvent event) {
-    }
-
-    public void onPacketEventExternal(PacketEvent event) {
+        super(PacketListenerPriority.NORMAL);
     }
 }

src/main/java/io/github/retrooper/packetevents/event/PacketListenerPriority.java

@@ -0,0 +1,72 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.event;
+
+/**
+ * The priority of packet listeners affect the order they will be invoked in.
+ * The lowest priority listeners are invoked first, the most high ones are invoked last.
+ * The most high priority listener has the final decider on an event being cancelled.
+ * This priority can be specified in the PacketListenerAbstract constructor.
+ * If you don't specify a priority in the constructor, it will use the {@link #NORMAL} priority.
+ *
+ * @author retrooper
+ * @since 1.8
+ */
+public enum PacketListenerPriority {
+    /**
+     * Listener is of very low importance.
+     * This listener will be ran first.
+     */
+    LOWEST,
+
+    /**
+     * Listener is of low importance.
+     */
+    LOW,
+
+    /**
+     * Default listener priority.
+     * Listener is neither important nor unimportant and may run normally.
+     */
+    NORMAL,
+
+    /**
+     * Listener is of high importance.
+     */
+    HIGH,
+
+    /**
+     * Listener is of critical importance and wants to decide the cancellation of an event.
+     */
+    HIGHEST,
+
+    /**
+     * Listener is purely trying to decide the cancellation of an event.
+     * This listener should be ran last.
+     */
+    MONITOR;
+
+    public static PacketListenerPriority getById(byte id) {
+        return values()[id];
+    }
+
+    public byte getId() {
+        return (byte) ordinal();
+    }
+}

src/main/java/io/github/retrooper/packetevents/event/annotation/PacketHandler.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.annotation;

src/main/java/io/github/retrooper/packetevents/event/eventtypes/CallableEvent.java

@@ -1,38 +1,32 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.eventtypes;
 
 import io.github.retrooper.packetevents.event.PacketEvent;
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.impl.PacketPlayReceiveEvent;
 
 /**
  * The {@link PacketEvent} implements this interface.
- * Every inbuilt event should implement the {@link #call(PacketListenerDynamic)} method.
+ * Every inbuilt event should implement the {@link #call(PacketListenerAbstract)} method.
  * If you are making a custom event, don't implement this.
- * The {@link PacketListenerDynamic#onPacketEventExternal(PacketEvent)} method is called for every event that is not in-built.
+ * The {@link PacketListenerAbstract#onPacketEventExternal(PacketEvent)} method is called for every event that is not in-built.
  * including custom events.
  *
  * @author retrooper
@@ -40,5 +34,5 @@ import io.github.retrooper.packetevents.event.impl.PacketPlayReceiveEvent;
  * @since 1.8
  */
 public interface CallableEvent {
-    void call(PacketListenerDynamic listener);
+    void call(PacketListenerAbstract listener);
 }

src/main/java/io/github/retrooper/packetevents/event/eventtypes/CancellableEvent.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.eventtypes;

src/main/java/io/github/retrooper/packetevents/event/eventtypes/CancellableNMSPacketEvent.java

@@ -1,3 +1,21 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
 package io.github.retrooper.packetevents.event.eventtypes;
 
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
@@ -11,10 +29,6 @@ public abstract class CancellableNMSPacketEvent extends NMSPacketEvent implement
         super(channel, packet);
     }
 
-    public CancellableNMSPacketEvent(InetSocketAddress address, NMSPacket packet) {
-        super(address, packet);
-    }
-
     @Override
     public boolean isCancelled() {
         return cancelled;

src/main/java/io/github/retrooper/packetevents/event/eventtypes/NMSPacketEvent.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.eventtypes;
@@ -41,17 +35,14 @@ import java.net.InetSocketAddress;
  * @since 1.8
  */
 public abstract class NMSPacketEvent extends PacketEvent implements CallableEvent {
+    private final Object channel;
     private final InetSocketAddress socketAddress;
-    protected NMSPacket packet;
-    protected boolean cancelled;
     private final byte packetID;
+    protected NMSPacket packet;
 
     public NMSPacketEvent(Object channel, NMSPacket packet) {
-        this(ChannelUtils.getSocketAddress(channel), packet);//Call the constructor below
-    }
-
-    public NMSPacketEvent(InetSocketAddress address, NMSPacket packet) {
-        this.socketAddress = address;
+        this.channel = channel;
+        this.socketAddress = ChannelUtils.getSocketAddress(channel);
         this.packet = packet;
         packetID = PacketType.packetIDMap.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
     }
@@ -66,11 +57,18 @@ public abstract class NMSPacketEvent extends PacketEvent implements CallableEven
     }
 
     /**
-     * This method returns the name of the packet.
-     * To get the name of the packet we get the class of the packet and then the name of the class.
+     * Get the associated player's netty channel.
+     * @return Netty channel
+     */
+    public Object getChannel() {
+        return channel;
+    }
+
+    /**
+     * This method returns the NMS name of the packet.
+     * To get the name of the packet we get the class of the packet and then the simple name of the class.
      * See also: {@link Class#getSimpleName()}
      * We cache the name after the first call to improve performance.
-     * Java 8 does not cache the name.
      * It is not recommended to call this method unless you NEED it.
      * If you are comparing packet types, use the {@link PacketType} byte system.
      * You would only need the packet name if packet type system doesn't contain your desired packet yet.

src/main/java/io/github/retrooper/packetevents/event/eventtypes/PlayerEvent.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.eventtypes;

src/main/java/io/github/retrooper/packetevents/event/eventtypes/PostTaskEvent.java

@@ -0,0 +1,37 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.event.eventtypes;
+
+import io.github.retrooper.packetevents.event.impl.PacketPlayReceiveEvent;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+/**
+ * Every event that allows you to schedule a task that will run after the action associated with the event.
+ *
+ * @author retrooper
+ * @since 1.8
+ */
+public interface PostTaskEvent {
+    boolean isPostTaskAvailable();
+
+    @Nullable Runnable getPostTask();
+
+    void setPostTask(@NotNull Runnable postTask);
+}

src/main/java/io/github/retrooper/packetevents/event/impl/PacketConfigReceiveEvent.java

@@ -0,0 +1,44 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.event.impl;
+
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
+import io.github.retrooper.packetevents.event.eventtypes.CancellableNMSPacketEvent;
+import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
+
+/**
+ * The {@code PacketConfigReceiveEvent} event is fired whenever the a CONFIG packet is received from a client.
+ * Use the {@link #getSocketAddress()} to identify who sends the packet.
+ *
+ * @author retrooper
+ * @see <a href="https://wiki.vg/Protocol#Configuration">https://wiki.vg/Protocol#Configuration</a>
+ * @since 1.8
+ */
+public class PacketConfigReceiveEvent extends CancellableNMSPacketEvent {
+    public PacketConfigReceiveEvent(Object channel, NMSPacket packet) {
+        super(channel, packet);
+    }
+
+    @Override
+    public void call(PacketListenerAbstract listener) {
+        if (listener.clientSidedLoginAllowance == null || listener.clientSidedLoginAllowance.contains(getPacketId())) {
+            listener.onPacketConfigReceive(this);
+        }
+    }
+}

src/main/java/io/github/retrooper/packetevents/event/impl/PacketConfigSendEvent.java

@@ -0,0 +1,62 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.event.impl;
+
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
+import io.github.retrooper.packetevents.event.eventtypes.CancellableNMSPacketEvent;
+import io.github.retrooper.packetevents.event.eventtypes.PostTaskEvent;
+import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
+import org.jetbrains.annotations.NotNull;
+
+/**
+ * The {@code PacketConfigSendEvent} event is fired whenever the a LOGIN packet is being planned to be sent to the client.
+ * Use the {@link #getSocketAddress()} to identify who sends the packet.
+ *
+ * @author retrooper
+ * @see <a href="https://wiki.vg/Protocol#Configuration">https://wiki.vg/Protocol#Configuration</a>
+ * @since 1.8
+ */
+public class PacketConfigSendEvent extends CancellableNMSPacketEvent implements PostTaskEvent {
+    private Runnable postTask;
+    public PacketConfigSendEvent(Object channel, NMSPacket packet) {
+        super(channel, packet);
+    }
+
+    @Override
+    public boolean isPostTaskAvailable() {
+        return postTask != null;
+    }
+
+    @Override
+    public Runnable getPostTask() {
+        return postTask;
+    }
+
+    @Override
+    public void setPostTask(@NotNull Runnable postTask) {
+        this.postTask = postTask;
+    }
+
+    @Override
+    public void call(PacketListenerAbstract listener) {
+        if (listener.serverSidedLoginAllowance == null || listener.serverSidedLoginAllowance.contains(getPacketId())) {
+            listener.onPacketConfigSend(this);
+        }
+    }
+}

src/main/java/io/github/retrooper/packetevents/event/impl/PacketHandshakeReceiveEvent.java

@@ -1,15 +1,32 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
 package io.github.retrooper.packetevents.event.impl;
 
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.CancellableNMSPacketEvent;
-import io.github.retrooper.packetevents.packettype.PacketType;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 
 import java.net.InetSocketAddress;
 
 /**
  * The {@code PacketHandshakeReceiveEvent} event is fired whenever the a HANDSHAKE packet is received from a client.
- * The {@code PacketHandshakeReceiveEvent} does not have to do with a bukkit player object due to the player object being null in this state.
+ * The {@code PacketHandshakeReceiveEvent} has no Bukkit player, the player object is null in this state.
  * Use the {@link #getSocketAddress()} to identify who sends the packet.
  *
  * @author retrooper
@@ -17,16 +34,12 @@ import java.net.InetSocketAddress;
  * @since 1.8
  */
 public class PacketHandshakeReceiveEvent extends CancellableNMSPacketEvent {
-    public PacketHandshakeReceiveEvent(final Object channel, final NMSPacket packet) {
+    public PacketHandshakeReceiveEvent(Object channel, NMSPacket packet) {
         super(channel, packet);
     }
 
-    public PacketHandshakeReceiveEvent(final InetSocketAddress socketAddress, final NMSPacket packet) {
-        super(socketAddress, packet);
-    }
-
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         if (listener.clientSidedLoginAllowance == null || listener.clientSidedLoginAllowance.contains(getPacketId())) {
             listener.onPacketHandshakeReceive(this);
         }

src/main/java/io/github/retrooper/packetevents/event/impl/PacketLoginReceiveEvent.java

@@ -1,40 +1,32 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.CancellableNMSPacketEvent;
-import io.github.retrooper.packetevents.packettype.PacketType;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 
 import java.net.InetSocketAddress;
 
 /**
  * The {@code PacketLoginReceiveEvent} event is fired whenever the a LOGIN packet is received from a client.
- * The {@code PacketLoginReceiveEvent} does not have to do with a bukkit player object due to
- * the player object being null in this state.
+ * The {@code PacketLoginReceiveEvent} has no Bukkit player, the player object is null in this state.
  * Use the {@link #getSocketAddress()} to identify who sends the packet.
  *
  * @author retrooper
@@ -42,16 +34,12 @@ import java.net.InetSocketAddress;
  * @since 1.8
  */
 public class PacketLoginReceiveEvent extends CancellableNMSPacketEvent {
-    public PacketLoginReceiveEvent(final Object channel, final NMSPacket packet) {
+    public PacketLoginReceiveEvent(Object channel, NMSPacket packet) {
         super(channel, packet);
     }
 
-    public PacketLoginReceiveEvent(final InetSocketAddress socketAddress, final NMSPacket packet) {
-        super(socketAddress, packet);
-    }
-
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         if (listener.clientSidedLoginAllowance == null || listener.clientSidedLoginAllowance.contains(getPacketId())) {
             listener.onPacketLoginReceive(this);
         }

src/main/java/io/github/retrooper/packetevents/event/impl/PacketLoginSendEvent.java

@@ -1,57 +1,63 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.CancellableNMSPacketEvent;
-import io.github.retrooper.packetevents.packettype.PacketType;
+import io.github.retrooper.packetevents.event.eventtypes.PostTaskEvent;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
+import org.jetbrains.annotations.NotNull;
 
 import java.net.InetSocketAddress;
 
 /**
  * The {@code PacketLoginSendEvent} event is fired whenever the a LOGIN packet is being planned to be sent to the client.
- * The {@code PacketLoginSendEvent} does not have to do with a bukkit player object due to
- * the player object being null in this state.
+ * The {@code PacketLoginSendEvent} has no Bukkit player, the player object is null in this state.
  * Use the {@link #getSocketAddress()} to identify who sends the packet.
  *
  * @author retrooper
  * @see <a href="https://wiki.vg/Protocol#Login">https://wiki.vg/Protocol#Login</a>
  * @since 1.8
  */
-public class PacketLoginSendEvent extends CancellableNMSPacketEvent {
+public class PacketLoginSendEvent extends CancellableNMSPacketEvent implements PostTaskEvent {
+    private Runnable postTask;
     public PacketLoginSendEvent(Object channel, NMSPacket packet) {
         super(channel, packet);
     }
 
-    public PacketLoginSendEvent(InetSocketAddress address, NMSPacket packet) {
-        super(address, packet);
+    @Override
+    public boolean isPostTaskAvailable() {
+        return postTask != null;
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public Runnable getPostTask() {
+        return postTask;
+    }
+
+    @Override
+    public void setPostTask(@NotNull Runnable postTask) {
+        this.postTask = postTask;
+    }
+
+    @Override
+    public void call(PacketListenerAbstract listener) {
         if (listener.serverSidedLoginAllowance == null || listener.serverSidedLoginAllowance.contains(getPacketId())) {
             listener.onPacketLoginSend(this);
         }

src/main/java/io/github/retrooper/packetevents/event/impl/PacketPlayReceiveEvent.java

@@ -1,33 +1,26 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.CancellableNMSPacketEvent;
 import io.github.retrooper.packetevents.event.eventtypes.PlayerEvent;
-import io.github.retrooper.packetevents.packettype.PacketType;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
@@ -63,7 +56,7 @@ public final class PacketPlayReceiveEvent extends CancellableNMSPacketEvent impl
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         if (listener.clientSidedPlayAllowance == null || listener.clientSidedPlayAllowance.contains(getPacketId())) {
             listener.onPacketPlayReceive(this);
         }

src/main/java/io/github/retrooper/packetevents/event/impl/PacketPlaySendEvent.java

@@ -1,42 +1,34 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.CancellableNMSPacketEvent;
 import io.github.retrooper.packetevents.event.eventtypes.PlayerEvent;
-import io.github.retrooper.packetevents.packettype.PacketType;
+import io.github.retrooper.packetevents.event.eventtypes.PostTaskEvent;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
-import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
-
-import java.util.Optional;
+import org.jetbrains.annotations.Nullable;
 
 /**
- * The {@code PacketPlaySendEvent} event is fired whenever the a PLAY packet is about to be sent.
+ * The {@code PacketPlaySendEvent} event is fired whenever the a PLAY packet is about to be sent to a client.
  * Cancelling this event will result in preventing minecraft from sending the packet.
  * The player won't receive the packet if you cancel it.
  *
@@ -44,8 +36,9 @@ import java.util.Optional;
  * @see <a href="https://wiki.vg/Protocol#Play">https://wiki.vg/Protocol#Play</a>
  * @since 1.2.6
  */
-public final class PacketPlaySendEvent extends CancellableNMSPacketEvent implements PlayerEvent {
+public final class PacketPlaySendEvent extends CancellableNMSPacketEvent implements PlayerEvent, PostTaskEvent {
     private final Player player;
+    private Runnable postTask;
 
     public PacketPlaySendEvent(final Player player, final Object channel, final NMSPacket packet) {
         super(channel, packet);
@@ -65,7 +58,22 @@ public final class PacketPlaySendEvent extends CancellableNMSPacketEvent impleme
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public boolean isPostTaskAvailable() {
+        return postTask != null;
+    }
+
+    @Override
+    public Runnable getPostTask() {
+        return postTask;
+    }
+
+    @Override
+    public void setPostTask(@NotNull Runnable postTask) {
+        this.postTask = postTask;
+    }
+
+    @Override
+    public void call(PacketListenerAbstract listener) {
         if (listener.serverSidedPlayAllowance == null || listener.serverSidedPlayAllowance.contains(getPacketId())) {
             listener.onPacketPlaySend(this);
         }

src/main/java/io/github/retrooper/packetevents/event/impl/PacketStatusReceiveEvent.java

@@ -1,40 +1,32 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.CancellableNMSPacketEvent;
-import io.github.retrooper.packetevents.packettype.PacketType;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 
 import java.net.InetSocketAddress;
 
 /**
  * The {@code PacketStatusReceiveEvent} event is fired whenever the server receives a STATUS packet from a client.
- * The {@code PacketStatusSendEvent} does not have to do with a bukkit player object due to
- * the player object being null in this state.
+ * The {@code PacketStatusSendEvent} has no Bukkit player, the player object is null in this state.
  * Use the {@link #getSocketAddress()} to identify who sends the packet.
  *
  * @author retrooper
@@ -46,12 +38,8 @@ public class PacketStatusReceiveEvent extends CancellableNMSPacketEvent {
         super(channel, packet);
     }
 
-    public PacketStatusReceiveEvent(final InetSocketAddress socketAddress, final NMSPacket packet) {
-        super(socketAddress, packet);
-    }
-
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         if (listener.clientSidedStatusAllowance == null || listener.clientSidedStatusAllowance.contains(getPacketId())) {
             listener.onPacketStatusReceive(this);
         }

src/main/java/io/github/retrooper/packetevents/event/impl/PacketStatusSendEvent.java

@@ -1,60 +1,66 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.CancellableEvent;
 import io.github.retrooper.packetevents.event.eventtypes.CancellableNMSPacketEvent;
-import io.github.retrooper.packetevents.packettype.PacketType;
+import io.github.retrooper.packetevents.event.eventtypes.PostTaskEvent;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
 
 import java.net.InetSocketAddress;
 
 /**
- * The {@code PacketStatusSendEvent} event is fired whenever the server wants to send a STATUS packet to the client.
+ * The {@code PacketStatusSendEvent} event is fired whenever the server wants to send a STATUS packet to a client.
  * This class implements {@link CancellableEvent}.
- * The {@code PacketStatusSendEvent} does not have to do with a bukkit player object due to
- * the player object being null in this state.
+ * The {@code PacketStatusSendEvent} has no Bukkit player, the player object is null in this state.
  * Use the {@link #getSocketAddress()} to identify who sends the packet.
  *
  * @author retrooper
  * @see <a href="https://wiki.vg/Protocol#Status">https://wiki.vg/Protocol#Status</a>
  * @since 1.8
  */
-public class PacketStatusSendEvent extends CancellableNMSPacketEvent {
+public class PacketStatusSendEvent extends CancellableNMSPacketEvent implements PostTaskEvent {
+    private Runnable postTask;
     public PacketStatusSendEvent(Object channel, NMSPacket packet) {
         super(channel, packet);
     }
 
-    public PacketStatusSendEvent(InetSocketAddress address, NMSPacket packet) {
-        super(address, packet);
+    @Override
+    public boolean isPostTaskAvailable() {
+        return postTask != null;
     }
 
+    @Override
+    public Runnable getPostTask() {
+        return postTask;
+    }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void setPostTask(@NotNull Runnable postTask) {
+        this.postTask = postTask;
+    }
+
+    @Override
+    public void call(PacketListenerAbstract listener) {
         if (listener.serverSidedStatusAllowance == null || listener.serverSidedStatusAllowance.contains(getPacketId())) {
             listener.onPacketStatusSend(this);
         }

src/main/java/io/github/retrooper/packetevents/event/impl/PlayerEjectEvent.java

@@ -1,31 +1,25 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
 import io.github.retrooper.packetevents.event.PacketEvent;
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.CancellableEvent;
 import io.github.retrooper.packetevents.event.eventtypes.PlayerEvent;
 import org.bukkit.entity.Player;
@@ -79,7 +73,7 @@ public final class PlayerEjectEvent extends PacketEvent implements CancellableEv
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         listener.onPlayerEject(this);
     }
 

src/main/java/io/github/retrooper/packetevents/event/impl/PlayerInjectEvent.java

@@ -1,32 +1,26 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
 import io.github.retrooper.packetevents.PacketEvents;
 import io.github.retrooper.packetevents.event.PacketEvent;
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.CancellableEvent;
 import io.github.retrooper.packetevents.event.eventtypes.PlayerEvent;
 import io.github.retrooper.packetevents.utils.netty.channel.ChannelUtils;
@@ -51,7 +45,7 @@ public final class PlayerInjectEvent extends PacketEvent implements CancellableE
 
     public PlayerInjectEvent(final Player player) {
         this.player = player;
-        this.address = ChannelUtils.getSocketAddress(PacketEvents.get().packetProcessorInternal.getChannel(player));
+        this.address = ChannelUtils.getSocketAddress(PacketEvents.get().getPlayerUtils().getChannel(player));
     }
 
     @Override
@@ -95,7 +89,7 @@ public final class PlayerInjectEvent extends PacketEvent implements CancellableE
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         listener.onPlayerInject(this);
     }
 

src/main/java/io/github/retrooper/packetevents/event/impl/PostPacketPlayReceiveEvent.java

@@ -1,43 +1,33 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.NMSPacketEvent;
 import io.github.retrooper.packetevents.event.eventtypes.PlayerEvent;
-import io.github.retrooper.packetevents.packettype.PacketType;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import org.bukkit.entity.Player;
 
 /**
- * The {@code PostPacketPlayReceiveEvent} event is fired after minecraft processes
- * a PLAY server-bound packet.
- * You cannot cancel this event since minecraft already processed/is processing this packet.
- * If the incoming packet was cancelled, resulting in it not being processed by minecraft,
- * this event won't be called.
- * This event assures you that the {@link PacketPlayReceiveEvent} event wasn't cancelled.
+ * The {@code PostPacketPlayReceiveEvent} event is fired after all PacketEvents listeners finished processing
+ * the {@code PacketPlayReceiveEvent}. This event won't be called if the PacketPlayReceiveEvent event was cancelled.
+ * You cannot cancel this event.
  *
  * @author retrooper
  * @see <a href="https://wiki.vg/Protocol#Serverbound_4">https://wiki.vg/Protocol#Serverbound_4</a>
@@ -62,7 +52,7 @@ public class PostPacketPlayReceiveEvent extends NMSPacketEvent implements Player
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         if (listener.clientSidedPlayAllowance == null || listener.clientSidedPlayAllowance.contains(getPacketId())) {
             listener.onPostPacketPlayReceive(this);
         }

src/main/java/io/github/retrooper/packetevents/event/impl/PostPacketPlaySendEvent.java

@@ -1,43 +1,33 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.NMSPacketEvent;
 import io.github.retrooper.packetevents.event.eventtypes.PlayerEvent;
-import io.github.retrooper.packetevents.packettype.PacketType;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import org.bukkit.entity.Player;
 
 /**
- * The {@code PostPacketPlaySendEvent} event is fired after minecraft processes
- * a PLAY client-bound packet.
- * You cannot cancel this event since minecraft already processed this packet.
- * If the incoming packet was cancelled, resulting in it not being processed by minecraft,
- * this event won't be called.
- * This event assures you that the {@link PacketPlaySendEvent} event wasn't cancelled.
+ * The {@code PostPacketPlaySendEvent} event is fired after all PacketEvents listeners finished processing
+ * the {@code PacketPlaySendEvent}. This event won't be called if the PacketPlaySendEvent event was cancelled.
+ * You cannot cancel this event.
  *
  * @author retrooper
  * @see <a href="https://wiki.vg/Protocol#Clientbound_4">https://wiki.vg/Protocol#Clientbound_4</a>
@@ -62,7 +52,7 @@ public class PostPacketPlaySendEvent extends NMSPacketEvent implements PlayerEve
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         if (listener.serverSidedPlayAllowance == null || listener.serverSidedPlayAllowance.contains(getPacketId())) {
             listener.onPostPacketPlaySend(this);
         }

src/main/java/io/github/retrooper/packetevents/event/impl/PostPlayerInjectEvent.java

@@ -1,32 +1,26 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.impl;
 
 import io.github.retrooper.packetevents.PacketEvents;
 import io.github.retrooper.packetevents.event.PacketEvent;
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.eventtypes.PlayerEvent;
 import io.github.retrooper.packetevents.utils.netty.channel.ChannelUtils;
 import io.github.retrooper.packetevents.utils.player.ClientVersion;
@@ -37,11 +31,8 @@ import java.net.InetSocketAddress;
 
 /**
  * The {@code PostPlayerInjectEvent} event is fired after a successful injection.
- * If you are on an older version of PacketEvents DON'T use this to register player data.
- * This event might be called asynchronously and sometimes synchronously.
  * Use the {@link #isAsync()} method to figure out if is being called sync or async.
- * Make sure you do null checks in your packet listeners as this might be called a bit later.
- * A player is injected by PacketEvents whenever they join the server.
+ * A player is injected by PacketEvents each time they join the server.
  *
  * @author retrooper
  * @see <a href="https://github.com/retrooper/packetevents/blob/dev/src/main/java/io/github/retrooper/packetevents/handler/PacketHandlerInternal.java">https://github.com/retrooper/packetevents/blob/dev/src/main/java/io/github/retrooper/packetevents/handler/PacketHandlerInternal.java</a>
@@ -75,7 +66,7 @@ public class PostPlayerInjectEvent extends PacketEvent implements PlayerEvent {
      */
     @NotNull
     public Object getChannel() {
-        return PacketEvents.get().packetProcessorInternal.getChannel(player);
+        return PacketEvents.get().getPlayerUtils().getChannel(player);
     }
 
     @NotNull
@@ -104,7 +95,7 @@ public class PostPlayerInjectEvent extends PacketEvent implements PlayerEvent {
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         listener.onPostPlayerInject(this);
     }
 

src/main/java/io/github/retrooper/packetevents/event/manager/EventManager.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.manager;
@@ -27,6 +21,7 @@ package io.github.retrooper.packetevents.event.manager;
 import io.github.retrooper.packetevents.PacketEvents;
 import io.github.retrooper.packetevents.event.PacketEvent;
 import io.github.retrooper.packetevents.event.PacketListener;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
 import io.github.retrooper.packetevents.event.PacketListenerDynamic;
 
 /**
@@ -54,7 +49,7 @@ public interface EventManager {
      */
     default EventManager callEvent(PacketEvent event) {
         //The dynamic event manager calls the legacy event manager.
-        PEEventManager.EVENT_MANAGER_DYNAMIC.callEvent(event);
+        PEEventManager.EVENT_MANAGER_MODERN.callEvent(event);
         return this;
     }
 
@@ -113,26 +108,75 @@ public interface EventManager {
     }
 
     /**
-     * Register the dynamic event listener.
+     * Register a PacketListenerDynamic listener.
      *
      * @param listener {@link PacketListenerDynamic}
      * @return Same event manager instance.
      */
+    @Deprecated
     default EventManager registerListener(PacketListenerDynamic listener) {
+        PEEventManager.EVENT_MANAGER_MODERN.registerListener(listener);
+        return this;
+    }
+
+    /**
+     * Register multiple PacketListenerDynamic listeners.
+     *
+     * @param listeners {@link PacketListenerDynamic}
+     * @return Same event manager instance.
+     */
+    @Deprecated
+    default EventManager registerListeners(PacketListenerDynamic... listeners) {
+        PEEventManager.EVENT_MANAGER_MODERN.registerListeners(listeners);
+        return this;
+    }
+
+
+    /**
+     * Register a PacketListenerAbstract listener.
+     *
+     * @param listener {@link PacketListenerAbstract}
+     * @return Same event manager instance.
+     */
+    default EventManager registerListener(PacketListenerAbstract listener) {
         if (listener != null) {
-            PEEventManager.EVENT_MANAGER_DYNAMIC.registerListener(listener);
+            PEEventManager.EVENT_MANAGER_MODERN.registerListener(listener);
         }
         return this;
     }
 
     /**
-     * Register multiple dynamic event listeners with one method.
+     * Register multiple PacketListenerAbstract listeners.
      *
-     * @param listeners {@link PacketListenerDynamic}
+     * @param listeners {@link PacketListenerAbstract}
      * @return Same event manager instance.
      */
-    default EventManager registerListeners(PacketListenerDynamic... listeners) {
-        PEEventManager.EVENT_MANAGER_DYNAMIC.registerListeners(listeners);
+    default EventManager registerListeners(PacketListenerAbstract... listeners) {
+        PEEventManager.EVENT_MANAGER_MODERN.registerListeners(listeners);
+        return this;
+    }
+
+    /**
+     * Unregister a PacketListenerAbstract listener.
+     *
+     * @param listener {@link PacketListenerAbstract}
+     * @return Same event manager instance.
+     */
+    default EventManager unregisterListener(PacketListenerAbstract listener) {
+        if (listener != null) {
+            PEEventManager.EVENT_MANAGER_MODERN.unregisterListener(listener);
+        }
+        return this;
+    }
+
+    /**
+     * Unregister multiple PacketListenerAbstract listeners.
+     *
+     * @param listeners {@link PacketListenerAbstract}
+     * @return Same event manager instance.
+     */
+    default EventManager unregisterListeners(PacketListenerAbstract... listeners) {
+        PEEventManager.EVENT_MANAGER_MODERN.unregisterListeners(listeners);
         return this;
     }
 
@@ -143,7 +187,7 @@ public interface EventManager {
      * @return Same event manager instance.
      */
     default EventManager unregisterAllListeners() {
-        PEEventManager.EVENT_MANAGER_DYNAMIC.unregisterAllListeners();
+        PEEventManager.EVENT_MANAGER_MODERN.unregisterAllListeners();
         PEEventManager.EVENT_MANAGER_LEGACY.unregisterAllListeners();
         return this;
     }

src/main/java/io/github/retrooper/packetevents/event/manager/EventManagerDynamic.java

@@ -1,115 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.event.manager;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.event.PacketEvent;
-import io.github.retrooper.packetevents.event.PacketListenerDynamic;
-import io.github.retrooper.packetevents.event.eventtypes.CancellableEvent;
-import io.github.retrooper.packetevents.event.priority.PacketEventPriority;
-
-import java.util.HashSet;
-import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.logging.Level;
-
-class EventManagerDynamic {
-    private final Map<Byte, HashSet<PacketListenerDynamic>> listenersMap = new ConcurrentHashMap<>();
-
-    /**
-     * Call the PacketEvent.
-     * This method processes the event on all the registered dynamic packet event listeners.
-     * The {@link PacketEventPriority#LOWEST} prioritized listeners will be processing first,
-     * the {@link PacketEventPriority#MONITOR} will be processing last and can
-     * be the final decider whether the event has been cancelled or not.
-     * This call event also calls the legacy event manager call event.
-     *
-     * @param event {@link PacketEvent}
-     * @see EventManagerLegacy#callEvent(PacketEvent, byte)
-     */
-    public void callEvent(final PacketEvent event) {
-        boolean cancel = false;
-        if (event instanceof CancellableEvent) {
-            cancel = ((CancellableEvent) event).isCancelled();
-        }
-        byte highestReachedPriority = PacketEventPriority.LOWEST.getPriorityValue();
-        for (byte priority = PacketEventPriority.LOWEST.getPriorityValue(); priority <= PacketEventPriority.MONITOR.getPriorityValue(); priority++) {
-            HashSet<PacketListenerDynamic> listeners = listenersMap.get(priority);
-            if (listeners != null) {
-                for (PacketListenerDynamic listener : listeners) {
-                    try {
-                        event.call(listener);
-                    } catch (Exception ex) {
-                        PacketEvents.get().getPlugin().getLogger()
-                                .log(Level.SEVERE, "PacketEvents found an exception while calling a packet listener.", ex);
-                    }
-                    if (event instanceof CancellableEvent) {
-                        CancellableEvent ce = (CancellableEvent) event;
-                        cancel = ce.isCancelled();
-                        highestReachedPriority = priority;
-                    }
-                }
-                if (event instanceof CancellableEvent) {
-                    CancellableEvent ce = (CancellableEvent) event;
-                    ce.setCancelled(cancel);
-                }
-            }
-        }
-        PEEventManager.EVENT_MANAGER_LEGACY.callEvent(event, highestReachedPriority);
-    }
-
-    /**
-     * Register the dynamic packet event listener.
-     *
-     * @param listener {@link PacketListenerDynamic}
-     */
-    public synchronized void registerListener(final PacketListenerDynamic listener) {
-        byte priority = listener.getPriority().getPriorityValue();
-        HashSet<PacketListenerDynamic> listenerSet = listenersMap.get(priority);
-        if (listenerSet == null) {
-            listenerSet = new HashSet<>();
-        }
-        listenerSet.add(listener);
-        listenersMap.put(priority, listenerSet);
-    }
-
-    /**
-     * Register multiple dynamic packet event listeners with one method.
-     *
-     * @param listeners {@link PacketListenerDynamic}
-     */
-    public synchronized void registerListeners(PacketListenerDynamic... listeners) {
-        for (PacketListenerDynamic listener : listeners) {
-            registerListener(listener);
-        }
-    }
-
-    /**
-     * Unregister all dynamic packet event listeners.
-     */
-    public synchronized void unregisterAllListeners() {
-        listenersMap.clear();
-    }
-}

src/main/java/io/github/retrooper/packetevents/event/manager/EventManagerLegacy.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.manager;
@@ -47,7 +41,7 @@ class EventManagerLegacy {
     /**
      * Call a PacketEvent with the legacy event manager.
      * This method processes the event on all legacy packet event listeners.
-     * This method is actually called by {@link EventManagerDynamic#callEvent(PacketEvent)} as the
+     * This method is actually called by {@link EventManagerModern#callEvent(PacketEvent)} as the
      * if you mix the two event systems, the dynamic listeners are always processed first and pass
      * their highest reached event priority that this legacy one has to beat/reach to be able to cancel
      * the event.

src/main/java/io/github/retrooper/packetevents/event/manager/EventManagerModern.java

@@ -0,0 +1,127 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.event.manager;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.event.PacketEvent;
+import io.github.retrooper.packetevents.event.PacketListenerAbstract;
+import io.github.retrooper.packetevents.event.eventtypes.CancellableEvent;
+import io.github.retrooper.packetevents.event.priority.PacketEventPriority;
+import io.github.retrooper.packetevents.event.PacketListenerPriority;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+import java.util.logging.Level;
+
+class EventManagerModern {
+    private final Map<Byte, HashSet<PacketListenerAbstract>> listenersMap = new ConcurrentHashMap<>();
+
+    /**
+     * Call the PacketEvent.
+     * This method processes the event on all the registered dynamic packet event listeners.
+     * The {@link PacketEventPriority#LOWEST} prioritized listeners will be processing first,
+     * the {@link PacketEventPriority#MONITOR} will be processing last and can
+     * be the final decider whether the event has been cancelled or not.
+     * This call event also calls the legacy event manager call event.
+     *
+     * @param event {@link PacketEvent}
+     * @see EventManagerLegacy#callEvent(PacketEvent, byte)
+     */
+    public void callEvent(final PacketEvent event) {
+        byte highestReachedPriority = (byte) (PacketListenerPriority.LOWEST.getId() - 1);
+        for (byte priority = PacketListenerPriority.LOWEST.getId(); priority <= PacketListenerPriority.MONITOR.getId(); priority++) {
+            HashSet<PacketListenerAbstract> listeners = listenersMap.get(priority);
+            if (listeners != null) {
+                for (PacketListenerAbstract listener : listeners) {
+                    try {
+                        event.call(listener);
+                    } catch (Exception ex) {
+                        PacketEvents.get().getPlugin().getLogger()
+                                .log(Level.SEVERE, "PacketEvents found an exception while calling a packet listener.", ex);
+                    }
+                    //TODO Remove, because its redundant. We are only keeping it for compatibility with the legacy event manager.
+                    if (event instanceof CancellableEvent) {
+                        if (priority > highestReachedPriority) {
+                            highestReachedPriority = priority;
+                        }
+                    }
+                }
+            }
+        }
+        PEEventManager.EVENT_MANAGER_LEGACY.callEvent(event, highestReachedPriority);
+    }
+
+    /**
+     * Register the dynamic packet event listener.
+     *
+     * @param listener {@link PacketListenerAbstract}
+     */
+    public synchronized void registerListener(final PacketListenerAbstract listener) {
+        byte priority = listener.getPriority().getId();
+        HashSet<PacketListenerAbstract> listenerSet = listenersMap.get(priority);
+        if (listenerSet == null) {
+            listenerSet = new HashSet<>();
+        }
+        listenerSet.add(listener);
+        listenersMap.put(priority, listenerSet);
+    }
+
+    /**
+     * Register multiple dynamic packet event listeners with one method.
+     *
+     * @param listeners {@link PacketListenerAbstract}
+     */
+    public synchronized void registerListeners(PacketListenerAbstract... listeners) {
+        for (PacketListenerAbstract listener : listeners) {
+            registerListener(listener);
+        }
+    }
+
+    /**
+     * Unregister the dynamic packet event listener.
+     *
+     * @param listener {@link PacketListenerAbstract}
+     */
+    public synchronized void unregisterListener(final PacketListenerAbstract listener) {
+        byte priority = listener.getPriority().getId();
+        HashSet<PacketListenerAbstract> listenerSet = listenersMap.get(priority);
+        if (listenerSet != null) {
+            listenerSet.remove(listener);
+        }
+    }
+
+    /**
+     * Unregister multiple dynamic packet event listeners with one method.
+     *
+     * @param listeners {@link PacketListenerAbstract}
+     */
+    public synchronized void unregisterListeners(PacketListenerAbstract... listeners) {
+        for (PacketListenerAbstract listener : listeners) {
+            unregisterListener(listener);
+        }
+    }
+
+    /**
+     * Unregister all dynamic packet event listeners.
+     */
+    public synchronized void unregisterAllListeners() {
+        listenersMap.clear();
+    }
+}

src/main/java/io/github/retrooper/packetevents/event/manager/PEEventManager.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.manager;
@@ -33,6 +27,6 @@ package io.github.retrooper.packetevents.event.manager;
 public class PEEventManager implements EventManager {
 
     public static final EventManagerLegacy EVENT_MANAGER_LEGACY = new EventManagerLegacy();
-    public static final EventManagerDynamic EVENT_MANAGER_DYNAMIC = new EventManagerDynamic();
+    public static final EventManagerModern EVENT_MANAGER_MODERN = new EventManagerModern();
 
 }

src/main/java/io/github/retrooper/packetevents/event/priority/PacketEventPriority.java

@@ -1,39 +1,34 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.event.priority;
 
 /**
  * Event priority enum for the new event system.
- * The event priority counts for the whole {@link io.github.retrooper.packetevents.event.PacketListenerDynamic}
+ * The event priority counts for the whole {@link io.github.retrooper.packetevents.event.PacketListenerAbstract}
  * and not for just one event.
- * The priority can be specified in the PacketListenerDynamic constructor.
+ * The priority can be specified in the PacketListenerAbstract constructor.
  * If you don't specify a priority in the constructor, it will use the {@link #NORMAL} priority.
  *
  * @author retrooper
  * @since 1.6.9
  */
+@Deprecated
 public enum PacketEventPriority {
     /**
      * The weakest event priority.

src/main/java/io/github/retrooper/packetevents/exceptions/PacketEventsLoadFailureException.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.exceptions;

src/main/java/io/github/retrooper/packetevents/exceptions/WrapperFieldNotFoundException.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.exceptions;

src/main/java/io/github/retrooper/packetevents/exceptions/WrapperUnsupportedUsageException.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.exceptions;

src/main/java/io/github/retrooper/packetevents/injector/ChannelInjector.java

@@ -1,8 +1,30 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
 package io.github.retrooper.packetevents.injector;
 
 import org.bukkit.entity.Player;
 
 public interface ChannelInjector {
+    default boolean isBound() {
+        return true;
+    }
+
     void inject();
 
     void eject();
@@ -13,5 +35,9 @@ public interface ChannelInjector {
 
     boolean hasInjected(Player player);
 
+    void writePacket(Object channel, Object rawNMSPacket);
+
+    void flushPackets(Object channel);
+
     void sendPacket(Object channel, Object rawNMSPacket);
 }

src/main/java/io/github/retrooper/packetevents/injector/EarlyInjector.java

@@ -0,0 +1,25 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.injector;
+
+import org.bukkit.entity.Player;
+
+public interface EarlyInjector extends ChannelInjector {
+    void updatePlayerObject(Player player, Object channel);
+}

src/main/java/io/github/retrooper/packetevents/injector/GlobalChannelInjector.java

@@ -1,25 +1,36 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
 package io.github.retrooper.packetevents.injector;
 
 import io.github.retrooper.packetevents.PacketEvents;
 import io.github.retrooper.packetevents.event.impl.PlayerEjectEvent;
 import io.github.retrooper.packetevents.event.impl.PlayerInjectEvent;
-import io.github.retrooper.packetevents.injector.earlyinjector.EarlyInjector;
-import io.github.retrooper.packetevents.injector.earlyinjector.legacy.EarlyChannelInjectorLegacy;
-import io.github.retrooper.packetevents.injector.earlyinjector.modern.EarlyChannelInjectorModern;
-import io.github.retrooper.packetevents.injector.lateinjector.legacy.LateChannelInjectorLegacy;
-import io.github.retrooper.packetevents.injector.lateinjector.modern.LateChannelInjectorModern;
+import io.github.retrooper.packetevents.injector.legacy.early.EarlyChannelInjectorLegacy;
+import io.github.retrooper.packetevents.injector.legacy.late.LateChannelInjectorLegacy;
+import io.github.retrooper.packetevents.injector.modern.early.EarlyChannelInjectorModern;
+import io.github.retrooper.packetevents.injector.modern.late.LateChannelInjectorModern;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
 import org.bukkit.entity.Player;
 
-import java.util.NoSuchElementException;
-
-public class GlobalChannelInjector implements ChannelInjector {
+public class GlobalChannelInjector {
     private ChannelInjector injector;
 
-    public GlobalChannelInjector() {
-
-    }
-
     public void load() {
         boolean legacy = NMSUtils.legacyNettyImportMode;
         if (!PacketEvents.get().getSettings().shouldUseCompatibilityInjector()) {
@@ -29,7 +40,10 @@ public class GlobalChannelInjector implements ChannelInjector {
         }
     }
 
-    @Override
+    public boolean isBound() {
+        return injector.isBound();
+    }
+
     public void inject() {
         try {
             //Try inject...
@@ -40,17 +54,16 @@ public class GlobalChannelInjector implements ChannelInjector {
                 PacketEvents.get().getSettings().compatInjector(true);
                 load();
                 injector.inject();
-                PacketEvents.get().getPlugin().getLogger().warning("PacketEvents failed to inject with the Early Injector. Reverting to the Compatibility/Late Injector... This is just a warning, but please report this!");
+                PacketEvents.get().getPlugin().getLogger().warning("[packetevents] Failed to inject with the Early Injector. Reverting to the Compatibility/Late Injector... This is just a warning, but please report this!");
+                ex.printStackTrace();
             }
         }
     }
 
-    @Override
     public void eject() {
         injector.eject();
     }
 
-    @Override
     public void injectPlayer(Player player) {
         PlayerInjectEvent injectEvent = new PlayerInjectEvent(player);
         PacketEvents.get().callEvent(injectEvent);
@@ -59,7 +72,6 @@ public class GlobalChannelInjector implements ChannelInjector {
         }
     }
 
-    @Override
     public void ejectPlayer(Player player) {
         PlayerEjectEvent ejectEvent = new PlayerEjectEvent(player);
         PacketEvents.get().callEvent(ejectEvent);
@@ -68,12 +80,18 @@ public class GlobalChannelInjector implements ChannelInjector {
         }
     }
 
-    @Override
     public boolean hasInjected(Player player) {
         return injector.hasInjected(player);
     }
 
-    @Override
+    public void writePacket(Object ch, Object rawNMSPacket) {
+        injector.writePacket(ch, rawNMSPacket);
+    }
+
+    public void flushPackets(Object ch) {
+        injector.flushPackets(ch);
+    }
+
     public void sendPacket(Object ch, Object rawNMSPacket) {
         injector.sendPacket(ch, rawNMSPacket);
     }

src/main/java/io/github/retrooper/packetevents/injector/LateInjector.java

@@ -0,0 +1,23 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.injector;
+
+public interface LateInjector extends ChannelInjector {
+
+}

src/main/java/io/github/retrooper/packetevents/injector/earlyinjector/EarlyInjector.java

@@ -1,34 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.injector.earlyinjector;
-
-import io.github.retrooper.packetevents.injector.ChannelInjector;
-import org.bukkit.entity.Player;
-
-public interface EarlyInjector extends ChannelInjector {
-    void updatePlayerObject(Player player, Object channel);
-
-    boolean isBound();
-}

src/main/java/io/github/retrooper/packetevents/injector/earlyinjector/legacy/PEChannelInitializerLegacy.java

@@ -1,60 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.injector.earlyinjector.legacy;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.injector.handler.legacy.PlayerChannelHandlerLegacy;
-import io.github.retrooper.packetevents.utils.reflection.Reflection;
-import net.minecraft.util.io.netty.channel.ChannelInitializer;
-import net.minecraft.util.io.netty.channel.socket.SocketChannel;
-
-import java.lang.reflect.Method;
-
-public class PEChannelInitializerLegacy extends ChannelInitializer<SocketChannel> {
-    private final ChannelInitializer<?> oldChannelInitializer;
-    private Method initChannelMethod;
-
-    public PEChannelInitializerLegacy(ChannelInitializer<?> oldChannelInitializer) {
-        this.oldChannelInitializer = oldChannelInitializer;
-        load();
-    }
-
-    private void load() {
-        initChannelMethod = Reflection.getMethod(oldChannelInitializer.getClass(), "initChannel", 0);
-    }
-
-    public ChannelInitializer<?> getOldChannelInitializer() {
-        return oldChannelInitializer;
-    }
-
-    @Override
-    protected void initChannel(SocketChannel socketChannel) throws Exception {
-        initChannelMethod.invoke(oldChannelInitializer, socketChannel);
-        PlayerChannelHandlerLegacy channelHandler = new PlayerChannelHandlerLegacy();
-        if (socketChannel.pipeline().get("packet_handler") != null) {
-            socketChannel.pipeline().addBefore("packet_handler", PacketEvents.handlerName, channelHandler);
-        }
-    }
-}

src/main/java/io/github/retrooper/packetevents/injector/earlyinjector/modern/PEChannelInitializerModern.java

@@ -1,60 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.injector.earlyinjector.modern;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.injector.handler.modern.PlayerChannelHandlerModern;
-import io.github.retrooper.packetevents.utils.reflection.Reflection;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.socket.SocketChannel;
-
-import java.lang.reflect.Method;
-
-public class PEChannelInitializerModern extends ChannelInitializer<SocketChannel> {
-    private final ChannelInitializer<?> oldChannelInitializer;
-    private Method initChannelMethod;
-
-    public PEChannelInitializerModern(ChannelInitializer<?> oldChannelInitializer) {
-        this.oldChannelInitializer = oldChannelInitializer;
-        load();
-    }
-
-    private void load() {
-        initChannelMethod = Reflection.getMethod(oldChannelInitializer.getClass(), "initChannel", 0);
-    }
-
-    public ChannelInitializer<?> getOldChannelInitializer() {
-        return oldChannelInitializer;
-    }
-
-    @Override
-    protected void initChannel(SocketChannel socketChannel) throws Exception {
-        initChannelMethod.invoke(oldChannelInitializer, socketChannel);
-        PlayerChannelHandlerModern channelHandler = new PlayerChannelHandlerModern();
-        if (socketChannel.pipeline().get("packet_handler") != null) {
-            socketChannel.pipeline().addBefore("packet_handler", PacketEvents.handlerName, channelHandler);
-        }
-    }
-}

src/main/java/io/github/retrooper/packetevents/injector/handler/legacy/PlayerChannelHandlerLegacy.java

@@ -1,84 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.injector.handler.legacy;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import net.minecraft.util.io.netty.channel.ChannelDuplexHandler;
-import net.minecraft.util.io.netty.channel.ChannelHandlerContext;
-import net.minecraft.util.io.netty.channel.ChannelPromise;
-import org.bukkit.entity.Player;
-
-import java.util.logging.Level;
-
-public class PlayerChannelHandlerLegacy extends ChannelDuplexHandler {
-    /**
-     * Associated player.
-     * This is null until the player is injected.
-     */
-    public volatile Player player;
-
-    /**
-     * Incoming packet interception.
-     *
-     * @param ctx    Netty channel handler context.
-     * @param packet Raw NMS Packet.
-     * @throws Exception Possible exception.
-     */
-    @Override
-    public void channelRead(final ChannelHandlerContext ctx, Object packet) throws Exception {
-        try {
-            packet = PacketEvents.get().packetProcessorInternal.read(player, ctx.channel(), packet);
-            if (packet != null) {
-                super.channelRead(ctx, packet);
-                PacketEvents.get().packetProcessorInternal.postRead(player, ctx.channel(), packet);
-            }
-        }
-        catch (Throwable t) {
-            PacketEvents.get().getPlugin().getLogger().log(Level.SEVERE, "Unable to handle an incoming packet ", t.getMessage());
-        }
-    }
-
-    /**
-     * Outgoing packet interception.
-     *
-     * @param ctx     Netty channel handler context.
-     * @param packet  Raw NMS Packet
-     * @param promise Netty channel promise.
-     * @throws Exception Possible exception.
-     */
-    @Override
-    public void write(final ChannelHandlerContext ctx, Object packet, final ChannelPromise promise) throws Exception {
-        try {
-            packet = PacketEvents.get().packetProcessorInternal.write(player, ctx.channel(), packet);
-            if (packet != null) {
-                super.write(ctx, packet, promise);
-                PacketEvents.get().packetProcessorInternal.postWrite(player, ctx.channel(), packet);
-            }
-        }
-        catch (Throwable t) {
-            PacketEvents.get().getPlugin().getLogger().log(Level.SEVERE, "Unable to handle an outgoing packet ", t.getMessage());
-        }
-    }
-}

src/main/java/io/github/retrooper/packetevents/injector/handler/modern/PlayerChannelHandlerModern.java

@@ -1,84 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.injector.handler.modern;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.netty.channel.ChannelDuplexHandler;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelPromise;
-import org.bukkit.entity.Player;
-
-import java.util.logging.Level;
-
-public class PlayerChannelHandlerModern extends ChannelDuplexHandler {
-    /**
-     * Associated player.
-     * This is null until we inject the player.
-     */
-    public volatile Player player;
-
-    /**
-     * Incoming packet interception.
-     *
-     * @param ctx    Netty channel handler context.
-     * @param packet Raw NMS Packet.
-     * @throws Exception Possible exception.
-     */
-    @Override
-    public void channelRead(final ChannelHandlerContext ctx, Object packet) throws Exception {
-        try {
-            packet = PacketEvents.get().packetProcessorInternal.read(player, ctx.channel(), packet);
-            if (packet != null) {
-                super.channelRead(ctx, packet);
-                PacketEvents.get().packetProcessorInternal.postRead(player, ctx.channel(), packet);
-            }
-        }
-        catch (Throwable t) {
-            PacketEvents.get().getPlugin().getLogger().log(Level.SEVERE, "Unable to handle an incoming packet ", t.getMessage());
-        }
-    }
-
-    /**
-     * Outgoing packet interception.
-     *
-     * @param ctx     Netty channel handler context.
-     * @param packet  Raw NMS Packet
-     * @param promise Netty channel promise.
-     * @throws Exception Possible exception.
-     */
-    @Override
-    public void write(final ChannelHandlerContext ctx, Object packet, final ChannelPromise promise) throws Exception {
-        try {
-            packet = PacketEvents.get().packetProcessorInternal.write(player, ctx.channel(), packet);
-            if (packet != null) {
-                super.write(ctx, packet, promise);
-                PacketEvents.get().packetProcessorInternal.postWrite(player, ctx.channel(), packet);
-            }
-        }
-        catch (Throwable t) {
-            PacketEvents.get().getPlugin().getLogger().log(Level.SEVERE, "Unable to handle an outgoing packet ", t.getMessage());
-        }
-    }
-}

src/main/java/io/github/retrooper/packetevents/injector/lateinjector/LateInjector.java

@@ -1,7 +0,0 @@
-package io.github.retrooper.packetevents.injector.lateinjector;
-
-import io.github.retrooper.packetevents.injector.ChannelInjector;
-
-public interface LateInjector extends ChannelInjector {
-
-}

src/main/java/io/github/retrooper/packetevents/injector/lateinjector/legacy/LateChannelInjectorLegacy.java

@@ -1,76 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.injector.lateinjector.legacy;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.injector.handler.legacy.PlayerChannelHandlerLegacy;
-import io.github.retrooper.packetevents.injector.lateinjector.LateInjector;
-import net.minecraft.util.io.netty.channel.Channel;
-import org.bukkit.entity.Player;
-
-public class LateChannelInjectorLegacy implements LateInjector {
-    @Override
-    public void inject() {
-
-    }
-
-    @Override
-    public void eject() {
-
-    }
-
-    @Override
-    public void injectPlayer(Player player) {
-        PlayerChannelHandlerLegacy playerChannelHandlerLegacy = new PlayerChannelHandlerLegacy();
-        Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
-        channel.pipeline().addBefore("packet_handler", PacketEvents.handlerName, playerChannelHandlerLegacy);
-    }
-
-    @Override
-    public void ejectPlayer(Player player) {
-        Object channel = PacketEvents.get().packetProcessorInternal.getChannel(player);
-        if (channel != null) {
-            Channel chnl = (Channel) channel;
-            try {
-                chnl.pipeline().remove(PacketEvents.handlerName);
-            }
-            catch (Exception ex) {
-
-            }
-        }
-    }
-
-    @Override
-    public boolean hasInjected(Player player) {
-        Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
-        return channel.pipeline().get(PacketEvents.handlerName) != null;
-    }
-
-    @Override
-    public void sendPacket(Object rawChannel, Object packet) {
-        Channel channel = (Channel) rawChannel;
-        channel.pipeline().writeAndFlush(packet);
-    }
-}

src/main/java/io/github/retrooper/packetevents/injector/lateinjector/modern/LateChannelInjectorModern.java

@@ -1,81 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.injector.lateinjector.modern;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.injector.handler.modern.PlayerChannelHandlerModern;
-import io.github.retrooper.packetevents.injector.lateinjector.LateInjector;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelDuplexHandler;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelPromise;
-import org.bukkit.entity.Player;
-
-import java.util.NoSuchElementException;
-
-public class LateChannelInjectorModern implements LateInjector {
-    @Override
-    public void inject() {
-
-    }
-
-    @Override
-    public void eject() {
-
-    }
-
-    @Override
-    public void injectPlayer(Player player) {
-        PlayerChannelHandlerModern playerChannelHandlerModern = new PlayerChannelHandlerModern();
-        Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
-        channel.pipeline().addBefore("packet_handler", PacketEvents.handlerName, playerChannelHandlerModern);
-    }
-
-    @Override
-    public void ejectPlayer(Player player) {
-        Object channel = PacketEvents.get().packetProcessorInternal.getChannel(player);
-        if (channel != null) {
-            Channel chnl = (Channel) channel;
-            try {
-                chnl.pipeline().remove(PacketEvents.handlerName);
-            }
-            catch (Exception ex) {
-
-            }
-        }
-    }
-
-    @Override
-    public boolean hasInjected(Player player) {
-        Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
-        return channel.pipeline().get(PacketEvents.handlerName) != null;
-    }
-
-    @Override
-    public void sendPacket(Object rawChannel, Object packet) {
-        Channel channel = (Channel) rawChannel;
-        channel.pipeline().writeAndFlush(packet);
-    }
-}

src/main/java/io/github/retrooper/packetevents/injector/legacy/PlayerChannelHandlerLegacy.java

@@ -0,0 +1,64 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2021 ViaVersion and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.injector.legacy;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.processor.PacketProcessorInternal;
+import net.minecraft.util.io.netty.buffer.ByteBuf;
+import net.minecraft.util.io.netty.channel.ChannelDuplexHandler;
+import net.minecraft.util.io.netty.channel.ChannelHandler;
+import net.minecraft.util.io.netty.channel.ChannelHandlerContext;
+import net.minecraft.util.io.netty.channel.ChannelPromise;
+import org.bukkit.entity.Player;
+@ChannelHandler.Sharable
+public class PlayerChannelHandlerLegacy extends ChannelDuplexHandler {
+    /**
+     * Associated player.
+     * This is null until we inject the player.
+     */
+    public volatile Player player;
+
+    @Override
+    public void channelRead(final ChannelHandlerContext ctx, Object packet) throws Exception {
+        PacketProcessorInternal.PacketData data = PacketEvents.get().getInternalPacketProcessor().read(player, ctx.channel(), packet);
+        if (data.packet != null) {
+            super.channelRead(ctx, data.packet);
+            PacketEvents.get().getInternalPacketProcessor().postRead(player, ctx.channel(), data.packet);
+        }
+    }
+
+    @Override
+    public void write(final ChannelHandlerContext ctx, Object packet, final ChannelPromise promise) throws Exception {
+         if (packet instanceof ByteBuf) {
+            //Ignore bytebufs!
+            super.write(ctx, packet, promise);
+            return;
+        }
+        PacketProcessorInternal.PacketData data = PacketEvents.get().getInternalPacketProcessor().write(player, ctx.channel(), packet);
+        if (data.postAction != null) {
+            promise.addListener(f -> {
+                data.postAction.run();
+            });
+        }
+        if (data.packet != null) {
+            super.write(ctx, data.packet, promise);
+            PacketEvents.get().getInternalPacketProcessor().postWrite(player, ctx.channel(), data.packet);
+        }
+    }
+}

src/main/java/io/github/retrooper/packetevents/injector/legacy/early/EarlyChannelInjectorLegacy.java

@@ -1,42 +1,35 @@
 /*
- * MIT License
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2021 ViaVersion and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-package io.github.retrooper.packetevents.injector.earlyinjector.legacy;
+package io.github.retrooper.packetevents.injector.legacy.early;
 
 import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.injector.earlyinjector.EarlyInjector;
-import io.github.retrooper.packetevents.injector.handler.legacy.PlayerChannelHandlerLegacy;
+import io.github.retrooper.packetevents.injector.EarlyInjector;
+import io.github.retrooper.packetevents.injector.legacy.PlayerChannelHandlerLegacy;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
 import io.github.retrooper.packetevents.utils.list.ListWrapper;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
-import io.github.retrooper.packetevents.utils.reflection.Reflection;
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
 import net.minecraft.util.io.netty.channel.Channel;
 import net.minecraft.util.io.netty.channel.ChannelFuture;
 import net.minecraft.util.io.netty.channel.ChannelHandler;
 import net.minecraft.util.io.netty.channel.ChannelInitializer;
-import net.minecraft.util.io.netty.channel.socket.SocketChannel;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.PluginDescriptionFile;
 
@@ -46,18 +39,38 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-/**
- * Early channel injector for 1.7.10 server versions.
- * Thank you ViaVersion.
- * https://github.com/ViaVersion/ViaVersion/tree/master/bukkit/src/main/java/us/myles/ViaVersion/bukkit/platform/BukkitViaInjector.java
- *
- * @author retrooper, Thomazz, ViaVersion
- * @since 1.8
- */
 public class EarlyChannelInjectorLegacy implements EarlyInjector {
     private final List<ChannelFuture> injectedFutures = new ArrayList<>();
     private final List<Map<Field, Object>> injectedLists = new ArrayList<>();
 
+    @Override
+    public boolean isBound() {
+        try {
+            Object connection = NMSUtils.getMinecraftServerConnection();
+            if (connection == null) {
+                return false;
+            }
+            for (Field field : connection.getClass().getDeclaredFields()) {
+                field.setAccessible(true);
+                final Object value = field.get(connection);
+                if (value instanceof List) {
+                    // Inject the list
+                    synchronized (value) {
+                        for (Object o : (List<?>) value) {
+                            if (o instanceof ChannelFuture) {
+                                return true;
+                            } else {
+                                break; // not the right list.
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Exception ignored) {
+        }
+        return false;
+    }
+
     @Override
     public void inject() {
         try {
@@ -72,7 +85,7 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
                 }
                 if (value instanceof List) {
                     //Get the list.
-                    List listWrapper = new ListWrapper((List) value) {
+                    List<?> listWrapper = new ListWrapper((List<?>) value) {
                         @Override
                         public void processAdd(Object o) {
                             if (o instanceof ChannelFuture) {
@@ -91,7 +104,7 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
                     field.set(serverConnection, listWrapper);
 
                     synchronized (listWrapper) {
-                        for (Object serverChannel : (List) value) {
+                        for (Object serverChannel : (List<?>) value) {
                             //Is this the server channel future list?
                             if (serverChannel instanceof ChannelFuture) {
                                 //Yes it is...
@@ -113,14 +126,18 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
         List<Object> networkManagers = NMSUtils.getNetworkManagers();
         synchronized (networkManagers) {
             for (Object networkManager : networkManagers) {
-                WrappedPacket networkManagerWrapper = new WrappedPacket(new NMSPacket(networkManager));
+                WrappedPacket networkManagerWrapper = new WrappedPacket(new NMSPacket(networkManager), NMSUtils.networkManagerClass);
                 Channel channel = (Channel) networkManagerWrapper.readObject(0, NMSUtils.nettyChannelClass);
-                if (channel == null) {
+                if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                        || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
                     continue;
                 }
+                if (channel.pipeline().get(PacketEvents.get().getHandlerName()) != null) {
+                    channel.pipeline().remove(PacketEvents.get().getHandlerName());
+                }
 
                 if (channel.pipeline().get("packet_handler") != null) {
-                    channel.pipeline().addBefore("packet_handler", PacketEvents.handlerName, new PlayerChannelHandlerLegacy());
+                    channel.pipeline().addBefore("packet_handler", PacketEvents.get().getHandlerName(), new PlayerChannelHandlerLegacy());
                 }
             }
         }
@@ -138,7 +155,7 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
                 bootstrapAcceptorField.setAccessible(true);
                 bootstrapAcceptorField.get(handler);
                 bootstrapAcceptor = handler;
-            } catch (Exception ex) {
+            } catch (Exception ignored) {
 
             }
         }
@@ -154,7 +171,8 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
             ChannelInitializer<?> channelInitializer = new PEChannelInitializerLegacy(oldChannelInitializer);
 
             //Replace the old channel initializer with our own.
-            Reflection.updateFinalField(bootstrapAcceptorField, bootstrapAcceptor, channelInitializer);
+            bootstrapAcceptorField.setAccessible(true);
+            bootstrapAcceptorField.set(bootstrapAcceptor, channelInitializer);
 
             injectedFutures.add(channelFuture);
         } catch (IllegalAccessException e) {
@@ -189,7 +207,7 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
                         childHandlerField.setAccessible(true);
                     }
 
-                    ChannelInitializer<SocketChannel> oldInit = (ChannelInitializer<SocketChannel>) childHandlerField.get(handler);
+                    ChannelInitializer<Channel> oldInit = (ChannelInitializer<Channel>) childHandlerField.get(handler);
                     if (oldInit instanceof PEChannelInitializerLegacy) {
                         bootstrapAcceptor = handler;
                     }
@@ -203,13 +221,13 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
             }
 
             try {
-                ChannelInitializer<SocketChannel> oldInit = (ChannelInitializer<SocketChannel>) childHandlerField.get(bootstrapAcceptor);
+                ChannelInitializer<Channel> oldInit = (ChannelInitializer<Channel>) childHandlerField.get(bootstrapAcceptor);
                 if (oldInit instanceof PEChannelInitializerLegacy) {
-                    Reflection.updateFinalField(childHandlerField, bootstrapAcceptor, oldInit);
-                    Reflection.updateFinalField(childHandlerField,bootstrapAcceptor, ((PEChannelInitializerLegacy) oldInit).getOldChannelInitializer());
+                    childHandlerField.setAccessible(true);
+                    childHandlerField.set(bootstrapAcceptor, ((PEChannelInitializerLegacy) oldInit).getOldChannelInitializer());
                 }
             } catch (Exception e) {
-                PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to eject the injection handler! Please reboot!");
+                //PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to eject the injection handler! Please reboot!");
             }
         }
         injectedFutures.clear();
@@ -225,7 +243,7 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
                 }
 
             } catch (IllegalAccessException e) {
-                PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to eject the injection handler! Please reboot!!");
+                //PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to eject the injection handler! Please reboot!!");
             }
         }
 
@@ -234,7 +252,7 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
 
     @Override
     public void injectPlayer(Player player) {
-        Object channel = PacketEvents.get().packetProcessorInternal.getChannel(player);
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
         if (channel != null) {
             updatePlayerObject(player, channel);
         }
@@ -242,13 +260,11 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
 
     @Override
     public void ejectPlayer(Player player) {
-        Object channel = PacketEvents.get().packetProcessorInternal.getChannel(player);
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
         if (channel != null) {
-            Channel chnl = (Channel) channel;
             try {
-                chnl.pipeline().remove(PacketEvents.handlerName);
-            }
-            catch (Exception ex) {
+                ((Channel) channel).pipeline().remove(PacketEvents.get().getHandlerName());
+            } catch (Exception ignored) {
 
             }
         }
@@ -256,7 +272,7 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
 
     @Override
     public boolean hasInjected(Player player) {
-        Object channel = PacketEvents.get().packetProcessorInternal.getChannel(player);
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
         if (channel == null) {
             return false;
         }
@@ -264,15 +280,42 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
         return handler != null && handler.player != null;
     }
 
+    @Override
+    public void writePacket(Object ch, Object rawNMSPacket) {
+        Channel channel = (Channel) ch;
+        //Don't write packets to fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        channel.write(rawNMSPacket);
+    }
+
+    @Override
+    public void flushPackets(Object ch) {
+        Channel channel = (Channel) ch;
+        //Don't flush packets for fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        channel.flush();
+    }
+
     @Override
     public void sendPacket(Object ch, Object rawNMSPacket) {
         Channel channel = (Channel) ch;
+        //Don't send packets to fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
         channel.writeAndFlush(rawNMSPacket);
     }
 
     private PlayerChannelHandlerLegacy getHandler(Object rawChannel) {
         Channel channel = (Channel) rawChannel;
-        ChannelHandler handler = channel.pipeline().get(PacketEvents.handlerName);
+        ChannelHandler handler = channel.pipeline().get(PacketEvents.get().getHandlerName());
         if (handler instanceof PlayerChannelHandlerLegacy) {
             return (PlayerChannelHandlerLegacy) handler;
         } else {
@@ -287,32 +330,4 @@ public class EarlyChannelInjectorLegacy implements EarlyInjector {
             handler.player = player;
         }
     }
-
-    @Override
-    public boolean isBound() {
-        try {
-            Object connection = NMSUtils.getMinecraftServerConnection();
-            if (connection == null) {
-                return false;
-            }
-            for (Field field : connection.getClass().getDeclaredFields()) {
-                field.setAccessible(true);
-                final Object value = field.get(connection);
-                if (value instanceof List) {
-                    // Inject the list
-                    synchronized (value) {
-                        for (Object o : (List) value) {
-                            if (o instanceof ChannelFuture) {
-                                return true;
-                            } else {
-                                break; // not the right list.
-                            }
-                        }
-                    }
-                }
-            }
-        } catch (Exception e) {
-        }
-        return false;
-    }
 }

src/main/java/io/github/retrooper/packetevents/injector/legacy/early/PEChannelInitializerLegacy.java

@@ -0,0 +1,64 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2021 ViaVersion and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.injector.legacy.early;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.injector.legacy.PlayerChannelHandlerLegacy;
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
+import io.github.retrooper.packetevents.utils.reflection.Reflection;
+import net.minecraft.util.io.netty.channel.Channel;
+import net.minecraft.util.io.netty.channel.ChannelInitializer;
+
+import java.lang.reflect.Method;
+
+public class PEChannelInitializerLegacy extends ChannelInitializer<Channel> {
+    private final ChannelInitializer<?> oldChannelInitializer;
+    private Method initChannelMethod;
+
+    public PEChannelInitializerLegacy(ChannelInitializer<?> oldChannelInitializer) {
+        this.oldChannelInitializer = oldChannelInitializer;
+        load();
+    }
+
+    private void load() {
+        initChannelMethod = Reflection.getMethod(oldChannelInitializer.getClass(), "initChannel", 0);
+    }
+
+    public ChannelInitializer<?> getOldChannelInitializer() {
+        return oldChannelInitializer;
+    }
+
+    @Override
+    protected void initChannel(Channel channel) throws Exception {
+        initChannelMethod.invoke(oldChannelInitializer, channel);
+        PlayerChannelHandlerLegacy channelHandler = new PlayerChannelHandlerLegacy();
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        if (channel.pipeline().get("packet_handler") != null) {
+            String handlerName = PacketEvents.get().getHandlerName();
+            if (channel.pipeline().get(handlerName) != null) {
+                PacketEvents.get().getPlugin().getLogger().warning("[PacketEvents] Attempted to initialize a channel twice!");
+            } else {
+                channel.pipeline().addBefore("packet_handler", handlerName, channelHandler);
+            }
+        }
+    }
+}

src/main/java/io/github/retrooper/packetevents/injector/legacy/late/LateChannelInjectorLegacy.java

@@ -0,0 +1,101 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.injector.legacy.late;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.injector.LateInjector;
+import io.github.retrooper.packetevents.injector.legacy.PlayerChannelHandlerLegacy;
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
+import net.minecraft.util.io.netty.channel.Channel;
+import org.bukkit.entity.Player;
+
+public class LateChannelInjectorLegacy implements LateInjector {
+    @Override
+    public void inject() {
+
+    }
+
+    @Override
+    public void eject() {
+
+    }
+
+    @Override
+    public void injectPlayer(Player player) {
+        PlayerChannelHandlerLegacy playerChannelHandlerLegacy = new PlayerChannelHandlerLegacy();
+        playerChannelHandlerLegacy.player = player;
+        Channel channel = (Channel) PacketEvents.get().getPlayerUtils().getChannel(player);
+       if (channel != null) {
+           channel.eventLoop().execute(() -> {
+               channel.pipeline().addBefore("packet_handler", PacketEvents.get().getHandlerName(), playerChannelHandlerLegacy);
+           });
+       }
+    }
+
+    @Override
+    public void ejectPlayer(Player player) {
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
+        if (channel != null) {
+            try {
+                ((Channel) channel).pipeline().remove(PacketEvents.get().getHandlerName());
+            } catch (Exception ignored) {
+
+            }
+        }
+    }
+
+    @Override
+    public boolean hasInjected(Player player) {
+        Channel channel = (Channel) PacketEvents.get().getPlayerUtils().getChannel(player);
+        return channel != null && channel.pipeline().get(PacketEvents.get().getHandlerName()) != null;
+    }
+
+    @Override
+    public void writePacket(Object ch, Object rawNMSPacket) {
+        Channel channel = (Channel) ch;
+        //Don't write packets to fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        channel.write(rawNMSPacket);
+    }
+
+    @Override
+    public void flushPackets(Object ch) {
+        Channel channel = (Channel) ch;
+        //Don't flush packets for fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        channel.flush();
+    }
+
+    @Override
+    public void sendPacket(Object rawChannel, Object packet) {
+        Channel channel = (Channel) rawChannel;
+        //Don't send packets to fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        channel.pipeline().writeAndFlush(packet);
+    }
+}

src/main/java/io/github/retrooper/packetevents/injector/modern/PlayerChannelHandlerModern.java

@@ -0,0 +1,65 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2021 ViaVersion and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.injector.modern;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.processor.PacketProcessorInternal;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelDuplexHandler;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import org.bukkit.entity.Player;
+
+@ChannelHandler.Sharable
+public class PlayerChannelHandlerModern extends ChannelDuplexHandler {
+    /**
+     * Associated player.
+     * This is null until we inject the player.
+     */
+    public volatile Player player;
+
+    @Override
+    public void channelRead(final ChannelHandlerContext ctx, Object packet) throws Exception {
+        PacketProcessorInternal.PacketData data = PacketEvents.get().getInternalPacketProcessor().read(player, ctx.channel(), packet);
+        if (data.packet != null) {
+            super.channelRead(ctx, data.packet);
+            PacketEvents.get().getInternalPacketProcessor().postRead(player, ctx.channel(), data.packet);
+        }
+    }
+
+    @Override
+    public void write(final ChannelHandlerContext ctx, Object packet, final ChannelPromise promise) throws Exception {
+        if (packet instanceof ByteBuf) {
+            //Ignore bytebufs!
+            super.write(ctx, packet, promise);
+            return;
+        }
+        PacketProcessorInternal.PacketData data = PacketEvents.get().getInternalPacketProcessor().write(player, ctx.channel(), packet);
+        if (data.postAction != null) {
+            promise.addListener(f -> {
+                data.postAction.run();
+            });
+        }
+        if (data.packet != null) {
+            super.write(ctx, data.packet, promise);
+            PacketEvents.get().getInternalPacketProcessor().postWrite(player, ctx.channel(), data.packet);
+        }
+    }
+}

src/main/java/io/github/retrooper/packetevents/injector/modern/early/EarlyChannelInjectorModern.java

@@ -1,42 +1,35 @@
 /*
- * MIT License
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2021 ViaVersion and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-package io.github.retrooper.packetevents.injector.earlyinjector.modern;
+package io.github.retrooper.packetevents.injector.modern.early;
 
 import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.injector.earlyinjector.EarlyInjector;
-import io.github.retrooper.packetevents.injector.handler.modern.PlayerChannelHandlerModern;
+import io.github.retrooper.packetevents.injector.EarlyInjector;
+import io.github.retrooper.packetevents.injector.modern.PlayerChannelHandlerModern;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
 import io.github.retrooper.packetevents.utils.list.ListWrapper;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
-import io.github.retrooper.packetevents.utils.reflection.Reflection;
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelInitializer;
-import io.netty.channel.socket.SocketChannel;
 import org.bukkit.entity.Player;
 import org.bukkit.plugin.PluginDescriptionFile;
 
@@ -46,21 +39,45 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-/**
- * Early channel injector for all server versions higher than 1.7.10.
- * Thank you ViaVersion.
- * https://github.com/ViaVersion/ViaVersion/tree/master/bukkit/src/main/java/us/myles/ViaVersion/bukkit/platform/BukkitViaInjector.java
- *
- * @author retrooper, Thomazz, ViaVersion
- * @since 1.8
- */
 public class EarlyChannelInjectorModern implements EarlyInjector {
     private final List<ChannelFuture> injectedFutures = new ArrayList<>();
     private final List<Map<Field, Object>> injectedLists = new ArrayList<>();
 
+    @Override
+    public boolean isBound() {
+        try {
+            Object connection = NMSUtils.getMinecraftServerConnection();
+            if (connection == null) {
+                return false;
+            }
+            for (Field field : connection.getClass().getDeclaredFields()) {
+                field.setAccessible(true);
+                final Object value = field.get(connection);
+                if (value instanceof List) {
+                    // Inject the list
+                    synchronized (value) {
+                        for (Object o : (List) value) {
+                            if (o instanceof ChannelFuture) {
+                                return true;
+                            } else {
+                                break; // not the right list.
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Exception e) {
+        }
+        return false;
+    }
+
     @Override
     public void inject() {
         try {
+           /* if (PaperChannelInjector.PAPER_INJECTION_METHOD) {
+                PaperChannelInjector.setPaperChannelInitializeListener();
+                return;
+            }*/
             Object serverConnection = NMSUtils.getMinecraftServerConnection();
             for (Field field : serverConnection.getClass().getDeclaredFields()) {
                 field.setAccessible(true);
@@ -112,14 +129,19 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
         List<Object> networkManagers = NMSUtils.getNetworkManagers();
         synchronized (networkManagers) {
             for (Object networkManager : networkManagers) {
-                WrappedPacket networkManagerWrapper = new WrappedPacket(new NMSPacket(networkManager));
+                WrappedPacket networkManagerWrapper = new WrappedPacket(new NMSPacket(networkManager), NMSUtils.networkManagerClass);
                 Channel channel = (Channel) networkManagerWrapper.readObject(0, NMSUtils.nettyChannelClass);
-                if (channel == null) {
+                if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                        || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
                     continue;
                 }
 
+                if (channel.pipeline().get(PacketEvents.get().getHandlerName()) != null) {
+                    channel.pipeline().remove(PacketEvents.get().getHandlerName());
+                }
+
                 if (channel.pipeline().get("packet_handler") != null) {
-                    channel.pipeline().addBefore("packet_handler", PacketEvents.handlerName, new PlayerChannelHandlerModern());
+                    channel.pipeline().addBefore("packet_handler", PacketEvents.get().getHandlerName(), new PlayerChannelHandlerModern());
                 }
             }
         }
@@ -137,7 +159,8 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
                 bootstrapAcceptorField.setAccessible(true);
                 bootstrapAcceptorField.get(handler);
                 bootstrapAcceptor = handler;
-            } catch (Exception ignored) {}
+            } catch (Exception ignored) {
+            }
         }
 
         if (bootstrapAcceptor == null) {
@@ -151,7 +174,8 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
             ChannelInitializer<?> channelInitializer = new PEChannelInitializerModern(oldChannelInitializer);
 
             //Replace the old channel initializer with our own.
-            Reflection.updateFinalField(bootstrapAcceptorField, bootstrapAcceptor,  channelInitializer);
+            bootstrapAcceptorField.setAccessible(true);
+            bootstrapAcceptorField.set(bootstrapAcceptor, channelInitializer);
             injectedFutures.add(channelFuture);
         } catch (IllegalAccessException e) {
             ClassLoader cl = bootstrapAcceptor.getClass().getClassLoader();
@@ -172,6 +196,14 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
 
     @Override
     public void eject() {
+        // TODO: Uninject from players currently online to prevent protocol lib issues.
+       /* if (PaperChannelInjector.PAPER_INJECTION_METHOD) {
+            try {
+                PaperChannelInjector.removePaperChannelInitializeListener();
+            } catch (ReflectiveOperationException e) {
+                e.printStackTrace();
+            }
+        }*/
         Field childHandlerField = null;
         for (ChannelFuture future : injectedFutures) {
             List<String> names = future.channel().pipeline().names();
@@ -185,7 +217,7 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
                         childHandlerField.setAccessible(true);
                     }
 
-                    ChannelInitializer<SocketChannel> oldInit = (ChannelInitializer<SocketChannel>) childHandlerField.get(handler);
+                    ChannelInitializer<Channel> oldInit = (ChannelInitializer<Channel>) childHandlerField.get(handler);
                     if (oldInit instanceof PEChannelInitializerModern) {
                         bootstrapAcceptor = handler;
                     }
@@ -199,13 +231,13 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
             }
 
             try {
-                ChannelInitializer<SocketChannel> oldInit = (ChannelInitializer<SocketChannel>) childHandlerField.get(bootstrapAcceptor);
+                ChannelInitializer<Channel> oldInit = (ChannelInitializer<Channel>) childHandlerField.get(bootstrapAcceptor);
                 if (oldInit instanceof PEChannelInitializerModern) {
-                    Reflection.updateFinalField(childHandlerField, bootstrapAcceptor, oldInit);
-                    Reflection.updateFinalField(childHandlerField, bootstrapAcceptor, ((PEChannelInitializerModern) oldInit).getOldChannelInitializer());
+                    childHandlerField.setAccessible(true);
+                    childHandlerField.set(bootstrapAcceptor, ((PEChannelInitializerModern) oldInit).getOldChannelInitializer());
                 }
             } catch (Exception e) {
-                PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to eject the injection handler! Please reboot!");
+                //PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to eject the injection handler! Please reboot!");
             }
         }
         injectedFutures.clear();
@@ -221,7 +253,7 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
                 }
 
             } catch (IllegalAccessException e) {
-                PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to eject the injection handler! Please reboot!!");
+                //PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to eject the injection handler! Please reboot!!");
             }
         }
 
@@ -230,7 +262,7 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
 
     @Override
     public void injectPlayer(Player player) {
-        Object channel = PacketEvents.get().packetProcessorInternal.getChannel(player);
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
         if (channel != null) {
             updatePlayerObject(player, channel);
         }
@@ -238,18 +270,18 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
 
     @Override
     public void ejectPlayer(Player player) {
-        Object channel = PacketEvents.get().packetProcessorInternal.getChannel(player);
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
         if (channel != null) {
-            Channel chnl = (Channel) channel;
             try {
-                chnl.pipeline().remove(PacketEvents.handlerName);
-            } catch (Exception ignored) {}
+                ((Channel)channel).pipeline().remove(PacketEvents.get().getHandlerName());
+            } catch (Exception ignored) {
+            }
         }
     }
 
     @Override
     public boolean hasInjected(Player player) {
-        Object channel = PacketEvents.get().packetProcessorInternal.getChannel(player);
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
         if (channel == null) {
             return false;
         }
@@ -257,15 +289,42 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
         return handler != null && handler.player != null;
     }
 
+    @Override
+    public void writePacket(Object ch, Object rawNMSPacket) {
+        Channel channel = (Channel) ch;
+        //Don't write packets to fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        channel.write(rawNMSPacket);
+    }
+
+    @Override
+    public void flushPackets(Object ch) {
+        Channel channel = (Channel) ch;
+        //Don't flush packets for fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        channel.flush();
+    }
+
     @Override
     public void sendPacket(Object ch, Object rawNMSPacket) {
         Channel channel = (Channel) ch;
+        //Don't send packets to fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
         channel.writeAndFlush(rawNMSPacket);
     }
 
     private PlayerChannelHandlerModern getHandler(Object rawChannel) {
         Channel channel = (Channel) rawChannel;
-        ChannelHandler handler = channel.pipeline().get(PacketEvents.handlerName);
+        ChannelHandler handler = channel.pipeline().get(PacketEvents.get().getHandlerName());
         if (handler instanceof PlayerChannelHandlerModern) {
             return (PlayerChannelHandlerModern) handler;
         } else {
@@ -280,31 +339,4 @@ public class EarlyChannelInjectorModern implements EarlyInjector {
             handler.player = player;
         }
     }
-
-    @Override
-    public boolean isBound() {
-        try {
-            Object connection = NMSUtils.getMinecraftServerConnection();
-            if (connection == null) {
-                return false;
-            }
-            for (Field field : connection.getClass().getDeclaredFields()) {
-                field.setAccessible(true);
-                final Object value = field.get(connection);
-                if (value instanceof List) {
-                    // Inject the list
-                    synchronized (value) {
-                        for (Object o : (List) value) {
-                            if (o instanceof ChannelFuture) {
-                                return true;
-                            } else {
-                                break; // not the right list.
-                            }
-                        }
-                    }
-                }
-            }
-        } catch (Exception ignored) {}
-        return false;
-    }
 }

src/main/java/io/github/retrooper/packetevents/injector/modern/early/PEChannelInitializerModern.java

@@ -0,0 +1,69 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2021 ViaVersion and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.injector.modern.early;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.injector.modern.PlayerChannelHandlerModern;
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
+import io.github.retrooper.packetevents.utils.reflection.Reflection;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelInitializer;
+
+import java.lang.reflect.Method;
+
+public class PEChannelInitializerModern extends ChannelInitializer<Channel> {
+    private final ChannelInitializer<?> oldChannelInitializer;
+    private Method initChannelMethod;
+
+    public PEChannelInitializerModern(ChannelInitializer<?> oldChannelInitializer) {
+        this.oldChannelInitializer = oldChannelInitializer;
+        load();
+    }
+
+    public static void postInitChannel(Channel channel) {
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        PlayerChannelHandlerModern channelHandler = new PlayerChannelHandlerModern();
+        if (channel.pipeline().get("packet_handler") != null) {
+            String handlerName = PacketEvents.get().getHandlerName();
+            if (channel.pipeline().get(handlerName) != null) {
+                //Just ignore this to support latest ProtocolLib snapshots.
+                //PacketEvents.get().getPlugin().getLogger().warning("[PacketEvents] Attempted to initialize a channel twice!");
+            } else {
+                channel.pipeline().addBefore("packet_handler", handlerName, channelHandler);
+            }
+        }
+    }
+
+    private void load() {
+        initChannelMethod = Reflection.getMethod(oldChannelInitializer.getClass(), "initChannel", 0);
+    }
+
+    public ChannelInitializer<?> getOldChannelInitializer() {
+        return oldChannelInitializer;
+    }
+
+    @Override
+    protected void initChannel(Channel channel) throws Exception {
+        initChannelMethod.invoke(oldChannelInitializer, channel);
+        postInitChannel(channel);
+    }
+}

src/main/java/io/github/retrooper/packetevents/injector/modern/late/LateChannelInjectorModern.java

@@ -0,0 +1,101 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.injector.modern.late;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.injector.LateInjector;
+import io.github.retrooper.packetevents.injector.modern.PlayerChannelHandlerModern;
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
+import io.netty.channel.Channel;
+import org.bukkit.entity.Player;
+
+public class LateChannelInjectorModern implements LateInjector {
+    @Override
+    public void inject() {
+
+    }
+
+    @Override
+    public void eject() {
+
+    }
+
+    @Override
+    public void injectPlayer(Player player) {
+        PlayerChannelHandlerModern playerChannelHandlerModern = new PlayerChannelHandlerModern();
+        playerChannelHandlerModern.player = player;
+        Channel channel = (Channel) PacketEvents.get().getPlayerUtils().getChannel(player);
+        if (channel != null) {
+            channel.eventLoop().execute(() -> {
+                channel.pipeline().addBefore("packet_handler", PacketEvents.get().getHandlerName(), playerChannelHandlerModern);
+            });
+        }
+    }
+
+    @Override
+    public void ejectPlayer(Player player) {
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
+        if (channel != null) {
+            try {
+                ((Channel) channel).pipeline().remove(PacketEvents.get().getHandlerName());
+            } catch (Exception ex) {
+
+            }
+        }
+    }
+
+    @Override
+    public boolean hasInjected(Player player) {
+        Channel channel = (Channel) PacketEvents.get().getPlayerUtils().getChannel(player);
+        return channel != null && channel.pipeline().get(PacketEvents.get().getHandlerName()) != null;
+    }
+
+    @Override
+    public void writePacket(Object ch, Object rawNMSPacket) {
+        Channel channel = (Channel) ch;
+        //Don't write packets to fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        channel.write(rawNMSPacket);
+    }
+
+    @Override
+    public void flushPackets(Object ch) {
+        Channel channel = (Channel) ch;
+        //Don't flush packets for fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        channel.flush();
+    }
+
+    @Override
+    public void sendPacket(Object rawChannel, Object packet) {
+        Channel channel = (Channel) rawChannel;
+        //Don't send packets to fake channels
+        if (channel == null || ClassUtil.getClassSimpleName(channel.getClass()).equals("FakeChannel")
+                || ClassUtil.getClassSimpleName(channel.getClass()).equals("SpoofedChannel")) {
+            return;
+        }
+        channel.pipeline().writeAndFlush(packet);
+    }
+}

src/main/java/io/github/retrooper/packetevents/packettype/PacketState.java

@@ -1,3 +1,21 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
 package io.github.retrooper.packetevents.packettype;
 
 /**
@@ -5,5 +23,5 @@ package io.github.retrooper.packetevents.packettype;
  * @since 1.8
  */
 public enum PacketState {
-    STATUS, HANDSHAKING, LOGIN, PLAY
+    STATUS, HANDSHAKING, LOGIN, CONFIG, PLAY
 }

src/main/java/io/github/retrooper/packetevents/packettype/PacketType.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packettype;
@@ -27,9 +21,8 @@ package io.github.retrooper.packetevents.packettype;
 import io.github.retrooper.packetevents.PacketEvents;
 import io.github.retrooper.packetevents.utils.server.ServerVersion;
 
-import java.util.HashMap;
+import java.util.IdentityHashMap;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
 
 /**
  * Packet Type IDs.
@@ -45,8 +38,9 @@ public class PacketType {
      * This value may change over the versions so it is important to use the variable and not hard code its value.
      */
     public static final byte INVALID = -128;
-    public static final Map<Class<?>, Byte> packetIDMap = new HashMap<>();
-    
+    public static final Map<Class<?>, Byte> packetIDMap = new IdentityHashMap<>();
+    private static final boolean isNine = ServerVersion.getVersion().isNewerThanOrEquals(ServerVersion.v_1_9);
+
     private static void insertPacketID(Class<?> cls, byte packetID) {
         if (cls != null) {
             packetIDMap.put(cls, packetID);
@@ -83,6 +77,7 @@ public class PacketType {
          */
         public static class Client {
             public static final byte START = -127, PING = -126;
+
             private static void load() {
                 insertPacketID(PacketTypeClasses.Status.Client.START, Client.START);
                 insertPacketID(PacketTypeClasses.Status.Client.PING, Client.PING);
@@ -98,6 +93,7 @@ public class PacketType {
          */
         public static class Server {
             public static final byte PONG = -125, SERVER_INFO = -124;
+
             private static void load() {
                 insertPacketID(PacketTypeClasses.Status.Server.PONG, Server.PONG);
                 insertPacketID(PacketTypeClasses.Status.Server.SERVER_INFO, Server.SERVER_INFO);
@@ -121,6 +117,7 @@ public class PacketType {
          */
         public static class Client {
             public static final byte SET_PROTOCOL = -123;
+
             private static void load() {
                 insertPacketID(PacketTypeClasses.Handshaking.Client.SET_PROTOCOL, Client.SET_PROTOCOL);
             }
@@ -144,6 +141,7 @@ public class PacketType {
          */
         public static class Client {
             public static final byte CUSTOM_PAYLOAD = -122, START = -121, ENCRYPTION_BEGIN = -120;
+
             private static void load() {
                 insertPacketID(PacketTypeClasses.Login.Client.CUSTOM_PAYLOAD, Client.CUSTOM_PAYLOAD);
                 insertPacketID(PacketTypeClasses.Login.Client.START, Client.START);
@@ -160,6 +158,7 @@ public class PacketType {
          */
         public static class Server {
             public static final byte CUSTOM_PAYLOAD = -119, DISCONNECT = -118, ENCRYPTION_BEGIN = -117, SUCCESS = -116, SET_COMPRESSION = -115;
+
             private static void load() {
                 insertPacketID(PacketTypeClasses.Login.Server.CUSTOM_PAYLOAD, Server.CUSTOM_PAYLOAD);
                 insertPacketID(PacketTypeClasses.Login.Server.DISCONNECT, Server.DISCONNECT);
@@ -198,7 +197,7 @@ public class PacketType {
                     ADVANCEMENTS = -81, TR_SEL = -80, BEACON = -79, HELD_ITEM_SLOT = -78,
                     SET_COMMAND_BLOCK = -77, SET_COMMAND_MINECART = -76, SET_CREATIVE_SLOT = -75, SET_JIGSAW = -74,
                     STRUCT = -73, UPDATE_SIGN = -72, ARM_ANIMATION = -71, SPECTATE = -70,
-                    USE_ITEM = -69, BLOCK_PLACE = -68;
+                    USE_ITEM = -69, BLOCK_PLACE = -68, PONG = 28;
 
             private static void load() {
                 insertPacketID(PacketTypeClasses.Play.Client.TELEPORT_ACCEPT, TELEPORT_ACCEPT);
@@ -222,7 +221,7 @@ public class PacketType {
                 insertPacketID(PacketTypeClasses.Play.Client.POSITION, POSITION);
                 insertPacketID(PacketTypeClasses.Play.Client.POSITION_LOOK, POSITION_LOOK);
                 insertPacketID(PacketTypeClasses.Play.Client.LOOK, LOOK);
-                insertPacketID(PacketTypeClasses.Play.Client.FLYING, FLYING);
+                insertPacketID(PacketTypeClasses.Play.Client.GROUND, FLYING);
                 insertPacketID(PacketTypeClasses.Play.Client.VEHICLE_MOVE, VEHICLE_MOVE);
                 insertPacketID(PacketTypeClasses.Play.Client.BOAT_MOVE, BOAT_MOVE);
                 insertPacketID(PacketTypeClasses.Play.Client.PICK_ITEM, PICK_ITEM);
@@ -248,6 +247,7 @@ public class PacketType {
                 insertPacketID(PacketTypeClasses.Play.Client.SPECTATE, SPECTATE);
                 insertPacketID(PacketTypeClasses.Play.Client.USE_ITEM, USE_ITEM);
                 insertPacketID(PacketTypeClasses.Play.Client.BLOCK_PLACE, BLOCK_PLACE);
+                insertPacketID(PacketTypeClasses.Play.Client.PONG, PONG);
             }
 
             /**
@@ -287,10 +287,7 @@ public class PacketType {
                  * @return Has the client placed a block?
                  */
                 public static boolean isBlockPlace(final byte packetID) {
-                    final ServerVersion version = PacketEvents.get().getServerUtils().getVersion();
-                    return version.isNewerThan(ServerVersion.v_1_8_8) ?
-                            packetID == PacketType.Play.Client.USE_ITEM
-                            : packetID == PacketType.Play.Client.BLOCK_PLACE;
+                    return isNine ? packetID == PacketType.Play.Client.USE_ITEM : packetID == PacketType.Play.Client.BLOCK_PLACE;
                 }
             }
         }
@@ -325,7 +322,11 @@ public class PacketType {
                     SCOREBOARD_SCORE = 10, SPAWN_POSITION = 11, UPDATE_TIME = 12, TITLE = 13,
                     ENTITY_SOUND = 14, NAMED_SOUND_EFFECT = 15, STOP_SOUND = 16, PLAYER_LIST_HEADER_FOOTER = 17,
                     NBT_QUERY = 18, COLLECT = 19, ENTITY_TELEPORT = 20, ADVANCEMENTS = 21, UPDATE_ATTRIBUTES = 22,
-                    ENTITY_EFFECT = 23, RECIPE_UPDATE = 24, TAGS = 25, MAP_CHUNK_BULK = 26, NAMED_ENTITY_SPAWN = 27;
+                    ENTITY_EFFECT = 23, RECIPE_UPDATE = 24, TAGS = 25, MAP_CHUNK_BULK = 26, NAMED_ENTITY_SPAWN = 27, PING = 29,
+                    ADD_VIBRATION_SIGNAL = 30, CLEAR_TITLES = 31, INITIALIZE_BORDER = 32, PLAYER_COMBAT_END = 33,
+                    PLAYER_COMBAT_ENTER = 34, PLAYER_COMBAT_KILL = 35, SET_ACTIONBAR_TEXT = 36, SET_BORDER_CENTER = 37,
+                    SET_BORDER_LERP_SIZE = 38, SET_BORDER_SIZE = 39, SET_BORDER_WARNING_DELAY = 40, SET_BORDER_WARNING_DISTANCE = 41,
+                    SET_SUBTITLE_TEXT = 42, SET_TITLES_ANIMATION = 43, SET_TITLE_TEXT = 44, SYSTEM_CHAT = 45;
 
             private static void load() {
                 insertPacketID(PacketTypeClasses.Play.Server.SPAWN_ENTITY, SPAWN_ENTITY);
@@ -342,7 +343,6 @@ public class PacketType {
                 insertPacketID(PacketTypeClasses.Play.Server.BLOCK_ACTION, BLOCK_ACTION);
                 insertPacketID(PacketTypeClasses.Play.Server.BLOCK_CHANGE, BLOCK_CHANGE);
                 insertPacketID(PacketTypeClasses.Play.Server.BOSS, BOSS);
-                insertPacketID(PacketTypeClasses.Play.Server.SPAWN_ENTITY, SPAWN_ENTITY);
                 insertPacketID(PacketTypeClasses.Play.Server.SERVER_DIFFICULTY, SERVER_DIFFICULTY);
                 insertPacketID(PacketTypeClasses.Play.Server.CHAT, CHAT);
                 insertPacketID(PacketTypeClasses.Play.Server.MULTI_BLOCK_CHANGE, MULTI_BLOCK_CHANGE);
@@ -365,7 +365,6 @@ public class PacketType {
                 insertPacketID(PacketTypeClasses.Play.Server.KEEP_ALIVE, KEEP_ALIVE);
                 insertPacketID(PacketTypeClasses.Play.Server.MAP_CHUNK, MAP_CHUNK);
                 insertPacketID(PacketTypeClasses.Play.Server.WORLD_EVENT, WORLD_EVENT);
-                insertPacketID(PacketTypeClasses.Play.Server.WORLD_EVENT, SPAWN_ENTITY);
                 insertPacketID(PacketTypeClasses.Play.Server.WORLD_PARTICLES, WORLD_PARTICLES);
                 insertPacketID(PacketTypeClasses.Play.Server.LIGHT_UPDATE, LIGHT_UPDATE);
                 insertPacketID(PacketTypeClasses.Play.Server.LOGIN, LOGIN);
@@ -425,6 +424,23 @@ public class PacketType {
                 insertPacketID(PacketTypeClasses.Play.Server.TAGS, TAGS);
                 insertPacketID(PacketTypeClasses.Play.Server.MAP_CHUNK_BULK, MAP_CHUNK_BULK);
                 insertPacketID(PacketTypeClasses.Play.Server.NAMED_ENTITY_SPAWN, NAMED_ENTITY_SPAWN);
+                insertPacketID(PacketTypeClasses.Play.Server.PING, PING);
+                insertPacketID(PacketTypeClasses.Play.Server.ADD_VIBRATION_SIGNAL, ADD_VIBRATION_SIGNAL);
+                insertPacketID(PacketTypeClasses.Play.Server.CLEAR_TITLES, CLEAR_TITLES );
+                insertPacketID(PacketTypeClasses.Play.Server.INITIALIZE_BORDER, INITIALIZE_BORDER);
+                insertPacketID(PacketTypeClasses.Play.Server.PLAYER_COMBAT_END, PLAYER_COMBAT_END);
+                insertPacketID(PacketTypeClasses.Play.Server.PLAYER_COMBAT_ENTER, PLAYER_COMBAT_ENTER);
+                insertPacketID(PacketTypeClasses.Play.Server.PLAYER_COMBAT_KILL, PLAYER_COMBAT_KILL);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_ACTIONBAR_TEXT, SET_ACTIONBAR_TEXT);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_BORDER_CENTER, SET_BORDER_CENTER);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_BORDER_LERP_SIZE, SET_BORDER_LERP_SIZE);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_BORDER_SIZE, SET_BORDER_SIZE);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_BORDER_WARNING_DELAY, SET_BORDER_WARNING_DELAY);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_BORDER_WARNING_DISTANCE, SET_BORDER_WARNING_DISTANCE);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_SUBTITLE_TEXT, SET_SUBTITLE_TEXT);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_TITLES_ANIMATION, SET_TITLES_ANIMATION);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_TITLE_TEXT, SET_TITLE_TEXT);
+                insertPacketID(PacketTypeClasses.Play.Server.SYSTEM_CHAT, SYSTEM_CHAT);
             }
 
             /**

src/main/java/io/github/retrooper/packetevents/packettype/PacketTypeClasses.java

@@ -1,31 +1,25 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packettype;
 
 import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.utils.nms.NMSUtils;
+import io.github.retrooper.packetevents.utils.reflection.Reflection;
 import io.github.retrooper.packetevents.utils.reflection.SubclassUtil;
 import io.github.retrooper.packetevents.utils.server.ServerVersion;
 
@@ -46,61 +40,96 @@ public class PacketTypeClasses {
 
     public static class Status {
         public static class Client {
+            private static String PREFIX;
             public static Class<?> START, PING;
 
             public static void load() {
-                Client.START = NMSUtils.getNMSClassWithoutException("PacketStatusInStart");
-                Client.PING = NMSUtils.getNMSClassWithoutException("PacketStatusInPing");
+                if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_17)) {
+                    PREFIX  = "net.minecraft.network.protocol.status.";
+                }
+                else {
+                    PREFIX = ServerVersion.getNMSDirectory();
+                }
+                Client.START = Reflection.getClassByNameWithoutException(PREFIX + "PacketStatusInStart");
+                Client.PING = Reflection.getClassByNameWithoutException(PREFIX + "PacketStatusInPing");
             }
         }
 
         public static class Server {
+            private static String PREFIX;
             public static Class<?> PONG, SERVER_INFO;
 
             public static void load() {
-                Server.PONG = NMSUtils.getNMSClassWithoutException("PacketStatusOutPong");
-                Server.SERVER_INFO = NMSUtils.getNMSClassWithoutException("PacketStatusOutServerInfo");
+                if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_17)) {
+                    PREFIX  = "net.minecraft.network.protocol.status.";
+                }
+                else {
+                    PREFIX = ServerVersion.getNMSDirectory();
+                }
+                Server.PONG = Reflection.getClassByNameWithoutException(PREFIX + "PacketStatusOutPong");
+                Server.SERVER_INFO = Reflection.getClassByNameWithoutException(PREFIX + "PacketStatusOutServerInfo");
             }
         }
     }
 
     public static class Handshaking {
         public static class Client {
+            private static String PREFIX;
             public static Class<?> SET_PROTOCOL;
 
             public static void load() {
-                Handshaking.Client.SET_PROTOCOL = NMSUtils.getNMSClassWithoutException("PacketHandshakingInSetProtocol");
+                if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_17)) {
+                    PREFIX  = "net.minecraft.network.protocol.handshake.";
+                }
+                else {
+                    PREFIX = ServerVersion.getNMSDirectory();
+                }
+                Handshaking.Client.SET_PROTOCOL = Reflection.getClassByNameWithoutException(PREFIX + "PacketHandshakingInSetProtocol");
             }
         }
     }
 
     public static class Login {
         public static class Client {
+            private static String PREFIX;
             public static Class<?> CUSTOM_PAYLOAD, START, ENCRYPTION_BEGIN;
 
             public static void load() {
+                if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_17)) {
+                    PREFIX  = "net.minecraft.network.protocol.login.";
+                }
+                else {
+                    PREFIX = ServerVersion.getNMSDirectory();
+                }
                 //In and Out custom payload login packets have been here since 1.13
                 if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_13)) {
-                    Client.CUSTOM_PAYLOAD = NMSUtils.getNMSClassWithoutException("PacketLoginInCustomPayload");
+                    Client.CUSTOM_PAYLOAD = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginInCustomPayload");
                 }
-                Client.START = NMSUtils.getNMSClassWithoutException("PacketLoginInStart");
-                Client.ENCRYPTION_BEGIN = NMSUtils.getNMSClassWithoutException("PacketLoginInEncryptionBegin");
+                Client.START = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginInStart");
+                Client.ENCRYPTION_BEGIN = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginInEncryptionBegin");
             }
         }
 
         public static class Server {
+            private static String PREFIX;
             public static Class<?> CUSTOM_PAYLOAD, DISCONNECT, ENCRYPTION_BEGIN, SUCCESS, SET_COMPRESSION;
 
             public static void load() {
+                if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_17)) {
+                    PREFIX  = "net.minecraft.network.protocol.login.";
+                }
+                else {
+                    PREFIX = ServerVersion.getNMSDirectory();
+                }
                 //In and Out custom payload login packets have been here since 1.13
                 if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_13)) {
-                    Server.CUSTOM_PAYLOAD = NMSUtils.getNMSClassWithoutException("PacketLoginOutCustomPayload");
+                    Server.CUSTOM_PAYLOAD = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginOutCustomPayload");
                 }
-                Server.DISCONNECT = NMSUtils.getNMSClassWithoutException("PacketLoginOutDisconnect");
-                Server.ENCRYPTION_BEGIN = NMSUtils.getNMSClassWithoutException("PacketLoginOutEncryptionBegin");
-                Server.SUCCESS = NMSUtils.getNMSClassWithoutException("PacketLoginOutSuccess");
+                Server.DISCONNECT = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginOutDisconnect");
+                Server.ENCRYPTION_BEGIN = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginOutEncryptionBegin");
+                Server.SUCCESS = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginOutSuccess");
                 if (PacketEvents.get().getServerUtils().getVersion().isNewerThan(ServerVersion.v_1_7_10)) {
-                    Server.SET_COMPRESSION = NMSUtils.getNMSClassWithoutException("PacketLoginOutSetCompression");
+                    Server.SET_COMPRESSION = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginOutSetCompression");
                 }
             }
         }
@@ -108,8 +137,8 @@ public class PacketTypeClasses {
 
     public static class Play {
         public static class Client {
-            private static final String PREFIX = "PacketPlayIn";
-            public static Class<?> FLYING, POSITION, POSITION_LOOK, LOOK, CLIENT_COMMAND,
+            private static String COMMON_PREFIX, PREFIX, PREFIX_COMMON_STATES;
+            public static Class<?> FLYING, POSITION, POSITION_LOOK, LOOK, GROUND, CLIENT_COMMAND,
                     TRANSACTION, BLOCK_DIG, ENTITY_ACTION, USE_ENTITY,
                     WINDOW_CLICK, STEER_VEHICLE, CUSTOM_PAYLOAD, ARM_ANIMATION,
                     BLOCK_PLACE, USE_ITEM, ABILITIES, HELD_ITEM_SLOT,
@@ -119,76 +148,118 @@ public class PacketTypeClasses {
                     JIGSAW_GENERATE, DIFFICULTY_LOCK, VEHICLE_MOVE, BOAT_MOVE, PICK_ITEM,
                     AUTO_RECIPE, RECIPE_DISPLAYED, ITEM_NAME, RESOURCE_PACK_STATUS,
                     ADVANCEMENTS, TR_SEL, BEACON, SET_COMMAND_BLOCK,
-                    SET_COMMAND_MINECART, SET_JIGSAW, STRUCT, UPDATE_SIGN, SPECTATE;
+                    SET_COMMAND_MINECART, SET_JIGSAW, STRUCT, UPDATE_SIGN, SPECTATE, PONG;
 
             /**
              * Initiate all server-bound play packet classes.
              */
             public static void load() {
-                FLYING = NMSUtils.getNMSClassWithoutException(PREFIX + "Flying");
-                try {
-                    POSITION = NMSUtils.getNMSClass(PREFIX + "Position");
-                    POSITION_LOOK = NMSUtils.getNMSClass(PREFIX + "PositionLook");
-                    LOOK = NMSUtils.getNMSClass(PREFIX + "Look");
-                } catch (Exception e) {
-                    POSITION = SubclassUtil.getSubClass(FLYING, PREFIX + "Position");
-                    POSITION_LOOK = SubclassUtil.getSubClass(FLYING, PREFIX + "PositionLook");
-                    LOOK = SubclassUtil.getSubClass(FLYING, PREFIX + "Look");
+                if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_17)) {
+                    PREFIX  = "net.minecraft.network.protocol.game.";
+                    if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_20_2)) {
+                        PREFIX_COMMON_STATES = "net.minecraft.network.protocol.common.";
+                    }
                 }
-
+                else {
+                    PREFIX = ServerVersion.getNMSDirectory();
+                }
+                COMMON_PREFIX  = PREFIX + "PacketPlayIn";
+                FLYING = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Flying");
                 try {
-                    SETTINGS = NMSUtils.getNMSClass(PREFIX + "Settings");
-                    ENCHANT_ITEM = NMSUtils.getNMSClass(PREFIX + "EnchantItem");
+                    POSITION = Class.forName(COMMON_PREFIX + "Position");
+                    POSITION_LOOK = Class.forName(COMMON_PREFIX + "PositionLook");
+                    LOOK = Class.forName(COMMON_PREFIX + "Look");
+                } catch (ClassNotFoundException ex) {
+                    POSITION = SubclassUtil.getSubClass(FLYING,"PacketPlayInPosition");
+                    POSITION_LOOK = SubclassUtil.getSubClass(FLYING, "PacketPlayInPositionLook");
+                    LOOK = SubclassUtil.getSubClass(FLYING, "PacketPlayInLook");
+                }
+                if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_17)) {
+                    GROUND = SubclassUtil.getSubClass(FLYING, "d");
+                    if (GROUND == null) {
+                        GROUND = SubclassUtil.getSubClass(FLYING, 0);
+                    }
+                    if (POSITION == null) {
+                        POSITION = SubclassUtil.getSubClass(FLYING, 2);
+                    }
+                    if (POSITION_LOOK == null) {
+                        POSITION_LOOK = SubclassUtil.getSubClass(FLYING, 3);
+                    }
 
-                    CLIENT_COMMAND = NMSUtils.getNMSClass(PREFIX + "ClientCommand");
-                    TRANSACTION = NMSUtils.getNMSClass(PREFIX + "Transaction");
-                    BLOCK_DIG = NMSUtils.getNMSClass(PREFIX + "BlockDig");
-                    ENTITY_ACTION = NMSUtils.getNMSClass(PREFIX + "EntityAction");
-                    USE_ENTITY = NMSUtils.getNMSClass(PREFIX + "UseEntity");
-                    WINDOW_CLICK = NMSUtils.getNMSClass(PREFIX + "WindowClick");
-                    STEER_VEHICLE = NMSUtils.getNMSClass(PREFIX + "SteerVehicle");
-                    CUSTOM_PAYLOAD = NMSUtils.getNMSClass(PREFIX + "CustomPayload");
-                    ARM_ANIMATION = NMSUtils.getNMSClass(PREFIX + "ArmAnimation");
-                    ABILITIES = NMSUtils.getNMSClass(PREFIX + "Abilities");
-                    HELD_ITEM_SLOT = NMSUtils.getNMSClass(PREFIX + "HeldItemSlot");
-                    CLOSE_WINDOW = NMSUtils.getNMSClass(PREFIX + "CloseWindow");
-                    TAB_COMPLETE = NMSUtils.getNMSClass(PREFIX + "TabComplete");
-                    CHAT = NMSUtils.getNMSClass(PREFIX + "Chat");
-                    SET_CREATIVE_SLOT = NMSUtils.getNMSClass(PREFIX + "SetCreativeSlot");
-                    KEEP_ALIVE = NMSUtils.getNMSClass(PREFIX + "KeepAlive");
-                    UPDATE_SIGN = NMSUtils.getNMSClassWithoutException(PREFIX + "UpdateSign");
+                    if (LOOK == null) {
+                        LOOK = SubclassUtil.getSubClass(FLYING, 1);
+                    }
+                }
+                else {
+                    GROUND = FLYING;
+                }
+                //This packet does not exist in the 1.17+ protocol
+                TRANSACTION = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Transaction");
+                //This packet was added in 1.17 protocol
+                PONG = Reflection.getClassByNameWithoutException(PREFIX + "ServerboundPongPacket");
+                if (PONG == null) {
+                    PONG = Reflection.getClassByNameWithoutException(PREFIX_COMMON_STATES + "ServerboundPongPacket");
+                }
+                SETTINGS = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Settings");
+                if (SETTINGS == null) {
+                    SETTINGS = Reflection.getClassByNameWithoutException(PREFIX_COMMON_STATES + "ServerboundClientInformationPacket");
+                }
+                try {
+                    ENCHANT_ITEM = Class.forName(COMMON_PREFIX + "EnchantItem");
+                    CLIENT_COMMAND = Class.forName(COMMON_PREFIX + "ClientCommand");
+                    BLOCK_DIG = Class.forName(COMMON_PREFIX + "BlockDig");
+                    ENTITY_ACTION = Class.forName(COMMON_PREFIX + "EntityAction");
+                    USE_ENTITY = Class.forName(COMMON_PREFIX + "UseEntity");
+                    WINDOW_CLICK = Class.forName(COMMON_PREFIX + "WindowClick");
+                    STEER_VEHICLE = Class.forName(COMMON_PREFIX + "SteerVehicle");
+                    CUSTOM_PAYLOAD = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "CustomPayload");
+                    if (CUSTOM_PAYLOAD == null) {
+                        CUSTOM_PAYLOAD = Reflection.getClassByNameWithoutException(PREFIX_COMMON_STATES + "ServerboundCustomPayloadPacket");
+                    }
+                    ARM_ANIMATION = Class.forName(COMMON_PREFIX + "ArmAnimation");
+                    ABILITIES = Class.forName(COMMON_PREFIX + "Abilities");
+                    HELD_ITEM_SLOT = Class.forName(COMMON_PREFIX + "HeldItemSlot");
+                    CLOSE_WINDOW = Class.forName(COMMON_PREFIX + "CloseWindow");
+                    TAB_COMPLETE = Class.forName(COMMON_PREFIX + "TabComplete");
+                    CHAT = Class.forName(COMMON_PREFIX + "Chat");
+                    SET_CREATIVE_SLOT = Class.forName(COMMON_PREFIX + "SetCreativeSlot");
+                    KEEP_ALIVE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "KeepAlive");
+                    if (KEEP_ALIVE == null) {
+                        KEEP_ALIVE = Reflection.getClassByNameWithoutException(PREFIX_COMMON_STATES + "ServerboundKeepAlivePacket");
+                    }
+                    UPDATE_SIGN = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "UpdateSign");
 
-                    TELEPORT_ACCEPT = NMSUtils.getNMSClassWithoutException(PREFIX + "TeleportAccept");
-                    TILE_NBT_QUERY = NMSUtils.getNMSClassWithoutException(PREFIX + "TileNBTQuery");
-                    DIFFICULTY_CHANGE = NMSUtils.getNMSClassWithoutException(PREFIX + "DifficultyChange");
-                    B_EDIT = NMSUtils.getNMSClassWithoutException(PREFIX + "BEdit");
-                    ENTITY_NBT_QUERY = NMSUtils.getNMSClassWithoutException(PREFIX + "EntityNBTQuery");
-                    JIGSAW_GENERATE = NMSUtils.getNMSClassWithoutException(PREFIX + "JigsawGenerate");
-                    DIFFICULTY_LOCK = NMSUtils.getNMSClassWithoutException(PREFIX + "DifficultyLock");
-                    VEHICLE_MOVE = NMSUtils.getNMSClassWithoutException(PREFIX + "VehicleMove");
-                    BOAT_MOVE = NMSUtils.getNMSClassWithoutException(PREFIX + "BoatMove");
-                    PICK_ITEM = NMSUtils.getNMSClassWithoutException(PREFIX + "PickItem");
-                    AUTO_RECIPE = NMSUtils.getNMSClassWithoutException(PREFIX + "AutoRecipe");
-                    RECIPE_DISPLAYED = NMSUtils.getNMSClassWithoutException(PREFIX + "RecipeDisplayed");
-                    ITEM_NAME = NMSUtils.getNMSClassWithoutException(PREFIX + "ItemName");
+                    TELEPORT_ACCEPT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "TeleportAccept");
+                    TILE_NBT_QUERY = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "TileNBTQuery");
+                    DIFFICULTY_CHANGE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "DifficultyChange");
+                    B_EDIT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "BEdit");
+                    ENTITY_NBT_QUERY = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "EntityNBTQuery");
+                    JIGSAW_GENERATE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "JigsawGenerate");
+                    DIFFICULTY_LOCK = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "DifficultyLock");
+                    VEHICLE_MOVE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "VehicleMove");
+                    BOAT_MOVE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "BoatMove");
+                    PICK_ITEM = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "PickItem");
+                    AUTO_RECIPE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "AutoRecipe");
+                    RECIPE_DISPLAYED = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "RecipeDisplayed");
+                    ITEM_NAME = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "ItemName");
                     //1.8+
-                    RESOURCE_PACK_STATUS = NMSUtils.getNMSClassWithoutException(PREFIX + "ResourcePackStatus");
+                    RESOURCE_PACK_STATUS = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "ResourcePackStatus");
 
-                    ADVANCEMENTS = NMSUtils.getNMSClassWithoutException(PREFIX + "Advancements");
-                    TR_SEL = NMSUtils.getNMSClassWithoutException(PREFIX + "TrSel");
-                    BEACON = NMSUtils.getNMSClassWithoutException(PREFIX + "Beacon");
-                    SET_COMMAND_BLOCK = NMSUtils.getNMSClassWithoutException(PREFIX + "SetCommandBlock");
-                    SET_COMMAND_MINECART = NMSUtils.getNMSClassWithoutException(PREFIX + "SetCommandMinecart");
-                    SET_JIGSAW = NMSUtils.getNMSClassWithoutException(PREFIX + "SetJigsaw");
-                    STRUCT = NMSUtils.getNMSClassWithoutException(PREFIX + "Struct");
-                    SPECTATE = NMSUtils.getNMSClassWithoutException(PREFIX + "Spectate");
+                    ADVANCEMENTS = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Advancements");
+                    TR_SEL = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "TrSel");
+                    BEACON = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Beacon");
+                    SET_COMMAND_BLOCK = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SetCommandBlock");
+                    SET_COMMAND_MINECART = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SetCommandMinecart");
+                    SET_JIGSAW = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SetJigsaw");
+                    STRUCT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Struct");
+                    SPECTATE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Spectate");
                 } catch (Exception e) {
                     e.printStackTrace();
                 }
 
                 try {
-                    BLOCK_PLACE = NMSUtils.getNMSClass(PREFIX + "BlockPlace");
-                    USE_ITEM = NMSUtils.getNMSClass(PREFIX + "UseItem");
+                    BLOCK_PLACE = Class.forName(COMMON_PREFIX + "BlockPlace");
+                    USE_ITEM = Class.forName(COMMON_PREFIX + "UseItem");
                 } catch (Exception ignored) {
                 }
 
@@ -196,7 +267,7 @@ public class PacketTypeClasses {
         }
 
         public static class Server {
-            private static final String s = "PacketPlayOut";
+            private static String COMMON_PREFIX, PREFIX, PREFIX_COMMON_STATES;
             public static Class<?> SPAWN_ENTITY, SPAWN_ENTITY_EXPERIENCE_ORB, SPAWN_ENTITY_WEATHER, SPAWN_ENTITY_LIVING,
                     SPAWN_ENTITY_PAINTING, SPAWN_ENTITY_SPAWN, ANIMATION, STATISTIC,
                     BLOCK_BREAK, BLOCK_BREAK_ANIMATION, TILE_ENTITY_DATA, BLOCK_ACTION,
@@ -219,115 +290,177 @@ public class PacketTypeClasses {
                     SCOREBOARD_SCORE, SPAWN_POSITION, UPDATE_TIME, TITLE,
                     ENTITY_SOUND, NAMED_SOUND_EFFECT, STOP_SOUND, PLAYER_LIST_HEADER_FOOTER,
                     NBT_QUERY, COLLECT, ENTITY_TELEPORT, ADVANCEMENTS, UPDATE_ATTRIBUTES,
-                    ENTITY_EFFECT, RECIPE_UPDATE, TAGS, MAP_CHUNK_BULK, NAMED_ENTITY_SPAWN;
+                    ENTITY_EFFECT, RECIPE_UPDATE, TAGS, MAP_CHUNK_BULK, NAMED_ENTITY_SPAWN, PING, ADD_VIBRATION_SIGNAL,
+                    CLEAR_TITLES, INITIALIZE_BORDER, PLAYER_COMBAT_END, PLAYER_COMBAT_ENTER, PLAYER_COMBAT_KILL,
+                    SET_ACTIONBAR_TEXT, SET_BORDER_CENTER, SET_BORDER_LERP_SIZE, SET_BORDER_SIZE, SET_BORDER_WARNING_DELAY,
+                    SET_BORDER_WARNING_DISTANCE, SET_SUBTITLE_TEXT, SET_TITLES_ANIMATION, SET_TITLE_TEXT,
+                    SYSTEM_CHAT;
 
             /**
              * Initiate all client-bound packet classes.
              */
             public static void load() {
-                SPAWN_ENTITY = NMSUtils.getNMSClassWithoutException(s + "SpawnEntity");
-                SPAWN_ENTITY_EXPERIENCE_ORB = NMSUtils.getNMSClassWithoutException(s + "SpawnEntityExperienceOrb");
-                SPAWN_ENTITY_WEATHER = NMSUtils.getNMSClassWithoutException(s + "SpawnEntityWeather");
-                SPAWN_ENTITY_LIVING = NMSUtils.getNMSClassWithoutException(s + "SpawnEntityLiving");
-                SPAWN_ENTITY_PAINTING = NMSUtils.getNMSClassWithoutException(s + "SpawnEntityPainting");
-                SPAWN_ENTITY_SPAWN = NMSUtils.getNMSClassWithoutException(s + "SpawnEntitySpawn");
-                ANIMATION = NMSUtils.getNMSClassWithoutException(s + "Animation");
-                STATISTIC = NMSUtils.getNMSClassWithoutException(s + "Statistic");
-                BLOCK_BREAK = NMSUtils.getNMSClassWithoutException(s + "BlockBreak");
-                BLOCK_BREAK_ANIMATION = NMSUtils.getNMSClassWithoutException(s + "BlockBreakAnimation");
-                TILE_ENTITY_DATA = NMSUtils.getNMSClassWithoutException(s + "TileEntityData");
-                BLOCK_ACTION = NMSUtils.getNMSClassWithoutException(s + "BlockAction");
-                BLOCK_CHANGE = NMSUtils.getNMSClassWithoutException(s + "BlockChange");
-                BOSS = NMSUtils.getNMSClassWithoutException(s + "Boss");
-                SERVER_DIFFICULTY = NMSUtils.getNMSClassWithoutException(s + "ServerDifficulty");
-                CHAT = NMSUtils.getNMSClassWithoutException(s + "Chat");
-                MULTI_BLOCK_CHANGE = NMSUtils.getNMSClassWithoutException(s + "MultiBlockChange");
-                TAB_COMPLETE = NMSUtils.getNMSClassWithoutException(s + "TabComplete");
-                COMMANDS = NMSUtils.getNMSClassWithoutException(s + "Commands");
-                TRANSACTION = NMSUtils.getNMSClassWithoutException(s + "Transaction");
-                CLOSE_WINDOW = NMSUtils.getNMSClassWithoutException(s + "CloseWindow");
-                WINDOW_ITEMS = NMSUtils.getNMSClassWithoutException(s + "WindowItems");
-                WINDOW_DATA = NMSUtils.getNMSClassWithoutException(s + "WindowData");
-                SET_SLOT = NMSUtils.getNMSClassWithoutException(s + "SetSlot");
-                SET_COOLDOWN = NMSUtils.getNMSClassWithoutException(s + "SetCooldown");
-                CUSTOM_PAYLOAD = NMSUtils.getNMSClassWithoutException(s + "CustomPayload");
-                CUSTOM_SOUND_EFFECT = NMSUtils.getNMSClassWithoutException(s + "CustomSoundEffect");
-                KICK_DISCONNECT = NMSUtils.getNMSClassWithoutException(s + "KickDisconnect");
-                ENTITY_STATUS = NMSUtils.getNMSClassWithoutException(s + "EntityStatus");
-                EXPLOSION = NMSUtils.getNMSClassWithoutException(s + "Explosion");
-                UNLOAD_CHUNK = NMSUtils.getNMSClassWithoutException(s + "UnloadChunk");
-                GAME_STATE_CHANGE = NMSUtils.getNMSClassWithoutException(s + "GameStateChange");
-                OPEN_WINDOW_HORSE = NMSUtils.getNMSClassWithoutException(s + "OpenWindowHorse");
-                KEEP_ALIVE = NMSUtils.getNMSClassWithoutException(s + "KeepAlive");
-                MAP_CHUNK = NMSUtils.getNMSClassWithoutException(s + "MapChunk");
-                WORLD_EVENT = NMSUtils.getNMSClassWithoutException(s + "WorldEvent");
-                WORLD_PARTICLES = NMSUtils.getNMSClassWithoutException(s + "WorldParticles");
-                LIGHT_UPDATE = NMSUtils.getNMSClassWithoutException(s + "LightUpdate");
-                LOGIN = NMSUtils.getNMSClassWithoutException(s + "Login");
-                MAP = NMSUtils.getNMSClassWithoutException(s + "Map");
-                OPEN_WINDOW_MERCHANT = NMSUtils.getNMSClassWithoutException(s + "OpenWindowMerchant");
-                ENTITY = NMSUtils.getNMSClassWithoutException(s + "Entity");
-                REL_ENTITY_MOVE = SubclassUtil.getSubClass(ENTITY, s + "RelEntityMove");
-                REL_ENTITY_MOVE_LOOK = SubclassUtil.getSubClass(ENTITY, s + "RelEntityMoveLook");
-                ENTITY_LOOK = SubclassUtil.getSubClass(ENTITY, s + "EntityLook");
+                if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_17)) {
+                    PREFIX  = "net.minecraft.network.protocol.game.";
+                    if (PacketEvents.get().getServerUtils().getVersion().isNewerThanOrEquals(ServerVersion.v_1_20_2)) {
+                        PREFIX_COMMON_STATES = "net.minecraft.network.protocol.common.";
+                    }
+                }
+                else {
+                    PREFIX = ServerVersion.getNMSDirectory();
+                }
+                COMMON_PREFIX  = PREFIX + "PacketPlayOut";
+                SPAWN_ENTITY = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SpawnEntity");
+                SPAWN_ENTITY_EXPERIENCE_ORB = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SpawnEntityExperienceOrb");
+                SPAWN_ENTITY_WEATHER = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SpawnEntityWeather");
+                SPAWN_ENTITY_LIVING = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SpawnEntityLiving");
+                SPAWN_ENTITY_PAINTING = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SpawnEntityPainting");
+                SPAWN_ENTITY_SPAWN = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SpawnEntitySpawn");
+                ANIMATION = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Animation");
+                STATISTIC = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Statistic");
+                BLOCK_BREAK = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "BlockBreak");
+                BLOCK_BREAK_ANIMATION = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "BlockBreakAnimation");
+                TILE_ENTITY_DATA = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "TileEntityData");
+                BLOCK_ACTION = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "BlockAction");
+                BLOCK_CHANGE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "BlockChange");
+                BOSS = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Boss");
+                SERVER_DIFFICULTY = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "ServerDifficulty");
+                CHAT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Chat");
+                if (CHAT == null) {
+                    CHAT = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundPlayerChatPacket");
+                }
+                MULTI_BLOCK_CHANGE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "MultiBlockChange");
+                TAB_COMPLETE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "TabComplete");
+                COMMANDS = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Commands");
+                TRANSACTION = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Transaction");
+                CLOSE_WINDOW = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "CloseWindow");
+                WINDOW_ITEMS = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "WindowItems");
+                WINDOW_DATA = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "WindowData");
+                SET_SLOT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SetSlot");
+                SET_COOLDOWN = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SetCooldown");
+                CUSTOM_PAYLOAD = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "CustomPayload");
+                if (CUSTOM_PAYLOAD == null) {
+                    CUSTOM_PAYLOAD = Reflection.getClassByNameWithoutException(PREFIX_COMMON_STATES + "ClientboundCustomPayloadPacket");
+                }
+                CUSTOM_SOUND_EFFECT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "CustomSoundEffect");
+                KICK_DISCONNECT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "KickDisconnect");
+                if (KICK_DISCONNECT == null) {
+                    KICK_DISCONNECT = Reflection.getClassByNameWithoutException(PREFIX_COMMON_STATES + "ClientboundDisconnectPacket");
+                }
+                ENTITY_STATUS = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "EntityStatus");
+                EXPLOSION = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Explosion");
+                UNLOAD_CHUNK = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "UnloadChunk");
+                GAME_STATE_CHANGE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "GameStateChange");
+                OPEN_WINDOW_HORSE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "OpenWindowHorse");
+                KEEP_ALIVE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "KeepAlive");
+                if (KEEP_ALIVE == null) {
+                    KEEP_ALIVE = Reflection.getClassByNameWithoutException(PREFIX_COMMON_STATES + "ClientboundKeepAlivePacket");
+                }
+                MAP_CHUNK = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "MapChunk");
+                WORLD_EVENT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "WorldEvent");
+                WORLD_PARTICLES = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "WorldParticles");
+                LIGHT_UPDATE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "LightUpdate");
+                LOGIN = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Login");
+                MAP = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Map");
+                OPEN_WINDOW_MERCHANT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "OpenWindowMerchant");
+                ENTITY = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Entity");
+                REL_ENTITY_MOVE = SubclassUtil.getSubClass(ENTITY, "PacketPlayOutRelEntityMove");
+                REL_ENTITY_MOVE_LOOK = SubclassUtil.getSubClass(ENTITY, "PacketPlayOutRelEntityMoveLook");
+                ENTITY_LOOK = SubclassUtil.getSubClass(ENTITY, "PacketPlayOutEntityLook");
                 if (REL_ENTITY_MOVE == null) {
                     //is not a subclass and should be accessed normally
-                    REL_ENTITY_MOVE = NMSUtils.getNMSClassWithoutException(s + "RelEntityMove");
-                    REL_ENTITY_MOVE_LOOK = NMSUtils.getNMSClassWithoutException(s + "RelEntityMoveLook");
-                    ENTITY_LOOK = NMSUtils.getNMSClassWithoutException(s + "RelEntityLook");
+                    REL_ENTITY_MOVE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "RelEntityMove");
+                    REL_ENTITY_MOVE_LOOK = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "RelEntityMoveLook");
+                    ENTITY_LOOK = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "RelEntityLook");
+
+                    if (REL_ENTITY_MOVE == null) {
+                        REL_ENTITY_MOVE = SubclassUtil.getSubClass(ENTITY, 1);
+                    }
+                    if (REL_ENTITY_MOVE_LOOK == null) {
+                        REL_ENTITY_MOVE_LOOK = SubclassUtil.getSubClass(ENTITY, 2);
+                    }
+                    if (ENTITY_LOOK == null) {
+                        ENTITY_LOOK = SubclassUtil.getSubClass(ENTITY, 0);
+                    }
+                }
+                VEHICLE_MOVE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "VehicleMove");
+                OPEN_BOOK = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "OpenBook");
+                OPEN_WINDOW = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "OpenWindow");
+                OPEN_SIGN_EDITOR = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "OpenSignEditor");
+                AUTO_RECIPE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "AutoRecipe");
+                ABILITIES = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Abilities");
+                COMBAT_EVENT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "CombatEvent");
+                PLAYER_INFO = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "PlayerInfo");
+                LOOK_AT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "LookAt");
+                POSITION = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Position");
+                RECIPES = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Recipes");
+                ENTITY_DESTROY = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "EntityDestroy");
+                REMOVE_ENTITY_EFFECT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "RemoveEntityEffect");
+                RESOURCE_PACK_SEND = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "ResourcePackSend");
+                RESPAWN = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Respawn");
+                ENTITY_HEAD_ROTATION = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "EntityHeadRotation");
+                SELECT_ADVANCEMENT_TAB = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SelectAdvancementTab");
+                WORLD_BORDER = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "WorldBorder");
+                CAMERA = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Camera");
+                HELD_ITEM_SLOT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "HeldItemSlot");
+                VIEW_CENTRE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "ViewCentre");
+                VIEW_DISTANCE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "ViewDistance");
+                SCOREBOARD_DISPLAY_OBJECTIVE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "ScoreboardDisplayObjective");
+                ENTITY_METADATA = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "EntityMetadata");
+                ATTACH_ENTITY = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "AttachEntity");
+                ENTITY_VELOCITY = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "EntityVelocity");
+                ENTITY_EQUIPMENT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "EntityEquipment");
+                EXPERIENCE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Experience");
+                UPDATE_HEALTH = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "UpdateHealth");
+                SCOREBOARD_OBJECTIVE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "ScoreboardObjective");
+                MOUNT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Mount");
+                SCOREBOARD_TEAM = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "ScoreboardTeam");
+                SCOREBOARD_SCORE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "ScoreboardScore");
+                SPAWN_POSITION = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "SpawnPosition");
+                UPDATE_TIME = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "UpdateTime");
+                TITLE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Title");
+                ENTITY_SOUND = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "EntitySound");
+                NAMED_SOUND_EFFECT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "NamedSoundEffect");
+                STOP_SOUND = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "StopSound");
+                PLAYER_LIST_HEADER_FOOTER = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "PlayerListHeaderFooter");
+                NBT_QUERY = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "NBTQuery");
+                COLLECT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Collect");
+                ENTITY_TELEPORT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "EntityTeleport");
+                ADVANCEMENTS = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Advancements");
+                UPDATE_ATTRIBUTES = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "UpdateAttributes");
+                ENTITY_EFFECT = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "EntityEffect");
+                RECIPE_UPDATE = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "RecipeUpdate");
+                TAGS = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "Tags");
+                MAP_CHUNK_BULK = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "MapChunkBulk");
+                NAMED_ENTITY_SPAWN = Reflection.getClassByNameWithoutException(COMMON_PREFIX + "NamedEntitySpawn");
+
+                //These packets were added in 1.17
+                PING = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundPingPacket");
+                if (PING == null) {
+                    PING = Reflection.getClassByNameWithoutException(PREFIX_COMMON_STATES + "ClientboundPingPacket");
+                }
+                ADD_VIBRATION_SIGNAL = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundAddVibrationSignalPacket");
+                CLEAR_TITLES = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundClearTitlesPacket");
+                INITIALIZE_BORDER = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundInitializeBorderPacket");
+                PLAYER_COMBAT_END = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundPlayerCombatEndPacket");
+                PLAYER_COMBAT_ENTER = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundPlayerCombatEnterPacket");
+                PLAYER_COMBAT_KILL = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundPlayerCombatKillPacket");
+                SET_ACTIONBAR_TEXT = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundSetActionBarTextPacket");
+                SET_BORDER_CENTER = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundSetBorderCenterPacket");
+                SET_BORDER_LERP_SIZE = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundSetBorderLerpSizePacket");
+                SET_BORDER_SIZE = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundSetBorderSizePacket");
+                SET_BORDER_WARNING_DELAY = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundSetBorderWarningDelayPacket");
+                SET_BORDER_WARNING_DISTANCE = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundSetBorderWarningDistancePacket");
+                SET_SUBTITLE_TEXT = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundSetSubtitleTextPacket");
+                SET_TITLES_ANIMATION = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundSetTitlesAnimationPacket");
+                SET_TITLE_TEXT = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundSetTitleTextPacket");
+                SYSTEM_CHAT = Reflection.getClassByNameWithoutException(PREFIX + "ClientboundSystemChatPacket");
+
+                // 1.18+ only, doesn't follow the naming convention
+                if (MAP_CHUNK == null) {
+                    MAP_CHUNK = Reflection.getClassByNameWithoutException("net.minecraft.network.protocol.game.ClientboundLevelChunkWithLightPacket");
                 }
-                VEHICLE_MOVE = NMSUtils.getNMSClassWithoutException(s + "VehicleMove");
-                OPEN_BOOK = NMSUtils.getNMSClassWithoutException(s + "OpenBook");
-                OPEN_WINDOW = NMSUtils.getNMSClassWithoutException(s + "OpenWindow");
-                OPEN_SIGN_EDITOR = NMSUtils.getNMSClassWithoutException(s + "OpenSignEditor");
-                AUTO_RECIPE = NMSUtils.getNMSClassWithoutException(s + "AutoRecipe");
-                ABILITIES = NMSUtils.getNMSClassWithoutException(s + "Abilities");
-                COMBAT_EVENT = NMSUtils.getNMSClassWithoutException(s + "CombatEvent");
-                PLAYER_INFO = NMSUtils.getNMSClassWithoutException(s + "PlayerInfo");
-                LOOK_AT = NMSUtils.getNMSClassWithoutException(s + "LookAt");
-                POSITION = NMSUtils.getNMSClassWithoutException(s + "Position");
-                RECIPES = NMSUtils.getNMSClassWithoutException(s + "Recipes");
-                ENTITY_DESTROY = NMSUtils.getNMSClassWithoutException(s + "EntityDestroy");
-                REMOVE_ENTITY_EFFECT = NMSUtils.getNMSClassWithoutException(s + "RemoveEntityEffect");
-                RESOURCE_PACK_SEND = NMSUtils.getNMSClassWithoutException(s + "ResourcePackSend");
-                RESPAWN = NMSUtils.getNMSClassWithoutException(s + "Respawn");
-                ENTITY_HEAD_ROTATION = NMSUtils.getNMSClassWithoutException(s + "EntityHeadRotation");
-                SELECT_ADVANCEMENT_TAB = NMSUtils.getNMSClassWithoutException(s + "SelectAdvancementTab");
-                WORLD_BORDER = NMSUtils.getNMSClassWithoutException(s + "WorldBorder");
-                CAMERA = NMSUtils.getNMSClassWithoutException(s + "Camera");
-                HELD_ITEM_SLOT = NMSUtils.getNMSClassWithoutException(s + "HeldItemSlot");
-                VIEW_CENTRE = NMSUtils.getNMSClassWithoutException(s + "ViewCentre");
-                VIEW_DISTANCE = NMSUtils.getNMSClassWithoutException(s + "ViewDistance");
-                SCOREBOARD_DISPLAY_OBJECTIVE = NMSUtils.getNMSClassWithoutException(s + "ScoreboardDisplayObjective");
-                ENTITY_METADATA = NMSUtils.getNMSClassWithoutException(s + "EntityMetadata");
-                ATTACH_ENTITY = NMSUtils.getNMSClassWithoutException(s + "AttachEntity");
-                ENTITY_VELOCITY = NMSUtils.getNMSClassWithoutException(s + "EntityVelocity");
-                ENTITY_EQUIPMENT = NMSUtils.getNMSClassWithoutException(s + "EntityEquipment");
-                EXPERIENCE = NMSUtils.getNMSClassWithoutException(s + "Experience");
-                UPDATE_HEALTH = NMSUtils.getNMSClassWithoutException(s + "UpdateHealth");
-                SCOREBOARD_OBJECTIVE = NMSUtils.getNMSClassWithoutException(s + "ScoreboardObjective");
-                MOUNT = NMSUtils.getNMSClassWithoutException(s + "Mount");
-                SCOREBOARD_TEAM = NMSUtils.getNMSClassWithoutException(s + "ScoreboardTeam");
-                SCOREBOARD_SCORE = NMSUtils.getNMSClassWithoutException(s + "ScoreboardScore");
-                SPAWN_POSITION = NMSUtils.getNMSClassWithoutException(s + "SpawnPosition");
-                UPDATE_TIME = NMSUtils.getNMSClassWithoutException(s + "UpdateTime");
-                TITLE = NMSUtils.getNMSClassWithoutException(s + "Title");
-                ENTITY_SOUND = NMSUtils.getNMSClassWithoutException(s + "EntitySound");
-                NAMED_SOUND_EFFECT = NMSUtils.getNMSClassWithoutException(s + "NamedSoundEffect");
-                STOP_SOUND = NMSUtils.getNMSClassWithoutException(s + "StopSound");
-                PLAYER_LIST_HEADER_FOOTER = NMSUtils.getNMSClassWithoutException(s + "PlayerListHeaderFooter");
-                NBT_QUERY = NMSUtils.getNMSClassWithoutException(s + "NBTQuery");
-                COLLECT = NMSUtils.getNMSClassWithoutException(s + "Collect");
-                ENTITY_TELEPORT = NMSUtils.getNMSClassWithoutException(s + "EntityTeleport");
-                ADVANCEMENTS = NMSUtils.getNMSClassWithoutException(s + "Advancements");
-                UPDATE_ATTRIBUTES = NMSUtils.getNMSClassWithoutException(s + "UpdateAttributes");
-                ENTITY_EFFECT = NMSUtils.getNMSClassWithoutException(s + "EntityEffect");
-                RECIPE_UPDATE = NMSUtils.getNMSClassWithoutException(s + "RecipeUpdate");
-                TAGS = NMSUtils.getNMSClassWithoutException(s + "Tags");
-                MAP_CHUNK_BULK = NMSUtils.getNMSClassWithoutException(s + "MapChunkBulk");
-                NAMED_ENTITY_SPAWN = NMSUtils.getNMSClassWithoutException(s + "NamedEntitySpawn");
             }
         }
     }
-
 }

src/main/java/io/github/retrooper/packetevents/packetwrappers/NMSPacket.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers;

src/main/java/io/github/retrooper/packetevents/packetwrappers/SendableWrapper.java

@@ -1,32 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.packetwrappers;
-
-/**
- * This interface indicates that a packet wrapper supports being sent to a client.
- */
-public interface SendableWrapper {
-    Object asNMSPacket();
-}

src/main/java/io/github/retrooper/packetevents/packetwrappers/WrappedPacket.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers;
@@ -28,31 +22,42 @@ import io.github.retrooper.packetevents.PacketEvents;
 import io.github.retrooper.packetevents.exceptions.WrapperFieldNotFoundException;
 import io.github.retrooper.packetevents.exceptions.WrapperUnsupportedUsageException;
 import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
+import io.github.retrooper.packetevents.packetwrappers.api.WrapperPacketReader;
+import io.github.retrooper.packetevents.packetwrappers.api.WrapperPacketWriter;
+import io.github.retrooper.packetevents.utils.ConditionalValue;
+import io.github.retrooper.packetevents.utils.MojangEitherUtil;
+import io.github.retrooper.packetevents.utils.enums.EnumUtil;
+import io.github.retrooper.packetevents.utils.nms.NMSUtils;
+import io.github.retrooper.packetevents.utils.player.GameMode;
 import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
 import io.github.retrooper.packetevents.utils.reflection.Reflection;
 import io.github.retrooper.packetevents.utils.server.ServerVersion;
+import io.github.retrooper.packetevents.utils.vector.Vector3i;
+import io.github.retrooper.packetevents.utils.world.Difficulty;
+import io.github.retrooper.packetevents.utils.world.Dimension;
+import org.bukkit.inventory.ItemStack;
+import org.jetbrains.annotations.Nullable;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;
 import java.lang.annotation.RetentionPolicy;
 import java.lang.annotation.Target;
 import java.lang.reflect.Field;
+import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.Arrays;
-import java.util.List;
-import java.util.Map;
+import java.util.*;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Supplier;
 import java.util.logging.Level;
 
 public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
-
     private static final Map<Class<? extends WrappedPacket>, Boolean> LOADED_WRAPPERS = new ConcurrentHashMap<>();
     private static final Map<Class<?>, Map<Class<?>, Field[]>> FIELD_CACHE = new ConcurrentHashMap<>();
     private static final Field[] EMPTY_FIELD_ARRAY = new Field[0];
+    private static byte isVersion_1_17 = -1;
     public static ServerVersion version;
-    private final Class<?> packetClass;
     protected final NMSPacket packet;
+    private final Class<?> packetClass;
 
     public WrappedPacket() {
         packet = null;
@@ -76,15 +81,15 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
     }
 
     private void load0() {
-        if (!isSupported()) {
-            throw new WrapperUnsupportedUsageException(getClass());
-        }
         final Class<? extends WrappedPacket> clazz = getClass();
         if (!LOADED_WRAPPERS.containsKey(clazz)) {
+            if (!isSupported()) {
+                throw new WrapperUnsupportedUsageException(getClass());
+            }
             try {
                 load();
             } catch (Exception ex) {
-                String wrapperName = ClassUtil.getClassSimpleName(getClass());
+                String wrapperName = ClassUtil.getClassSimpleName(clazz);
                 PacketEvents.get().getPlugin().getLogger()
                         .log(Level.SEVERE, "PacketEvents found an exception while loading the " + wrapperName + " packet wrapper. Please report this bug! Tell us about your server version, spigot and code(of you using the wrapper)", ex);
                 LOADED_WRAPPERS.put(clazz, false);
@@ -94,7 +99,6 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
     }
 
     protected void load() {
-
     }
 
     protected boolean hasLoaded() {
@@ -132,7 +136,7 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
         }
         StackTraceElement stackTraceElement = stackTraceElements[stackTraceElementIndex];
         String methodName = stackTraceElement.getMethodName();
-        List<Method> possibleMethods = Reflection.getMethods(getClass(), methodName, null);
+        List<Method> possibleMethods = Reflection.getMethods(getClass(), methodName, (Class<?>) null);
         Method method = null;
         for (Method m : possibleMethods) {
             if (m.isAnnotationPresent(SupportedVersions.class)) {
@@ -281,14 +285,15 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
 
     @SuppressWarnings("unchecked")
     public <T> T read(int index, Class<? extends T> type) {
-        Field field = getField(type, index);
         try {
+            Field field = getField(type, index);
             return (T) field.get(packet.getRawNMSPacket());
         } catch (IllegalAccessException | NullPointerException | ArrayIndexOutOfBoundsException e) {
             throw new WrapperFieldNotFoundException(packetClass, type, index);
         }
     }
 
+
     @Override
     public void writeBoolean(int index, boolean value) {
         write(boolean.class, index, value);
@@ -378,6 +383,9 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
     public void writeAnyObject(int index, Object value) {
         try {
             Field f = packetClass.getDeclaredFields()[index];
+            if (!f.isAccessible()) {
+                f.setAccessible(true);
+            }
             f.set(packet.getRawNMSPacket(), value);
         } catch (Exception e) {
             throw new WrapperFieldNotFoundException("PacketEvents failed to find any field indexed " + index + " in the " + ClassUtil.getClassSimpleName(packetClass) + " class!");
@@ -386,12 +394,15 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
 
     @Override
     public void writeEnumConstant(int index, Enum<?> enumConstant) {
-        write(enumConstant.getClass(), index, enumConstant);
+        try {
+            write(enumConstant.getClass(), index, enumConstant);
+        } catch (WrapperFieldNotFoundException ex) {
+            write(enumConstant.getDeclaringClass(), index, enumConstant);
+        }
     }
 
     public void write(Class<?> type, int index, Object value) throws WrapperFieldNotFoundException {
         Field field = getField(type, index);
-        //Reflection.getFieldWithoutFinalModifier(field);
         if (field == null) {
             throw new WrapperFieldNotFoundException(packetClass, type, index);
         }
@@ -402,6 +413,166 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
         }
     }
 
+    public Vector3i readBlockPosition(int index) {
+        Object blockPosObj = readObject(index, NMSUtils.blockPosClass);
+        try {
+            int x, y, z;
+            if (version.isNewerThanOrEquals(ServerVersion.v_1_20_5)) {
+                x = (int) NMSUtils.getBaseBlockPosX.get(blockPosObj);
+                y = (int) NMSUtils.getBaseBlockPosY.get(blockPosObj);
+                z = (int) NMSUtils.getBaseBlockPosZ.get(blockPosObj);
+            }
+            else {
+                x = (int) NMSUtils.getBlockPosX.invoke(blockPosObj);
+                y = (int) NMSUtils.getBlockPosY.invoke(blockPosObj);
+                z = (int) NMSUtils.getBlockPosZ.invoke(blockPosObj);
+            }
+            return new Vector3i(x, y, z);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public Vector3i readSectionPosition(int index) {
+        Object blockPosObj = readObject(index, NMSUtils.sectionPositionClass);
+        try {
+            int x = (Integer) NMSUtils.getBlockPosX.invoke(blockPosObj);
+            int y = (Integer) NMSUtils.getBlockPosY.invoke(blockPosObj);
+            int z = (Integer) NMSUtils.getBlockPosZ.invoke(blockPosObj);
+            return new Vector3i(x, y, z);
+        } catch (IllegalAccessException | InvocationTargetException e) {
+            e.printStackTrace();
+            return null;
+        }
+    }
+
+    public void writeBlockPosition(int index, Vector3i blockPosition) {
+        Object blockPosObj = NMSUtils.generateNMSBlockPos(blockPosition);
+        write(NMSUtils.blockPosClass, index, blockPosObj);
+    }
+
+    public ItemStack readItemStack(int index) {
+        Object nmsItemStack = readObject(index, NMSUtils.nmsItemStackClass);
+        return NMSUtils.toBukkitItemStack(nmsItemStack);
+    }
+
+    public void writeItemStack(int index, ItemStack stack) {
+        Object nmsItemStack = NMSUtils.toNMSItemStack(stack);
+        write(NMSUtils.nmsItemStackClass, index, nmsItemStack);
+    }
+
+    @Nullable
+    public GameMode readGameMode(int index) {
+        Enum<?> enumConst = readEnumConstant(index, NMSUtils.enumGameModeClass);
+        int targetIndex = enumConst.ordinal() - 1;
+        if (targetIndex == -1) {
+            return null;
+        }
+        return GameMode.values()[targetIndex];
+    }
+
+    public void writeGameMode(int index, @Nullable GameMode gameMode) {
+        int i = gameMode != null ? (gameMode.ordinal() + 1) : (0);
+        Enum<?> enumConst = EnumUtil.valueByIndex(NMSUtils.enumGameModeClass, i);
+        writeEnumConstant(index, enumConst);
+    }
+
+    public Dimension readDimension(int index, int dimensionIDLegacyIndex) {
+        int dimensionID;
+        if (version.isOlderThan(ServerVersion.v_1_13_2)) {
+            dimensionID = readInt(dimensionIDLegacyIndex);
+        } else {
+            Object dimensionManagerObject = readObject(index, NMSUtils.dimensionManagerClass);
+            WrappedPacket dimensionManagerWrapper = new WrappedPacket(new NMSPacket(dimensionManagerObject));
+            dimensionID = dimensionManagerWrapper.readInt(0) - 1;
+        }
+        return Dimension.getById(dimensionID);
+    }
+
+    public void writeDimension(int index, int dimensionIDLegacyIndex, Dimension dimension) {
+        if (version.isOlderThan(ServerVersion.v_1_13_2)) {
+            writeInt(dimensionIDLegacyIndex, dimension.getId());
+        } else {
+            Object dimensionManagerObject = readObject(index, NMSUtils.dimensionManagerClass);
+            WrappedPacket dimensionManagerWrapper = new WrappedPacket(new NMSPacket(dimensionManagerObject));
+            dimensionManagerWrapper.writeInt(0, dimension.getId() + 1);
+        }
+    }
+
+
+    public Difficulty readDifficulty(int index) {
+        Enum<?> enumConstant = readEnumConstant(index, NMSUtils.enumDifficultyClass);
+        return Difficulty.values()[enumConstant.ordinal()];
+    }
+
+    public void writeDifficulty(int index, Difficulty difficulty) {
+        Enum<?> enumConstant = EnumUtil.valueByIndex(NMSUtils.enumDifficultyClass, difficulty.ordinal());
+        writeEnumConstant(index, enumConstant);
+    }
+
+    public String readIChatBaseComponent(int index) {
+        Object iChatBaseComponent = readObject(index, NMSUtils.iChatBaseComponentClass);
+        return NMSUtils.readIChatBaseComponent(iChatBaseComponent);
+    }
+
+    public void writeIChatBaseComponent(int index, String content) {
+        Object iChatBaseComponent = NMSUtils.generateIChatBaseComponent(content);
+        write(NMSUtils.iChatBaseComponentClass, index, iChatBaseComponent);
+    }
+
+    public String readMinecraftKey(int index) {
+        if (isVersion_1_17 == -1) {
+            isVersion_1_17 = (byte) (version.isNewerThanOrEquals(ServerVersion.v_1_17) ? 1 : 0);
+        }
+        int namespaceIndex = isVersion_1_17 == 1 ? 2 : 0;
+        int keyIndex = isVersion_1_17 == 1 ? 3 : 1;
+        Object minecraftKey = readObject(index, NMSUtils.minecraftKeyClass);
+        WrappedPacket minecraftKeyWrapper = new WrappedPacket(new NMSPacket(minecraftKey));
+        return minecraftKeyWrapper.readString(namespaceIndex) + ":" + minecraftKeyWrapper.readString(keyIndex);
+    }
+
+    public void writeMinecraftKey(int index, String content) {
+        Object minecraftKey = NMSUtils.generateMinecraftKeyNew(content);
+        write(NMSUtils.minecraftKeyClass, index, minecraftKey);
+    }
+
+    public List<Object> readList(int index) {
+        return read(index, List.class);
+    }
+
+    public void writeList(int index, List<Object> list) {
+        write(List.class, index, list);
+    }
+
+    public <T, K> ConditionalValue<T, K> readEither(int index) {
+        Object either = readObject(index, NMSUtils.mojangEitherClass);
+        Optional<T> left = MojangEitherUtil.getLeft(either);
+        if (left.isPresent()) {
+            return ConditionalValue.makeLeft(left.get());
+        }
+        else {
+            Optional<K> right = MojangEitherUtil.getRight(either);
+            try {
+                return ConditionalValue.makeRight(right.orElseThrow((Supplier<Throwable>) () -> new IllegalStateException("Conditional value has no values. Atleast one side must have a value!")));
+            } catch (Throwable e) {
+                e.printStackTrace();
+            }
+        }
+        return null;
+    }
+
+    public <T, K> void writeEither(int index, ConditionalValue<T, K> conditionalValue) {
+        Object either;
+        if (conditionalValue.left().isPresent()) {
+            either = MojangEitherUtil.makeLeft(conditionalValue.left().get());
+        }
+        else {
+            either = MojangEitherUtil.makeRight(conditionalValue.right().get());
+        }
+        write(NMSUtils.mojangEitherClass, index, either);
+    }
+
     private Field getField(Class<?> type, int index) {
         Map<Class<?>, Field[]> cached = FIELD_CACHE.computeIfAbsent(packetClass, k -> new ConcurrentHashMap<>());
         Field[] fields = cached.computeIfAbsent(type, typeClass -> getFields(typeClass, packetClass.getDeclaredFields()));

src/main/java/io/github/retrooper/packetevents/packetwrappers/WrapperPacketReader.java

@@ -1,66 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.packetwrappers;
-
-public interface WrapperPacketReader {
-
-    boolean readBoolean(int index);
-
-    byte readByte(int index);
-
-    short readShort(int index);
-
-    int readInt(int index);
-
-    long readLong(int index);
-
-    float readFloat(int index);
-
-    double readDouble(int index);
-
-    boolean[] readBooleanArray(int index);
-
-    byte[] readByteArray(int index);
-
-    short[] readShortArray(int index);
-
-    int[] readIntArray(int index);
-
-    long[] readLongArray(int index);
-
-    float[] readFloatArray(int index);
-
-    double[] readDoubleArray(int index);
-
-    String[] readStringArray(int index);
-
-    String readString(int index);
-
-    <T> T readObject(int index, Class<? extends T> type);
-
-    Enum<?> readEnumConstant(int index, Class<? extends Enum<?>> type);
-
-    Object readAnyObject(int index);
-}

src/main/java/io/github/retrooper/packetevents/packetwrappers/WrapperPacketWriter.java

@@ -1,66 +0,0 @@
-/*
- * MIT License
- *
- * Copyright (c) 2020 retrooper
- *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
- */
-
-package io.github.retrooper.packetevents.packetwrappers;
-
-public interface WrapperPacketWriter {
-    void writeBoolean(int index, boolean value);
-
-    void writeByte(int index, byte value);
-
-    void writeShort(int index, short value);
-
-    void writeInt(int index, int value);
-
-    void writeLong(int index, long value);
-
-    void writeFloat(int index, float value);
-
-    void writeDouble(int index, double value);
-
-    void writeString(int index, String value);
-
-    //ARRAYS
-    void writeBooleanArray(int index, boolean[] array);
-
-    void writeByteArray(int index, byte[] value);
-
-    void writeShortArray(int index, short[] value);
-
-    void writeIntArray(int index, int[] value);
-
-    void writeLongArray(int index, long[] value);
-
-    void writeFloatArray(int index, float[] value);
-
-    void writeDoubleArray(int index, double[] value);
-
-    void writeStringArray(int index, String[] value);
-
-    void writeObject(int index, Object object);
-
-    void writeAnyObject(int index, Object value);
-
-    void writeEnumConstant(int index, Enum<?> enumConstant);
-}

src/main/java/io/github/retrooper/packetevents/packetwrappers/api/SendableWrapper.java

@@ -0,0 +1,29 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.packetwrappers.api;
+
+/**
+ * Packet-Wrappers that can be sent to clients.
+ *
+ * @author retrooper
+ * //TODO since javadoc annotation
+ */
+public interface SendableWrapper {
+    Object asNMSPacket() throws Exception;
+}

src/main/java/io/github/retrooper/packetevents/packetwrappers/api/WrapperPacketReader.java

@@ -0,0 +1,60 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.packetwrappers.api;
+
+public interface WrapperPacketReader {
+
+    boolean readBoolean(int index);
+
+    byte readByte(int index);
+
+    short readShort(int index);
+
+    int readInt(int index);
+
+    long readLong(int index);
+
+    float readFloat(int index);
+
+    double readDouble(int index);
+
+    boolean[] readBooleanArray(int index);
+
+    byte[] readByteArray(int index);
+
+    short[] readShortArray(int index);
+
+    int[] readIntArray(int index);
+
+    long[] readLongArray(int index);
+
+    float[] readFloatArray(int index);
+
+    double[] readDoubleArray(int index);
+
+    String[] readStringArray(int index);
+
+    String readString(int index);
+
+    <T> T readObject(int index, Class<? extends T> type);
+
+    Enum<?> readEnumConstant(int index, Class<? extends Enum<?>> type);
+
+    Object readAnyObject(int index);
+}

src/main/java/io/github/retrooper/packetevents/packetwrappers/api/WrapperPacketWriter.java

@@ -0,0 +1,60 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.packetwrappers.api;
+
+public interface WrapperPacketWriter {
+    void writeBoolean(int index, boolean value);
+
+    void writeByte(int index, byte value);
+
+    void writeShort(int index, short value);
+
+    void writeInt(int index, int value);
+
+    void writeLong(int index, long value);
+
+    void writeFloat(int index, float value);
+
+    void writeDouble(int index, double value);
+
+    void writeString(int index, String value);
+
+    //ARRAYS
+    void writeBooleanArray(int index, boolean[] array);
+
+    void writeByteArray(int index, byte[] value);
+
+    void writeShortArray(int index, short[] value);
+
+    void writeIntArray(int index, int[] value);
+
+    void writeLongArray(int index, long[] value);
+
+    void writeFloatArray(int index, float[] value);
+
+    void writeDoubleArray(int index, double[] value);
+
+    void writeStringArray(int index, String[] value);
+
+    void writeObject(int index, Object object);
+
+    void writeAnyObject(int index, Object value);
+
+    void writeEnumConstant(int index, Enum<?> enumConstant);
+}

src/main/java/io/github/retrooper/packetevents/packetwrappers/api/helper/WrappedPacketEntityAbstraction.java

@@ -0,0 +1,91 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.packetwrappers.api.helper;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
+import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.utils.nms.NMSUtils;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+public abstract class WrappedPacketEntityAbstraction extends WrappedPacket {
+    private final int entityIDFieldIndex;
+    protected Entity entity;
+    protected int entityID = -1;
+
+    public WrappedPacketEntityAbstraction(NMSPacket packet, int entityIDFieldIndex) {
+        super(packet);
+        this.entityIDFieldIndex = entityIDFieldIndex;
+    }
+
+    public WrappedPacketEntityAbstraction(NMSPacket packet) {
+        super(packet);
+        this.entityIDFieldIndex = 0;
+    }
+
+    public WrappedPacketEntityAbstraction(int entityIDFieldIndex) {
+        super();
+        this.entityIDFieldIndex = entityIDFieldIndex;
+    }
+
+    public WrappedPacketEntityAbstraction() {
+        super();
+        this.entityIDFieldIndex = 0;
+    }
+
+    public int getEntityId() {
+        if (entityID != -1 || packet == null) {
+            return entityID;
+        }
+        return entityID = readInt(entityIDFieldIndex);
+    }
+
+    public void setEntityId(int entityID) {
+        if (packet != null) {
+            writeInt(entityIDFieldIndex, this.entityID = entityID);
+        } else {
+            this.entityID = entityID;
+        }
+        this.entity = null;
+    }
+
+    @Nullable
+    public Entity getEntity(@Nullable World world) {
+        if (entity != null) {
+            return entity;
+        }
+        return PacketEvents.get().getServerUtils().getEntityById(world, getEntityId());
+    }
+
+    @Nullable
+    public Entity getEntity() {
+        if (entity != null) {
+            return entity;
+        }
+        return PacketEvents.get().getServerUtils().getEntityById(getEntityId());
+    }
+
+    public void setEntity(@NotNull Entity entity) {
+        setEntityId(entity.getEntityId());
+        this.entity = entity;
+    }
+}

src/main/java/io/github/retrooper/packetevents/packetwrappers/handshaking/setprotocol/WrappedPacketHandshakingInSetProtocol.java

@@ -1,52 +1,52 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.handshaking.setprotocol;
 
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.utils.server.ServerVersion;
 
 public class WrappedPacketHandshakingInSetProtocol extends WrappedPacket {
-
+    private static boolean between_V_1_17_And_1_20_1;
     public WrappedPacketHandshakingInSetProtocol(NMSPacket packet) {
         super(packet);
     }
 
+    @Override
+    protected void load() {
+        between_V_1_17_And_1_20_1 = version.isNewerThanOrEquals(ServerVersion.v_1_17) && version.isOlderThan(ServerVersion.v_1_20_2);
+    }
+
     public int getProtocolVersion() {
-        return readInt(0);
+        return readInt(between_V_1_17_And_1_20_1 ? 1 : 0);
     }
 
     public void setProtocolVersion(int protocolVersion) {
-        writeInt(0, protocolVersion);
+        writeInt(between_V_1_17_And_1_20_1 ? 1 : 0, protocolVersion);
     }
 
     public int getPort() {
-        return readInt(1);
+        return readInt(between_V_1_17_And_1_20_1 ? 2 : 1);
     }
 
     public void setPort(int port) {
-        writeInt(1, port);
+        writeInt(between_V_1_17_And_1_20_1 ? 2 : 1, port);
     }
 
     public String getHostName() {

src/main/java/io/github/retrooper/packetevents/packetwrappers/login/in/custompayload/WrappedPacketLoginInCustomPayload.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.login.in.custompayload;
@@ -31,42 +25,44 @@ import io.github.retrooper.packetevents.utils.nms.NMSUtils;
 import io.github.retrooper.packetevents.utils.server.ServerVersion;
 
 public class WrappedPacketLoginInCustomPayload extends WrappedPacket {
-    private static Class<?> byteBufClass;
-    private static Class<?> packetDataSerializerClass;
-
+    private static boolean v_1_17;
     public WrappedPacketLoginInCustomPayload(NMSPacket packet) {
         super(packet);
     }
 
     @Override
     protected void load() {
-        packetDataSerializerClass = NMSUtils.getNMSClassWithoutException("PacketDataSerializer");
-        try {
-            byteBufClass = NMSUtils.getNettyClass("buffer.ByteBuf");
-        } catch (ClassNotFoundException ignored) {
-        }
+        v_1_17 = version.isNewerThanOrEquals(ServerVersion.v_1_17);
     }
 
     public int getMessageId() {
-        return readInt(0);
+        return readInt(v_1_17 ? 1 : 0);
     }
 
     public void setMessageId(int id) {
-        writeInt(0, id);
+        writeInt(v_1_17 ? 1 : 0, id);
     }
 
     public byte[] getData() {
-        Object dataSerializer = readObject(0, packetDataSerializerClass);
-        WrappedPacket byteBufWrapper = new WrappedPacket(new NMSPacket(dataSerializer));
-        Object byteBuf = byteBufWrapper.readObject(0, byteBufClass);
-        return PacketEvents.get().getByteBufUtil().getBytes(byteBuf);
+        return PacketEvents.get().getByteBufUtil().getBytes(getBuffer());
     }
 
     public void setData(byte[] data) {
-        Object dataSerializer = readObject(0, packetDataSerializerClass);
-        WrappedPacket dataSerializerWrapper = new WrappedPacket(new NMSPacket(dataSerializer));
-        Object byteBuf = dataSerializerWrapper.readObject(0, byteBufClass);
-        PacketEvents.get().getByteBufUtil().setBytes(byteBuf, data);
+        PacketEvents.get().getByteBufUtil().setBytes(getBuffer(), data);
+    }
+
+    private Object getBuffer() {
+        Object dataSerializer = readObject(0, NMSUtils.packetDataSerializerClass);
+        WrappedPacket byteBufWrapper = new WrappedPacket(new NMSPacket(dataSerializer));
+        return byteBufWrapper.readObject(0, NMSUtils.byteBufClass);
+    }
+
+    public void retain() {
+        PacketEvents.get().getByteBufUtil().retain(getBuffer());
+    }
+
+    public void release() {
+        PacketEvents.get().getByteBufUtil().release(getBuffer());
     }
 
     @Override

src/main/java/io/github/retrooper/packetevents/packetwrappers/login/in/encryptionbegin/WrappedPacketLoginInEncryptionBegin.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.login.in.encryptionbegin;
@@ -27,12 +21,38 @@ package io.github.retrooper.packetevents.packetwrappers.login.in.encryptionbegin
 import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.utils.ConditionalValue;
+import io.github.retrooper.packetevents.utils.MojangEitherUtil;
+import io.github.retrooper.packetevents.utils.SaltSignature;
+import io.github.retrooper.packetevents.utils.nms.NMSUtils;
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
+import io.github.retrooper.packetevents.utils.reflection.Reflection;
+import io.github.retrooper.packetevents.utils.reflection.SubclassUtil;
+import io.github.retrooper.packetevents.utils.server.ServerVersion;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
 
 public class WrappedPacketLoginInEncryptionBegin extends WrappedPacket {
+    private static Class<?> VANILLA_SALT_SIGNATURE_CLASS;
+    private static Constructor<?> VANILLA_SALT_SIGNATURE_CONSTRUCTOR;
     public WrappedPacketLoginInEncryptionBegin(NMSPacket packet) {
         super(packet);
     }
 
+    @Override
+    protected void load() {
+        Class<?> minecraftEncryptionClass = Reflection.getClassByNameWithoutException("net.minecraft.util.MinecraftEncryption");
+        if (minecraftEncryptionClass != null) {
+            VANILLA_SALT_SIGNATURE_CLASS = SubclassUtil.getSubClass(minecraftEncryptionClass, "b");
+            try {
+                VANILLA_SALT_SIGNATURE_CONSTRUCTOR = VANILLA_SALT_SIGNATURE_CLASS.getConstructor(long.class, byte[].class);
+            } catch (NoSuchMethodException e) {
+                e.printStackTrace();
+            }
+        }
+    }
+
     public byte[] getPublicKey() {
         return readByteArray(0);
     }
@@ -41,12 +61,46 @@ public class WrappedPacketLoginInEncryptionBegin extends WrappedPacket {
         writeByteArray(0, key);
     }
 
-    public byte[] getVerifyToken() {
-        return readByteArray(1);
+
+    public ConditionalValue<byte[], SaltSignature> getVerifyTokenOrSaltSignature() {
+        if (version.isNewerThanOrEquals(ServerVersion.v_1_19)) {
+            ConditionalValue<byte[], Object> rawEither = readEither(0);
+            if (rawEither.left().isPresent()) {
+                return ConditionalValue.makeLeft(rawEither.left().get());
+            }
+            else {
+                Object rawRight = rawEither.right().get();
+                WrappedPacket rawRightWrapper = new WrappedPacket(new NMSPacket(rawRight));
+                SaltSignature ss = new SaltSignature(rawRightWrapper.readLong(0), rawRightWrapper.readByteArray(0));
+                return ConditionalValue.makeRight(ss);
+            }
+        }
+        else {
+            return ConditionalValue.makeLeft(readByteArray(1));
+        }
     }
 
-    public void setVerifyToken(byte[] token) {
-        writeByteArray(1, token);
+    public void setVerifyTokenOrSaltSignature(ConditionalValue<byte[], SaltSignature> value) {
+        if (version.isNewerThanOrEquals(ServerVersion.v_1_19)) {
+            Object either;
+            if (value.left().isPresent()) {
+                either = MojangEitherUtil.makeLeft(value.left().get());
+            }
+            else {
+                SaltSignature ss = value.right().get();
+                Object rawSS = null;
+                try {
+                    rawSS = VANILLA_SALT_SIGNATURE_CONSTRUCTOR.newInstance(ss.getSalt(), ss.getSignature());
+                } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+                    e.printStackTrace();
+                }
+                either = MojangEitherUtil.makeRight(rawSS);
+            }
+            write(NMSUtils.mojangEitherClass, 0, either);
+        }
+        else {
+            writeByteArray(1, value.left().get());
+        }
     }
 
     @Override

src/main/java/io/github/retrooper/packetevents/packetwrappers/login/in/start/WrappedPacketLoginInStart.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.login.in.start;
@@ -30,19 +24,71 @@ import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
 import io.github.retrooper.packetevents.utils.gameprofile.GameProfileUtil;
 import io.github.retrooper.packetevents.utils.gameprofile.WrappedGameProfile;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
+import io.github.retrooper.packetevents.utils.server.ServerVersion;
+import org.jetbrains.annotations.Nullable;
 
+import java.util.Optional;
+import java.util.UUID;
+
+// TODO: This wrapper needs Signature data @retrooper
 public class WrappedPacketLoginInStart extends WrappedPacket {
     public WrappedPacketLoginInStart(NMSPacket packet) {
         super(packet);
     }
 
-    public WrappedGameProfile getGameProfile() {
-        return GameProfileUtil.getWrappedGameProfile(readObject(0, NMSUtils.gameProfileClass));
+    //TODO Allow accessing game profile property
+    public Optional<WrappedGameProfile> getGameProfile() {
+        if (version.isNewerThanOrEquals(ServerVersion.v_1_19)) {
+            return Optional.empty();
+        }
+        return Optional.of(GameProfileUtil.getWrappedGameProfile(readObject(0, NMSUtils.gameProfileClass)));
     }
 
+    //TODO Add support for game profile property
     public void setGameProfile(WrappedGameProfile wrappedGameProfile) {
-        Object gameProfile = GameProfileUtil.getGameProfile(wrappedGameProfile.getId(), wrappedGameProfile.getName());
-        write(NMSUtils.gameProfileClass, 0, gameProfile);
+        if (version.isNewerThanOrEquals(ServerVersion.v_1_19)) {
+            writeString(0, wrappedGameProfile.getName());
+        }
+        else {
+            Object gameProfile = GameProfileUtil.getGameProfile(wrappedGameProfile.getId(), wrappedGameProfile.getName());
+            write(NMSUtils.gameProfileClass, 0, gameProfile);
+        }
+    }
+
+    public String getUsername() {
+        if (version.isNewerThanOrEquals(ServerVersion.v_1_19)) {
+            return readString(0);
+        }
+        else {
+            return GameProfileUtil.getWrappedGameProfile(readObject(0, NMSUtils.gameProfileClass)).getName();
+        }
+    }
+
+    public void setUsername(String username) throws IllegalAccessException {
+        if (version.isNewerThanOrEquals(ServerVersion.v_1_19)) {
+            writeString(0, username);
+        }
+        else {
+            throw new IllegalAccessException("Please use the setGameProfile method in the WrappedPacketLoginInStart wrapper to change the username!");
+        }
+    }
+
+    public @Nullable UUID getPlayerUUID() {
+        if (version.isNewerThanOrEquals(ServerVersion.v_1_19_1)) {
+            return readObject(0, UUID.class);
+        }
+        else {
+            return GameProfileUtil.getWrappedGameProfile(readObject(0, NMSUtils.gameProfileClass)).getId();
+        }
+    }
+
+    public void setPlayerUUID(UUID playerUUID) throws IllegalAccessException {
+        if (version.isNewerThanOrEquals(ServerVersion.v_1_19_1)) {
+            writeObject(0, playerUUID);
+        }
+        else {
+            throw new IllegalAccessException("Please use the setGameProfile method in the WrappedPacketLoginInStart wrapper to change the uuid!");
+        }
     }
 
     @Override

src/main/java/io/github/retrooper/packetevents/packetwrappers/login/out/custompayload/WrappedPacketLoginOutCustomPayload.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.login.out.custompayload;
@@ -27,18 +21,17 @@ package io.github.retrooper.packetevents.packetwrappers.login.out.custompayload;
 import io.github.retrooper.packetevents.PacketEvents;
 import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
-import io.github.retrooper.packetevents.packetwrappers.SendableWrapper;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.packetwrappers.api.SendableWrapper;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
+import io.github.retrooper.packetevents.utils.server.ServerVersion;
 
 import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
 
 public class WrappedPacketLoginOutCustomPayload extends WrappedPacket implements SendableWrapper {
+    private static boolean v_1_17;
     private static Constructor<?> constructor;
     private static Constructor<?> packetDataSerializerConstructor;
-    private static Class<?> byteBufClass;
-    private static Class<?> packetDataSerializerClass;
     private int messageID;
     private String channelName;
     private byte[] data;
@@ -47,27 +40,27 @@ public class WrappedPacketLoginOutCustomPayload extends WrappedPacket implements
         super(packet);
     }
 
+    public WrappedPacketLoginOutCustomPayload(int messageID, String channelName, byte[] data) {
+        this.messageID = messageID;
+        this.channelName = channelName;
+        this.data = data;
+    }
+
     @Override
     protected void load() {
+        v_1_17 = version.isNewerThanOrEquals(ServerVersion.v_1_17);
         Class<?> packetClass = PacketTypeClasses.Login.Server.CUSTOM_PAYLOAD;
         if (packetClass != null) {
-            packetDataSerializerClass = NMSUtils.getNMSClassWithoutException("PacketDataSerializer");
             try {
-                byteBufClass = NMSUtils.getNettyClass("buffer.ByteBuf");
-            } catch (ClassNotFoundException ex) {
-                ex.printStackTrace();
-            }
-
-            try {
-                if (packetDataSerializerClass != null) {
-                    packetDataSerializerConstructor = packetDataSerializerClass.getConstructor(byteBufClass);
+                if (NMSUtils.packetDataSerializerClass != null) {
+                    packetDataSerializerConstructor = NMSUtils.packetDataSerializerClass.getConstructor(NMSUtils.byteBufClass);
                 }
             } catch (NoSuchMethodException e) {
                 e.printStackTrace();
             }
 
             try {
-                constructor = packetClass.getConstructor();
+                constructor = packetClass.getConstructor(int.class, NMSUtils.minecraftKeyClass, NMSUtils.packetDataSerializerClass);
             } catch (NoSuchMethodException e3) {
                 throw new IllegalStateException("PacketEvents is unable to resolve the PacketPlayOutCustomPayload constructor.");
             }
@@ -76,14 +69,14 @@ public class WrappedPacketLoginOutCustomPayload extends WrappedPacket implements
 
     public int getMessageId() {
         if (packet != null) {
-            return readInt(0);
+            return readInt(v_1_17 ? 1 : 0);
         }
         return messageID;
     }
 
     public void setMessageId(int messageID) {
         if (packet != null) {
-            writeInt(0, messageID);
+            writeInt(v_1_17 ? 1 : 0, messageID);
         } else {
             this.messageID = messageID;
         }
@@ -91,16 +84,16 @@ public class WrappedPacketLoginOutCustomPayload extends WrappedPacket implements
 
     public String getChannelName() {
         if (packet != null) {
-            Object minecraftKey = readObject(0, NMSUtils.minecraftKeyClass);
-            return NMSUtils.getStringFromMinecraftKey(minecraftKey);
+           return readMinecraftKey(0);
+        }
+        else {
+            return channelName;
         }
-        return channelName;
     }
 
     public void setChannelName(String channelName) {
         if (packet != null) {
-            Object minecraftKey = NMSUtils.generateMinecraftKey(channelName);
-            writeObject(0, minecraftKey);
+            writeMinecraftKey(0, channelName);
         } else {
             this.channelName = channelName;
         }
@@ -108,37 +101,35 @@ public class WrappedPacketLoginOutCustomPayload extends WrappedPacket implements
 
     public byte[] getData() {
         if (packet != null) {
-            Object dataSerializer = readObject(0, packetDataSerializerClass);
+            Object dataSerializer = readObject(0, NMSUtils.packetDataSerializerClass);
             WrappedPacket byteBufWrapper = new WrappedPacket(new NMSPacket(dataSerializer));
-            Object byteBuf = byteBufWrapper.readObject(0, byteBufClass);
+            Object byteBuf = byteBufWrapper.readObject(0, NMSUtils.byteBufClass);
             return PacketEvents.get().getByteBufUtil().getBytes(byteBuf);
+        } else {
+            return data;
         }
-        return data;
     }
 
     public void setData(byte[] data) {
-        Object dataSerializer = readObject(0, packetDataSerializerClass);
-        WrappedPacket dataSerializerWrapper = new WrappedPacket(new NMSPacket(dataSerializer));
-        Object byteBuf = dataSerializerWrapper.readObject(0, byteBufClass);
-        PacketEvents.get().getByteBufUtil().setBytes(byteBuf, data);
+        if (packet != null) {
+            PacketEvents.get().getByteBufUtil().setBytes(getBuffer(), data);
+        } else {
+            this.data = data;
+        }
+    }
+
+    private Object getBuffer() {
+        Object dataSerializer = readObject(0, NMSUtils.packetDataSerializerClass);
+        WrappedPacket byteBufWrapper = new WrappedPacket(new NMSPacket(dataSerializer));
+        return byteBufWrapper.readObject(0, NMSUtils.byteBufClass);
     }
 
     @Override
-    public Object asNMSPacket() {
-        Object byteBufObject = PacketEvents.get().getByteBufUtil().wrappedBuffer(data);
-        try {
-            Object minecraftKey = NMSUtils.generateMinecraftKey(channelName);
-            Object dataSerializer = packetDataSerializerConstructor.newInstance(byteBufObject);
-            Object packetInstance = constructor.newInstance();
-            WrappedPacket packetWrapper = new WrappedPacket(new NMSPacket(packetInstance));
-            packetWrapper.writeInt(0, messageID);
-            packetWrapper.writeObject(0, minecraftKey);
-            packetWrapper.writeObject(0, dataSerializer);
-            return packetInstance;
-        } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        return null;
+    public Object asNMSPacket() throws Exception {
+        Object byteBufObject = PacketEvents.get().getByteBufUtil().newByteBuf(data);
+        Object minecraftKey = NMSUtils.generateMinecraftKeyNew(channelName);
+        Object dataSerializer = packetDataSerializerConstructor.newInstance(byteBufObject);
+        return constructor.newInstance(getMessageId(), minecraftKey, dataSerializer);
     }
 
     @Override

src/main/java/io/github/retrooper/packetevents/packetwrappers/login/out/disconnect/WrappedPacketLoginOutDisconnect.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.login.out.disconnect;
@@ -27,21 +21,51 @@ package io.github.retrooper.packetevents.packetwrappers.login.out.disconnect;
 import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.packetwrappers.api.SendableWrapper;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
 
-public class WrappedPacketLoginOutDisconnect extends WrappedPacket {
+import java.lang.reflect.Constructor;
+
+public class WrappedPacketLoginOutDisconnect extends WrappedPacket implements SendableWrapper {
+    private static Constructor<?> packetConstructor;
+    private String reason;
+
     public WrappedPacketLoginOutDisconnect(NMSPacket packet) {
         super(packet);
     }
 
-    public String getReason() {
-        Object iChatBaseComponent = readObject(0, NMSUtils.iChatBaseComponentClass);
-        return NMSUtils.readIChatBaseComponent(iChatBaseComponent);
+    public WrappedPacketLoginOutDisconnect(String reason) {
+        this.reason = reason;
     }
 
-    public void setReason(String reason) {
-        Object iChatBaseComponent = NMSUtils.generateIChatBaseComponent(reason);
-        writeObject(0, iChatBaseComponent);
+    @Override
+    protected void load() {
+        try {
+            packetConstructor = PacketTypeClasses.Login.Server.DISCONNECT.getConstructor(NMSUtils.iChatBaseComponentClass);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public String getReason() {
+        if (packet != null) {
+            return readIChatBaseComponent(0);
+        } else {
+            return this.reason;
+        }
+    }
+
+    public void setReason(final String reason) {
+        if (packet != null) {
+            writeIChatBaseComponent(0, reason);
+        } else {
+            this.reason = reason;
+        }
+    }
+
+    @Override
+    public Object asNMSPacket() throws Exception {
+        return packetConstructor.newInstance(NMSUtils.generateIChatBaseComponent(getReason()));
     }
 
     @Override

src/main/java/io/github/retrooper/packetevents/packetwrappers/login/out/encryptionbegin/WrappedPacketLoginOutEncryptionBegin.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.login.out.encryptionbegin;
@@ -27,14 +21,24 @@ package io.github.retrooper.packetevents.packetwrappers.login.out.encryptionbegi
 import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.utils.server.ServerVersion;
 
+import java.security.KeyFactory;
 import java.security.PublicKey;
+import java.security.spec.EncodedKeySpec;
+import java.security.spec.X509EncodedKeySpec;
 
 public class WrappedPacketLoginOutEncryptionBegin extends WrappedPacket {
+    private static boolean v_1_17;
     public WrappedPacketLoginOutEncryptionBegin(NMSPacket packet) {
         super(packet);
     }
 
+    @Override
+    protected void load() {
+        v_1_17 = version.isNewerThanOrEquals(ServerVersion.v_1_17);
+    }
+
     public String getEncodedString() {
         return readString(0);
     }
@@ -44,19 +48,34 @@ public class WrappedPacketLoginOutEncryptionBegin extends WrappedPacket {
     }
 
     public PublicKey getPublicKey() {
-        return readObject(1, PublicKey.class);
+        return v_1_17 ? encrypt(readByteArray(0)) : readObject(0, PublicKey.class);
     }
 
     public void setPublicKey(PublicKey key) {
-        writeObject(0, key);
+        if (v_1_17) {
+            writeByteArray(0, key.getEncoded());
+        } else {
+            writeObject(0, key);
+        }
     }
 
     public byte[] getVerifyToken() {
-        return readByteArray(0);
+        return readByteArray(v_1_17 ? 1 : 0);
     }
 
     public void setVerifyToken(byte[] verifyToken) {
-        writeByteArray(0, verifyToken);
+        writeByteArray(v_1_17 ? 1 : 0, verifyToken);
+    }
+
+    private PublicKey encrypt(byte[] bytes) {
+        try {
+            EncodedKeySpec encodedKeySpec = new X509EncodedKeySpec(bytes);
+            KeyFactory keyFactory = KeyFactory.getInstance("RSA");
+            return keyFactory.generatePublic(encodedKeySpec);
+        } catch (Exception ex) {
+            ex.printStackTrace();
+            return null;
+        }
     }
 
     @Override

src/main/java/io/github/retrooper/packetevents/packetwrappers/login/out/setcompression/WrappedPacketLoginOutSetCompression.java

@@ -1,39 +1,31 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.login.out.setcompression;
 
 import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
-import io.github.retrooper.packetevents.packetwrappers.SendableWrapper;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.packetwrappers.api.SendableWrapper;
 import io.github.retrooper.packetevents.utils.server.ServerVersion;
 
 import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
 
-//This packet does not exist on 1.7.10
 public class WrappedPacketLoginOutSetCompression extends WrappedPacket implements SendableWrapper {
     private static Constructor<?> constructor;
     private int threshold;
@@ -78,13 +70,8 @@ public class WrappedPacketLoginOutSetCompression extends WrappedPacket implement
     }
 
     @Override
-    public Object asNMSPacket() {
-        try {
-            return constructor.newInstance(getThreshold());
-        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-        return null;
+    public Object asNMSPacket() throws Exception {
+        return constructor.newInstance(getThreshold());
     }
 
     @Override

src/main/java/io/github/retrooper/packetevents/packetwrappers/login/out/success/WrappedPacketLoginOutSuccess.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.login.out.success;
@@ -27,23 +21,37 @@ package io.github.retrooper.packetevents.packetwrappers.login.out.success;
 import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.packetwrappers.api.SendableWrapper;
 import io.github.retrooper.packetevents.utils.gameprofile.GameProfileUtil;
 import io.github.retrooper.packetevents.utils.gameprofile.WrappedGameProfile;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
 
+import java.lang.reflect.Constructor;
+
 public class WrappedPacketLoginOutSuccess extends WrappedPacket {
-    public WrappedPacketLoginOutSuccess(NMSPacket packet) {
+    private WrappedGameProfile wrappedGameProfile;
+
+    public WrappedPacketLoginOutSuccess(final NMSPacket packet) {
         super(packet);
     }
 
+    //TODO Support property reading in wrapped game profile(NECESSARY IN 1.19!, PLEASE UPDATE TO 2.0 PACKETEVENTS)
     public WrappedGameProfile getGameProfile() {
-        return GameProfileUtil.getWrappedGameProfile(readObject(0, NMSUtils.gameProfileClass));
+        if (packet != null) {
+            return GameProfileUtil.getWrappedGameProfile(readObject(0, NMSUtils.gameProfileClass));
+        } else {
+            return this.wrappedGameProfile;
+        }
     }
 
-
-    public void setGameProfile(WrappedGameProfile wrappedGameProfile) {
-        Object gameProfile = GameProfileUtil.getGameProfile(wrappedGameProfile.getId(), wrappedGameProfile.getName());
-        write(NMSUtils.gameProfileClass, 0, gameProfile);
+    //TODO Support writing property in wrapped game profile(NECESSARY IN 1.19!, PLEASE UPDATE TO 2.0 PACKETEVENTS)
+    public void setGameProfile(final WrappedGameProfile wrappedGameProfile) {
+        if (packet != null) {
+            final Object gameProfile = GameProfileUtil.getGameProfile(wrappedGameProfile.getId(), wrappedGameProfile.getName());
+            write(NMSUtils.gameProfileClass, 0, gameProfile);
+        } else {
+            this.wrappedGameProfile = wrappedGameProfile;
+        }
     }
 
     @Override

src/main/java/io/github/retrooper/packetevents/packetwrappers/play/in/abilities/WrappedPacketInAbilities.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.play.in.abilities;
@@ -28,7 +22,8 @@ import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
 import io.github.retrooper.packetevents.utils.reflection.Reflection;
-import io.github.retrooper.packetevents.utils.server.ServerVersion;
+
+import java.util.Optional;
 
 public final class WrappedPacketInAbilities extends WrappedPacket {
     private static boolean v_1_16_Mode;
@@ -50,118 +45,69 @@ public final class WrappedPacketInAbilities extends WrappedPacket {
         writeBoolean(v_1_16_Mode ? 0 : 1, flying);
     }
 
-    /**
-     * This will return null if the server version is not available in 1.16.x and above
-     *
-     * @return Whether the player is vulnerable to damage or not.
-     */
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_15_2})
-    @Deprecated
-    public boolean isVulnerable() throws UnsupportedOperationException {
+    public Optional<Boolean> isVulnerable() {
         if (v_1_16_Mode) {
-            throwUnsupportedOperation();
+            return Optional.empty();
         }
-        return readBoolean(0);
+        return Optional.of(readBoolean(0));
     }
 
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_15_2})
-    @Deprecated
-    public void setVulnerable(boolean vulnerable) throws UnsupportedOperationException {
-        if (v_1_16_Mode) {
-            throwUnsupportedOperation();
+    public void setVulnerable(boolean vulnerable) {
+        if (!v_1_16_Mode) {
+            writeBoolean(0, vulnerable);
         }
-        writeBoolean(0, vulnerable);
     }
 
-    /**
-     * This will return null if the server version is not available in 1.16.x and above
-     *
-     * @return Whether or not the player can fly.
-     */
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_15_2})
-    @Deprecated
-    public boolean isFlightAllowed() throws UnsupportedOperationException {
+
+    public Optional<Boolean> isFlightAllowed() {
         if (v_1_16_Mode) {
-            throwUnsupportedOperation();
+            return Optional.empty();
         }
-        return readBoolean(2);
+        return Optional.of(readBoolean(2));
     }
 
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_15_2})
-    @Deprecated
-    public void setFlightAllowed(boolean flightAllowed) throws UnsupportedOperationException {
-        if (v_1_16_Mode) {
-            throwUnsupportedOperation();
+    public void setFlightAllowed(boolean flightAllowed) {
+        if (!v_1_16_Mode) {
+            writeBoolean(2, flightAllowed);
         }
-        writeBoolean(2, flightAllowed);
     }
 
-    /**
-     * This will return null if the server version is not available in 1.16.x and above
-     *
-     * @return Whether or not the player can break blocks instantly.
-     */
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_15_2})
-    @Deprecated
-    public boolean canInstantlyBuild() throws UnsupportedOperationException {
+    public Optional<Boolean> canInstantlyBuild() {
         if (v_1_16_Mode) {
-            throwUnsupportedOperation();
+            return Optional.empty();
         }
-        return readBoolean(3);
+        return Optional.of(readBoolean(3));
     }
 
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_15_2})
-    @Deprecated
-    public void setCanInstantlyBuild(boolean canInstantlyBuild) throws UnsupportedOperationException {
-        if (v_1_16_Mode) {
-            throwUnsupportedOperation();
+    public void setCanInstantlyBuild(boolean canInstantlyBuild) {
+        if (!v_1_16_Mode) {
+            writeBoolean(3, canInstantlyBuild);
         }
-        writeBoolean(3, canInstantlyBuild);
     }
 
-    /**
-     * This will return null if the server version is not available in 1.16.x and above
-     *
-     * @return The speed at which the player can fly, as a float.
-     */
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_15_2})
-    @Deprecated
-    public float getFlySpeed() throws UnsupportedOperationException {
+    public Optional<Float> getFlySpeed() {
         if (v_1_16_Mode) {
-            throwUnsupportedOperation();
+            return Optional.empty();
         }
-        return readFloat(0);
+        return Optional.of(readFloat(0));
     }
 
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_15_2})
-    @Deprecated
-    public void setFlySpeed(float flySpeed) throws UnsupportedOperationException {
-        if (v_1_16_Mode) {
-            throwUnsupportedOperation();
+    public void setFlySpeed(float flySpeed) {
+        if (!v_1_16_Mode) {
+            writeFloat(0, flySpeed);
         }
-        writeFloat(0, flySpeed);
     }
 
-    /**
-     * This will return null if the server version is not available in 1.16.x and above
-     *
-     * @return The speed at which the player can walk, as a float.
-     */
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_15_2})
-    @Deprecated
-    public float getWalkSpeed() throws UnsupportedOperationException {
+    public Optional<Float> getWalkSpeed() {
         if (v_1_16_Mode) {
-            throwUnsupportedOperation();
+            return Optional.empty();
         }
-        return readFloat(1);
+        return Optional.of(readFloat(1));
     }
 
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_15_2})
-    @Deprecated
-    public void setWalkSpeed(float walkSpeed) throws UnsupportedOperationException {
-        if (v_1_16_Mode) {
-            throwUnsupportedOperation();
+    public void setWalkSpeed(float walkSpeed) {
+        if (!v_1_16_Mode) {
+            writeFloat(1, walkSpeed);
         }
-        writeFloat(1, walkSpeed);
     }
 }

src/main/java/io/github/retrooper/packetevents/packetwrappers/play/in/armanimation/WrappedPacketInArmAnimation.java

@@ -0,0 +1,56 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
+package io.github.retrooper.packetevents.packetwrappers.play.in.armanimation;
+
+import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
+import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.utils.enums.EnumUtil;
+import io.github.retrooper.packetevents.utils.nms.NMSUtils;
+import io.github.retrooper.packetevents.utils.player.Hand;
+import io.github.retrooper.packetevents.utils.server.ServerVersion;
+
+public class WrappedPacketInArmAnimation extends WrappedPacket {
+    private static boolean v_1_9;
+    public WrappedPacketInArmAnimation(NMSPacket packet) {
+        super(packet);
+    }
+
+    @Override
+    protected void load() {
+        v_1_9 = version.isNewerThanOrEquals(ServerVersion.v_1_9);
+    }
+
+    public Hand getHand() {
+        if (v_1_9) {
+            Enum<?> enumConst = readEnumConstant(0, NMSUtils.enumHandClass);
+            return Hand.values()[enumConst.ordinal()];
+        }
+        else {
+            return Hand.MAIN_HAND;
+        }
+    }
+
+    public void setHand(Hand hand) {
+        //Optimize to do nothing on legacy versions. The protocol of the legacy versions only support one hand, the main hand.
+        if (v_1_9) {
+            Enum<?> enumConst = EnumUtil.valueByIndex(NMSUtils.enumHandClass, hand.ordinal());
+            writeEnumConstant(0, enumConst);
+        }
+    }
+}

src/main/java/io/github/retrooper/packetevents/packetwrappers/play/in/beacon/WrappedPacketInBeacon.java

@@ -1,3 +1,21 @@
+/*
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
+ *
+ * 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 <http://www.gnu.org/licenses/>.
+ */
+
 package io.github.retrooper.packetevents.packetwrappers.play.in.beacon;
 
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;

src/main/java/io/github/retrooper/packetevents/packetwrappers/play/in/blockdig/WrappedPacketInBlockDig.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.play.in.blockdig;
@@ -34,8 +28,6 @@ import io.github.retrooper.packetevents.utils.reflection.SubclassUtil;
 import io.github.retrooper.packetevents.utils.server.ServerVersion;
 import io.github.retrooper.packetevents.utils.vector.Vector3i;
 
-import java.lang.reflect.InvocationTargetException;
-
 public final class WrappedPacketInBlockDig extends WrappedPacket {
     private static Class<? extends Enum<?>> digTypeClass;
     private static boolean isVersionLowerThan_v_1_8;
@@ -55,29 +47,22 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
             } catch (ClassNotFoundException e) {
                 //It is probably a subclass
                 digTypeClass = SubclassUtil.getEnumSubClass(blockDigClass, "EnumPlayerDigType");
+                if (digTypeClass == null) {
+                    digTypeClass = SubclassUtil.getEnumSubClass(blockDigClass, 0);
+                }
             }
         }
     }
 
     public Vector3i getBlockPosition() {
-        int x = 0;
-        int y = 0;
-        int z = 0;
         if (isVersionLowerThan_v_1_8) {
-            x = readInt(0);
-            y = readInt(1);
-            z = readInt(2);
+            int x = readInt(0);
+            int y = readInt(1);
+            int z = readInt(2);
+            return new Vector3i(x, y, z);
         } else {
-            Object blockPosObj = readObject(0, NMSUtils.blockPosClass);
-            try {
-                x = (int) NMSUtils.getBlockPosX.invoke(blockPosObj);
-                y = (int) NMSUtils.getBlockPosY.invoke(blockPosObj);
-                z = (int) NMSUtils.getBlockPosZ.invoke(blockPosObj);
-            } catch (IllegalAccessException | InvocationTargetException e) {
-                e.printStackTrace();
-            }
+            return readBlockPosition(0);
         }
-        return new Vector3i(x, y, z);
     }
 
     public void setBlockPosition(Vector3i blockPos) {
@@ -86,8 +71,7 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
             writeInt(1, blockPos.y);
             writeInt(2, blockPos.z);
         } else {
-            Object blockPosObj = NMSUtils.generateNMSBlockPos(blockPos.x, blockPos.y, blockPos.z);
-            write(NMSUtils.blockPosClass, 0, blockPosObj);
+            writeBlockPosition(0, blockPos);
         }
     }
 
@@ -101,7 +85,7 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
             return Direction.getDirection(readInt(3));
         } else {
             Enum<?> enumDir = readEnumConstant(0, NMSUtils.enumDirectionClass);
-            return Direction.valueOf(enumDir.name());
+            return Direction.values()[enumDir.ordinal()];
         }
     }
 
@@ -109,7 +93,7 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
         if (isVersionLowerThan_v_1_8) {
             writeInt(3, direction.getFaceValue());
         } else {
-            Enum<?> enumConst = EnumUtil.valueOf(NMSUtils.enumDirectionClass, direction.name());
+            Enum<?> enumConst = EnumUtil.valueByIndex(NMSUtils.enumDirectionClass, direction.ordinal());
             write(NMSUtils.enumDirectionClass, 0, enumConst);
         }
     }
@@ -123,7 +107,7 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
         if (isVersionLowerThan_v_1_8) {
             return PlayerDigType.values()[readInt(4)];
         } else {
-            return PlayerDigType.valueOf(readObject(0, digTypeClass).name());
+            return PlayerDigType.values()[readEnumConstant(0, digTypeClass).ordinal()];
         }
     }
 
@@ -131,8 +115,8 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
         if (isVersionLowerThan_v_1_8) {
             writeInt(4, type.ordinal());
         } else {
-            Enum<?> enumConst = EnumUtil.valueOf(digTypeClass, type.name());
-            write(digTypeClass, 0, enumConst);
+            Enum<?> enumConst = EnumUtil.valueByIndex(digTypeClass, type.ordinal());
+            writeEnumConstant(0, enumConst);
         }
     }
 
@@ -143,14 +127,6 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
         DROP_ALL_ITEMS,
         DROP_ITEM,
         RELEASE_USE_ITEM,
-
-        /**
-         * Doesn't exist on the newest versions.
-         */
-        @Deprecated
-        SWAP_HELD_ITEMS,
-
-        SWAP_ITEM_WITH_OFFHAND,
-        UNKNOWN
+        SWAP_ITEM_WITH_OFFHAND
     }
 }

src/main/java/io/github/retrooper/packetevents/packetwrappers/play/in/blockplace/WrappedPacketInBlockPlace.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.play.in.blockplace;
@@ -35,6 +29,8 @@ import io.github.retrooper.packetevents.utils.vector.Vector3f;
 import io.github.retrooper.packetevents.utils.vector.Vector3i;
 import org.bukkit.inventory.ItemStack;
 
+import java.util.Optional;
+
 
 public final class WrappedPacketInBlockPlace extends WrappedPacket {
     private static boolean newerThan_v_1_8_8, newerThan_v_1_7_10;
@@ -57,19 +53,20 @@ public final class WrappedPacketInBlockPlace extends WrappedPacket {
     }
 
     public Hand getHand() {
-        if (version.isOlderThan(ServerVersion.v_1_9)) {
+        if (newerThan_v_1_8_8) {
+            Enum<?> enumConst = readEnumConstant(handEnumIndex, NMSUtils.enumHandClass);
+            return Hand.values()[enumConst.ordinal()];
+        }
+        else {
             return Hand.MAIN_HAND;
-        } else {
-            Enum<?> enumConst = read(handEnumIndex, NMSUtils.enumHandClass);
-            return Hand.valueOf(enumConst.name());
         }
     }
 
     public void setHand(Hand hand) {
         //Optimize to do nothing on legacy versions. The protocol of the legacy versions only support one hand, the main hand.
-        if (version.isNewerThan(ServerVersion.v_1_8_8)) {
-            Enum<?> enumConst = EnumUtil.valueOf(NMSUtils.enumHandClass, hand.name());
-            write(NMSUtils.enumHandClass, handEnumIndex, enumConst);
+        if (newerThan_v_1_8_8) {
+            Enum<?> enumConst = EnumUtil.valueByIndex(NMSUtils.enumHandClass, hand.ordinal());
+            writeEnumConstant(handEnumIndex, enumConst);
         }
     }
 
@@ -100,7 +97,7 @@ public final class WrappedPacketInBlockPlace extends WrappedPacket {
     }
 
     public Vector3i getBlockPosition() {
-        Vector3i blockPos = new Vector3i();
+        Vector3i blockPos;
         if (newerThan_v_1_8_8) {
             WrappedPacketInBlockPlace_1_9 blockPlace_1_9 = new WrappedPacketInBlockPlace_1_9(packet);
             blockPos = blockPlace_1_9.getBlockPosition();
@@ -114,26 +111,21 @@ public final class WrappedPacketInBlockPlace extends WrappedPacket {
         return blockPos;
     }
 
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_8_8})
-    @Deprecated
-    public Vector3f getCursorPosition() throws UnsupportedOperationException {
+    public Optional<Vector3f> getCursorPosition() {
         if (newerThan_v_1_8_8) {
-            throwUnsupportedOperation();
-            return Vector3f.INVALID;
+            return Optional.empty();
         } else if (newerThan_v_1_7_10) {
             WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
-            return blockPlace_1_8.getCursorPosition();
+            return Optional.of(blockPlace_1_8.getCursorPosition());
         } else {
             WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(packet);
-            return blockPlace_1_7_10.getCursorPosition();
+            return Optional.of(blockPlace_1_7_10.getCursorPosition());
         }
     }
 
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_8_8})
-    @Deprecated
-    public void setCursorPosition(Vector3f cursorPos) throws UnsupportedOperationException {
+    public void setCursorPosition(Vector3f cursorPos) {
         if (newerThan_v_1_8_8) {
-            throwUnsupportedOperation();
+
         } else if (newerThan_v_1_7_10) {
             WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
             blockPlace_1_8.setCursorPosition(cursorPos);
@@ -143,24 +135,22 @@ public final class WrappedPacketInBlockPlace extends WrappedPacket {
         }
     }
 
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_8_8})
-    public ItemStack getItemStack() throws UnsupportedOperationException {
+    public Optional<ItemStack> getItemStack() {
         if (newerThan_v_1_8_8) {
-            throwUnsupportedOperation();
-            return null;
+            return Optional.empty();
         } else if (newerThan_v_1_7_10) {
             WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
-            return blockPlace_1_8.getItemStack();
+            return Optional.of(blockPlace_1_8.getItemStack());
         } else {
             WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(packet);
-            return blockPlace_1_7_10.getItemStack();
+            return Optional.of(blockPlace_1_7_10.getItemStack());
         }
     }
 
-    @SupportedVersions(ranges = {ServerVersion.v_1_7_10, ServerVersion.v_1_8_8})
-    public void setItemStack(ItemStack stack) throws UnsupportedOperationException {
+
+    public void setItemStack(ItemStack stack) {
         if (newerThan_v_1_8_8) {
-            throwUnsupportedOperation();
+            //Newer versions do not contain an itemstack
         } else if (newerThan_v_1_7_10) {
             WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
             blockPlace_1_8.setItemStack(stack);

src/main/java/io/github/retrooper/packetevents/packetwrappers/play/in/blockplace/WrappedPacketInBlockPlace_1_7_10.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.play.in.blockplace;
@@ -31,33 +25,22 @@ import io.github.retrooper.packetevents.utils.vector.Vector3i;
 import org.bukkit.inventory.ItemStack;
 
 final class WrappedPacketInBlockPlace_1_7_10 extends WrappedPacket {
-    private final net.minecraft.server.v1_7_R4.PacketPlayInBlockPlace blockPlace;
-
     WrappedPacketInBlockPlace_1_7_10(final NMSPacket packet) {
         super(packet);
-        blockPlace =
-                (net.minecraft.server.v1_7_R4.PacketPlayInBlockPlace) packet.getRawNMSPacket();
     }
 
     public Vector3i getBlockPosition() {
-        return new Vector3i(blockPlace.c(), blockPlace.d(), blockPlace.e());
+        return new Vector3i(readInt(0), readInt(1), readInt(2));
     }
 
     public void setBlockPosition(Vector3i blockPos) {
-        Vector3i currentBlockPos = getBlockPosition();
-        if (blockPos.x != currentBlockPos.x) {
-            writeInt(0, blockPos.x);
-        }
-        if (blockPos.y != currentBlockPos.y) {
-            writeInt(1, blockPos.y);
-        }
-        if (blockPos.z != currentBlockPos.z) {
-            writeInt(2, blockPos.z);
-        }
+        writeInt(0, blockPos.x);
+        writeInt(1, blockPos.y);
+        writeInt(2, blockPos.z);
     }
 
     public int getFace() {
-        return blockPlace.getFace();
+        return readInt(3);
     }
 
     public void setFace(int face) {
@@ -65,28 +48,20 @@ final class WrappedPacketInBlockPlace_1_7_10 extends WrappedPacket {
     }
 
     public ItemStack getItemStack() {
-        return org.bukkit.craftbukkit.v1_7_R4.inventory.CraftItemStack.asBukkitCopy(blockPlace.getItemStack());
+        return readItemStack(0);
     }
 
     public void setItemStack(ItemStack stack) {
-        Object nmsItemStack = org.bukkit.craftbukkit.v1_7_R4.inventory.CraftItemStack.asNMSCopy(stack);
-        writeObject(0, nmsItemStack);
+        writeItemStack(0, stack);
     }
 
     public Vector3f getCursorPosition() {
-        return new Vector3f(blockPlace.h(), blockPlace.i(), blockPlace.j());
+        return new Vector3f(readFloat(0), readFloat(1), readFloat(2));
     }
 
     public void setCursorPosition(Vector3f cursorPos) {
-        Vector3f currentCursorPos = getCursorPosition();
-        if (cursorPos.x != currentCursorPos.x) {
-            writeFloat(0, cursorPos.x);
-        }
-        if (cursorPos.y != currentCursorPos.y) {
-            writeFloat(1, cursorPos.y);
-        }
-        if (cursorPos.z != currentCursorPos.z) {
-            writeFloat(2, cursorPos.z);
-        }
+        writeFloat(0, cursorPos.x);
+        writeFloat(1, cursorPos.y);
+        writeFloat(2, cursorPos.z);
     }
 }

src/main/java/io/github/retrooper/packetevents/packetwrappers/play/in/blockplace/WrappedPacketInBlockPlace_1_8.java

@@ -1,38 +1,29 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.play.in.blockplace;
 
 import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
-import io.github.retrooper.packetevents.utils.nms.NMSUtils;
 import io.github.retrooper.packetevents.utils.vector.Vector3f;
 import io.github.retrooper.packetevents.utils.vector.Vector3i;
 import org.bukkit.inventory.ItemStack;
 
-import java.lang.reflect.InvocationTargetException;
-
 final class WrappedPacketInBlockPlace_1_8 extends WrappedPacket {
 
     WrappedPacketInBlockPlace_1_8(final NMSPacket packet) {
@@ -40,31 +31,19 @@ final class WrappedPacketInBlockPlace_1_8 extends WrappedPacket {
     }
 
     public Vector3i getBlockPosition() {
-        Vector3i blockPos = new Vector3i();
-
-        Object blockPosObj = readObject(1, NMSUtils.blockPosClass);
-        try {
-            blockPos.x = (int) NMSUtils.getBlockPosX.invoke(blockPosObj);
-            blockPos.y = (int) NMSUtils.getBlockPosY.invoke(blockPosObj);
-            blockPos.z = (int) NMSUtils.getBlockPosZ.invoke(blockPosObj);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-        return blockPos;
+        return readBlockPosition(1);
     }
 
     public void setBlockPosition(Vector3i blockPos) {
-        Object blockPosObj = NMSUtils.generateNMSBlockPos(blockPos.x, blockPos.y, blockPos.z);
-        write(NMSUtils.blockPosClass, 1, blockPosObj);
+        writeBlockPosition(1, blockPos);
     }
 
     public ItemStack getItemStack() {
-        return NMSUtils.toBukkitItemStack(readObject(0, NMSUtils.nmsItemStackClass));
+        return readItemStack(0);
     }
 
     public void setItemStack(ItemStack stack) {
-        Object nmsItemStack = NMSUtils.toNMSItemStack(stack);
-        write(NMSUtils.nmsItemStackClass, 0, nmsItemStack);
+        writeItemStack(0, stack);
     }
 
     public int getFace() {

src/main/java/io/github/retrooper/packetevents/packetwrappers/play/in/blockplace/WrappedPacketInBlockPlace_1_9.java

@@ -1,25 +1,19 @@
 /*
- * MIT License
+ * This file is part of packetevents - https://github.com/retrooper/packetevents
+ * Copyright (C) 2021 retrooper and contributors
  *
- * Copyright (c) 2020 retrooper
+ * 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.
  *
- * Permission is hereby granted, free of charge, to any person obtaining a copy
- * of this software and associated documentation files (the "Software"), to deal
- * in the Software without restriction, including without limitation the rights
- * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
- * copies of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
- * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
- * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
- * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
- * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
- * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
- * SOFTWARE.
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
  */
 
 package io.github.retrooper.packetevents.packetwrappers.play.in.blockplace;
@@ -35,74 +29,57 @@ import io.github.retrooper.packetevents.utils.vector.Vector3i;
 import java.lang.reflect.InvocationTargetException;
 
 final class WrappedPacketInBlockPlace_1_9 extends WrappedPacket {
-    private static Class<?> movingObjectPositionBlockClass;
     private Object movingObjPos;
 
     public WrappedPacketInBlockPlace_1_9(final NMSPacket packet) {
         super(packet);
     }
 
-    @Override
-    protected void load() {
-        movingObjectPositionBlockClass = NMSUtils.getNMSClassWithoutException("MovingObjectPositionBlock");
-    }
-
     public Vector3i getBlockPosition() {
-        Vector3i blockPos = new Vector3i();
-        Object blockPosObj;
-        if (movingObjectPositionBlockClass == null) {
-            blockPosObj = readObject(0, NMSUtils.blockPosClass);
+        if (NMSUtils.movingObjectPositionBlockClass == null) {
+            return readBlockPosition(0);
         } else {
             if (movingObjPos == null) {
-                movingObjPos = readObject(0, movingObjectPositionBlockClass);
+                movingObjPos = readObject(0, NMSUtils.movingObjectPositionBlockClass);
             }
             WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjPos));
-            blockPosObj = movingObjectPosWrapper.readObject(0, NMSUtils.blockPosClass);
+            return movingObjectPosWrapper.readBlockPosition(0);
         }
-        try {
-            blockPos.x = (int) NMSUtils.getBlockPosX.invoke(blockPosObj);
-            blockPos.y = (int) NMSUtils.getBlockPosY.invoke(blockPosObj);
-            blockPos.z = (int) NMSUtils.getBlockPosZ.invoke(blockPosObj);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-        return blockPos;
     }
 
     public void setBlockPosition(Vector3i blockPos) {
-        Object blockPosObj = NMSUtils.generateNMSBlockPos(blockPos.x, blockPos.y, blockPos.z);
-        if (movingObjectPositionBlockClass == null) {
-            write(NMSUtils.blockPosClass, 0, blockPosObj);
+        if (NMSUtils.movingObjectPositionBlockClass == null) {
+            writeBlockPosition(0, blockPos);
         } else {
             if (movingObjPos == null) {
-                movingObjPos = readObject(0, movingObjectPositionBlockClass);
+                movingObjPos = readObject(0, NMSUtils.movingObjectPositionBlockClass);
             }
             WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjPos));
-            movingObjectPosWrapper.write(NMSUtils.blockPosClass, 0, blockPos);
+            movingObjectPosWrapper.writeBlockPosition(0, blockPos);
         }
     }
 
     public Direction getDirection() {
         Enum<?> enumConst;
-        if (movingObjectPositionBlockClass == null) {
+        if (NMSUtils.movingObjectPositionBlockClass == null) {
             enumConst = readEnumConstant(0, NMSUtils.enumDirectionClass);
         } else {
             if (movingObjPos == null) {
-                movingObjPos = readObject(0, movingObjectPositionBlockClass);
+                movingObjPos = readObject(0, NMSUtils.movingObjectPositionBlockClass);
             }
             WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjPos));
             enumConst = movingObjectPosWrapper.readEnumConstant(0, NMSUtils.enumDirectionClass);
         }
-        return Direction.valueOf(enumConst.name());
+        return Direction.values()[enumConst.ordinal()];
     }
 
     public void setDirection(Direction direction) {
-        Enum<?> enumConst = EnumUtil.valueOf(NMSUtils.enumDirectionClass, direction.name());
-        if (movingObjectPositionBlockClass == null) {
+        Enum<?> enumConst = EnumUtil.valueByIndex(NMSUtils.enumDirectionClass, direction.ordinal());
+        if (NMSUtils.movingObjectPositionBlockClass == null) {
             writeEnumConstant(0, enumConst);
         } else {
             if (movingObjPos == null) {
-                movingObjPos = readObject(0, movingObjectPositionBlockClass);
+                movingObjPos = readObject(0, NMSUtils.movingObjectPositionBlockClass);
             }
             WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjPos));
             movingObjectPosWrapper.writeEnumConstant(0, enumConst);