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,170 +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-1</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>
-                        </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>dmulloy2-repo</id>
-            <url>https://repo.dmulloy2.net/nexus/repository/public/</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.12.2</artifactId>
-            <version>1.12.2</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>com.comphenix.protocol</groupId>
-            <artifactId>ProtocolLib</artifactId>
-            <version>4.5.0</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,102 +1,100 @@
 /*
- * 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;
 import io.github.retrooper.packetevents.exceptions.PacketEventsLoadFailureException;
-import io.github.retrooper.packetevents.handler.PacketHandlerInternal;
+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.ClientVersion;
 import io.github.retrooper.packetevents.utils.player.PlayerUtils;
 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 io.github.retrooper.packetevents.utils.versionlookup.VersionLookupUtils;
-import io.github.retrooper.packetevents.utils.versionlookup.protocollib.ProtocolLibVersionLookupUtils;
-import io.github.retrooper.packetevents.utils.versionlookup.v_1_7_10.ProtocolVersionAccessor_v_1_7;
-import io.github.retrooper.packetevents.utils.versionlookup.viaversion.ViaVersionLookupUtils;
 import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
 import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.plugin.ServicePriority;
-import org.jetbrains.annotations.NotNull;
+import org.bukkit.plugin.java.JavaPlugin;
 
-import java.lang.ref.WeakReference;
-import java.net.InetSocketAddress;
 import java.util.concurrent.ExecutorService;
-import java.util.concurrent.Executors;
-import java.util.concurrent.ThreadFactory;
-import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicBoolean;
 
 public final class PacketEvents implements Listener, EventManager {
     private static PacketEvents instance;
-    private final PEVersion version = new PEVersion(1, 7, 9, 1);
+    private static Plugin plugin;
+    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 static Plugin plugin;
-    public static String handlerName;
-    /**
-     * General executor service, basically for anything that the packet executor service doesn't do.
-     * For example update checking when you initialize PacketEvents.
-     */
-    public ExecutorService generalExecutorService = Executors.newSingleThreadExecutor(r -> new Thread(r, "PacketEvents-general"));
-
-    //Executor used for player injecting/ejecting.
-    public ExecutorService injectAndEjectExecutorService;//Initiated in init method
-
-    public PacketHandlerInternal packetHandlerInternal;
-    private boolean loading, loaded, initialized, initializing, stopping;
+    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 final ByteBufUtil byteBufUtil = NMSUtils.legacyNettyImportMode ? new ByteBufUtil_7() : new ByteBufUtil_8();
-
+    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.getServicesManager().isProvidedFor(PacketEvents.class)) {
-            instance = new PacketEvents();
-            Bukkit.getServicesManager().register(PacketEvents.class, instance,
-                    plugin, ServicePriority.Normal);
+        if (Bukkit.isPrimaryThread()) {
+            //We are on the main thread
+            if (!Bukkit.getServicesManager().isProvidedFor(PacketEvents.class)) {
+                //We can register in the service manager.
+                instance = new PacketEvents();
+                Bukkit.getServicesManager().register(PacketEvents.class, instance,
+                        plugin, ServicePriority.Normal);
+                PacketEvents.plugin = plugin;
+                return instance;
+            } else {
+                //We have already registered. Let us load what was registered.
+                return instance = Bukkit.getServicesManager().load(PacketEvents.class);
+            }
+        } else {
+            //We are off thread, we cannot use the service manager.
+            if (instance == null) {
+                PacketEvents.plugin = plugin;
+                instance = new PacketEvents();
+            }
             return instance;
         }
-        return instance = Bukkit.getServicesManager().load(PacketEvents.class);
     }
 
     public static PacketEvents get() {
@@ -105,119 +103,187 @@ 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 {
                 NMSUtils.load();
 
-                //Load all classes
                 PacketTypeClasses.load();
 
+                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();
+                lateBind = !injector.isBound();
+                //If late-bind is enabled, we will inject a bit later.
+                if (!lateBind) {
+                    injector.inject();
+                }
+                injectorReady.set(true);
+            }
+
             loaded = true;
             loading = false;
         }
     }
 
+    @Deprecated
+    public void loadAsyncNewThread() {
+        new Thread(this::load).start();
+    }
+
+    @Deprecated
+    public void loadAsync(ExecutorService executorService) {
+        executorService.execute(this::load);
+    }
+
     public void loadSettings(PacketEventsSettings settings) {
         this.settings = settings;
     }
 
-    public void init(final Plugin plugin) {
-        init(plugin, settings);
+    public void init() {
+        init(getSettings());
     }
 
-    public void init(final Plugin pl, PacketEventsSettings packetEventsSettings) {
+    public void init(PacketEventsSettings packetEventsSettings) {
+        //Load if we haven't loaded already
         load();
         if (!initialized && !initializing) {
             initializing = true;
             settings = packetEventsSettings;
-            if (settings.getInjectAndEjectThreadCount() < 1) {
-                settings.injectAndEjectThreadCount(1);
-            }
             settings.lock();
 
-            int injectAndEjectThreadCount = settings.getInjectAndEjectThreadCount();
-            injectAndEjectExecutorService = Executors.newFixedThreadPool(injectAndEjectThreadCount, new ThreadFactory() {
-
-                private final AtomicInteger id = new AtomicInteger();
-
-                @Override
-                public Thread newThread(@NotNull Runnable r) {
-                    return new Thread(r, "PacketEvents-inject-eject #" + id.getAndIncrement());
-                }
-            });
-
-            //Register Bukkit listener
-            plugin = pl;
-            Bukkit.getPluginManager().registerEvents(this, plugin);
-            handlerName = "pe-" + plugin.getName();
-            packetHandlerInternal = new PacketHandlerInternal(plugin);
-            for (final Player p : Bukkit.getOnlinePlayers()) {
-                try {
-                    getPlayerUtils().injectPlayer(p);
-                } catch (Exception ex) {
-                    p.kickPlayer(getSettings().getInjectionFailureMessage());
-                }
-            }
-
             if (settings.shouldCheckForUpdates()) {
-                generalExecutorService.execute(() -> new UpdateChecker().handleUpdate());
-
+                handleUpdateCheck();
             }
+
+            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();
+                }));
+            }
+
+            //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;
             initializing = false;
         }
     }
 
-    public void terminate() {
-        if (initialized && !stopping) {
-            for (Player player : Bukkit.getOnlinePlayers()) {
-                packetHandlerInternal.ejectPlayer(player);
-            }
-            packetHandlerInternal.cleanup();
-
-            getEventManager().unregisterAllListeners();
-            generalExecutorService.shutdownNow();
-            injectAndEjectExecutorService.shutdownNow();
-            initialized = false;
-            stopping = false;
-        }
+    @Deprecated
+    public void init(Plugin plugin) {
+        init(plugin, settings);
     }
 
     @Deprecated
-    public void stop() {
-        terminate();
+    public void init(Plugin pl, PacketEventsSettings packetEventsSettings) {
+        init(packetEventsSettings);
     }
 
-    public boolean hasLoaded() {
-        return loaded;
+    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;
+        }
+    }
+
+    /**
+     * Use {@link #terminate()}. This is deprecated
+     *
+     * @deprecated "Stop" might be misleading and "terminate" sounds better I guess...
+     */
+    @Deprecated
+    public void stop() {
+        terminate();
     }
 
     public boolean isLoading() {
         return loading;
     }
 
-    public boolean isInitializing() {
-        return initializing;
+    public boolean hasLoaded() {
+        return loaded;
     }
 
+    public boolean isTerminating() {
+        return terminating;
+    }
+
+    @Deprecated
     public boolean isStopping() {
-        return stopping;
+        return isTerminating();
+    }
+
+    public boolean isInitializing() {
+        return initializing;
     }
 
     public boolean isInitialized() {
@@ -228,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;
     }
@@ -257,67 +330,43 @@ public final class PacketEvents implements Listener, EventManager {
         return byteBufUtil;
     }
 
-    @EventHandler(priority = EventPriority.LOWEST)
-    public void onLogin(final PlayerLoginEvent e) {
-        if (getSettings().shouldInjectEarly()) {
-            try {
-                packetHandlerInternal.injectPlayer(e.getPlayer());
-            } catch (Exception ex) {
-               e.disallow(PlayerLoginEvent.Result.KICK_OTHER, PacketEvents.get().getSettings().getInjectionFailureMessage());
-            }
-        }
+    public UpdateChecker getUpdateChecker() {
+        return updateChecker;
     }
 
-    @EventHandler(priority = EventPriority.HIGH)
-    public void onJoin(final PlayerJoinEvent e) {
-        final InetSocketAddress address = e.getPlayer().getAddress();
-        boolean viaAvailable = ViaVersionLookupUtils.isAvailable();
-        if (viaAvailable) {
-            PacketEvents.get().getPlayerUtils().clientVersionsMap.put(e.getPlayer().getAddress(), ClientVersion.TEMP_UNRESOLVED);
-            Bukkit.getScheduler().runTaskLaterAsynchronously(getPlugin(), new Runnable() {
-                @Override
-                public void run() {
-                    int protocolVersion = VersionLookupUtils.getProtocolVersion(e.getPlayer());
-                    ClientVersion version = ClientVersion.getClientVersion(protocolVersion);
-                    PacketEvents.get().getPlayerUtils().clientVersionsMap.put(address, version);
-                    PacketEvents.get().getEventManager().callEvent(new PostPlayerInjectEvent(e.getPlayer(), true));
-                }
-            }, 1L);
-        } else if (getServerUtils().getVersion() == ServerVersion.v_1_7_10) {
-            ClientVersion version = ClientVersion.getClientVersion(ProtocolVersionAccessor_v_1_7.getProtocolVersion(e.getPlayer()));
-            if (version == ClientVersion.UNRESOLVED) {
-                version = getPlayerUtils().tempClientVersionMap.get(address);
-                if (version == null) {
-                    version = ClientVersion.UNRESOLVED;
-                }
-            }
-            getPlayerUtils().clientVersionsMap.put(address, version);
+    private void handleUpdateCheck() {
+        if (updateChecker == null) {
+            updateChecker = new UpdateChecker();
         }
+        Thread thread = new Thread(() -> {
+            getPlugin().getLogger().info("[packetevents] Checking for an update, please wait...");
+            UpdateChecker.UpdateCheckerStatus status = updateChecker.checkForUpdate();
+            int seconds = 5;
+            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();
+                }
 
-        if (!getSettings().shouldInjectEarly()) {
-            try {
-                packetHandlerInternal.injectPlayer(e.getPlayer());
-                //Injection was successful as no exception was thrown...
-                if (!viaAvailable) {
-                    if (ProtocolLibVersionLookupUtils.isAvailable()) {
-                        ClientVersion version = ClientVersion.getClientVersion(ProtocolLibVersionLookupUtils.getProtocolVersion(e.getPlayer()));
-                        PacketEvents.get().getPlayerUtils().clientVersionsMap.put(address, version);
-                    }
-                    PacketEvents.get().getEventManager().callEvent(new PostPlayerInjectEvent(e.getPlayer(), false));
+                seconds *= 2;
+
+                status = updateChecker.checkForUpdate();
+
+                if (i == (retryCount - 1)) {
+                    getPlugin().getLogger().severe("[packetevents] PacketEvents failed to check for an update. No longer retrying.");
+                    break;
                 }
-            } catch (Exception ex) {
-                e.getPlayer().kickPlayer(getSettings().getInjectionFailureMessage());
+
             }
-        } else {
-            if (!viaAvailable) {
-                PacketEvents.get().getEventManager().callEvent(new PostPlayerInjectEvent(e.getPlayer(), false));
-            }
-        }
+
+        }, "packetevents-update-check-thread");
+        thread.start();
     }
 
-
-    @EventHandler(priority = EventPriority.HIGHEST)
-    public void onQuit(final PlayerQuitEvent e) {
-        packetHandlerInternal.ejectPlayer(e.getPlayer());
-    }
 }

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

@@ -1,51 +1,117 @@
 /*
- * 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.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.server.ServerVersion;
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.java.JavaPlugin;
 
-public class PacketEventsPlugin extends JavaPlugin {
+import java.nio.charset.StandardCharsets;
 
+public class PacketEventsPlugin extends JavaPlugin {
     @Override
     public void onLoad() {
-
+        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() {
-        if (PacketEvents.get() == null) {
-            PacketEvents.create(this);
-            PacketEvents.get().load();
-            PacketEvents.get().init(this);
-        }
+        /*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();
     }
 
     @Override
     public void onDisable() {
-        if (PacketEvents.get() != null) {
-            PacketEvents.get().terminate();
-        }
+        PacketEvents.get().terminate();
     }
 }

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,11 @@ public abstract class PacketEvent implements CallableEvent {
         this.timestamp = timestamp;
     }
 
-    public void callPacketEvent(final PacketListenerDynamic listener) {
-        listener.onPacketEvent(this);
+    public void callPacketEventExternal(final PacketListenerAbstract listener) {
+        listener.onPacketEventExternal(this);
+    }
+
+    public boolean isInbuilt() {
+        return false;
     }
 }

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,91 +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;
 
 /**
- * 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;
-
+@Deprecated
+public abstract class PacketListenerDynamic extends PacketListenerAbstract {
+    @Deprecated
     public PacketListenerDynamic(final PacketEventPriority priority) {
-        this.priority = priority;
+        super(priority);
     }
 
+    public PacketListenerDynamic(PacketListenerPriority priority) {
+        super(priority);
+    }
+
+
     public PacketListenerDynamic() {
-        this(PacketEventPriority.NORMAL);
-    }
-
-    public PacketEventPriority getPriority() {
-        return priority;
-    }
-
-    public void onPacketStatusReceive(PacketStatusReceiveEvent event) {
-
-    }
-
-    public void onPacketStatusSend(PacketStatusSendEvent 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 onPacketEvent(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#onPacketEvent(PacketEvent)} method is called for every event,
+ * 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;
@@ -54,18 +48,4 @@ public interface CancellableEvent {
      * @param val Is the event cancelled
      */
     void setCancelled(boolean val);
-
-    /**
-     * Cancel the event.
-     * You can achieve the same result by just using {@link #setCancelled(boolean)}
-     */
-    @Deprecated
-    void cancel();
-
-    /**
-     * Uncancel the event.
-     * You can achieve the same result by just using {@link #setCancelled(boolean)}
-     */
-    @Deprecated
-    void uncancel();
 }

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,20 +29,6 @@ public abstract class CancellableNMSPacketEvent extends NMSPacketEvent implement
         super(channel, packet);
     }
 
-    public CancellableNMSPacketEvent(InetSocketAddress address, NMSPacket packet) {
-        super(address, packet);
-    }
-
-    @Override
-    public void cancel() {
-        cancelled = true;
-    }
-
-    @Override
-    public void uncancel() {
-        cancelled = false;
-    }
-
     @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,18 +35,16 @@ import java.net.InetSocketAddress;
  * @since 1.8
  */
 public abstract class NMSPacketEvent extends PacketEvent implements CallableEvent {
+    private final Object channel;
     private final InetSocketAddress socketAddress;
+    private final byte packetID;
     protected NMSPacket packet;
-    protected boolean cancelled;
 
     public NMSPacketEvent(Object channel, NMSPacket packet) {
+        this.channel = channel;
         this.socketAddress = ChannelUtils.getSocketAddress(channel);
         this.packet = packet;
-    }
-
-    public NMSPacketEvent(InetSocketAddress address, NMSPacket packet) {
-        this.socketAddress = address;
-        this.packet = packet;
+        packetID = PacketType.packetIDMap.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
     }
 
     /**
@@ -65,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.
@@ -104,5 +103,12 @@ public abstract class NMSPacketEvent extends PacketEvent implements CallableEven
      *
      * @return Packet ID.
      */
-    public abstract byte getPacketId();
+    public byte getPacketId() {
+        return packetID;
+    }
+
+    @Override
+    public boolean isInbuilt() {
+        return true;
+    }
 }

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

@@ -0,0 +1,48 @@
+/*
+ * 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;
+
+import java.net.InetSocketAddress;
+
+/**
+ * The {@code PacketHandshakeReceiveEvent} event is fired whenever the a HANDSHAKE packet is received from a client.
+ * 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
+ * @see <a href="https://wiki.vg/Protocol#Handshaking">https://wiki.vg/Protocol#Handshaking</a>
+ * @since 1.8
+ */
+public class PacketHandshakeReceiveEvent extends CancellableNMSPacketEvent {
+    public PacketHandshakeReceiveEvent(Object channel, NMSPacket packet) {
+        super(channel, packet);
+    }
+
+    @Override
+    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,30 +34,14 @@ 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);
-    }
-
-    /**
-     * Each binding in each packet state has their own constants.
-     * Example Usage:
-     * <p>
-     * {@code if (getPacketId() == PacketType.Login.Client.HANDSHAKE) }
-     * </p>
-     *
-     * @return Packet ID.
-     */
     @Override
-    public byte getPacketId() {
-        return PacketType.Login.Client.packetIds.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
-    }
-
-    @Override
-    public void call(PacketListenerDynamic listener) {
-        listener.onPacketLoginReceive(this);
+    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,62 +1,65 @@
 /*
- * 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 byte getPacketId() {
-        return PacketType.Login.Server.packetIds.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
+    public Runnable getPostTask() {
+        return postTask;
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
-        listener.onPacketLoginSend(this);
+    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;
@@ -45,7 +38,7 @@ import org.jetbrains.annotations.NotNull;
 public final class PacketPlayReceiveEvent extends CancellableNMSPacketEvent implements PlayerEvent {
     private final Player player;
 
-    public PacketPlayReceiveEvent(final Player player, final Object channel, final NMSPacket packet) {
+    public PacketPlayReceiveEvent(Player player, Object channel, NMSPacket packet) {
         super(channel, packet);
         this.player = player;
     }
@@ -62,31 +55,10 @@ public final class PacketPlayReceiveEvent extends CancellableNMSPacketEvent impl
         return player;
     }
 
-    /**
-     * This method returns the socket address of the packet sender.
-     * This address if guaranteed to never be null.
-     * You could use this to identify who is sending packets
-     * whenever the player object is null.
-     *
-     * @return Packet sender's socket address.
-     */
-
-    /**
-     * Each binding in each packet state has their own constants.
-     * Example Usage:
-     * <p>
-     * {@code if (getPacketId() == PacketType.Play.Client.USE_ENTITY) }
-     * </p>
-     *
-     * @return Packet ID.
-     */
     @Override
-    public byte getPacketId() {
-        return PacketType.Play.Client.packetIds.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
-    }
-
-    @Override
-    public void call(PacketListenerDynamic listener) {
-        listener.onPacketPlayReceive(this);
+    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,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.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 org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
+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.
  *
@@ -41,8 +36,9 @@ import org.jetbrains.annotations.NotNull;
  * @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);
@@ -61,23 +57,26 @@ public final class PacketPlaySendEvent extends CancellableNMSPacketEvent impleme
         return player;
     }
 
-    /**
-     * Each binding in each packet state has their own constants.
-     * Example Usage:
-     * <p>
-     * {@code if (getPacketId() == PacketType.Play.Server.KEEP_ALIVE) }
-     * </p>
-     *
-     * @return Packet ID.
-     */
     @Override
-    public byte getPacketId() {
-        return PacketType.Play.Server.packetIds.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
+    public boolean isPostTaskAvailable() {
+        return postTask != null;
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
-        listener.onPacketPlaySend(this);
+    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,26 +38,10 @@ public class PacketStatusReceiveEvent extends CancellableNMSPacketEvent {
         super(channel, packet);
     }
 
-    public PacketStatusReceiveEvent(final InetSocketAddress socketAddress, final NMSPacket packet) {
-        super(socketAddress, packet);
-    }
-
-    /**
-     * Each binding in each packet state has their own constants.
-     * Example Usage:
-     * <p>
-     * {@code if (getPacketId() == PacketType.Status.Client.PING) }
-     * </p>
-     *
-     * @return Packet ID.
-     */
     @Override
-    public byte getPacketId() {
-        return PacketType.Status.Client.packetIds.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
-    }
-
-    @Override
-    public void call(PacketListenerDynamic listener) {
-        listener.onPacketStatusReceive(this);
+    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,73 +1,68 @@
 /*
- * 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);
-    }
-
-    /**
-     * Each binding in each packet state has their own constants.
-     * Example Usage:
-     * <p>
-     * {@code if (getPacketId() == PacketType.Status.Server.PONG) }
-     * </p>
-     *
-     * @return Packet ID.
-     */
     @Override
-    public byte getPacketId() {
-        return PacketType.Status.Server.packetIds.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
+    public boolean isPostTaskAvailable() {
+        return postTask != null;
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
-        listener.onPacketStatusSend(this);
+    public Runnable getPostTask() {
+        return postTask;
+    }
+
+    @Override
+    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,41 +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.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.settings.PacketEventsSettings;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
 
 /**
  * The {@code PlayerEjectEvent} event is fired whenever a player is ejected.
- * A player is ejected by PacketEvents whenever they quit the server.
  * This class implements {@link CancellableEvent} and {@link PlayerEvent}.
  *
  * @author retrooper
@@ -44,22 +35,10 @@ import org.jetbrains.annotations.NotNull;
  */
 public final class PlayerEjectEvent extends PacketEvent implements CancellableEvent, PlayerEvent {
     private final Player player;
-    private final boolean async;
     private boolean cancelled;
 
-    public PlayerEjectEvent(final Player player, final boolean isAsync) {
+    public PlayerEjectEvent(final Player player) {
         this.player = player;
-        this.async = isAsync;
-    }
-
-    @Override
-    public void cancel() {
-        cancelled = true;
-    }
-
-    @Override
-    public void uncancel() {
-        cancelled = false;
     }
 
     @Override
@@ -85,20 +64,21 @@ public final class PlayerEjectEvent extends PacketEvent implements CancellableEv
     }
 
     /**
-     * This method returns if the event has been called asynchronously.
-     * If the {@link PacketEventsSettings#shouldEjectAsync()} is enabled, the event will be called asynchronously
-     * and the player will be ejected asynchronously.
-     * The {@link PacketEventsSettings} can be accessed here:
-     *
-     * @return Is the ejection asynchronous.
-     * @see PacketEvents#getSettings()
+     * @return Is the event called async?
+     * @deprecated Now always false
      */
+    @Deprecated
     public boolean isAsync() {
-        return async;
+        return false;
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         listener.onPlayerEject(this);
     }
+
+    @Override
+    public boolean isInbuilt() {
+        return true;
+    }
 }

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

@@ -1,38 +1,30 @@
 /*
- * 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.settings.PacketEventsSettings;
 import io.github.retrooper.packetevents.utils.netty.channel.ChannelUtils;
 import org.bukkit.entity.Player;
-import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
 
 import java.net.InetSocketAddress;
@@ -49,23 +41,11 @@ import java.net.InetSocketAddress;
 public final class PlayerInjectEvent extends PacketEvent implements CancellableEvent, PlayerEvent {
     private final Player player;
     private final InetSocketAddress address;
-    private final boolean async;
     private boolean cancelled;
 
-    public PlayerInjectEvent(final Player player, final boolean isAsync) {
+    public PlayerInjectEvent(final Player player) {
         this.player = player;
-        this.address = ChannelUtils.getSocketAddress(PacketEvents.get().packetHandlerInternal.getChannel(player));
-        this.async = isAsync;
-    }
-
-    @Override
-    public void cancel() {
-        cancelled = true;
-    }
-
-    @Override
-    public void uncancel() {
-        cancelled = false;
+        this.address = ChannelUtils.getSocketAddress(PacketEvents.get().getPlayerUtils().getChannel(player));
     }
 
     @Override
@@ -95,26 +75,26 @@ public final class PlayerInjectEvent extends PacketEvent implements CancellableE
      *
      * @return Socket address of the injecting player.
      */
-    @NotNull
+    @Nullable
     public InetSocketAddress getSocketAddress() {
         return address;
     }
 
     /**
-     * This method returns if the event has been called asynchronously.
-     * If the {@link PacketEventsSettings#shouldInjectAsync()} is enabled, the event will be called asynchronously
-     * and the player will be injected asynchronously.
-     * The {@link PacketEventsSettings} can be accessed here:
-     *
-     * @return Is the injection asynchronous.
-     * @see PacketEvents#getSettings()
+     * @deprecated Will always be false
      */
+    @Deprecated
     public boolean isAsync() {
-        return async;
+        return false;
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         listener.onPlayerInject(this);
     }
+
+    @Override
+    public boolean isInbuilt() {
+        return true;
+    }
 }

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

@@ -1,44 +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;
-import org.jetbrains.annotations.Nullable;
 
 /**
- * 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>
@@ -54,32 +43,18 @@ public class PostPacketPlayReceiveEvent extends NMSPacketEvent implements Player
 
     /**
      * This method returns the bukkit player object of the packet sender.
-     * The player object might be null during early packets.
      *
      * @return Packet sender.
      */
-    @Nullable
     @Override
     public Player getPlayer() {
         return player;
     }
 
-    /**
-     * Each binding in each packet state has their own constants.
-     * Example Usage:
-     * <p>
-     * {@code if (getPacketId() == PacketType.Play.Client.ARM_ANIMATION) }
-     * </p>
-     *
-     * @return Packet ID.
-     */
     @Override
-    public byte getPacketId() {
-        return PacketType.Play.Client.packetIds.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
-    }
-
-    @Override
-    public void call(PacketListenerDynamic listener) {
-        listener.onPostPacketPlayReceive(this);
+    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,44 +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;
-import org.jetbrains.annotations.Nullable;
 
 /**
- * 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>
@@ -54,32 +43,18 @@ public class PostPacketPlaySendEvent extends NMSPacketEvent implements PlayerEve
 
     /**
      * This method returns the bukkit player object of the packet sender.
-     * The player object is might be null during early packets.
      *
      * @return Packet receiver.
      */
-    @Nullable
     @Override
     public Player getPlayer() {
         return player;
     }
 
-    /**
-     * Each binding in each packet state has their own constants.
-     * Example Usage:
-     * <p>
-     * {@code if (getPacketId() == PacketType.Play.Server.KEEP_ALIVE) }
-     * </p>
-     *
-     * @return Packet ID.
-     */
     @Override
-    public byte getPacketId() {
-        return PacketType.Play.Server.packetIds.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
-    }
-
-    @Override
-    public void call(PacketListenerDynamic listener) {
-        listener.onPostPacketPlaySend(this);
+    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,48 +1,38 @@
 /*
- * 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;
 import org.bukkit.entity.Player;
 import org.jetbrains.annotations.NotNull;
-import org.jetbrains.annotations.Nullable;
 
 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>
@@ -76,7 +66,7 @@ public class PostPlayerInjectEvent extends PacketEvent implements PlayerEvent {
      */
     @NotNull
     public Object getChannel() {
-        return PacketEvents.get().packetHandlerInternal.getChannel(player);
+        return PacketEvents.get().getPlayerUtils().getChannel(player);
     }
 
     @NotNull
@@ -90,7 +80,7 @@ public class PostPlayerInjectEvent extends PacketEvent implements PlayerEvent {
      * @return ClientVersion of injected player.
      * @see ClientVersion
      */
-    @Nullable
+    @NotNull
     public ClientVersion getClientVersion() {
         return PacketEvents.get().getPlayerUtils().getClientVersion(player);
     }
@@ -105,7 +95,12 @@ public class PostPlayerInjectEvent extends PacketEvent implements PlayerEvent {
     }
 
     @Override
-    public void call(PacketListenerDynamic listener) {
+    public void call(PacketListenerAbstract listener) {
         listener.onPostPlayerInject(this);
     }
+
+    @Override
+    public boolean isInbuilt() {
+        return true;
+    }
 }

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,49 +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 the dynamic event listener.
+     * Unregister a PacketListenerAbstract listener.
      *
-     * @param listener {@link PacketListenerDynamic}
+     * @param listener {@link PacketListenerAbstract}
      * @return Same event manager instance.
      */
-    default EventManager unregisterListener(PacketListenerDynamic listener) {
-        PEEventManager.EVENT_MANAGER_DYNAMIC.unregisterListener(listener);
+    default EventManager unregisterListener(PacketListenerAbstract listener) {
+        if (listener != null) {
+            PEEventManager.EVENT_MANAGER_MODERN.unregisterListener(listener);
+        }
         return this;
     }
 
     /**
-     * Unregister multiple dynamic event listeners with one method.
-     * Recommended to use the dynamic event listener.
+     * Unregister multiple PacketListenerAbstract listeners.
      *
-     * @param listeners {@link PacketListenerDynamic}
+     * @param listeners {@link PacketListenerAbstract}
      * @return Same event manager instance.
      */
-    default EventManager unregisterListeners(PacketListenerDynamic... listeners) {
-        PEEventManager.EVENT_MANAGER_DYNAMIC.unregisterListeners(listeners);
+    default EventManager unregisterListeners(PacketListenerAbstract... listeners) {
+        PEEventManager.EVENT_MANAGER_MODERN.unregisterListeners(listeners);
         return this;
     }
 
@@ -166,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,145 +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.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.ArrayList;
-import java.util.List;
-
-class EventManagerDynamic {
-    /**
-     * All listeners ordered by their priority.
-     * The most low priority ones are at the begging of the list and the most high priority ones are at the end.
-     */
-    private final List<PacketListenerDynamic> listeners = new ArrayList<>();
-
-    /**
-     * 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 (PacketListenerDynamic listener : listeners) {
-            highestReachedPriority = listener.getPriority().getPriorityValue();
-            try {
-                event.callPacketEvent(listener);
-                event.call(listener);
-            }
-            catch (Exception ex) {
-                throw new IllegalStateException("PacketEvents found an exception while calling a packet listener.", ex);
-            }
-            if (event instanceof CancellableEvent) {
-                CancellableEvent ce = (CancellableEvent) event;
-                cancel = ce.isCancelled();
-            }
-        }
-        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 void registerListener(final PacketListenerDynamic listener) {
-        final byte priorityValue = listener.getPriority().getPriorityValue();
-        if (listeners.isEmpty()) {
-            listeners.add(listener);
-            return;
-        }
-        for (int i = 0; i < listeners.size(); i++) {
-            PacketListenerDynamic other = listeners.get(i);
-            byte otherPriorityValue = other.getPriority().getPriorityValue();
-            if (i + 1 == listeners.size()) {
-                listeners.add(listener);
-                break;
-            } else if (otherPriorityValue == priorityValue) {
-                listeners.add(i + 1, listener);
-                break;
-            } else if (otherPriorityValue > priorityValue) {
-                listeners.add(i, listener);
-                break;
-            }
-        }
-    }
-
-    /**
-     * Register multiple dynamic packet event listeners with one method.
-     *
-     * @param listeners {@link PacketListenerDynamic}
-     */
-    public void registerListeners(PacketListenerDynamic... listeners) {
-        for (PacketListenerDynamic listener : listeners) {
-            registerListener(listener);
-        }
-    }
-
-    /**
-     * Unregister the dynamic packet event listener.
-     *
-     * @param listener {@link PacketListenerDynamic}
-     */
-    public void unregisterListener(PacketListenerDynamic listener) {
-        listeners.remove(listener);
-    }
-
-    /**
-     * Unregister multiple dynamic packet event listeners with one method.
-     *
-     * @param listeners {@link PacketListenerDynamic}
-     */
-    public void unregisterListeners(PacketListenerDynamic... listeners) {
-        for (PacketListenerDynamic listener : listeners) {
-            unregisterListener(listener);
-        }
-    }
-
-    /**
-     * Unregister all dynamic packet event listeners.
-     */
-    public void unregisterAllListeners() {
-        listeners.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.
@@ -163,4 +157,4 @@ class EventManagerLegacy {
     public void unregisterAllListeners() {
         staticRegisteredMethods.clear();
     }
-}
+}

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.
@@ -41,7 +36,7 @@ public enum PacketEventPriority {
      * Use this if you need to be the first processing the event and
      * need no power in cancelling an event or preventing an event cancellation.
      */
-    LOWEST((byte) 0),
+    LOWEST,
 
     /**
      * A weak event priority.
@@ -49,7 +44,7 @@ public enum PacketEventPriority {
      * Use this if you would prefer to be one of the first to process the event,
      * but don't mind if some other listener processes before you.
      */
-    LOW((byte) 1),
+    LOW,
 
     /**
      * Default event priority.
@@ -57,14 +52,14 @@ public enum PacketEventPriority {
      * Use this if you don't really care/know when you process or just want to
      * be in the middle.
      */
-    NORMAL((byte) 2),
+    NORMAL,
 
     /**
      * Higher than the {@link PacketEventPriority#NORMAL} event priority.
      * Fourth to be processed(IN THE DYNAMIC EVENT SYSTEM ONLY).
      * Use this if you want to process before the default event prioritized listeners.
      */
-    HIGH((byte) 3),
+    HIGH,
 
     /**
      * Second most powerful event priority.
@@ -75,7 +70,7 @@ public enum PacketEventPriority {
      * mind if some other listener urgently needs to decide over you.
      * {@link PacketEventPriority#MONITOR} is rarely ever recommended to use.
      */
-    HIGHEST((byte) 4),
+    HIGHEST,
 
     /**
      * Most powerful event priority.
@@ -84,24 +79,14 @@ public enum PacketEventPriority {
      * or urgently need to be the final decider whether the event has cancelled or not.
      * This is rarely recommended.
      */
-    MONITOR((byte) 5);
+    MONITOR;
 
-    final byte priorityValue;
 
-    PacketEventPriority(byte priorityValue) {
-        this.priorityValue = priorityValue;
+    public static PacketEventPriority getPacketEventPriority(byte bytePriority) {
+        return values()[bytePriority];
     }
 
     public byte getPriorityValue() {
-        return priorityValue;
-    }
-
-    public static PacketEventPriority getPacketEventPriority(byte bytePriority) {
-        for (PacketEventPriority priority : values()) {
-            if (priority.priorityValue == bytePriority) {
-                return priority;
-            }
-        }
-        return NORMAL;
+        return (byte) ordinal();
     }
 }

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

@@ -0,0 +1,42 @@
+/*
+ * 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.exceptions;
+
+import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
+
+/**
+ * An exception thrown by PacketEvents when a wrapper is used although it isn't supported on the local server version.
+ * Make sure to decompile a wrapper before using it, if you are unsure if it is supported through out all the server versions.
+ * We override a {@link WrappedPacket#isSupported()} method if it isn't supported on all server versions.
+ *
+ * @author retrooper
+ * @see WrappedPacket#isSupported()
+ * @see WrappedPacket.SupportedVersions
+ * @since 1.7
+ */
+public class WrapperUnsupportedUsageException extends RuntimeException {
+    public WrapperUnsupportedUsageException(String message) {
+        super(message);
+    }
+
+    public WrapperUnsupportedUsageException(Class<? extends WrappedPacket> wrapperClass) {
+        this("You are using a packet wrapper which happens to be unsupported on the local server version. Packet wrapper you attempted to use: " + ClassUtil.getClassSimpleName(wrapperClass));
+    }
+}

src/main/java/io/github/retrooper/packetevents/handler/PacketHandlerInternal.java

@@ -1,446 +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.handler;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.event.impl.*;
-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.NMSPacket;
-import io.github.retrooper.packetevents.packetwrappers.login.in.handshake.WrappedPacketLoginInHandshake;
-import io.github.retrooper.packetevents.packetwrappers.login.in.start.WrappedPacketLoginInStart;
-import io.github.retrooper.packetevents.settings.PacketEventsSettings;
-import io.github.retrooper.packetevents.utils.gameprofile.WrappedGameProfile;
-import io.github.retrooper.packetevents.utils.nms.NMSUtils;
-import io.github.retrooper.packetevents.utils.player.ClientVersion;
-import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-
-import java.util.HashMap;
-import java.util.Map;
-import java.util.UUID;
-import java.util.WeakHashMap;
-import java.util.concurrent.ConcurrentHashMap;
-
-/**
- * Internal manager of everything related to packets.
- * For example injecting, channel caching, internal processing, packet sending....
- * This class is only meant to be used internally.
- * This could end up being refactored or renamed without a deprecation as it is only meant to be used internally.
- *
- * @author retrooper
- * @see <a href="http://netty.io">http://netty.io</a>
- * @since 1.7.9
- */
-public class PacketHandlerInternal {
-    public final GlobalChannelInjector injector;
-    public final HashMap<UUID, Long> keepAliveMap = new HashMap<>();
-    public final Map<String, Object> channelMap = new WeakHashMap<>();
-
-    public PacketHandlerInternal(Plugin plugin) {
-        injector = new GlobalChannelInjector();
-        injector.prepare();
-    }
-
-    /**
-     * Get a player's netty channel object with their name.
-     * This netty channel object is cached in a {@link ConcurrentHashMap} as the value and
-     * the name is the key.
-     * We cache the name and the channel quite early infact,
-     * once we receive the {@link PacketType.Login.Client#START} packet(which contains the game profile)
-     * and the game profile contains the player name.
-     * The wrapper for that packet is {@link WrappedPacketLoginInStart}.
-     * If PacketEvents couldn't cache(when you have {@link PacketEventsSettings#shouldInjectEarly()} set to false),
-     * PacketEvents will use some reflection to see if CraftBukkit has the netty channel.
-     * If you access this before the START login packet was sent, you will for sure experience issues.
-     *
-     * @param player Target player.
-     * @return Netty channel of a player by their name.
-     * @see <a href="https://wiki.vg/Protocol#Login_Start">https://wiki.vg/Protocol#Login_Start</a>
-     * @see Player#getName()
-     */
-    public Object getChannel(Player player) {
-        String name = player.getName();
-        Object channel = channelMap.get(name);
-        if (channel == null) {
-            channel = NMSUtils.getChannel(player);
-            channelMap.put(name, channel);
-        }
-        return channel;
-    }
-
-    /**
-     * Inject a player.
-     * Executed synchronously or asynchronously depending on what you have the associated setting set to.
-     * Injecting a player is basically pairing the cached netty channel
-     * {@link #getChannel(Player)} to a bukkit player object.
-     * Bukkit initializes the {@link Player} object some time after
-     * we inject the netty channel, so we need to pair the two.
-     * PacketEvents already injects a player when the bukkit
-     * {@link org.bukkit.event.player.PlayerJoinEvent} or {@link org.bukkit.event.player.PlayerLoginEvent}
-     * is called, depending on your {@link PacketEventsSettings#shouldInjectEarly()} setting is set to.
-     *
-     * @param player Target bukkit player.
-     */
-    public void injectPlayer(Player player) {
-        if (PacketEvents.get().getSettings().shouldInjectAsync()) {
-            injectPlayerAsync(player);
-        } else {
-            injectPlayerSync(player);
-        }
-    }
-
-    /**
-     * Eject a player.
-     * Executed synchronously or asynchronously depending on what you have the associated setting set to.
-     * Ejecting a player is basically unpairing the cached netty channel
-     * {@link #getChannel(Player)} from the bukkit player.
-     * Do this if you want to stop listening to a user's packets.
-     * PacketEvents already ejects a player when the bukkit
-     * {@link org.bukkit.event.player.PlayerQuitEvent} is called.
-     *
-     * @param player Target player.
-     */
-    public void ejectPlayer(Player player) {
-        if (PacketEvents.get().getSettings().shouldEjectAsync()) {
-            ejectPlayerAsync(player);
-        } else {
-            ejectPlayerSync(player);
-        }
-    }
-
-    /**
-     * Synchronously inject a player.
-     *
-     * @param player Target player.
-     * @see #injectPlayer(Player)
-     */
-    public void injectPlayerSync(Player player) {
-        PlayerInjectEvent injectEvent = new PlayerInjectEvent(player, false);
-        PacketEvents.get().getEventManager().callEvent(injectEvent);
-        if (!injectEvent.isCancelled()) {
-            injector.injectPlayerSync(player);
-        }
-    }
-
-    /**
-     * Asynchronously inject a player.
-     *
-     * @param player Target player.
-     * @see #injectPlayer(Player)
-     */
-    public void injectPlayerAsync(Player player) {
-        PlayerInjectEvent injectEvent = new PlayerInjectEvent(player, true);
-        PacketEvents.get().getEventManager().callEvent(injectEvent);
-        if (!injectEvent.isCancelled()) {
-            injector.injectPlayerAsync(player);
-        }
-    }
-
-    /**
-     * Synchronously eject a player.
-     *
-     * @param player Target player.
-     * @see #ejectPlayer(Player)
-     */
-    public void ejectPlayerSync(Player player) {
-        PlayerEjectEvent ejectEvent = new PlayerEjectEvent(player, false);
-        PacketEvents.get().getEventManager().callEvent(ejectEvent);
-        if (!ejectEvent.isCancelled()) {
-            injector.ejectPlayerSync(player);
-            keepAliveMap.remove(player.getUniqueId());
-            channelMap.remove(player.getName());
-        }
-    }
-
-    /**
-     * Asynchronously eject a player.
-     *
-     * @param player Target player.
-     * @see #ejectPlayer(Player)
-     */
-    public void ejectPlayerAsync(Player player) {
-        PlayerEjectEvent ejectEvent = new PlayerEjectEvent(player, true);
-        PacketEvents.get().getEventManager().callEvent(ejectEvent);
-        if (!ejectEvent.isCancelled()) {
-            injector.ejectPlayerAsync(player);
-        }
-    }
-
-    /**
-     * Write and flush a packet to a netty channel.
-     * This netty channel is an object as 1.7.10 and 1.8 and above
-     * have different netty package locations.
-     *
-     * @param channel Netty channel.
-     * @param packet  NMS Packet.
-     */
-    public void sendPacket(Object channel, Object packet) {
-        injector.sendPacket(channel, packet);
-    }
-
-    /**
-     * Make PacketEvents process an incoming packet.
-     *
-     * @param player  Packet sender.
-     * @param channel Packet sender's netty channel.
-     * @param packet  NMS Packet.
-     * @return NMS Packet, null if the event was cancelled.
-     */
-    public Object read(Player player, Object channel, Object packet) {
-        if (PacketTypeClasses.Login.Client.START.equals(packet.getClass())) {
-            WrappedPacketLoginInStart startWrapper = new WrappedPacketLoginInStart(new NMSPacket(packet));
-            WrappedGameProfile gameProfile = startWrapper.getGameProfile();
-            channelMap.put(gameProfile.name, channel);
-        }
-        if (player == null) {
-            String simpleClassName = ClassUtil.getClassSimpleName(packet.getClass());
-            //Status packet
-            if (simpleClassName.startsWith("PacketS")) {
-                final PacketStatusReceiveEvent event = new PacketStatusReceiveEvent(channel, new NMSPacket(packet));
-                PacketEvents.get().getEventManager().callEvent(event);
-                packet = event.getNMSPacket().getRawNMSPacket();
-                interceptStatusReceive(event);
-                if (event.isCancelled()) {
-                    packet = null;
-                }
-            } else {
-                //Login packet
-                final PacketLoginReceiveEvent event = new PacketLoginReceiveEvent(channel, new NMSPacket(packet));//Cache the channel
-                //f (event.getPacketId() == PacketType.Login.Client.START) {
-                //  WrappedPacketLoginInStart startWrapper = new WrappedPacketLoginInStart(event.getNMSPacket());
-                //WrappedGameProfile gameProfile = startWrapper.getGameProfile();
-                //channelMap.put(gameProfile.name, channel);
-                //}
-                PacketEvents.get().getEventManager().callEvent(event);
-                packet = event.getNMSPacket().getRawNMSPacket();
-                interceptLoginReceive(event);
-                if (event.isCancelled()) {
-                    packet = null;
-                }
-            }
-        } else {
-            final PacketPlayReceiveEvent event = new PacketPlayReceiveEvent(player, channel, new NMSPacket(packet));
-            PacketEvents.get().getEventManager().callEvent(event);
-            packet = event.getNMSPacket().getRawNMSPacket();
-            interceptRead(event);
-            if (event.isCancelled()) {
-                packet = null;
-            }
-        }
-        return packet;
-    }
-
-    /**
-     * Make PacketEvents process an outgoing packet.
-     * The NMS Packet will be null when netty should cancel a packet.
-     *
-     * @param player  Packet receiver.
-     * @param channel Packet receiver's netty channel.
-     * @param packet  NMS Packet.
-     * @return NMS Packet, null if the event was cancelled.
-     */
-    public Object write(Player player, Object channel, Object packet) {
-        if (player == null) {
-            String simpleClassName = ClassUtil.getClassSimpleName(packet.getClass());
-            //Status packet
-            if (simpleClassName.startsWith("PacketS")) {
-                final PacketStatusSendEvent event = new PacketStatusSendEvent(channel, new NMSPacket(packet));
-                PacketEvents.get().getEventManager().callEvent(event);
-                packet = event.getNMSPacket().getRawNMSPacket();
-                interceptStatusSend(event);
-                if (event.isCancelled()) {
-                    packet = null;
-                }
-            }
-            //Login packet
-            else {
-                final PacketLoginSendEvent event = new PacketLoginSendEvent(channel, new NMSPacket(packet));
-                PacketEvents.get().getEventManager().callEvent(event);
-                packet = event.getNMSPacket().getRawNMSPacket();
-                interceptLoginSend(event);
-                if (event.isCancelled()) {
-                    packet = null;
-                }
-            }
-        } else {
-            final PacketPlaySendEvent event = new PacketPlaySendEvent(player, channel, new NMSPacket(packet));
-            PacketEvents.get().getEventManager().callEvent(event);
-            packet = event.getNMSPacket().getRawNMSPacket();
-            interceptWrite(event);
-            if (event.isCancelled()) {
-                packet = null;
-            }
-        }
-        return packet;
-    }
-
-    /**
-     * Make PacketEvents process an incoming PLAY packet after minecraft has processed it.
-     * As minecraft has already processed the packet, we cannot cancel the action, nor the event.
-     *
-     * @param player  Packet sender.
-     * @param channel Netty channel of the packet sender.
-     * @param packet  NMS Packet.
-     */
-    public void postRead(Player player, Object channel, Object packet) {
-        if (player != null) {
-            //Since player != null check is done, status and login packets won't come passed this point.
-            PostPacketPlayReceiveEvent event = new PostPacketPlayReceiveEvent(player, channel, new NMSPacket(packet));
-            PacketEvents.get().getEventManager().callEvent(event);
-            interceptPostPlayReceive(event);
-        }
-    }
-
-    /**
-     * Make PacketEvents process an outgoing PLAY packet after minecraft has already sent the packet.
-     * This doesn't necessarily mean the client already received the packet,
-     * but the server has sent it for sure by this time.
-     * As minecraft has already processed the packet, we cannot cancel the action, nor the event.
-     *
-     * @param player  Packet receiver.
-     * @param channel Netty channel of the packet receiver.
-     * @param packet  NMS Packet.
-     */
-    public void postWrite(Player player, Object channel, Object packet) {
-        if (player != null) {
-            //Since player != null check is done, status and login packets won't come passed this point.
-            PostPacketPlaySendEvent event = new PostPacketPlaySendEvent(player, channel, new NMSPacket(packet));
-            PacketEvents.get().getEventManager().callEvent(event);
-            interceptPostPlaySend(event);
-        }
-    }
-
-    /**
-     * Internal processing of an incoming PLAY packet.
-     *
-     * @param event PLAY server-bound packet event.
-     */
-    private void interceptRead(PacketPlayReceiveEvent event) {
-        if (event.getPacketId() == PacketType.Play.Client.KEEP_ALIVE) {
-            UUID uuid = event.getPlayer().getUniqueId();
-            long timestamp = keepAliveMap.getOrDefault(uuid, event.getTimestamp());
-            long currentTime = event.getTimestamp();
-            long ping = currentTime - timestamp;
-            long smoothedPing = (PacketEvents.get().getPlayerUtils().getSmoothedPing(event.getPlayer()) * 3 + ping) / 4;
-            PacketEvents.get().getPlayerUtils().playerPingMap.put(uuid, (short) ping);
-            PacketEvents.get().getPlayerUtils().playerSmoothedPingMap.put(uuid, (short) smoothedPing);
-        }
-    }
-
-    /**
-     * Internal processing of an outgoing PLAY packet.
-     *
-     * @param event PLAY client-bound packet event.
-     */
-    private void interceptWrite(PacketPlaySendEvent event) {
-
-    }
-
-    /**
-     * Internal processing of an incoming LOGIN packet.
-     *
-     * @param event LOGIN server-bound packet event.
-     */
-    private void interceptLoginReceive(PacketLoginReceiveEvent event) {
-        if (event.getPacketId() == PacketType.Login.Client.HANDSHAKE) {
-            WrappedPacketLoginInHandshake handshake = new WrappedPacketLoginInHandshake(event.getNMSPacket());
-            int protocolVersion = handshake.getProtocolVersion();
-            ClientVersion version = ClientVersion.getClientVersion(protocolVersion);
-            PacketEvents.get().getPlayerUtils().tempClientVersionMap.put(event.getSocketAddress(), version);
-        }
-    }
-
-    /**
-     * Internal processing of an outgoing LOGIN packet.
-     *
-     * @param event client-bound LOGIN packet event.
-     */
-    private void interceptLoginSend(PacketLoginSendEvent event) {
-
-    }
-
-    /**
-     * Internal processing of an incoming STATUS packet.
-     *
-     * @param event server-bound STATUS packet event.
-     */
-    private void interceptStatusReceive(PacketStatusReceiveEvent event) {
-
-    }
-
-    /**
-     * Internal processing of an outgoing STATUS packet.
-     *
-     * @param event client-bound STATUS packet event.
-     */
-    private void interceptStatusSend(PacketStatusSendEvent event) {
-
-    }
-
-    /**
-     * Internal processing of a packet that has already been processed by minecraft.
-     *
-     * @param event post server-bound play packet event.
-     */
-    private void interceptPostPlayReceive(PostPacketPlayReceiveEvent event) {
-
-    }
-
-    /**
-     * Internal processing of a packet that has already been sent to a client.
-     * Doesn't necessarily mean the client has received it yet.
-     *
-     * @param event post client-bound play packet event.
-     */
-    private void interceptPostPlaySend(PostPacketPlaySendEvent event) {
-        if (event.getPacketId() == PacketType.Play.Server.KEEP_ALIVE) {
-            if (event.getPlayer() != null) {
-                keepAliveMap.put(event.getPlayer().getUniqueId(), event.getTimestamp());
-            }
-        }
-    }
-
-    /**
-     * If you are using the EarlyInjector,
-     * calling this close method will unregister the channel handlers it registered when the plugin enabled.
-     * PacketEvents already unregisters them in the {@link PacketEvents#terminate()} method.
-     */
-    public void cleanup() {
-        injector.cleanup();
-    }
-
-    /**
-     * If you are using the EarlyInjector,
-     * calling this close method will unregister the channel handlers it registered when the plugin enabled
-     * ASYNCHRONOUSLY.
-     * PacketEvents already unregisters them in the {@link PacketEvents#terminate()} method.
-     */
-    public void cleanupAsync() {
-        injector.cleanupAsync();
-    }
-}

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

@@ -1,33 +1,43 @@
+/*
+ * 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 org.bukkit.entity.Player;
 
 public interface ChannelInjector {
-    default void prepare() {
-
+    default boolean isBound() {
+        return true;
     }
 
-    default void cleanup() {
+    void inject();
 
-    }
+    void eject();
 
-    default void cleanupAsync() {
-        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
-            @Override
-            public void run() {
-                cleanup();
-            }
-        });
-    }
+    void injectPlayer(Player player);
 
-    void injectPlayerSync(Player player);
+    void ejectPlayer(Player player);
 
-    void ejectPlayerSync(Player player);
+    boolean hasInjected(Player player);
 
-    void injectPlayerAsync(Player player);
+    void writePacket(Object channel, Object rawNMSPacket);
 
-    void ejectPlayerAsync(Player player);
+    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,65 +1,98 @@
+/*
+ * 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.injector.earlyinjector.EarlyChannelInjector7;
-import io.github.retrooper.packetevents.injector.earlyinjector.EarlyChannelInjector8;
-import io.github.retrooper.packetevents.injector.lateinjector.LateChannelInjector7;
-import io.github.retrooper.packetevents.injector.lateinjector.LateChannelInjector8;
+import io.github.retrooper.packetevents.event.impl.PlayerEjectEvent;
+import io.github.retrooper.packetevents.event.impl.PlayerInjectEvent;
+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;
 
-public class GlobalChannelInjector implements ChannelInjector {
-    private final ChannelInjector injector;
+public class GlobalChannelInjector {
+    private ChannelInjector injector;
 
-    public GlobalChannelInjector() {
+    public void load() {
         boolean legacy = NMSUtils.legacyNettyImportMode;
-        //Early injector
-        if (PacketEvents.get().getSettings().shouldInjectEarly()) {
-            injector = legacy ? new EarlyChannelInjector7() : new EarlyChannelInjector8();
-        }
-        //Late injector
-        else {
-            injector = legacy ? new LateChannelInjector7() : new LateChannelInjector8();
+        if (!PacketEvents.get().getSettings().shouldUseCompatibilityInjector()) {
+            injector = legacy ? new EarlyChannelInjectorLegacy() : new EarlyChannelInjectorModern();
+        } else {
+            injector = legacy ? new LateChannelInjectorLegacy() : new LateChannelInjectorModern();
         }
     }
 
-    @Override
-    public void prepare() {
-        injector.prepare();
+    public boolean isBound() {
+        return injector.isBound();
     }
 
-    @Override
-    public void cleanup() {
-        injector.cleanup();
+    public void inject() {
+        try {
+            //Try inject...
+            injector.inject();
+        } catch (Exception ex) {
+            //Failed to inject! Let us revert to the compatibility injector and re-inject.
+            if (injector instanceof EarlyInjector) {
+                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!");
+                ex.printStackTrace();
+            }
+        }
     }
 
-    @Override
-    public void cleanupAsync() {
-        injector.cleanupAsync();
+    public void eject() {
+        injector.eject();
     }
 
-    @Override
-    public void injectPlayerSync(Player player) {
-        injector.injectPlayerSync(player);
+    public void injectPlayer(Player player) {
+        PlayerInjectEvent injectEvent = new PlayerInjectEvent(player);
+        PacketEvents.get().callEvent(injectEvent);
+        if (!injectEvent.isCancelled()) {
+            injector.injectPlayer(player);
+        }
     }
 
-    @Override
-    public void ejectPlayerSync(Player player) {
-        injector.ejectPlayerSync(player);
+    public void ejectPlayer(Player player) {
+        PlayerEjectEvent ejectEvent = new PlayerEjectEvent(player);
+        PacketEvents.get().callEvent(ejectEvent);
+        if (!ejectEvent.isCancelled()) {
+            injector.ejectPlayer(player);
+        }
     }
 
-    @Override
-    public void injectPlayerAsync(Player player) {
-        injector.injectPlayerAsync(player);
+    public boolean hasInjected(Player player) {
+        return injector.hasInjected(player);
     }
 
-    @Override
-    public void ejectPlayerAsync(Player player) {
-        injector.ejectPlayerAsync(player);
+    public void writePacket(Object ch, Object rawNMSPacket) {
+        injector.writePacket(ch, rawNMSPacket);
     }
 
-    @Override
-    public void sendPacket(Object channel, Object rawNMSPacket) {
-        injector.sendPacket(channel, 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/EarlyChannelInjector7.java

@@ -1,337 +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.PacketEvents;
-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.server.ServerVersion;
-import net.minecraft.util.io.netty.channel.*;
-import org.bukkit.entity.Player;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.NoSuchElementException;
-
-/**
- * 1.7.10 Spigot Early channel injector.
- * This is an early injector  for 1.7.10 spigot servers.
- * The netty import on spigot changed since 1.8.
- * So we needed to make a new class using the older import location to support 1.7.10.
- * This is why we also commonly use a java {@link Object} class when it comes to netty channels
- * in some classes to maintain support for both netty imports.
- *
- * @author retrooper
- * @since 1.8
- */
-public class EarlyChannelInjector7 implements EarlyInjector {
-    /**
-     * Netty minecraft server channels.
-     */
-    private final List<Channel> serverChannels = new ArrayList<>();
-
-    /**
-     * First channel initializer.
-     * Used to inject incoming channels.
-     */
-    private ChannelInitializer<Channel> firstChannelInitializer;
-
-    /**
-     * Second channel initializer.
-     */
-    private ChannelInitializer<Channel> secondChannelInitializer;
-
-    /**
-     * Channel handler.
-     */
-    private ChannelInboundHandlerAdapter channelHandler;
-
-    /**
-     * Network managers.
-     */
-    private List<Object> networkMarkers;
-
-
-    /**
-     * Access minecraft's network managers to synchronize against as they interfere with our channel injection.
-     * Initiate the channel initializers and the channel handler.
-     * Access minecraft's server channels and add our own.
-     */
-    @Override
-    public void prepare() {
-        networkMarkers = NMSUtils.getNetworkMarkers();
-        firstChannelInitializer = new ChannelInitializer<Channel>() {
-            @Override
-            protected void initChannel(final Channel channel) {
-                if (networkMarkers != null) {
-                    synchronized (networkMarkers) {
-                        channel.eventLoop().execute(new Runnable() {
-                            @Override
-                            public void run() {
-                                if (PacketEvents.get().getServerUtils().getVersion().isHigherThan(ServerVersion.v_1_11_2)) {
-                                    channel.eventLoop().execute(new Runnable() {
-                                        @Override
-                                        public void run() {
-                                            injectChannel(channel);
-                                        }
-                                    });
-                                } else {
-                                    injectChannel(channel);
-                                }
-                            }
-                        });
-                    }
-                } else {
-                    channel.eventLoop().execute(new Runnable() {
-                        @Override
-                        public void run() {
-                            if (PacketEvents.get().getServerUtils().getVersion().isHigherThan(ServerVersion.v_1_11_2)) {
-                                channel.eventLoop().execute(new Runnable() {
-                                    @Override
-                                    public void run() {
-                                        injectChannel(channel);
-                                    }
-                                });
-                            } else {
-                                injectChannel(channel);
-                            }
-                        }
-                    });
-                }
-            }
-        };
-
-        secondChannelInitializer = new ChannelInitializer<Channel>() {
-            @Override
-            protected void initChannel(Channel channel) {
-                channel.pipeline().addLast(firstChannelInitializer);
-            }
-        };
-
-        channelHandler = new ChannelInboundHandlerAdapter() {
-            @Override
-            public void channelRead(ChannelHandlerContext ctx, Object msg) {
-                Channel channel = (Channel) msg;
-                channel.pipeline().addFirst(secondChannelInitializer);
-                ctx.fireChannelRead(msg);
-            }
-        };
-
-        //Wrapper for the minecraft server connection.
-        WrappedPacket serverConnectionWrapper = new WrappedPacket(new NMSPacket(NMSUtils.getMinecraftServerConnection()));
-        boolean searching = true;
-        for (int i = 0; searching; i++) {
-            try {
-                //Get the list.
-                List<Object> serverChannelList = (List<Object>) serverConnectionWrapper.readObject(i, List.class);
-                for (Object serverChannel : serverChannelList) {
-                    //Is this the server channel list?
-                    if (serverChannel instanceof ChannelFuture) {
-                        //Yes it is...
-                        Channel channel = ((ChannelFuture) serverChannel).channel();
-                        serverChannels.add(channel);
-                        //Add our channel handler to all the server channel pipelines.
-                        channel.pipeline().addFirst(channelHandler);
-                        searching = false;
-                    }
-                }
-            } catch (Exception ex) {
-                break;
-            }
-        }
-    }
-
-    /**
-     * Remove our channel handler from all server channel pipelines from the current thread.
-     */
-    @Override
-    public void cleanup() {
-        for (Channel channel : serverChannels) {
-            try {
-                channel.pipeline().remove(channelHandler);
-            } catch (NoSuchElementException ignored) {
-
-            }
-        }
-    }
-
-    /**
-     * Inject a netty channel to listen to packets.
-     * If already injected, get the channel interceptor.
-     *
-     * @param ch Netty channel.
-     * @return {@link PlayerChannelInterceptor}
-     */
-    @Override
-    public PlayerChannelInterceptor injectChannel(Object ch) {
-        Channel channel = (Channel) ch;
-        String handlerName = PacketEvents.handlerName;
-        PlayerChannelInterceptor interceptor = (PlayerChannelInterceptor) channel.pipeline().get(handlerName);
-        if (interceptor == null) {
-            interceptor = new PlayerChannelInterceptor();
-            if (channel.pipeline().get("packet_handler") != null) {
-                channel.pipeline().addBefore("packet_handler", handlerName, interceptor);
-            } else {
-                throw new IllegalStateException("Failed to inject an incoming channel due to \"packet_handler\" not being added to the pipeline! Let them rejoin!");
-            }
-        }
-        return interceptor;
-    }
-
-    /**
-     * Eject a netty channel.
-     *
-     * @param ch Netty channel.
-     */
-    @Override
-    public void ejectChannel(Object ch) {
-        Channel channel = (Channel) ch;
-        String handlerName = PacketEvents.handlerName;
-        if (channel.pipeline().get(handlerName) != null) {
-            channel.pipeline().remove(handlerName);
-        }
-    }
-
-    /**
-     * Inject a player on the current thread.
-     *
-     * @param player Target player.
-     */
-    @Override
-    public void injectPlayerSync(Player player) {
-        Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-        injectChannel(channel).player = player;
-    }
-
-    /**
-     * Eject a player on the current thread.
-     *
-     * @param player Target player.
-     */
-    @Override
-    public void ejectPlayerSync(Player player) {
-        Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-        ejectChannel(channel);
-        PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
-        PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
-    }
-
-    /**
-     * Inject a player on our custom inject and eject (fixed) thread pool (=asynchronously).
-     *
-     * @param player Target player.
-     */
-    @Override
-    public void injectPlayerAsync(Player player) {
-        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
-            @Override
-            public void run() {
-                Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-                injectChannel(channel).player = player;
-            }
-        });
-    }
-
-    /**
-     * Eject a player on our custom inject and eject (fixed) thread pool (=asynchronously).
-     *
-     * @param player Target player.
-     */
-    @Override
-    public void ejectPlayerAsync(Player player) {
-        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
-            @Override
-            public void run() {
-                Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-                ejectChannel(channel);
-                PacketEvents.get().packetHandlerInternal.keepAliveMap.remove(player.getUniqueId());
-                PacketEvents.get().packetHandlerInternal.channelMap.remove(player.getName());
-                PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
-                PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
-            }
-        });
-    }
-
-    /**
-     * Send a raw NMS packet to a netty channel.
-     *
-     * @param ch     Netty channel.
-     * @param packet Raw NMS Packet.
-     */
-    @Override
-    public void sendPacket(Object ch, Object packet) {
-        Channel channel = (Channel) ch;
-        channel.writeAndFlush(packet);
-    }
-
-    /**
-     * Player channel interceptor.
-     *
-     * @author retrooper
-     * @since 1.8
-     */
-    public static class PlayerChannelInterceptor extends ChannelDuplexHandler {
-        /**
-         * Associated player.
-         * This is null until you inject the player.
-         * (We inject the PLAYER by PlayerLoginEvent or PlayerJoinEvent depending on your settings)
-         */
-        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 {
-            packet = PacketEvents.get().packetHandlerInternal.read(player, ctx.channel(), packet);
-            if (packet != null) {
-                super.channelRead(ctx, packet);
-                PacketEvents.get().packetHandlerInternal.postRead(player, ctx.channel(), packet);
-            }
-        }
-
-        /**
-         * 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 {
-            packet = PacketEvents.get().packetHandlerInternal.write(player, ctx.channel(), packet);
-            if (packet != null) {
-                super.write(ctx, packet, promise);
-                PacketEvents.get().packetHandlerInternal.postWrite(player, ctx.channel(), packet);
-            }
-        }
-    }
-}

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

@@ -1,332 +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.PacketEvents;
-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.server.ServerVersion;
-import io.netty.channel.*;
-import org.bukkit.entity.Player;
-
-import java.util.ArrayList;
-import java.util.List;
-import java.util.NoSuchElementException;
-
-/**
- * 1.8 (and above) Spigot Early channel injector.
- * This is an early injector for 1.8 (and above) spigot servers.
- * The netty import on spigot changed since 1.8.
- * So we needed to make separate classes for the 1.7.10 and the 1.8+ injector.
- * This is why we also commonly use a java {@link Object} class when it comes to netty channels
- * in some classes to maintain support for both netty imports.
- *
- * @author retrooper
- * @since 1.8
- */
-public class EarlyChannelInjector8 implements EarlyInjector {
-    /**
-     * Netty minecraft server channels.
-     */
-    private final List<Channel> serverChannels = new ArrayList<>();
-
-    /**
-     * First channel initializer.
-     * Used to inject incoming channels.
-     */
-    private ChannelInitializer<Channel> firstChannelInitializer;
-
-    /**
-     * Second channel initializer.
-     */
-    private ChannelInitializer<Channel> secondChannelInitializer;
-
-    /**
-     * Channel handler.
-     */
-    private ChannelInboundHandlerAdapter channelHandler;
-
-    /**
-     * Network managers.
-     */
-    private List<Object> networkMarkers;
-
-    /**
-     * Access minecraft's network managers to synchronize against as they interfere with our channel injection.
-     * Initiate the channel initializers and the channel handler.
-     * Access minecraft's server channels and add our own.
-     */
-    @Override
-    public void prepare() {
-        networkMarkers = NMSUtils.getNetworkMarkers();
-        firstChannelInitializer = new ChannelInitializer<Channel>() {
-            @Override
-            protected void initChannel(final Channel channel) {
-                if (networkMarkers != null) {
-                    synchronized (networkMarkers) {
-                        if (PacketEvents.get().getServerUtils().getVersion().isHigherThan(ServerVersion.v_1_11_2)) {
-                            channel.eventLoop().execute(new Runnable() {
-                                @Override
-                                public void run() {
-                                    injectChannel(channel);
-                                }
-                            });
-                        } else {
-                            injectChannel(channel);
-                        }
-                    }
-                } else {
-                    channel.eventLoop().execute(new Runnable() {
-                        @Override
-                        public void run() {
-                            if (PacketEvents.get().getServerUtils().getVersion().isHigherThan(ServerVersion.v_1_11_2)) {
-                                channel.eventLoop().execute(new Runnable() {
-                                    @Override
-                                    public void run() {
-                                        injectChannel(channel);
-                                    }
-                                });
-                            } else {
-                                injectChannel(channel);
-                            }
-                        }
-                    });
-                }
-            }
-        };
-        secondChannelInitializer = new ChannelInitializer<Channel>() {
-            @Override
-            protected void initChannel(Channel channel) {
-                channel.pipeline().addLast(firstChannelInitializer);
-            }
-        };
-
-        channelHandler = new ChannelInboundHandlerAdapter() {
-            @Override
-            public void channelRead(ChannelHandlerContext ctx, Object msg) {
-                Channel channel = (Channel) msg;
-                channel.pipeline().addFirst(secondChannelInitializer);
-                ctx.fireChannelRead(msg);
-            }
-        };
-        //Wrapper for the minecraft server connection.
-        WrappedPacket serverConnectionWrapper = new WrappedPacket(new NMSPacket(NMSUtils.getMinecraftServerConnection()));
-        boolean searching = true;
-        for (int i = 0; searching; i++) {
-            try {
-                //Get the list.
-                List<Object> serverChannelList = (List<Object>) serverConnectionWrapper.readObject(i, List.class);
-                for (Object serverChannel : serverChannelList) {
-                    //Is this the server channel list?
-                    if (serverChannel instanceof ChannelFuture) {
-                        //Yes it is...
-                        Channel channel = ((ChannelFuture) serverChannel).channel();
-                        serverChannels.add(channel);
-                        //Add our channel handler to all server channel pipelines.
-                        channel.pipeline().addFirst(channelHandler);
-                        searching = false;
-                    }
-                }
-            } catch (Exception ex) {
-                break;
-            }
-        }
-    }
-
-    /**
-     * Remove our channel handler from all server channel pipelines from the current thread.
-     */
-    @Override
-    public void cleanup() {
-        for (Channel channel : serverChannels) {
-            try {
-                channel.pipeline().remove(channelHandler);
-            } catch (NoSuchElementException ignored) {
-
-            }
-        }
-    }
-
-    /**
-     * Inject a netty channel to listen to packets.
-     * If already injected, get the channel interceptor.
-     *
-     * @param ch Netty channel.
-     * @return {@link PlayerChannelInterceptor}
-     */
-    @Override
-    public PlayerChannelInterceptor injectChannel(Object ch) {
-        Channel channel = (Channel) ch;
-        final String handlerName = PacketEvents.handlerName;
-        try {
-            PlayerChannelInterceptor interceptor = (PlayerChannelInterceptor) channel.pipeline().get(handlerName);
-            if (interceptor == null) {
-                interceptor = new PlayerChannelInterceptor();
-                if (channel.pipeline().get("packet_handler") != null) {
-                    channel.pipeline().addBefore("packet_handler", handlerName, interceptor);
-                }
-            }
-            return interceptor;
-        } catch (IllegalArgumentException ex) {
-            //Let us try again
-            return (PlayerChannelInterceptor) channel.pipeline().get(handlerName);
-        }
-    }
-
-    /**
-     * Eject a netty channel.
-     *
-     * @param ch Netty channel.
-     */
-    @Override
-    public void ejectChannel(Object ch) {
-        Channel channel = (Channel) ch;
-        String handlerName = PacketEvents.handlerName;
-        if (channel.pipeline().get(handlerName) != null) {
-            channel.pipeline().remove(handlerName);
-        }
-    }
-
-    /**
-     * Inject a player on the current thread.
-     *
-     * @param player Target player.
-     */
-    @Override
-    public void injectPlayerSync(Player player) {
-        Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-        injectChannel(channel).player = player;
-    }
-
-    /**
-     * Eject a player on the current thread.
-     *
-     * @param player Target player.
-     */
-    @Override
-    public void ejectPlayerSync(Player player) {
-        Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-        ejectChannel(channel);
-        PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
-        PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
-    }
-
-    /**
-     * Inject a player on our custom inject and eject (fixed) thread pool (=asynchronously).
-     *
-     * @param player Target player.
-     */
-    @Override
-    public void injectPlayerAsync(Player player) {
-        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
-            @Override
-            public void run() {
-                Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-                injectChannel(channel).player = player;
-            }
-        });
-    }
-
-    /**
-     * Eject a player on our custom inject and eject (fixed) thread pool (=asynchronously).
-     *
-     * @param player Target player.
-     */
-    @Override
-    public void ejectPlayerAsync(Player player) {
-        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
-            @Override
-            public void run() {
-                Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-                ejectChannel(channel);
-                PacketEvents.get().packetHandlerInternal.keepAliveMap.remove(player.getUniqueId());
-                PacketEvents.get().packetHandlerInternal.channelMap.remove(player.getName());
-                PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
-                PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
-            }
-        });
-    }
-
-    /**
-     * Send a raw NMS packet to a netty channel.
-     *
-     * @param ch     Netty channel.
-     * @param packet Raw NMS Packet.
-     */
-    @Override
-    public void sendPacket(Object ch, Object packet) {
-        Channel channel = (Channel) ch;
-        channel.writeAndFlush(packet);
-    }
-
-    /**
-     * Player channel interceptor.
-     *
-     * @author retrooper
-     * @since 1.8
-     */
-    public static class PlayerChannelInterceptor extends ChannelDuplexHandler {
-        /**
-         * Associated player.
-         * This is null until you inject the player.
-         * (We inject the PLAYER by PlayerLoginEvent or PlayerJoinEvent depending on your settings)
-         */
-        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 {
-            packet = PacketEvents.get().packetHandlerInternal.read(player, ctx.channel(), packet);
-            if (packet != null) {
-                super.channelRead(ctx, packet);
-                PacketEvents.get().packetHandlerInternal.postRead(player, ctx.channel(), packet);
-            }
-        }
-
-        /**
-         * 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 {
-            packet = PacketEvents.get().packetHandlerInternal.write(player, ctx.channel(), packet);
-            if (packet != null) {
-                super.write(ctx, packet, promise);
-                PacketEvents.get().packetHandlerInternal.postWrite(player, ctx.channel(), packet);
-            }
-        }
-    }
-}

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

@@ -1,13 +0,0 @@
-package io.github.retrooper.packetevents.injector.earlyinjector;
-
-import io.github.retrooper.packetevents.injector.ChannelInjector;
-
-public interface EarlyInjector extends ChannelInjector {
-    void prepare();
-
-    void cleanup();
-
-    Object injectChannel(Object channel);
-
-    void ejectChannel(Object channel);
-}

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

@@ -1,102 +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;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import net.minecraft.util.io.netty.channel.Channel;
-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;
-
-public class LateChannelInjector7 implements LateInjector {
-    @Override
-    public void injectPlayerSync(Player player) {
-        final ChannelDuplexHandler channelDuplexHandler = new ChannelDuplexHandler() {
-            @Override
-            public void channelRead(ChannelHandlerContext ctx, Object packet) throws Exception {
-                packet = PacketEvents.get().packetHandlerInternal.read(player, ctx.channel(), packet);
-                if (packet != null) {
-                    super.channelRead(ctx, packet);
-                    PacketEvents.get().packetHandlerInternal.postRead(player, ctx.channel(), packet);
-                }
-            }
-
-            @Override
-            public void write(ChannelHandlerContext ctx, Object packet, ChannelPromise promise) throws Exception {
-                packet = PacketEvents.get().packetHandlerInternal.write(player, ctx.channel(), packet);
-                if (packet != null) {
-                    super.write(ctx, packet, promise);
-                    PacketEvents.get().packetHandlerInternal.postWrite(player, ctx.channel(), packet);
-                }
-            }
-        };
-        final Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-        channel.pipeline().addBefore("packet_handler", PacketEvents.handlerName, channelDuplexHandler);
-    }
-
-    @Override
-    public void ejectPlayerSync(Player player) {
-        final Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-        if (channel.pipeline().get(PacketEvents.handlerName) != null) {
-            channel.pipeline().remove(PacketEvents.handlerName);
-        }
-        PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
-        PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
-    }
-
-    @Override
-    public void injectPlayerAsync(Player player) {
-        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
-            @Override
-            public void run() {
-                injectPlayerSync(player);
-            }
-        });
-    }
-
-    @Override
-    public void ejectPlayerAsync(Player player) {
-        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
-            @Override
-            public void run() {
-                final Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-                if (channel.pipeline().get(PacketEvents.handlerName) != null) {
-                    channel.pipeline().remove(PacketEvents.handlerName);
-                }
-                PacketEvents.get().packetHandlerInternal.keepAliveMap.remove(player.getUniqueId());
-                PacketEvents.get().packetHandlerInternal.channelMap.remove(player.getName());
-                PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
-                PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
-            }
-        });
-    }
-
-    @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/LateChannelInjector8.java

@@ -1,112 +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;
-
-import io.github.retrooper.packetevents.PacketEvents;
-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 LateChannelInjector8 implements LateInjector {
-    @Override
-    public void injectPlayerSync(Player player) {
-        final ChannelDuplexHandler channelDuplexHandler = new ChannelDuplexHandler() {
-            @Override
-            public void channelRead(ChannelHandlerContext ctx, Object packet) throws Exception {
-                packet = PacketEvents.get().packetHandlerInternal.read(player, ctx.channel(), packet);
-                if (packet != null) {
-                    super.channelRead(ctx, packet);
-                    PacketEvents.get().packetHandlerInternal.postRead(player, ctx.channel(), packet);
-                }
-            }
-
-            @Override
-            public void write(ChannelHandlerContext ctx, Object packet, ChannelPromise promise) throws Exception {
-                packet = PacketEvents.get().packetHandlerInternal.write(player, ctx.channel(), packet);
-                if (packet != null) {
-                    super.write(ctx, packet, promise);
-                    PacketEvents.get().packetHandlerInternal.postWrite(player, ctx.channel(), packet);
-                }
-            }
-        };
-        final Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-        channel.pipeline().addBefore("packet_handler", PacketEvents.handlerName, channelDuplexHandler);
-    }
-
-    @Override
-    public void ejectPlayerSync(Player player) {
-        final Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-        if (channel.pipeline().get(PacketEvents.handlerName) != null) {
-            try {
-                channel.pipeline().remove(PacketEvents.handlerName);
-            } catch (NoSuchElementException ignored) {
-
-            }
-        }
-        PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
-        PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
-    }
-
-    @Override
-    public void injectPlayerAsync(Player player) {
-        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
-            @Override
-            public void run() {
-                injectPlayerSync(player);
-            }
-        });
-    }
-
-    @Override
-    public void ejectPlayerAsync(Player player) {
-        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
-            @Override
-            public void run() {
-                final Channel channel = (Channel) PacketEvents.get().packetHandlerInternal.getChannel(player);
-                if (channel.pipeline().get(PacketEvents.handlerName) != null) {
-                    try {
-                        channel.pipeline().remove(PacketEvents.handlerName);
-                    } catch (NoSuchElementException ignored) {
-
-                    }
-                }
-                PacketEvents.get().packetHandlerInternal.keepAliveMap.remove(player.getUniqueId());
-                PacketEvents.get().packetHandlerInternal.channelMap.remove(player.getName());
-                PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
-                PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
-            }
-        });
-    }
-
-    @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/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/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

@@ -0,0 +1,333 @@
+/*
+ * 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.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.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 org.bukkit.entity.Player;
+import org.bukkit.plugin.PluginDescriptionFile;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+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 {
+            Object serverConnection = NMSUtils.getMinecraftServerConnection();
+            for (Field field : serverConnection.getClass().getDeclaredFields()) {
+                field.setAccessible(true);
+                Object value = null;
+                try {
+                    value = field.get(serverConnection);
+                } catch (IllegalAccessException e) {
+                    e.printStackTrace();
+                }
+                if (value instanceof List) {
+                    //Get the list.
+                    List<?> listWrapper = new ListWrapper((List<?>) value) {
+                        @Override
+                        public void processAdd(Object o) {
+                            if (o instanceof ChannelFuture) {
+                                try {
+                                    injectChannelFuture((ChannelFuture) o);
+                                } catch (Exception ex) {
+                                    ex.printStackTrace();
+                                }
+                            }
+                        }
+                    };
+                    HashMap<Field, Object> map = new HashMap<>();
+                    map.put(field, serverConnection);
+                    injectedLists.add(map);
+
+                    field.set(serverConnection, listWrapper);
+
+                    synchronized (listWrapper) {
+                        for (Object serverChannel : (List<?>) value) {
+                            //Is this the server channel future list?
+                            if (serverChannel instanceof ChannelFuture) {
+                                //Yes it is...
+                                injectChannelFuture((ChannelFuture) serverChannel);
+                            } else {
+                                break;//Wrong list
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Exception ex) {
+            PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to inject!");
+            ex.printStackTrace();
+        }
+
+        //Player channels might have been registered already. Let us add our handlers. We are a little late though.
+        //This only happens when you join extremely early on older versions of minecraft.
+        List<Object> networkManagers = NMSUtils.getNetworkManagers();
+        synchronized (networkManagers) {
+            for (Object networkManager : networkManagers) {
+                WrappedPacket networkManagerWrapper = new WrappedPacket(new NMSPacket(networkManager), NMSUtils.networkManagerClass);
+                Channel channel = (Channel) networkManagerWrapper.readObject(0, NMSUtils.nettyChannelClass);
+                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.get().getHandlerName(), new PlayerChannelHandlerLegacy());
+                }
+            }
+        }
+    }
+
+
+    private void injectChannelFuture(ChannelFuture channelFuture) {
+        List<String> channelHandlerNames = channelFuture.channel().pipeline().names();
+        ChannelHandler bootstrapAcceptor = null;
+        Field bootstrapAcceptorField = null;
+        for (String handlerName : channelHandlerNames) {
+            ChannelHandler handler = channelFuture.channel().pipeline().get(handlerName);
+            try {
+                bootstrapAcceptorField = handler.getClass().getDeclaredField("childHandler");
+                bootstrapAcceptorField.setAccessible(true);
+                bootstrapAcceptorField.get(handler);
+                bootstrapAcceptor = handler;
+            } catch (Exception ignored) {
+
+            }
+        }
+
+        if (bootstrapAcceptor == null) {
+            bootstrapAcceptor = channelFuture.channel().pipeline().first();
+        }
+
+        ChannelInitializer<?> oldChannelInitializer = null;
+        try {
+            oldChannelInitializer = (ChannelInitializer<?>) bootstrapAcceptorField.get(bootstrapAcceptor);
+
+            ChannelInitializer<?> channelInitializer = new PEChannelInitializerLegacy(oldChannelInitializer);
+
+            //Replace the old channel initializer with our own.
+            bootstrapAcceptorField.setAccessible(true);
+            bootstrapAcceptorField.set(bootstrapAcceptor, channelInitializer);
+
+            injectedFutures.add(channelFuture);
+        } catch (IllegalAccessException e) {
+            ClassLoader cl = bootstrapAcceptor.getClass().getClassLoader();
+            if (cl.getClass().getName().equals("org.bukkit.plugin.java.PluginClassLoader")) {
+                PluginDescriptionFile yaml = null;
+                try {
+                    yaml = (PluginDescriptionFile) PluginDescriptionFile.class.getDeclaredField("description").get(cl);
+                } catch (IllegalAccessException | NoSuchFieldException e2) {
+                    e2.printStackTrace();
+                }
+                throw new IllegalStateException("PacketEvents failed to inject, because of " + bootstrapAcceptor.getClass().getName() + ", you might want to try running without " + yaml.getName() + "?");
+            } else {
+                throw new IllegalStateException("PacketEvents failed to find core component 'childHandler', please check your plugins. issue: " + bootstrapAcceptor.getClass().getName());
+            }
+        }
+
+    }
+
+    @Override
+    public void eject() {
+        Field childHandlerField = null;
+        for (ChannelFuture future : injectedFutures) {
+            List<String> names = future.channel().pipeline().names();
+            ChannelHandler bootstrapAcceptor = null;
+            // Pick best
+            for (String name : names) {
+                try {
+                    ChannelHandler handler = future.channel().pipeline().get(name);
+                    if (childHandlerField == null) {
+                        childHandlerField = handler.getClass().getDeclaredField("childHandler");
+                        childHandlerField.setAccessible(true);
+                    }
+
+                    ChannelInitializer<Channel> oldInit = (ChannelInitializer<Channel>) childHandlerField.get(handler);
+                    if (oldInit instanceof PEChannelInitializerLegacy) {
+                        bootstrapAcceptor = handler;
+                    }
+                } catch (Exception e) {
+                    // Not this one
+                }
+            }
+            // Default to first
+            if (bootstrapAcceptor == null) {
+                bootstrapAcceptor = future.channel().pipeline().first();
+            }
+
+            try {
+                ChannelInitializer<Channel> oldInit = (ChannelInitializer<Channel>) childHandlerField.get(bootstrapAcceptor);
+                if (oldInit instanceof PEChannelInitializerLegacy) {
+                    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!");
+            }
+        }
+        injectedFutures.clear();
+
+        for (Map<Field, Object> map : injectedLists) {
+            try {
+                for (Field key : map.keySet()) {
+                    key.setAccessible(true);
+                    Object o = map.get(key);
+                    if (o instanceof ListWrapper) {
+                        key.set(o, ((ListWrapper) o).getOriginalList());
+                    }
+                }
+
+            } catch (IllegalAccessException e) {
+                //PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to eject the injection handler! Please reboot!!");
+            }
+        }
+
+        injectedLists.clear();
+    }
+
+    @Override
+    public void injectPlayer(Player player) {
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
+        if (channel != null) {
+            updatePlayerObject(player, channel);
+        }
+    }
+
+    @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) {
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
+        if (channel == null) {
+            return false;
+        }
+        PlayerChannelHandlerLegacy handler = getHandler(channel);
+        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.get().getHandlerName());
+        if (handler instanceof PlayerChannelHandlerLegacy) {
+            return (PlayerChannelHandlerLegacy) handler;
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public void updatePlayerObject(Player player, Object rawChannel) {
+        PlayerChannelHandlerLegacy handler = getHandler(rawChannel);
+        if (handler != null) {
+            handler.player = player;
+        }
+    }
+}

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

@@ -0,0 +1,342 @@
+/*
+ * 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.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.ClassUtil;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelFuture;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelInitializer;
+import org.bukkit.entity.Player;
+import org.bukkit.plugin.PluginDescriptionFile;
+
+import java.lang.reflect.Field;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+
+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);
+                Object value = null;
+                try {
+                    value = field.get(serverConnection);
+                } catch (IllegalAccessException e) {
+                    e.printStackTrace();
+                }
+                if (value instanceof List) {
+                    //Get the list.
+                    List listWrapper = new ListWrapper((List) value) {
+                        @Override
+                        public void processAdd(Object o) {
+                            if (o instanceof ChannelFuture) {
+                                try {
+                                    injectChannelFuture((ChannelFuture) o);
+                                } catch (Exception ex) {
+                                    ex.printStackTrace();
+                                }
+                            }
+                        }
+                    };
+                    HashMap<Field, Object> map = new HashMap<>();
+                    map.put(field, serverConnection);
+                    injectedLists.add(map);
+
+                    field.set(serverConnection, listWrapper);
+
+                    synchronized (listWrapper) {
+                        for (Object serverChannel : (List) value) {
+                            //Is this the server channel future list?
+                            if (serverChannel instanceof ChannelFuture) {
+                                //Yes it is...
+                                injectChannelFuture((ChannelFuture) serverChannel);
+                            } else {
+                                break;//Wrong list
+                            }
+                        }
+                    }
+                }
+            }
+        } catch (Exception ex) {
+            throw new IllegalStateException("PacketEvents failed to inject!", ex);
+        }
+
+        //Player channels might have been registered already. Let us add our handlers. We are a little late though.
+        //This only happens when you join extremely early on older versions of minecraft.
+        List<Object> networkManagers = NMSUtils.getNetworkManagers();
+        synchronized (networkManagers) {
+            for (Object networkManager : networkManagers) {
+                WrappedPacket networkManagerWrapper = new WrappedPacket(new NMSPacket(networkManager), NMSUtils.networkManagerClass);
+                Channel channel = (Channel) networkManagerWrapper.readObject(0, NMSUtils.nettyChannelClass);
+                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.get().getHandlerName(), new PlayerChannelHandlerModern());
+                }
+            }
+        }
+    }
+
+
+    private void injectChannelFuture(ChannelFuture channelFuture) {
+        List<String> channelHandlerNames = channelFuture.channel().pipeline().names();
+        ChannelHandler bootstrapAcceptor = null;
+        Field bootstrapAcceptorField = null;
+        for (String handlerName : channelHandlerNames) {
+            ChannelHandler handler = channelFuture.channel().pipeline().get(handlerName);
+            try {
+                bootstrapAcceptorField = handler.getClass().getDeclaredField("childHandler");
+                bootstrapAcceptorField.setAccessible(true);
+                bootstrapAcceptorField.get(handler);
+                bootstrapAcceptor = handler;
+            } catch (Exception ignored) {
+            }
+        }
+
+        if (bootstrapAcceptor == null) {
+            bootstrapAcceptor = channelFuture.channel().pipeline().first();
+        }
+
+        ChannelInitializer<?> oldChannelInitializer;
+        try {
+            oldChannelInitializer = (ChannelInitializer<?>) bootstrapAcceptorField.get(bootstrapAcceptor);
+
+            ChannelInitializer<?> channelInitializer = new PEChannelInitializerModern(oldChannelInitializer);
+
+            //Replace the old channel initializer with our own.
+            bootstrapAcceptorField.setAccessible(true);
+            bootstrapAcceptorField.set(bootstrapAcceptor, channelInitializer);
+            injectedFutures.add(channelFuture);
+        } catch (IllegalAccessException e) {
+            ClassLoader cl = bootstrapAcceptor.getClass().getClassLoader();
+            if (cl.getClass().getName().equals("org.bukkit.plugin.java.PluginClassLoader")) {
+                PluginDescriptionFile yaml = null;
+                try {
+                    yaml = (PluginDescriptionFile) PluginDescriptionFile.class.getDeclaredField("description").get(cl);
+                } catch (IllegalAccessException | NoSuchFieldException e2) {
+                    e2.printStackTrace();
+                }
+                throw new IllegalStateException("PacketEvents failed to inject, because of " + bootstrapAcceptor.getClass().getName() + ", you might want to try running without " + yaml.getName() + "?");
+            } else {
+                throw new IllegalStateException("PacketEvents failed to find core component 'childHandler', please check your plugins. issue: " + bootstrapAcceptor.getClass().getName());
+            }
+        }
+
+    }
+
+    @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();
+            ChannelHandler bootstrapAcceptor = null;
+            // Pick best
+            for (String name : names) {
+                try {
+                    ChannelHandler handler = future.channel().pipeline().get(name);
+                    if (childHandlerField == null) {
+                        childHandlerField = handler.getClass().getDeclaredField("childHandler");
+                        childHandlerField.setAccessible(true);
+                    }
+
+                    ChannelInitializer<Channel> oldInit = (ChannelInitializer<Channel>) childHandlerField.get(handler);
+                    if (oldInit instanceof PEChannelInitializerModern) {
+                        bootstrapAcceptor = handler;
+                    }
+                } catch (Exception ignored) {
+                    // Not this one
+                }
+            }
+            // Default to first
+            if (bootstrapAcceptor == null) {
+                bootstrapAcceptor = future.channel().pipeline().first();
+            }
+
+            try {
+                ChannelInitializer<Channel> oldInit = (ChannelInitializer<Channel>) childHandlerField.get(bootstrapAcceptor);
+                if (oldInit instanceof PEChannelInitializerModern) {
+                    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!");
+            }
+        }
+        injectedFutures.clear();
+
+        for (Map<Field, Object> map : injectedLists) {
+            try {
+                for (Field key : map.keySet()) {
+                    key.setAccessible(true);
+                    Object o = map.get(key);
+                    if (o instanceof ListWrapper) {
+                        key.set(o, ((ListWrapper) o).getOriginalList());
+                    }
+                }
+
+            } catch (IllegalAccessException e) {
+                //PacketEvents.get().getPlugin().getLogger().severe("PacketEvents failed to eject the injection handler! Please reboot!!");
+            }
+        }
+
+        injectedLists.clear();
+    }
+
+    @Override
+    public void injectPlayer(Player player) {
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
+        if (channel != null) {
+            updatePlayerObject(player, channel);
+        }
+    }
+
+    @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) {
+        Object channel = PacketEvents.get().getPlayerUtils().getChannel(player);
+        if (channel == null) {
+            return false;
+        }
+        PlayerChannelHandlerModern handler = getHandler(channel);
+        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.get().getHandlerName());
+        if (handler instanceof PlayerChannelHandlerModern) {
+            return (PlayerChannelHandlerModern) handler;
+        } else {
+            return null;
+        }
+    }
+
+    @Override
+    public void updatePlayerObject(Player player, Object rawChannel) {
+        PlayerChannelHandlerModern handler = getHandler(rawChannel);
+        if (handler != null) {
+            handler.player = player;
+        }
+    }
+}

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

@@ -0,0 +1,27 @@
+/*
+ * 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;
+
+/**
+ * @author retrooper
+ * @since 1.8
+ */
+public enum PacketState {
+    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,7 +21,7 @@ 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;
 
 /**
@@ -43,7 +37,29 @@ public class PacketType {
      * If a Packet Type could not be resolved, it will be set to the current value of this constant.
      * 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 = -1;
+    public static final byte INVALID = -128;
+    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);
+        }
+    }
+
+    public static void load() {
+        Status.Client.load();
+        Status.Server.load();
+
+        Handshaking.Client.load();
+
+        Login.Client.load();
+        Login.Server.load();
+
+        Play.Client.load();
+        Play.Server.load();
+    }
+
     /**
      * Status Packet IDs.
      *
@@ -60,15 +76,11 @@ public class PacketType {
          * @since 1.8
          */
         public static class Client {
-            public static final byte START = 0, PING = 1;
-            public static final Map<Class<?>, Byte> packetIds = new HashMap<>();
+            public static final byte START = -127, PING = -126;
 
-            /**
-             * Load the server-bound status Packet IDs.
-             */
-            public static void init() {
-                packetIds.put(PacketTypeClasses.Status.Client.START, Client.START);
-                packetIds.put(PacketTypeClasses.Status.Client.PING, Client.PING);
+            private static void load() {
+                insertPacketID(PacketTypeClasses.Status.Client.START, Client.START);
+                insertPacketID(PacketTypeClasses.Status.Client.PING, Client.PING);
             }
         }
 
@@ -80,15 +92,34 @@ public class PacketType {
          * @since 1.8
          */
         public static class Server {
-            public static final byte PONG = 0, SERVER_INFO = 1;
-            public static final Map<Class<?>, Byte> packetIds = new HashMap<>();
+            public static final byte PONG = -125, SERVER_INFO = -124;
 
-            /**
-             * Load the client-bound Status Packet IDs.
-             */
-            public static void init() {
-                packetIds.put(PacketTypeClasses.Status.Server.PONG, Server.PONG);
-                packetIds.put(PacketTypeClasses.Status.Server.SERVER_INFO, Server.SERVER_INFO);
+            private static void load() {
+                insertPacketID(PacketTypeClasses.Status.Server.PONG, Server.PONG);
+                insertPacketID(PacketTypeClasses.Status.Server.SERVER_INFO, Server.SERVER_INFO);
+            }
+        }
+    }
+
+    /**
+     * Handshaking Packet IDs.
+     *
+     * @author retrooper
+     * @see <a href="https://wiki.vg/Protocol#Handshaking">https://wiki.vg/Protocol#Handshaking</a>
+     * @since 1.8
+     */
+    public static class Handshaking {
+        /**
+         * Server-bound (client-sided) Handshaking Packet IDs.
+         *
+         * @author retrooper
+         * @since 1.8
+         */
+        public static class Client {
+            public static final byte SET_PROTOCOL = -123;
+
+            private static void load() {
+                insertPacketID(PacketTypeClasses.Handshaking.Client.SET_PROTOCOL, Client.SET_PROTOCOL);
             }
         }
     }
@@ -109,17 +140,12 @@ public class PacketType {
          * @since 1.8
          */
         public static class Client {
-            public static final Map<Class<?>, Byte> packetIds = new HashMap<>();
-            public static final byte HANDSHAKE = 0, CUSTOM_PAYLOAD = 1, START = 2, ENCRYPTION_BEGIN = 3;
+            public static final byte CUSTOM_PAYLOAD = -122, START = -121, ENCRYPTION_BEGIN = -120;
 
-            /**
-             * Load the server-bound Login Packet IDs.
-             */
-            public static void init() {
-                packetIds.put(PacketTypeClasses.Login.Client.HANDSHAKE, Client.HANDSHAKE);
-                packetIds.put(PacketTypeClasses.Login.Client.CUSTOM_PAYLOAD, Client.CUSTOM_PAYLOAD);
-                packetIds.put(PacketTypeClasses.Login.Client.START, Client.START);
-                packetIds.put(PacketTypeClasses.Login.Client.ENCRYPTION_BEGIN, Client.ENCRYPTION_BEGIN);
+            private static void load() {
+                insertPacketID(PacketTypeClasses.Login.Client.CUSTOM_PAYLOAD, Client.CUSTOM_PAYLOAD);
+                insertPacketID(PacketTypeClasses.Login.Client.START, Client.START);
+                insertPacketID(PacketTypeClasses.Login.Client.ENCRYPTION_BEGIN, Client.ENCRYPTION_BEGIN);
             }
         }
 
@@ -131,18 +157,14 @@ public class PacketType {
          * @since 1.8
          */
         public static class Server {
-            public static final Map<Class<?>, Byte> packetIds = new HashMap<>();
-            public static final byte CUSTOM_PAYLOAD = 0, DISCONNECT = 1, ENCRYPTION_BEGIN = 2, SUCCESS = 3, SET_COMPRESSION = 4;
+            public static final byte CUSTOM_PAYLOAD = -119, DISCONNECT = -118, ENCRYPTION_BEGIN = -117, SUCCESS = -116, SET_COMPRESSION = -115;
 
-            /**
-             * Load the client-bound Login Packet IDs.
-             */
-            public static void init() {
-                packetIds.put(PacketTypeClasses.Login.Server.CUSTOM_PAYLOAD, Server.CUSTOM_PAYLOAD);
-                packetIds.put(PacketTypeClasses.Login.Server.DISCONNECT, Server.DISCONNECT);
-                packetIds.put(PacketTypeClasses.Login.Server.ENCRYPTION_BEGIN, Server.ENCRYPTION_BEGIN);
-                packetIds.put(PacketTypeClasses.Login.Server.SUCCESS, Server.SUCCESS);
-                packetIds.put(PacketTypeClasses.Login.Server.SET_COMPRESSION, Server.SET_COMPRESSION);
+            private static void load() {
+                insertPacketID(PacketTypeClasses.Login.Server.CUSTOM_PAYLOAD, Server.CUSTOM_PAYLOAD);
+                insertPacketID(PacketTypeClasses.Login.Server.DISCONNECT, Server.DISCONNECT);
+                insertPacketID(PacketTypeClasses.Login.Server.ENCRYPTION_BEGIN, Server.ENCRYPTION_BEGIN);
+                insertPacketID(PacketTypeClasses.Login.Server.SUCCESS, Server.SUCCESS);
+                insertPacketID(PacketTypeClasses.Login.Server.SET_COMPRESSION, Server.SET_COMPRESSION);
             }
         }
     }
@@ -163,72 +185,69 @@ public class PacketType {
          * @since 1.8
          */
         public static class Client {
-            public static final Map<Class<?>, Byte> packetIds = new HashMap<>();
-            public static final byte TELEPORT_ACCEPT = 0,
-                    TILE_NBT_QUERY = 1, DIFFICULTY_CHANGE = 2, CHAT = 3, CLIENT_COMMAND = 4,
-                    SETTINGS = 5, TAB_COMPLETE = 6, TRANSACTION = 7, ENCHANT_ITEM = 8,
-                    WINDOW_CLICK = 9, CLOSE_WINDOW = 10, CUSTOM_PAYLOAD = 11, B_EDIT = 12,
-                    ENTITY_NBT_QUERY = 13, USE_ENTITY = 14, JIGSAW_GENERATE = 15, KEEP_ALIVE = 16,
-                    DIFFICULTY_LOCK = 17, POSITION = 18, POSITION_LOOK = 19, LOOK = 20,
-                    FLYING = 21, VEHICLE_MOVE = 22, BOAT_MOVE = 23, PICK_ITEM = 24,
-                    AUTO_RECIPE = 25, ABILITIES = 26, BLOCK_DIG = 27, ENTITY_ACTION = 28,
-                    STEER_VEHICLE = 29, RECIPE_DISPLAYED = 30, ITEM_NAME = 31, RESOURCE_PACK_STATUS = 32,
-                    ADVANCEMENTS = 33, TR_SEL = 34, BEACON = 35, HELD_ITEM_SLOT = 36,
-                    SET_COMMAND_BLOCK = 37, SET_COMMAND_MINECART = 38, SET_CREATIVE_SLOT = 39, SET_JIGSAW = 40,
-                    STRUCT = 41, UPDATE_SIGN = 42, ARM_ANIMATION = 43, SPECTATE = 44,
-                    USE_ITEM = 45, BLOCK_PLACE = 46;
+            public static final byte TELEPORT_ACCEPT = -114,
+                    TILE_NBT_QUERY = -113, DIFFICULTY_CHANGE = -112, CHAT = -111, CLIENT_COMMAND = -110,
+                    SETTINGS = -109, TAB_COMPLETE = -108, TRANSACTION = -107, ENCHANT_ITEM = -106,
+                    WINDOW_CLICK = -105, CLOSE_WINDOW = -104, CUSTOM_PAYLOAD = -103, B_EDIT = -102,
+                    ENTITY_NBT_QUERY = -101, USE_ENTITY = -100, JIGSAW_GENERATE = -99, KEEP_ALIVE = -98,
+                    DIFFICULTY_LOCK = -97, POSITION = -96, POSITION_LOOK = -95, LOOK = -94,
+                    FLYING = -93, VEHICLE_MOVE = -92, BOAT_MOVE = -91, PICK_ITEM = -90,
+                    AUTO_RECIPE = -89, ABILITIES = -88, BLOCK_DIG = -87, ENTITY_ACTION = -86,
+                    STEER_VEHICLE = -85, RECIPE_DISPLAYED = -84, ITEM_NAME = -83, RESOURCE_PACK_STATUS = -82,
+                    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, PONG = 28;
 
-            /**
-             * Load the server-bound Play Packet IDs.
-             */
-            public static void init() {
-                packetIds.put(PacketTypeClasses.Play.Client.TELEPORT_ACCEPT, TELEPORT_ACCEPT);
-                packetIds.put(PacketTypeClasses.Play.Client.TILE_NBT_QUERY, TILE_NBT_QUERY);
-                packetIds.put(PacketTypeClasses.Play.Client.DIFFICULTY_CHANGE, DIFFICULTY_CHANGE);
-                packetIds.put(PacketTypeClasses.Play.Client.CHAT, CHAT);
-                packetIds.put(PacketTypeClasses.Play.Client.CLIENT_COMMAND, CLIENT_COMMAND);
-                packetIds.put(PacketTypeClasses.Play.Client.SETTINGS, SETTINGS);
-                packetIds.put(PacketTypeClasses.Play.Client.TAB_COMPLETE, TAB_COMPLETE);
-                packetIds.put(PacketTypeClasses.Play.Client.TRANSACTION, TRANSACTION);
-                packetIds.put(PacketTypeClasses.Play.Client.ENCHANT_ITEM, ENCHANT_ITEM);
-                packetIds.put(PacketTypeClasses.Play.Client.WINDOW_CLICK, WINDOW_CLICK);
-                packetIds.put(PacketTypeClasses.Play.Client.CLOSE_WINDOW, CLOSE_WINDOW);
-                packetIds.put(PacketTypeClasses.Play.Client.CUSTOM_PAYLOAD, CUSTOM_PAYLOAD);
-                packetIds.put(PacketTypeClasses.Play.Client.B_EDIT, B_EDIT);
-                packetIds.put(PacketTypeClasses.Play.Client.ENTITY_NBT_QUERY, ENTITY_NBT_QUERY);
-                packetIds.put(PacketTypeClasses.Play.Client.USE_ENTITY, USE_ENTITY);
-                packetIds.put(PacketTypeClasses.Play.Client.JIGSAW_GENERATE, JIGSAW_GENERATE);
-                packetIds.put(PacketTypeClasses.Play.Client.KEEP_ALIVE, KEEP_ALIVE);
-                packetIds.put(PacketTypeClasses.Play.Client.DIFFICULTY_LOCK, DIFFICULTY_LOCK);
-                packetIds.put(PacketTypeClasses.Play.Client.POSITION, POSITION);
-                packetIds.put(PacketTypeClasses.Play.Client.POSITION_LOOK, POSITION_LOOK);
-                packetIds.put(PacketTypeClasses.Play.Client.LOOK, LOOK);
-                packetIds.put(PacketTypeClasses.Play.Client.FLYING, FLYING);
-                packetIds.put(PacketTypeClasses.Play.Client.VEHICLE_MOVE, VEHICLE_MOVE);
-                packetIds.put(PacketTypeClasses.Play.Client.BOAT_MOVE, BOAT_MOVE);
-                packetIds.put(PacketTypeClasses.Play.Client.PICK_ITEM, PICK_ITEM);
-                packetIds.put(PacketTypeClasses.Play.Client.AUTO_RECIPE, AUTO_RECIPE);
-                packetIds.put(PacketTypeClasses.Play.Client.ABILITIES, ABILITIES);
-                packetIds.put(PacketTypeClasses.Play.Client.BLOCK_DIG, BLOCK_DIG);
-                packetIds.put(PacketTypeClasses.Play.Client.ENTITY_ACTION, ENTITY_ACTION);
-                packetIds.put(PacketTypeClasses.Play.Client.STEER_VEHICLE, STEER_VEHICLE);
-                packetIds.put(PacketTypeClasses.Play.Client.RECIPE_DISPLAYED, RECIPE_DISPLAYED);
-                packetIds.put(PacketTypeClasses.Play.Client.ITEM_NAME, ITEM_NAME);
-                packetIds.put(PacketTypeClasses.Play.Client.RESOURCE_PACK_STATUS, RESOURCE_PACK_STATUS);
-                packetIds.put(PacketTypeClasses.Play.Client.ADVANCEMENTS, ADVANCEMENTS);
-                packetIds.put(PacketTypeClasses.Play.Client.TR_SEL, TR_SEL);
-                packetIds.put(PacketTypeClasses.Play.Client.BEACON, BEACON);
-                packetIds.put(PacketTypeClasses.Play.Client.HELD_ITEM_SLOT, HELD_ITEM_SLOT);
-                packetIds.put(PacketTypeClasses.Play.Client.SET_COMMAND_BLOCK, SET_COMMAND_BLOCK);
-                packetIds.put(PacketTypeClasses.Play.Client.SET_COMMAND_MINECART, SET_COMMAND_MINECART);
-                packetIds.put(PacketTypeClasses.Play.Client.SET_CREATIVE_SLOT, SET_CREATIVE_SLOT);
-                packetIds.put(PacketTypeClasses.Play.Client.SET_JIGSAW, SET_JIGSAW);
-                packetIds.put(PacketTypeClasses.Play.Client.STRUCT, STRUCT);
-                packetIds.put(PacketTypeClasses.Play.Client.UPDATE_SIGN, UPDATE_SIGN);
-                packetIds.put(PacketTypeClasses.Play.Client.ARM_ANIMATION, ARM_ANIMATION);
-                packetIds.put(PacketTypeClasses.Play.Client.SPECTATE, SPECTATE);
-                packetIds.put(PacketTypeClasses.Play.Client.USE_ITEM, USE_ITEM);
-                packetIds.put(PacketTypeClasses.Play.Client.BLOCK_PLACE, BLOCK_PLACE);
+            private static void load() {
+                insertPacketID(PacketTypeClasses.Play.Client.TELEPORT_ACCEPT, TELEPORT_ACCEPT);
+                insertPacketID(PacketTypeClasses.Play.Client.TILE_NBT_QUERY, TILE_NBT_QUERY);
+                insertPacketID(PacketTypeClasses.Play.Client.DIFFICULTY_CHANGE, DIFFICULTY_CHANGE);
+                insertPacketID(PacketTypeClasses.Play.Client.CHAT, CHAT);
+                insertPacketID(PacketTypeClasses.Play.Client.CLIENT_COMMAND, CLIENT_COMMAND);
+                insertPacketID(PacketTypeClasses.Play.Client.SETTINGS, SETTINGS);
+                insertPacketID(PacketTypeClasses.Play.Client.TAB_COMPLETE, TAB_COMPLETE);
+                insertPacketID(PacketTypeClasses.Play.Client.TRANSACTION, TRANSACTION);
+                insertPacketID(PacketTypeClasses.Play.Client.ENCHANT_ITEM, ENCHANT_ITEM);
+                insertPacketID(PacketTypeClasses.Play.Client.WINDOW_CLICK, WINDOW_CLICK);
+                insertPacketID(PacketTypeClasses.Play.Client.CLOSE_WINDOW, CLOSE_WINDOW);
+                insertPacketID(PacketTypeClasses.Play.Client.CUSTOM_PAYLOAD, CUSTOM_PAYLOAD);
+                insertPacketID(PacketTypeClasses.Play.Client.B_EDIT, B_EDIT);
+                insertPacketID(PacketTypeClasses.Play.Client.ENTITY_NBT_QUERY, ENTITY_NBT_QUERY);
+                insertPacketID(PacketTypeClasses.Play.Client.USE_ENTITY, USE_ENTITY);
+                insertPacketID(PacketTypeClasses.Play.Client.JIGSAW_GENERATE, JIGSAW_GENERATE);
+                insertPacketID(PacketTypeClasses.Play.Client.KEEP_ALIVE, KEEP_ALIVE);
+                insertPacketID(PacketTypeClasses.Play.Client.DIFFICULTY_LOCK, DIFFICULTY_LOCK);
+                insertPacketID(PacketTypeClasses.Play.Client.POSITION, POSITION);
+                insertPacketID(PacketTypeClasses.Play.Client.POSITION_LOOK, POSITION_LOOK);
+                insertPacketID(PacketTypeClasses.Play.Client.LOOK, LOOK);
+                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);
+                insertPacketID(PacketTypeClasses.Play.Client.AUTO_RECIPE, AUTO_RECIPE);
+                insertPacketID(PacketTypeClasses.Play.Client.ABILITIES, ABILITIES);
+                insertPacketID(PacketTypeClasses.Play.Client.BLOCK_DIG, BLOCK_DIG);
+                insertPacketID(PacketTypeClasses.Play.Client.ENTITY_ACTION, ENTITY_ACTION);
+                insertPacketID(PacketTypeClasses.Play.Client.STEER_VEHICLE, STEER_VEHICLE);
+                insertPacketID(PacketTypeClasses.Play.Client.RECIPE_DISPLAYED, RECIPE_DISPLAYED);
+                insertPacketID(PacketTypeClasses.Play.Client.ITEM_NAME, ITEM_NAME);
+                insertPacketID(PacketTypeClasses.Play.Client.RESOURCE_PACK_STATUS, RESOURCE_PACK_STATUS);
+                insertPacketID(PacketTypeClasses.Play.Client.ADVANCEMENTS, ADVANCEMENTS);
+                insertPacketID(PacketTypeClasses.Play.Client.TR_SEL, TR_SEL);
+                insertPacketID(PacketTypeClasses.Play.Client.BEACON, BEACON);
+                insertPacketID(PacketTypeClasses.Play.Client.HELD_ITEM_SLOT, HELD_ITEM_SLOT);
+                insertPacketID(PacketTypeClasses.Play.Client.SET_COMMAND_BLOCK, SET_COMMAND_BLOCK);
+                insertPacketID(PacketTypeClasses.Play.Client.SET_COMMAND_MINECART, SET_COMMAND_MINECART);
+                insertPacketID(PacketTypeClasses.Play.Client.SET_CREATIVE_SLOT, SET_CREATIVE_SLOT);
+                insertPacketID(PacketTypeClasses.Play.Client.SET_JIGSAW, SET_JIGSAW);
+                insertPacketID(PacketTypeClasses.Play.Client.STRUCT, STRUCT);
+                insertPacketID(PacketTypeClasses.Play.Client.UPDATE_SIGN, UPDATE_SIGN);
+                insertPacketID(PacketTypeClasses.Play.Client.ARM_ANIMATION, ARM_ANIMATION);
+                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);
             }
 
             /**
@@ -268,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.isHigherThan(ServerVersion.v_1_8_8) ?
-                            packetID == Client.USE_ITEM
-                            : packetID == Client.BLOCK_PLACE;
+                    return isNine ? packetID == PacketType.Play.Client.USE_ITEM : packetID == PacketType.Play.Client.BLOCK_PLACE;
                 }
             }
         }
@@ -284,132 +300,147 @@ public class PacketType {
          * @since 1.8
          */
         public static class Server {
-            public static final Map<Class<?>, Byte> packetIds = new HashMap<>();
-            public static final byte SPAWN_ENTITY = 0, SPAWN_ENTITY_EXPERIENCE_ORB = 1, SPAWN_ENTITY_WEATHER = 2, SPAWN_ENTITY_LIVING = 3,
-                    SPAWN_ENTITY_PAINTING = 4, SPAWN_ENTITY_SPAWN = 5, ANIMATION = 6, STATISTIC = 7,
-                    BLOCK_BREAK = 8, BLOCK_BREAK_ANIMATION = 9, TILE_ENTITY_DATA = 10, BLOCK_ACTION = 11,
-                    BLOCK_CHANGE = 12, BOSS = 13, SERVER_DIFFICULTY = 14, CHAT = 15, MULTI_BLOCK_CHANGE = 16,
-                    TAB_COMPLETE = 17, COMMANDS = 18, TRANSACTION = 19, CLOSE_WINDOW = 20,
-                    WINDOW_ITEMS = 21, WINDOW_DATA = 22, SET_SLOT = 23, SET_COOLDOWN = 24,
-                    CUSTOM_PAYLOAD = 25, CUSTOM_SOUND_EFFECT = 26, KICK_DISCONNECT = 27, ENTITY_STATUS = 28,
-                    EXPLOSION = 29, UNLOAD_CHUNK = 30, GAME_STATE_CHANGE = 31, OPEN_WINDOW_HORSE = 32,
-                    KEEP_ALIVE = 33, MAP_CHUNK = 34, WORLD_EVENT = 35, WORLD_PARTICLES = 36,
-                    LIGHT_UPDATE = 37, LOGIN = 38, MAP = 39, OPEN_WINDOW_MERCHANT = 40,
-                    REL_ENTITY_MOVE = 41, REL_ENTITY_MOVE_LOOK = 42, ENTITY_LOOK = 43, ENTITY = 44,
-                    VEHICLE_MOVE = 45, OPEN_BOOK = 46, OPEN_WINDOW = 47, OPEN_SIGN_EDITOR = 48,
-                    AUTO_RECIPE = 49, ABILITIES = 50, COMBAT_EVENT = 51, PLAYER_INFO = 52,
-                    LOOK_AT = 53, POSITION = 54, RECIPES = 55, ENTITY_DESTROY = 56,
-                    REMOVE_ENTITY_EFFECT = 57, RESOURCE_PACK_SEND = 58, RESPAWN = 59, ENTITY_HEAD_ROTATION = 60,
-                    SELECT_ADVANCEMENT_TAB = 61, WORLD_BORDER = 62, CAMERA = 63, HELD_ITEM_SLOT = 64,
-                    VIEW_CENTRE = 65, VIEW_DISTANCE = 66, SCOREBOARD_DISPLAY_OBJECTIVE = 67, ENTITY_METADATA = 68,
-                    ATTACH_ENTITY = 69, ENTITY_VELOCITY = 70, ENTITY_EQUIPMENT = 71, EXPERIENCE = 72,
-                    UPDATE_HEALTH = 73, SCOREBOARD_OBJECTIVE = 74, MOUNT = 75, SCOREBOARD_TEAM = 76,
-                    SCOREBOARD_SCORE = 77, SPAWN_POSITION = 78, UPDATE_TIME = 79, TITLE = 80,
-                    ENTITY_SOUND = 81, NAMED_SOUND_EFFECT = 82, STOP_SOUND = 83, PLAYER_LIST_HEADER_FOOTER = 84,
-                    NBT_QUERY = 85, COLLECT = 86, ENTITY_TELEPORT = 87, ADVANCEMENTS = 88, UPDATE_ATTRIBUTES = 89,
-                    ENTITY_EFFECT = 90, RECIPE_UPDATE = 91, TAGS = 92, MAP_CHUNK_BULK = 93, NAMED_ENTITY_SPAWN = 94;
+            public static final byte SPAWN_ENTITY = -67, SPAWN_ENTITY_EXPERIENCE_ORB = -66, SPAWN_ENTITY_WEATHER = -65, SPAWN_ENTITY_LIVING = -64,
+                    SPAWN_ENTITY_PAINTING = -63, SPAWN_ENTITY_SPAWN = -62, ANIMATION = -61, STATISTIC = -60,
+                    BLOCK_BREAK = -59, BLOCK_BREAK_ANIMATION = -58, TILE_ENTITY_DATA = -57, BLOCK_ACTION = -56,
+                    BLOCK_CHANGE = -55, BOSS = -54, SERVER_DIFFICULTY = -53, CHAT = -52, MULTI_BLOCK_CHANGE = -51,
+                    TAB_COMPLETE = -50, COMMANDS = -49, TRANSACTION = -48, CLOSE_WINDOW = -47,
+                    WINDOW_ITEMS = -46, WINDOW_DATA = -45, SET_SLOT = -44, SET_COOLDOWN = -43,
+                    CUSTOM_PAYLOAD = -42, CUSTOM_SOUND_EFFECT = -41, KICK_DISCONNECT = -40, ENTITY_STATUS = -39,
+                    EXPLOSION = -38, UNLOAD_CHUNK = -37, GAME_STATE_CHANGE = -36, OPEN_WINDOW_HORSE = -35,
+                    KEEP_ALIVE = -34, MAP_CHUNK = -33, WORLD_EVENT = -32, WORLD_PARTICLES = -31,
+                    LIGHT_UPDATE = -30, LOGIN = -29, MAP = -28, OPEN_WINDOW_MERCHANT = -27,
+                    REL_ENTITY_MOVE = -26, REL_ENTITY_MOVE_LOOK = -25, ENTITY_LOOK = -24, ENTITY = -23,
+                    VEHICLE_MOVE = -22, OPEN_BOOK = -21, OPEN_WINDOW = -20, OPEN_SIGN_EDITOR = -19,
+                    AUTO_RECIPE = -18, ABILITIES = -17, COMBAT_EVENT = -16, PLAYER_INFO = -15,
+                    LOOK_AT = -14, POSITION = -13, RECIPES = -12, ENTITY_DESTROY = -11,
+                    REMOVE_ENTITY_EFFECT = -10, RESOURCE_PACK_SEND = -9, RESPAWN = -8, ENTITY_HEAD_ROTATION = -7,
+                    SELECT_ADVANCEMENT_TAB = -6, WORLD_BORDER = -5, CAMERA = -4, HELD_ITEM_SLOT = -3,
+                    VIEW_CENTRE = -2, VIEW_DISTANCE = -1, SCOREBOARD_DISPLAY_OBJECTIVE = 0, ENTITY_METADATA = 1,
+                    ATTACH_ENTITY = 2, ENTITY_VELOCITY = 3, ENTITY_EQUIPMENT = 4, EXPERIENCE = 5,
+                    UPDATE_HEALTH = 6, SCOREBOARD_OBJECTIVE = 7, MOUNT = 8, SCOREBOARD_TEAM = 9,
+                    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, 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;
 
-            /**
-             * Load the client-bound Play Packet IDs.
-             */
-            public static void init() {
-                packetIds.put(PacketTypeClasses.Play.Server.SPAWN_ENTITY, SPAWN_ENTITY);
-                packetIds.put(PacketTypeClasses.Play.Server.SPAWN_ENTITY_EXPERIENCE_ORB, SPAWN_ENTITY_EXPERIENCE_ORB);
-                packetIds.put(PacketTypeClasses.Play.Server.SPAWN_ENTITY_WEATHER, SPAWN_ENTITY_WEATHER);
-                packetIds.put(PacketTypeClasses.Play.Server.SPAWN_ENTITY_LIVING, SPAWN_ENTITY_LIVING);
-                packetIds.put(PacketTypeClasses.Play.Server.SPAWN_ENTITY_PAINTING, SPAWN_ENTITY_PAINTING);
-                packetIds.put(PacketTypeClasses.Play.Server.SPAWN_ENTITY_SPAWN, SPAWN_ENTITY_SPAWN);
-                packetIds.put(PacketTypeClasses.Play.Server.ANIMATION, ANIMATION);
-                packetIds.put(PacketTypeClasses.Play.Server.STATISTIC, STATISTIC);
-                packetIds.put(PacketTypeClasses.Play.Server.BLOCK_BREAK, BLOCK_BREAK);
-                packetIds.put(PacketTypeClasses.Play.Server.BLOCK_BREAK_ANIMATION, BLOCK_BREAK_ANIMATION);
-                packetIds.put(PacketTypeClasses.Play.Server.TILE_ENTITY_DATA, TILE_ENTITY_DATA);
-                packetIds.put(PacketTypeClasses.Play.Server.BLOCK_ACTION, BLOCK_ACTION);
-                packetIds.put(PacketTypeClasses.Play.Server.BLOCK_CHANGE, BLOCK_CHANGE);
-                packetIds.put(PacketTypeClasses.Play.Server.BOSS, BOSS);
-                packetIds.put(PacketTypeClasses.Play.Server.SPAWN_ENTITY, SPAWN_ENTITY);
-                packetIds.put(PacketTypeClasses.Play.Server.SERVER_DIFFICULTY, SERVER_DIFFICULTY);
-                packetIds.put(PacketTypeClasses.Play.Server.CHAT, CHAT);
-                packetIds.put(PacketTypeClasses.Play.Server.MULTI_BLOCK_CHANGE, MULTI_BLOCK_CHANGE);
-                packetIds.put(PacketTypeClasses.Play.Server.TAB_COMPLETE, TAB_COMPLETE);
-                packetIds.put(PacketTypeClasses.Play.Server.COMMANDS, COMMANDS);
-                packetIds.put(PacketTypeClasses.Play.Server.TRANSACTION, TRANSACTION);
-                packetIds.put(PacketTypeClasses.Play.Server.CLOSE_WINDOW, CLOSE_WINDOW);
-                packetIds.put(PacketTypeClasses.Play.Server.WINDOW_ITEMS, WINDOW_ITEMS);
-                packetIds.put(PacketTypeClasses.Play.Server.WINDOW_DATA, WINDOW_DATA);
-                packetIds.put(PacketTypeClasses.Play.Server.SET_SLOT, SET_SLOT);
-                packetIds.put(PacketTypeClasses.Play.Server.SET_COOLDOWN, SET_COOLDOWN);
-                packetIds.put(PacketTypeClasses.Play.Server.CUSTOM_PAYLOAD, CUSTOM_PAYLOAD);
-                packetIds.put(PacketTypeClasses.Play.Server.CUSTOM_SOUND_EFFECT, CUSTOM_SOUND_EFFECT);
-                packetIds.put(PacketTypeClasses.Play.Server.KICK_DISCONNECT, KICK_DISCONNECT);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY_STATUS, ENTITY_STATUS);
-                packetIds.put(PacketTypeClasses.Play.Server.EXPLOSION, EXPLOSION);
-                packetIds.put(PacketTypeClasses.Play.Server.UNLOAD_CHUNK, UNLOAD_CHUNK);
-                packetIds.put(PacketTypeClasses.Play.Server.GAME_STATE_CHANGE, GAME_STATE_CHANGE);
-                packetIds.put(PacketTypeClasses.Play.Server.OPEN_WINDOW_HORSE, OPEN_WINDOW_HORSE);
-                packetIds.put(PacketTypeClasses.Play.Server.KEEP_ALIVE, KEEP_ALIVE);
-                packetIds.put(PacketTypeClasses.Play.Server.MAP_CHUNK, MAP_CHUNK);
-                packetIds.put(PacketTypeClasses.Play.Server.WORLD_EVENT, WORLD_EVENT);
-                packetIds.put(PacketTypeClasses.Play.Server.WORLD_EVENT, SPAWN_ENTITY);
-                packetIds.put(PacketTypeClasses.Play.Server.WORLD_PARTICLES, WORLD_PARTICLES);
-                packetIds.put(PacketTypeClasses.Play.Server.LIGHT_UPDATE, LIGHT_UPDATE);
-                packetIds.put(PacketTypeClasses.Play.Server.LOGIN, LOGIN);
-                packetIds.put(PacketTypeClasses.Play.Server.MAP, MAP);
-                packetIds.put(PacketTypeClasses.Play.Server.OPEN_WINDOW_MERCHANT, OPEN_WINDOW_MERCHANT);
-                packetIds.put(PacketTypeClasses.Play.Server.REL_ENTITY_MOVE, REL_ENTITY_MOVE);
-                packetIds.put(PacketTypeClasses.Play.Server.REL_ENTITY_MOVE_LOOK, REL_ENTITY_MOVE_LOOK);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY_LOOK, ENTITY_LOOK);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY, ENTITY);
-                packetIds.put(PacketTypeClasses.Play.Server.VEHICLE_MOVE, VEHICLE_MOVE);
-                packetIds.put(PacketTypeClasses.Play.Server.OPEN_BOOK, OPEN_BOOK);
-                packetIds.put(PacketTypeClasses.Play.Server.OPEN_WINDOW, OPEN_WINDOW);
-                packetIds.put(PacketTypeClasses.Play.Server.OPEN_SIGN_EDITOR, OPEN_SIGN_EDITOR);
-                packetIds.put(PacketTypeClasses.Play.Server.AUTO_RECIPE, AUTO_RECIPE);
-                packetIds.put(PacketTypeClasses.Play.Server.ABILITIES, ABILITIES);
-                packetIds.put(PacketTypeClasses.Play.Server.COMBAT_EVENT, COMBAT_EVENT);
-                packetIds.put(PacketTypeClasses.Play.Server.PLAYER_INFO, PLAYER_INFO);
-                packetIds.put(PacketTypeClasses.Play.Server.LOOK_AT, LOOK_AT);
-                packetIds.put(PacketTypeClasses.Play.Server.POSITION, POSITION);
-                packetIds.put(PacketTypeClasses.Play.Server.RECIPES, RECIPES);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY_DESTROY, ENTITY_DESTROY);
-                packetIds.put(PacketTypeClasses.Play.Server.REMOVE_ENTITY_EFFECT, REMOVE_ENTITY_EFFECT);
-                packetIds.put(PacketTypeClasses.Play.Server.RESOURCE_PACK_SEND, RESOURCE_PACK_SEND);
-                packetIds.put(PacketTypeClasses.Play.Server.RESPAWN, RESPAWN);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY_HEAD_ROTATION, ENTITY_HEAD_ROTATION);
-                packetIds.put(PacketTypeClasses.Play.Server.SELECT_ADVANCEMENT_TAB, SELECT_ADVANCEMENT_TAB);
-                packetIds.put(PacketTypeClasses.Play.Server.WORLD_BORDER, WORLD_BORDER);
-                packetIds.put(PacketTypeClasses.Play.Server.CAMERA, CAMERA);
-                packetIds.put(PacketTypeClasses.Play.Server.HELD_ITEM_SLOT, HELD_ITEM_SLOT);
-                packetIds.put(PacketTypeClasses.Play.Server.VIEW_CENTRE, VIEW_CENTRE);
-                packetIds.put(PacketTypeClasses.Play.Server.VIEW_DISTANCE, VIEW_DISTANCE);
-                packetIds.put(PacketTypeClasses.Play.Server.SCOREBOARD_DISPLAY_OBJECTIVE, SCOREBOARD_DISPLAY_OBJECTIVE);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY_METADATA, ENTITY_METADATA);
-                packetIds.put(PacketTypeClasses.Play.Server.ATTACH_ENTITY, ATTACH_ENTITY);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY_VELOCITY, ENTITY_VELOCITY);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY_EQUIPMENT, ENTITY_EQUIPMENT);
-                packetIds.put(PacketTypeClasses.Play.Server.EXPERIENCE, EXPERIENCE);
-                packetIds.put(PacketTypeClasses.Play.Server.UPDATE_HEALTH, UPDATE_HEALTH);
-                packetIds.put(PacketTypeClasses.Play.Server.SCOREBOARD_OBJECTIVE, SCOREBOARD_OBJECTIVE);
-                packetIds.put(PacketTypeClasses.Play.Server.MOUNT, MOUNT);
-                packetIds.put(PacketTypeClasses.Play.Server.SCOREBOARD_TEAM, SCOREBOARD_TEAM);
-                packetIds.put(PacketTypeClasses.Play.Server.SCOREBOARD_SCORE, SCOREBOARD_SCORE);
-                packetIds.put(PacketTypeClasses.Play.Server.SPAWN_POSITION, SPAWN_POSITION);
-                packetIds.put(PacketTypeClasses.Play.Server.UPDATE_TIME, UPDATE_TIME);
-                packetIds.put(PacketTypeClasses.Play.Server.TITLE, TITLE);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY_SOUND, ENTITY_SOUND);
-                packetIds.put(PacketTypeClasses.Play.Server.NAMED_SOUND_EFFECT, NAMED_SOUND_EFFECT);
-                packetIds.put(PacketTypeClasses.Play.Server.STOP_SOUND, STOP_SOUND);
-                packetIds.put(PacketTypeClasses.Play.Server.PLAYER_LIST_HEADER_FOOTER, PLAYER_LIST_HEADER_FOOTER);
-                packetIds.put(PacketTypeClasses.Play.Server.NBT_QUERY, NBT_QUERY);
-                packetIds.put(PacketTypeClasses.Play.Server.COLLECT, COLLECT);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY_TELEPORT, ENTITY_TELEPORT);
-                packetIds.put(PacketTypeClasses.Play.Server.ADVANCEMENTS, ADVANCEMENTS);
-                packetIds.put(PacketTypeClasses.Play.Server.UPDATE_ATTRIBUTES, UPDATE_ATTRIBUTES);
-                packetIds.put(PacketTypeClasses.Play.Server.ENTITY_EFFECT, ENTITY_EFFECT);
-                packetIds.put(PacketTypeClasses.Play.Server.RECIPE_UPDATE, RECIPE_UPDATE);
-                packetIds.put(PacketTypeClasses.Play.Server.TAGS, TAGS);
-                packetIds.put(PacketTypeClasses.Play.Server.MAP_CHUNK_BULK, MAP_CHUNK_BULK);
-                packetIds.put(PacketTypeClasses.Play.Server.NAMED_ENTITY_SPAWN, NAMED_ENTITY_SPAWN);
+            private static void load() {
+                insertPacketID(PacketTypeClasses.Play.Server.SPAWN_ENTITY, SPAWN_ENTITY);
+                insertPacketID(PacketTypeClasses.Play.Server.SPAWN_ENTITY_EXPERIENCE_ORB, SPAWN_ENTITY_EXPERIENCE_ORB);
+                insertPacketID(PacketTypeClasses.Play.Server.SPAWN_ENTITY_WEATHER, SPAWN_ENTITY_WEATHER);
+                insertPacketID(PacketTypeClasses.Play.Server.SPAWN_ENTITY_LIVING, SPAWN_ENTITY_LIVING);
+                insertPacketID(PacketTypeClasses.Play.Server.SPAWN_ENTITY_PAINTING, SPAWN_ENTITY_PAINTING);
+                insertPacketID(PacketTypeClasses.Play.Server.SPAWN_ENTITY_SPAWN, SPAWN_ENTITY_SPAWN);
+                insertPacketID(PacketTypeClasses.Play.Server.ANIMATION, ANIMATION);
+                insertPacketID(PacketTypeClasses.Play.Server.STATISTIC, STATISTIC);
+                insertPacketID(PacketTypeClasses.Play.Server.BLOCK_BREAK, BLOCK_BREAK);
+                insertPacketID(PacketTypeClasses.Play.Server.BLOCK_BREAK_ANIMATION, BLOCK_BREAK_ANIMATION);
+                insertPacketID(PacketTypeClasses.Play.Server.TILE_ENTITY_DATA, TILE_ENTITY_DATA);
+                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.SERVER_DIFFICULTY, SERVER_DIFFICULTY);
+                insertPacketID(PacketTypeClasses.Play.Server.CHAT, CHAT);
+                insertPacketID(PacketTypeClasses.Play.Server.MULTI_BLOCK_CHANGE, MULTI_BLOCK_CHANGE);
+                insertPacketID(PacketTypeClasses.Play.Server.TAB_COMPLETE, TAB_COMPLETE);
+                insertPacketID(PacketTypeClasses.Play.Server.COMMANDS, COMMANDS);
+                insertPacketID(PacketTypeClasses.Play.Server.TRANSACTION, TRANSACTION);
+                insertPacketID(PacketTypeClasses.Play.Server.CLOSE_WINDOW, CLOSE_WINDOW);
+                insertPacketID(PacketTypeClasses.Play.Server.WINDOW_ITEMS, WINDOW_ITEMS);
+                insertPacketID(PacketTypeClasses.Play.Server.WINDOW_DATA, WINDOW_DATA);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_SLOT, SET_SLOT);
+                insertPacketID(PacketTypeClasses.Play.Server.SET_COOLDOWN, SET_COOLDOWN);
+                insertPacketID(PacketTypeClasses.Play.Server.CUSTOM_PAYLOAD, CUSTOM_PAYLOAD);
+                insertPacketID(PacketTypeClasses.Play.Server.CUSTOM_SOUND_EFFECT, CUSTOM_SOUND_EFFECT);
+                insertPacketID(PacketTypeClasses.Play.Server.KICK_DISCONNECT, KICK_DISCONNECT);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY_STATUS, ENTITY_STATUS);
+                insertPacketID(PacketTypeClasses.Play.Server.EXPLOSION, EXPLOSION);
+                insertPacketID(PacketTypeClasses.Play.Server.UNLOAD_CHUNK, UNLOAD_CHUNK);
+                insertPacketID(PacketTypeClasses.Play.Server.GAME_STATE_CHANGE, GAME_STATE_CHANGE);
+                insertPacketID(PacketTypeClasses.Play.Server.OPEN_WINDOW_HORSE, OPEN_WINDOW_HORSE);
+                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_PARTICLES, WORLD_PARTICLES);
+                insertPacketID(PacketTypeClasses.Play.Server.LIGHT_UPDATE, LIGHT_UPDATE);
+                insertPacketID(PacketTypeClasses.Play.Server.LOGIN, LOGIN);
+                insertPacketID(PacketTypeClasses.Play.Server.MAP, MAP);
+                insertPacketID(PacketTypeClasses.Play.Server.OPEN_WINDOW_MERCHANT, OPEN_WINDOW_MERCHANT);
+                insertPacketID(PacketTypeClasses.Play.Server.REL_ENTITY_MOVE, REL_ENTITY_MOVE);
+                insertPacketID(PacketTypeClasses.Play.Server.REL_ENTITY_MOVE_LOOK, REL_ENTITY_MOVE_LOOK);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY_LOOK, ENTITY_LOOK);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY, ENTITY);
+                insertPacketID(PacketTypeClasses.Play.Server.VEHICLE_MOVE, VEHICLE_MOVE);
+                insertPacketID(PacketTypeClasses.Play.Server.OPEN_BOOK, OPEN_BOOK);
+                insertPacketID(PacketTypeClasses.Play.Server.OPEN_WINDOW, OPEN_WINDOW);
+                insertPacketID(PacketTypeClasses.Play.Server.OPEN_SIGN_EDITOR, OPEN_SIGN_EDITOR);
+                insertPacketID(PacketTypeClasses.Play.Server.AUTO_RECIPE, AUTO_RECIPE);
+                insertPacketID(PacketTypeClasses.Play.Server.ABILITIES, ABILITIES);
+                insertPacketID(PacketTypeClasses.Play.Server.COMBAT_EVENT, COMBAT_EVENT);
+                insertPacketID(PacketTypeClasses.Play.Server.PLAYER_INFO, PLAYER_INFO);
+                insertPacketID(PacketTypeClasses.Play.Server.LOOK_AT, LOOK_AT);
+                insertPacketID(PacketTypeClasses.Play.Server.POSITION, POSITION);
+                insertPacketID(PacketTypeClasses.Play.Server.RECIPES, RECIPES);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY_DESTROY, ENTITY_DESTROY);
+                insertPacketID(PacketTypeClasses.Play.Server.REMOVE_ENTITY_EFFECT, REMOVE_ENTITY_EFFECT);
+                insertPacketID(PacketTypeClasses.Play.Server.RESOURCE_PACK_SEND, RESOURCE_PACK_SEND);
+                insertPacketID(PacketTypeClasses.Play.Server.RESPAWN, RESPAWN);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY_HEAD_ROTATION, ENTITY_HEAD_ROTATION);
+                insertPacketID(PacketTypeClasses.Play.Server.SELECT_ADVANCEMENT_TAB, SELECT_ADVANCEMENT_TAB);
+                insertPacketID(PacketTypeClasses.Play.Server.WORLD_BORDER, WORLD_BORDER);
+                insertPacketID(PacketTypeClasses.Play.Server.CAMERA, CAMERA);
+                insertPacketID(PacketTypeClasses.Play.Server.HELD_ITEM_SLOT, HELD_ITEM_SLOT);
+                insertPacketID(PacketTypeClasses.Play.Server.VIEW_CENTRE, VIEW_CENTRE);
+                insertPacketID(PacketTypeClasses.Play.Server.VIEW_DISTANCE, VIEW_DISTANCE);
+                insertPacketID(PacketTypeClasses.Play.Server.SCOREBOARD_DISPLAY_OBJECTIVE, SCOREBOARD_DISPLAY_OBJECTIVE);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY_METADATA, ENTITY_METADATA);
+                insertPacketID(PacketTypeClasses.Play.Server.ATTACH_ENTITY, ATTACH_ENTITY);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY_VELOCITY, ENTITY_VELOCITY);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY_EQUIPMENT, ENTITY_EQUIPMENT);
+                insertPacketID(PacketTypeClasses.Play.Server.EXPERIENCE, EXPERIENCE);
+                insertPacketID(PacketTypeClasses.Play.Server.UPDATE_HEALTH, UPDATE_HEALTH);
+                insertPacketID(PacketTypeClasses.Play.Server.SCOREBOARD_OBJECTIVE, SCOREBOARD_OBJECTIVE);
+                insertPacketID(PacketTypeClasses.Play.Server.MOUNT, MOUNT);
+                insertPacketID(PacketTypeClasses.Play.Server.SCOREBOARD_TEAM, SCOREBOARD_TEAM);
+                insertPacketID(PacketTypeClasses.Play.Server.SCOREBOARD_SCORE, SCOREBOARD_SCORE);
+                insertPacketID(PacketTypeClasses.Play.Server.SPAWN_POSITION, SPAWN_POSITION);
+                insertPacketID(PacketTypeClasses.Play.Server.UPDATE_TIME, UPDATE_TIME);
+                insertPacketID(PacketTypeClasses.Play.Server.TITLE, TITLE);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY_SOUND, ENTITY_SOUND);
+                insertPacketID(PacketTypeClasses.Play.Server.NAMED_SOUND_EFFECT, NAMED_SOUND_EFFECT);
+                insertPacketID(PacketTypeClasses.Play.Server.STOP_SOUND, STOP_SOUND);
+                insertPacketID(PacketTypeClasses.Play.Server.PLAYER_LIST_HEADER_FOOTER, PLAYER_LIST_HEADER_FOOTER);
+                insertPacketID(PacketTypeClasses.Play.Server.NBT_QUERY, NBT_QUERY);
+                insertPacketID(PacketTypeClasses.Play.Server.COLLECT, COLLECT);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY_TELEPORT, ENTITY_TELEPORT);
+                insertPacketID(PacketTypeClasses.Play.Server.ADVANCEMENTS, ADVANCEMENTS);
+                insertPacketID(PacketTypeClasses.Play.Server.UPDATE_ATTRIBUTES, UPDATE_ATTRIBUTES);
+                insertPacketID(PacketTypeClasses.Play.Server.ENTITY_EFFECT, ENTITY_EFFECT);
+                insertPacketID(PacketTypeClasses.Play.Server.RECIPE_UPDATE, RECIPE_UPDATE);
+                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,99 +1,144 @@
 /*
- * 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.utils.nms.NMSUtils;
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.utils.reflection.Reflection;
 import io.github.retrooper.packetevents.utils.reflection.SubclassUtil;
+import io.github.retrooper.packetevents.utils.server.ServerVersion;
 
 public class PacketTypeClasses {
     public static void load() {
-        //PLAY
-        PacketTypeClasses.Play.Client.load();
-        PacketTypeClasses.Play.Server.load();
-        //LOGIN
-        PacketTypeClasses.Login.Client.load();
-        PacketTypeClasses.Login.Server.load();
         //STATUS
         PacketTypeClasses.Status.Client.load();
         PacketTypeClasses.Status.Server.load();
+        //HANDSHAKING
+        PacketTypeClasses.Handshaking.Client.load();
+        //LOGIN
+        PacketTypeClasses.Login.Client.load();
+        PacketTypeClasses.Login.Server.load();
+        //PLAY
+        PacketTypeClasses.Play.Client.load();
+        PacketTypeClasses.Play.Server.load();
     }
 
     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");
-                PacketType.Status.Client.init();
+                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");
-                PacketType.Status.Server.init();
+                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() {
+                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 {
-            public static Class<?> HANDSHAKE, CUSTOM_PAYLOAD, START, ENCRYPTION_BEGIN;
+            private static String PREFIX;
+            public static Class<?> CUSTOM_PAYLOAD, START, ENCRYPTION_BEGIN;
 
             public static void load() {
-                Client.HANDSHAKE = NMSUtils.getNMSClassWithoutException("PacketHandshakingInSetProtocol");
-                //In and Out custom payload login packets have been here since AROUND 1.13.2.
-                Client.CUSTOM_PAYLOAD = NMSUtils.getNMSClassWithoutException("PacketLoginInCustomPayload");
-                Client.START = NMSUtils.getNMSClassWithoutException("PacketLoginInStart");
-                Client.ENCRYPTION_BEGIN = NMSUtils.getNMSClassWithoutException("PacketLoginInEncryptionBegin");
-                PacketType.Login.Client.init();
+                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 = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginInCustomPayload");
+                }
+                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() {
-                Server.CUSTOM_PAYLOAD = NMSUtils.getNMSClassWithoutException("PacketLoginOutCustomPayload");
-                Server.DISCONNECT = NMSUtils.getNMSClassWithoutException("PacketLoginOutDisconnect");
-                Server.ENCRYPTION_BEGIN = NMSUtils.getNMSClassWithoutException("PacketLoginOutEncryptionBegin");
-                Server.SUCCESS = NMSUtils.getNMSClassWithoutException("PacketLoginOutSuccess");
-                Server.SET_COMPRESSION = NMSUtils.getNMSClassWithoutException("PacketLoginOutSetCompression");
-                PacketType.Login.Server.init();
+                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 = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginOutCustomPayload");
+                }
+                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 = Reflection.getClassByNameWithoutException(PREFIX + "PacketLoginOutSetCompression");
+                }
             }
         }
     }
 
     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,
@@ -103,85 +148,126 @@ 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 (ClassNotFoundException 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");
-                } catch (ClassNotFoundException e) {
+                    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");
-                } catch (ClassNotFoundException ignored) {
+                    BLOCK_PLACE = Class.forName(COMMON_PREFIX + "BlockPlace");
+                    USE_ITEM = Class.forName(COMMON_PREFIX + "UseItem");
+                } catch (Exception ignored) {
                 }
 
-                PacketType.Play.Client.init();
             }
         }
 
         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,
@@ -204,116 +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");
-                PacketType.Play.Server.init();
             }
         }
     }
-
 }

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,48 +1,62 @@
 /*
- * 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;
 
+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.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
-import java.util.Map;
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+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;
-    protected NMSPacket packet;
+    protected final NMSPacket packet;
     private final Class<?> packetClass;
 
     public WrappedPacket() {
@@ -69,13 +83,95 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
     private void load0() {
         final Class<? extends WrappedPacket> clazz = getClass();
         if (!LOADED_WRAPPERS.containsKey(clazz)) {
-            load();
+            if (!isSupported()) {
+                throw new WrapperUnsupportedUsageException(getClass());
+            }
+            try {
+                load();
+            } catch (Exception ex) {
+                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);
+            }
             LOADED_WRAPPERS.put(clazz, true);
         }
     }
 
     protected void load() {
+    }
 
+    protected boolean hasLoaded() {
+        return LOADED_WRAPPERS.getOrDefault(getClass(), false);
+    }
+
+    protected void throwUnsupportedOperation(Enum<?> enumConst) throws UnsupportedOperationException {
+        Class<?> enumConstClass = enumConst.getClass();
+        Field field = null;
+        try {
+            field = enumConstClass.getField(enumConst.name());
+        } catch (NoSuchFieldException e) {
+            e.printStackTrace();
+        }
+        if (field.isAnnotationPresent(SupportedVersions.class)) {
+            SupportedVersions supportedVersions = field.getAnnotation(SupportedVersions.class);
+            List<ServerVersion> versionList = parseSupportedVersionsAnnotation(supportedVersions);
+            String supportedVersionsMsg = Arrays.toString(versionList.toArray(new ServerVersion[0]));
+            throw new UnsupportedOperationException("PacketEvents failed to use the " + enumConst.name() + " enum constant in the " + enumConstClass.getSimpleName() + " enum. This enum constant is not supported on your server version. (" + PacketEvents.get().getServerUtils().getVersion() + ")\n This enum constant is only supported on these server versions: " + supportedVersionsMsg);
+        } else {
+            throw new UnsupportedOperationException("PacketEvents failed to use the " + enumConst.name() + " enum constant in the " + enumConstClass.getSimpleName() + " enum. This enum constant is not supported on your server version. (" + PacketEvents.get().getServerUtils().getVersion() + ")\n Failed to find out what server versions this enum constant is supported on.");
+        }
+    }
+
+    protected void throwUnsupportedOperation() throws UnsupportedOperationException {
+        final String currentMethodName = "throwUnsupportedOperation";
+        StackTraceElement[] stackTraceElements = Thread.currentThread().getStackTrace();
+        int stackTraceElementIndex = 2;
+        for (int i = 0; i < stackTraceElements.length; i++) {
+            StackTraceElement element = stackTraceElements[i];
+            if (element.getMethodName().equals(currentMethodName)) {
+                stackTraceElementIndex = i + 1; //It is the next method
+                break;
+            }
+        }
+        StackTraceElement stackTraceElement = stackTraceElements[stackTraceElementIndex];
+        String methodName = stackTraceElement.getMethodName();
+        List<Method> possibleMethods = Reflection.getMethods(getClass(), methodName, (Class<?>) null);
+        Method method = null;
+        for (Method m : possibleMethods) {
+            if (m.isAnnotationPresent(SupportedVersions.class)) {
+                method = m;
+                break;
+            }
+        }
+        if (method == null) {
+            throw new UnsupportedOperationException("PacketEvents failed to access your requested field. This field is not supported on your server version. Failed to lookup the server versions this field supports...");
+        } else {
+            SupportedVersions supportedVersions = method.getAnnotation(SupportedVersions.class);
+            List<ServerVersion> versionList = parseSupportedVersionsAnnotation(supportedVersions);
+
+            String supportedVersionsMsg = Arrays.toString(versionList.toArray(new ServerVersion[0]));
+            throw new UnsupportedOperationException("PacketEvents failed to access your requested field. This field is not supported on your server version. (" + PacketEvents.get().getServerUtils().getVersion() + ")\n This field is only supported on these server versions: " + supportedVersionsMsg);
+        }
+    }
+
+    private List<ServerVersion> parseSupportedVersionsAnnotation(SupportedVersions supportedVersions) {
+        List<ServerVersion> versionList = new ArrayList<>();
+        for (int i = 0; i < supportedVersions.ranges().length; i += 2) {
+            ServerVersion first = supportedVersions.ranges()[i];
+            ServerVersion last = supportedVersions.ranges()[i + 1];
+            if (first == last) {
+                versionList.add(first);
+                continue;
+            } else if (first == ServerVersion.ERROR) {
+                first = ServerVersion.getOldest();
+            } else if (last == ServerVersion.ERROR) {
+                last = ServerVersion.getLatest();
+            }
+            versionList.addAll(Arrays.asList(ServerVersion.values()).subList(first.ordinal(), last.ordinal() + 1));
+        }
+        versionList.remove(ServerVersion.ERROR);
+        return versionList;
     }
 
 
@@ -151,7 +247,7 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
 
     @Override
     public String[] readStringArray(int index) {
-        return read(index, String[].class); // Can we be sure that returning the original array is okay?
+        return read(index, String[].class); // JavaImpact: Can we be sure that returning the original array is okay? retrooper: Yes
     }
 
     @Override
@@ -159,6 +255,7 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
         return read(index, String.class);
     }
 
+    @Override
     public Object readAnyObject(int index) {
         try {
             Field f = packetClass.getDeclaredFields()[index];
@@ -176,20 +273,27 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
         return null;
     }
 
-    public Object readObject(int index, Class<?> type) {
+    @Override
+    public <T> T readObject(int index, Class<? extends T> type) {
+        return read(index, type);
+    }
+
+    @Override
+    public Enum<?> readEnumConstant(int index, Class<? extends Enum<?>> type) {
         return read(index, type);
     }
 
     @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 e) {
+        } catch (IllegalAccessException | NullPointerException | ArrayIndexOutOfBoundsException e) {
             throw new WrapperFieldNotFoundException(packetClass, type, index);
         }
     }
 
+
     @Override
     public void writeBoolean(int index, boolean value) {
         write(boolean.class, index, value);
@@ -235,6 +339,68 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
         write(value.getClass(), index, value);
     }
 
+    @Override
+    public void writeBooleanArray(int index, boolean[] array) {
+        write(boolean[].class, index, array);
+    }
+
+    @Override
+    public void writeByteArray(int index, byte[] value) {
+        write(byte[].class, index, value);
+    }
+
+    @Override
+    public void writeShortArray(int index, short[] value) {
+        write(short[].class, index, value);
+    }
+
+    @Override
+    public void writeIntArray(int index, int[] value) {
+        write(int[].class, index, value);
+    }
+
+    @Override
+    public void writeLongArray(int index, long[] value) {
+        write(long[].class, index, value);
+    }
+
+    @Override
+    public void writeFloatArray(int index, float[] value) {
+        write(float[].class, index, value);
+    }
+
+    @Override
+    public void writeDoubleArray(int index, double[] value) {
+        write(double[].class, index, value);
+    }
+
+    @Override
+    public void writeStringArray(int index, String[] value) {
+        write(String[].class, index, value);
+    }
+
+    @Override
+    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!");
+        }
+    }
+
+    @Override
+    public void writeEnumConstant(int index, Enum<?> 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);
         if (field == null) {
@@ -247,10 +413,174 @@ 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 HashMap<>());
+        Map<Class<?>, Field[]> cached = FIELD_CACHE.computeIfAbsent(packetClass, k -> new ConcurrentHashMap<>());
         Field[] fields = cached.computeIfAbsent(type, typeClass -> getFields(typeClass, packetClass.getDeclaredFields()));
-        return fields[index];
+        if (fields.length >= index + 1) {
+            return fields[index];
+        } else {
+            throw new WrapperFieldNotFoundException(packetClass, type, index);
+        }
     }
 
     private Field[] getFields(Class<?> type, Field[] fields) {
@@ -266,8 +596,29 @@ public class WrappedPacket implements WrapperPacketReader, WrapperPacketWriter {
         return ret.toArray(EMPTY_FIELD_ARRAY);
     }
 
-    // Does the server version support reading/sending this packet?
+
+    /**
+     * Does the local server version support reading at-least one field with this packet wrapper?
+     * If it does, we can label this wrapper to be supported on the local server version.
+     * One example where it would not be supported would be if the packet the wrapper is wrapping doesn't even exist on the local server version.
+     *
+     * @return Is the wrapper supported on the local server version?
+     */
     public boolean isSupported() {
         return true;
     }
+
+    /**
+     * If a method in a wrapper is annotated with this, it means it isn't supported on all server versions.
+     * It not being supported by all server versions can lead to exceptions. Make sure you always decompile a wrapper getter before using it.
+     * This annotation will specify what versions are supported.
+     *
+     * @author retrooper
+     * @since 1.8
+     */
+    @Target({ElementType.METHOD, ElementType.FIELD, ElementType.CONSTRUCTOR})
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface SupportedVersions {
+        ServerVersion[] ranges() default {};
+    }
 }

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

@@ -1,64 +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);
-
-    Object readObject(int index, Class<?> type);
-
-    Object readAnyObject(int index);
-}

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

@@ -1,47 +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 {
-
-    // TODO write for the arrays
-    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);
-
-    void writeObject(int index, Object object);
-}

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

@@ -0,0 +1,59 @@
+/*
+ * 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.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(between_V_1_17_And_1_20_1 ? 1 : 0);
+    }
+
+    public void setProtocolVersion(int protocolVersion) {
+        writeInt(between_V_1_17_And_1_20_1 ? 1 : 0, protocolVersion);
+    }
+
+    public int getPort() {
+        return readInt(between_V_1_17_And_1_20_1 ? 2 : 1);
+    }
+
+    public void setPort(int port) {
+        writeInt(between_V_1_17_And_1_20_1 ? 2 : 1, port);
+    }
+
+    public String getHostName() {
+        return readString(0);
+    }
+
+    public void setHostName(String hostName) {
+        writeString(0, hostName);
+    }
+}

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;
@@ -30,40 +24,50 @@ import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
 import io.github.retrooper.packetevents.utils.server.ServerVersion;
 
-/**
- * This packet exists since 1.13
- */
 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(v_1_17 ? 1 : 0, id);
     }
 
     public byte[] getData() {
-        Object dataSerializer = readObject(0, packetDataSerializerClass);
+        return PacketEvents.get().getByteBufUtil().getBytes(getBuffer());
+    }
+
+    public void setData(byte[] data) {
+        PacketEvents.get().getByteBufUtil().setBytes(getBuffer(), data);
+    }
+
+    private Object getBuffer() {
+        Object dataSerializer = readObject(0, NMSUtils.packetDataSerializerClass);
         WrappedPacket byteBufWrapper = new WrappedPacket(new NMSPacket(dataSerializer));
-        Object byteBuf = byteBufWrapper.readObject(0, byteBufClass);
-        return PacketEvents.get().getByteBufUtil().getBytes(byteBuf);
+        return byteBufWrapper.readObject(0, NMSUtils.byteBufClass);
+    }
+
+    public void retain() {
+        PacketEvents.get().getByteBufUtil().retain(getBuffer());
+    }
+
+    public void release() {
+        PacketEvents.get().getByteBufUtil().release(getBuffer());
     }
 
     @Override
     public boolean isSupported() {
-        return version.isHigherThan(ServerVersion.v_1_12_2);
+        return version.isNewerThan(ServerVersion.v_1_12_2);
     }
 }
 

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,18 +21,86 @@ 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);
     }
 
-    public byte[] getVerifyToken() {
-        return readByteArray(1);
+    public void setPublicKey(byte[] key) {
+        writeByteArray(0, key);
+    }
+
+
+    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 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/handshake/WrappedPacketLoginInHandshake.java

@@ -1,52 +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.login.in.handshake;
-
-import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
-import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
-import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
-
-public class WrappedPacketLoginInHandshake extends WrappedPacket {
-    public WrappedPacketLoginInHandshake(NMSPacket packet) {
-        super(packet);
-    }
-
-    public int getProtocolVersion() {
-        return readInt(0);
-    }
-
-    public String getHostName() {
-        return readString(0);
-    }
-
-    public int getPort() {
-        return readInt(1);
-    }
-
-    @Override
-    public boolean isSupported() {
-        return PacketTypeClasses.Login.Client.HANDSHAKE != null;
-    }
-}

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,14 +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) {
+        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,20 +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 Constructor<?> minecraftKeyConstructor;
-    private static Class<?> byteBufClass;
-    private static Class<?> packetDataSerializerClass;
-    private static Class<?> minecraftKeyClass;
     private int messageID;
     private String channelName;
     private byte[] data;
@@ -49,35 +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");
-            minecraftKeyClass = NMSUtils.getNMSClassWithoutException("MinecraftKey");
             try {
-                byteBufClass = NMSUtils.getNettyClass("buffer.ByteBuf");
-            } catch (ClassNotFoundException ex) {
-                ex.printStackTrace();
-            }
-
-            try {
-                if (packetDataSerializerClass != null) {
-                    packetDataSerializerConstructor = packetDataSerializerClass.getConstructor(byteBufClass);
-                }
-            } catch (NoSuchMethodException e) {
-                e.printStackTrace();
-            }
-            try {
-                if (minecraftKeyClass != null) {
-                    minecraftKeyConstructor = minecraftKeyClass.getConstructor(String.class);
+                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.");
             }
@@ -86,47 +69,67 @@ 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(v_1_17 ? 1 : 0, messageID);
+        } else {
+            this.messageID = messageID;
+        }
+    }
+
     public String getChannelName() {
         if (packet != null) {
-            Object minecraftKey = readObject(0, minecraftKeyClass);
-            WrappedPacket minecraftKeyWrapper = new WrappedPacket(new NMSPacket(minecraftKey));
-            return minecraftKeyWrapper.readString(1);
+           return readMinecraftKey(0);
+        }
+        else {
+            return channelName;
+        }
+    }
+
+    public void setChannelName(String channelName) {
+        if (packet != null) {
+            writeMinecraftKey(0, channelName);
+        } else {
+            this.channelName = channelName;
         }
-        return channelName;
     }
 
     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) {
+        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 = minecraftKeyConstructor.newInstance(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,17 +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.play.out.chat.WrappedPacketOutChat;
+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 WrappedPacketLoginOutDisconnect(String reason) {
+        this.reason = reason;
+    }
+
+    @Override
+    protected void load() {
+        try {
+            packetConstructor = PacketTypeClasses.Login.Server.DISCONNECT.getConstructor(NMSUtils.iChatBaseComponentClass);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+    }
+
     public String getReason() {
-        Object iChatBaseComponent = readObject(0, NMSUtils.iChatBaseComponentClass);
-        return WrappedPacketOutChat.toStringFromIChatBaseComponent(iChatBaseComponent);
+        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,24 +21,61 @@ 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);
     }
 
-    public PublicKey getPublicKey() {
-        return (PublicKey) readObject(1, PublicKey.class);
+    public void setEncodedString(String encodedString) {
+        writeString(0, encodedString);
     }
 
-    public byte[] getByteArray() {
-        return readByteArray(0);
+    public PublicKey getPublicKey() {
+        return v_1_17 ? encrypt(readByteArray(0)) : readObject(0, PublicKey.class);
+    }
+
+    public void setPublicKey(PublicKey key) {
+        if (v_1_17) {
+            writeByteArray(0, key.getEncoded());
+        } else {
+            writeObject(0, key);
+        }
+    }
+
+    public byte[] getVerifyToken() {
+        return readByteArray(v_1_17 ? 1 : 0);
+    }
+
+    public void setVerifyToken(byte[] 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,38 +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;
@@ -68,18 +61,21 @@ public class WrappedPacketLoginOutSetCompression extends WrappedPacket implement
         return threshold;
     }
 
-    @Override
-    public Object asNMSPacket() {
-        try {
-            return constructor.newInstance(threshold);
-        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
+    public void setThreshold(int threshold) {
+        if (packet != null) {
+            writeInt(0, threshold);
+        } else {
+            this.threshold = threshold;
         }
-        return null;
+    }
+
+    @Override
+    public Object asNMSPacket() throws Exception {
+        return constructor.newInstance(getThreshold());
     }
 
     @Override
     public boolean isSupported() {
-        return PacketTypeClasses.Login.Server.SET_COMPRESSION != null;
+        return version.isNewerThan(ServerVersion.v_1_7_10);
     }
 }

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,17 +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;
+        }
+    }
+
+    //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;
@@ -29,8 +23,10 @@ import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
 import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
 import io.github.retrooper.packetevents.utils.reflection.Reflection;
 
+import java.util.Optional;
+
 public final class WrappedPacketInAbilities extends WrappedPacket {
-    private static boolean v_1_16_Mode = false;
+    private static boolean v_1_16_Mode;
 
     public WrappedPacketInAbilities(NMSPacket packet) {
         super(packet);
@@ -41,76 +37,77 @@ public final class WrappedPacketInAbilities extends WrappedPacket {
         v_1_16_Mode = Reflection.getField(PacketTypeClasses.Play.Client.ABILITIES, boolean.class, 1) == null;
     }
 
-    /**
-     * 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.
-     */
-    @Deprecated
-    public boolean isVulnerable() throws UnsupportedOperationException {
-        if (v_1_16_Mode) {
-            throw new UnsupportedOperationException("This field does not exist on your version!");
-        }
-        return readBoolean(0);
-    }
-
     public boolean isFlying() {
+        return readBoolean(v_1_16_Mode ? 0 : 1);
+    }
+
+    public void setFlying(boolean flying) {
+        writeBoolean(v_1_16_Mode ? 0 : 1, flying);
+    }
+
+    public Optional<Boolean> isVulnerable() {
         if (v_1_16_Mode) {
-            return readBoolean(0);
-        } else {
-            return readBoolean(1);
+            return Optional.empty();
+        }
+        return Optional.of(readBoolean(0));
+    }
+
+    public void setVulnerable(boolean vulnerable) {
+        if (!v_1_16_Mode) {
+            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.
-     */
-    @Deprecated
-    public boolean isFlightAllowed() {
+
+    public Optional<Boolean> isFlightAllowed() {
         if (v_1_16_Mode) {
-            throw new UnsupportedOperationException("This field does not exist on your version!");
+            return Optional.empty();
         }
-        return readBoolean(2);
+        return Optional.of(readBoolean(2));
     }
 
-    /**
-     * 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.
-     */
-    @Deprecated
-    public boolean canInstantlyBuild() {
-        if (v_1_16_Mode) {
-            throw new UnsupportedOperationException("This field does not exist on your version!");
+    public void setFlightAllowed(boolean flightAllowed) {
+        if (!v_1_16_Mode) {
+            writeBoolean(2, flightAllowed);
         }
-        return readBoolean(3);
     }
 
-    /**
-     * 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.
-     */
-    @Deprecated
-    public float getFlySpeed() {
+    public Optional<Boolean> canInstantlyBuild() {
         if (v_1_16_Mode) {
-            throw new UnsupportedOperationException("This field does not exist on your version!");
+            return Optional.empty();
         }
-        return readFloat(0);
+        return Optional.of(readBoolean(3));
     }
 
-    /**
-     * 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.
-     */
-    @Deprecated
-    public float getWalkSpeed() {
-        if (v_1_16_Mode) {
-            throw new UnsupportedOperationException("This field does not exist on your version!");
+    public void setCanInstantlyBuild(boolean canInstantlyBuild) {
+        if (!v_1_16_Mode) {
+            writeBoolean(3, canInstantlyBuild);
+        }
+    }
+
+    public Optional<Float> getFlySpeed() {
+        if (v_1_16_Mode) {
+            return Optional.empty();
+        }
+        return Optional.of(readFloat(0));
+    }
+
+    public void setFlySpeed(float flySpeed) {
+        if (!v_1_16_Mode) {
+            writeFloat(0, flySpeed);
+        }
+    }
+
+    public Optional<Float> getWalkSpeed() {
+        if (v_1_16_Mode) {
+            return Optional.empty();
+        }
+        return Optional.of(readFloat(1));
+    }
+
+    public void setWalkSpeed(float walkSpeed) {
+        if (!v_1_16_Mode) {
+            writeFloat(1, walkSpeed);
         }
-        return readFloat(1);
     }
 }

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;
@@ -12,7 +30,15 @@ public class WrappedPacketInBeacon extends WrappedPacket {
         return readInt(0);
     }
 
+    public void setPrimaryEffect(int primaryEffect) {
+        writeInt(0, primaryEffect);
+    }
+
     public int getSecondaryEffect() {
         return readInt(1);
     }
+
+    public void setSecondaryEffect(int secondaryEffect) {
+        writeInt(1, secondaryEffect);
+    }
 }

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;
@@ -27,22 +21,16 @@ package io.github.retrooper.packetevents.packetwrappers.play.in.blockdig;
 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.enums.EnumUtil;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
 import io.github.retrooper.packetevents.utils.player.Direction;
-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 org.jetbrains.annotations.Nullable;
-
-import java.lang.reflect.InvocationTargetException;
+import io.github.retrooper.packetevents.utils.vector.Vector3i;
 
 public final class WrappedPacketInBlockDig extends WrappedPacket {
-    private static Class<?> blockPositionClass;
-    private static Class<?> enumDirectionClass;
-    private static Class<?> digTypeClass;
+    private static Class<? extends Enum<?>> digTypeClass;
     private static boolean isVersionLowerThan_v_1_8;
-    private Object blockPosObj;
-    private Object enumDirObj;
 
     public WrappedPacketInBlockDig(NMSPacket packet) {
         super(packet);
@@ -51,86 +39,39 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
     @Override
     protected void load() {
         Class<?> blockDigClass = PacketTypeClasses.Play.Client.BLOCK_DIG;
-        try {
-            if (version.isHigherThan(ServerVersion.v_1_7_10)) {
-                blockPositionClass = NMSUtils.getNMSClass("BlockPosition");
-                enumDirectionClass = NMSUtils.getNMSClass("EnumDirection");
-            }
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-        isVersionLowerThan_v_1_8 = version.isLowerThan(ServerVersion.v_1_8);
+        isVersionLowerThan_v_1_8 = version.isOlderThan(ServerVersion.v_1_8);
 
         if (version != ServerVersion.v_1_7_10) {
             try {
-                digTypeClass = NMSUtils.getNMSClass("EnumPlayerDigType");
+                digTypeClass = NMSUtils.getNMSEnumClass("EnumPlayerDigType");
             } catch (ClassNotFoundException e) {
                 //It is probably a subclass
-                digTypeClass = SubclassUtil.getSubClass(blockDigClass, "EnumPlayerDigType");
+                digTypeClass = SubclassUtil.getEnumSubClass(blockDigClass, "EnumPlayerDigType");
+                if (digTypeClass == null) {
+                    digTypeClass = SubclassUtil.getEnumSubClass(blockDigClass, 0);
+                }
             }
         }
     }
 
-    /**
-     * Get X position of the block
-     *
-     * @return Block Position X
-     */
-    public int getX() {
+    public Vector3i getBlockPosition() {
         if (isVersionLowerThan_v_1_8) {
-            return readInt(0);
+            int x = readInt(0);
+            int y = readInt(1);
+            int z = readInt(2);
+            return new Vector3i(x, y, z);
         } else {
-            if (blockPosObj == null) {
-                blockPosObj = readObject(0, blockPositionClass);
-            }
-            try {
-                return (int) Reflection.getMethod(blockPosObj.getClass().getSuperclass(), "getX", 0).invoke(blockPosObj);
-            } catch (IllegalAccessException | InvocationTargetException e) {
-                e.printStackTrace();
-            }
-            return -1;
+            return readBlockPosition(0);
         }
     }
 
-    /**
-     * Get Y position of the block
-     *
-     * @return Block Position Y
-     */
-    public int getY() {
+    public void setBlockPosition(Vector3i blockPos) {
         if (isVersionLowerThan_v_1_8) {
-            return readInt(1);
+            writeInt(0, blockPos.x);
+            writeInt(1, blockPos.y);
+            writeInt(2, blockPos.z);
         } else {
-            if (blockPosObj == null) {
-                blockPosObj = readObject(0, blockPositionClass);
-            }
-            try {
-                return (int) Reflection.getMethod(blockPosObj.getClass().getSuperclass(), "getY", 0).invoke(blockPosObj);
-            } catch (IllegalAccessException | InvocationTargetException e) {
-                e.printStackTrace();
-            }
-            return -1;
-        }
-    }
-
-    /**
-     * Get Z position of the block
-     *
-     * @return Block Position Z
-     */
-    public int getZ() {
-        if (isVersionLowerThan_v_1_8) {
-            return readInt(2);
-        } else {
-            if (blockPosObj == null) {
-                blockPosObj = readObject(0, blockPositionClass);
-            }
-            try {
-                return (int) Reflection.getMethod(blockPosObj.getClass().getSuperclass(), "getZ", 0).invoke(blockPosObj);
-            } catch (IllegalAccessException | InvocationTargetException e) {
-                e.printStackTrace();
-            }
-            return -1;
+            writeBlockPosition(0, blockPos);
         }
     }
 
@@ -139,19 +80,21 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
      *
      * @return Direction
      */
-    @Nullable
     public Direction getDirection() {
-        net.minecraft.server.v1_7_R4.PacketPlayInBlockDig bd;
         if (isVersionLowerThan_v_1_8) {
-            return new Direction((byte) readInt(3));
+            return Direction.getDirection(readInt(3));
         } else {
-            if (enumDirObj == null) {
-                enumDirObj = readObject(0, enumDirectionClass);
-                if (enumDirObj == null) {
-                    return null;
-                }
-            }
-            return Direction.getByName(((Enum) enumDirObj).name());
+            Enum<?> enumDir = readEnumConstant(0, NMSUtils.enumDirectionClass);
+            return Direction.values()[enumDir.ordinal()];
+        }
+    }
+
+    public void setDirection(Direction direction) {
+        if (isVersionLowerThan_v_1_8) {
+            writeInt(3, direction.getFaceValue());
+        } else {
+            Enum<?> enumConst = EnumUtil.valueByIndex(NMSUtils.enumDirectionClass, direction.ordinal());
+            write(NMSUtils.enumDirectionClass, 0, enumConst);
         }
     }
 
@@ -164,7 +107,16 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
         if (isVersionLowerThan_v_1_8) {
             return PlayerDigType.values()[readInt(4)];
         } else {
-            return PlayerDigType.valueOf(((Enum) readObject(0, digTypeClass)).name());
+            return PlayerDigType.values()[readEnumConstant(0, digTypeClass).ordinal()];
+        }
+    }
+
+    public void setDigType(PlayerDigType type) {
+        if (isVersionLowerThan_v_1_8) {
+            writeInt(4, type.ordinal());
+        } else {
+            Enum<?> enumConst = EnumUtil.valueByIndex(digTypeClass, type.ordinal());
+            writeEnumConstant(0, enumConst);
         }
     }
 
@@ -175,8 +127,6 @@ public final class WrappedPacketInBlockDig extends WrappedPacket {
         DROP_ALL_ITEMS,
         DROP_ITEM,
         RELEASE_USE_ITEM,
-        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,38 +1,40 @@
 /*
- * 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.enums.EnumUtil;
+import io.github.retrooper.packetevents.utils.nms.NMSUtils;
 import io.github.retrooper.packetevents.utils.player.Direction;
+import io.github.retrooper.packetevents.utils.player.Hand;
 import io.github.retrooper.packetevents.utils.server.ServerVersion;
-import org.jetbrains.annotations.Nullable;
+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 isHigherThan_v_1_8_8, isHigherThan_v_1_7_10;
+    private static boolean newerThan_v_1_8_8, newerThan_v_1_7_10;
+    private static int handEnumIndex;
 
     public WrappedPacketInBlockPlace(final NMSPacket packet) {
         super(packet);
@@ -40,62 +42,121 @@ public final class WrappedPacketInBlockPlace extends WrappedPacket {
 
     @Override
     protected void load() {
-        isHigherThan_v_1_8_8 = version.isHigherThan(ServerVersion.v_1_8_8);
-        isHigherThan_v_1_7_10 = version.isHigherThan(ServerVersion.v_1_7_10);
+        newerThan_v_1_7_10 = version.isNewerThan(ServerVersion.v_1_7_10);
+        newerThan_v_1_8_8 = version.isNewerThan(ServerVersion.v_1_8_8);
+        try {
+            Object handEnum = readObject(1, NMSUtils.enumHandClass);
+            handEnumIndex = 1;
+        } catch (Exception ex) {
+            handEnumIndex = 0;//Most likely a newer version
+        }
+    }
+
+    public Hand getHand() {
+        if (newerThan_v_1_8_8) {
+            Enum<?> enumConst = readEnumConstant(handEnumIndex, 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 (newerThan_v_1_8_8) {
+            Enum<?> enumConst = EnumUtil.valueByIndex(NMSUtils.enumHandClass, hand.ordinal());
+            writeEnumConstant(handEnumIndex, enumConst);
+        }
     }
 
-    @Nullable
     public Direction getDirection() {
-        if (isHigherThan_v_1_8_8) {
-            WrappedPacketInBlockPlace_1_9 blockPlace_1_9 = new WrappedPacketInBlockPlace_1_9(packet);
-            return Direction.getByName(((Enum) blockPlace_1_9.getEnumDirectionObject()).name());
-        } else if (isHigherThan_v_1_7_10) {
-            WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
-            return new Direction((byte) blockPlace_1_8.getFace());
+        if (newerThan_v_1_8_8) {
+            WrappedPacketInBlockPlace_1_9 blockPlace_1_9 = new WrappedPacketInBlockPlace_1_9(new NMSPacket(packet.getRawNMSPacket()));
+            return blockPlace_1_9.getDirection();
+        } else if (newerThan_v_1_7_10) {
+            WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(new NMSPacket(packet.getRawNMSPacket()));
+            return Direction.getDirection(blockPlace_1_8.getFace());
         } else {
-            WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(packet);
-            return new Direction((byte) blockPlace_1_7_10.face);
+            WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(new NMSPacket(packet.getRawNMSPacket()));
+            return Direction.getDirection(blockPlace_1_7_10.getFace());
         }
     }
 
-    public int getX() {
-        if (isHigherThan_v_1_8_8) {
-            WrappedPacketInBlockPlace_1_9 blockPlace_1_9 = new WrappedPacketInBlockPlace_1_9(packet);
-            return blockPlace_1_9.getX();
-        } else if (isHigherThan_v_1_7_10) {
-            WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
-            return blockPlace_1_8.getX();
+    public void setDirection(Direction direction) {
+        if (newerThan_v_1_8_8) {
+            WrappedPacketInBlockPlace_1_9 blockPlace_1_9 = new WrappedPacketInBlockPlace_1_9(new NMSPacket(packet.getRawNMSPacket()));
+            blockPlace_1_9.setDirection(direction);
+        } else if (newerThan_v_1_7_10) {
+            WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(new NMSPacket(packet.getRawNMSPacket()));
+            blockPlace_1_8.setFace(direction.getFaceValue());
         } else {
-            WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(packet);
-            return blockPlace_1_7_10.x;
+            WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(new NMSPacket(packet.getRawNMSPacket()));
+            blockPlace_1_7_10.setFace(direction.getFaceValue());
         }
     }
 
-    public int getY() {
-        if (isHigherThan_v_1_8_8) {
+    public Vector3i getBlockPosition() {
+        Vector3i blockPos;
+        if (newerThan_v_1_8_8) {
             WrappedPacketInBlockPlace_1_9 blockPlace_1_9 = new WrappedPacketInBlockPlace_1_9(packet);
-            return blockPlace_1_9.getY();
-
-        } else if (isHigherThan_v_1_7_10) {
+            blockPos = blockPlace_1_9.getBlockPosition();
+        } else if (newerThan_v_1_7_10) {
             WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
-            return blockPlace_1_8.getY();
+            blockPos = blockPlace_1_8.getBlockPosition();
         } else {
             WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(packet);
-            return blockPlace_1_7_10.y;
+            blockPos = blockPlace_1_7_10.getBlockPosition();
+        }
+        return blockPos;
+    }
+
+    public Optional<Vector3f> getCursorPosition() {
+        if (newerThan_v_1_8_8) {
+            return Optional.empty();
+        } else if (newerThan_v_1_7_10) {
+            WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
+            return Optional.of(blockPlace_1_8.getCursorPosition());
+        } else {
+            WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(packet);
+            return Optional.of(blockPlace_1_7_10.getCursorPosition());
         }
     }
 
-    public int getZ() {
-        if (isHigherThan_v_1_8_8) {
-            WrappedPacketInBlockPlace_1_9 blockPlace_1_9 = new WrappedPacketInBlockPlace_1_9(packet);
-            return blockPlace_1_9.getZ();
-        } else if (isHigherThan_v_1_7_10) {
+    public void setCursorPosition(Vector3f cursorPos) {
+        if (newerThan_v_1_8_8) {
+
+        } else if (newerThan_v_1_7_10) {
             WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
-            return blockPlace_1_8.getZ();
+            blockPlace_1_8.setCursorPosition(cursorPos);
         } else {
             WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(packet);
-            return blockPlace_1_7_10.z;
+            blockPlace_1_7_10.setCursorPosition(cursorPos);
         }
     }
 
+    public Optional<ItemStack> getItemStack() {
+        if (newerThan_v_1_8_8) {
+            return Optional.empty();
+        } else if (newerThan_v_1_7_10) {
+            WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
+            return Optional.of(blockPlace_1_8.getItemStack());
+        } else {
+            WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(packet);
+            return Optional.of(blockPlace_1_7_10.getItemStack());
+        }
+    }
+
+
+    public void setItemStack(ItemStack stack) {
+        if (newerThan_v_1_8_8) {
+            //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);
+        } else {
+            WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(packet);
+            blockPlace_1_7_10.setItemStack(stack);
+        }
+    }
 }

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

@@ -1,50 +1,67 @@
 /*
- * 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.vector.Vector3f;
+import io.github.retrooper.packetevents.utils.vector.Vector3i;
 import org.bukkit.inventory.ItemStack;
 
 final class WrappedPacketInBlockPlace_1_7_10 extends WrappedPacket {
-    public int x, y, z;
-    public ItemStack itemStack;
-    public int face;
-
     WrappedPacketInBlockPlace_1_7_10(final NMSPacket packet) {
         super(packet);
-        final net.minecraft.server.v1_7_R4.PacketPlayInBlockPlace blockPlace =
-                (net.minecraft.server.v1_7_R4.PacketPlayInBlockPlace) packet.getRawNMSPacket();
+    }
 
-        x = blockPlace.c();
-        y = blockPlace.d();
-        z = blockPlace.e();
+    public Vector3i getBlockPosition() {
+        return new Vector3i(readInt(0), readInt(1), readInt(2));
+    }
 
-        this.face = blockPlace.d();
+    public void setBlockPosition(Vector3i blockPos) {
+        writeInt(0, blockPos.x);
+        writeInt(1, blockPos.y);
+        writeInt(2, blockPos.z);
+    }
 
-        net.minecraft.server.v1_7_R4.ItemStack stack = blockPlace.getItemStack();
-        this.itemStack = org.bukkit.craftbukkit.v1_7_R4.inventory.CraftItemStack.asBukkitCopy(stack);
+    public int getFace() {
+        return readInt(3);
+    }
+
+    public void setFace(int face) {
+        writeInt(3, face);
+    }
+
+    public ItemStack getItemStack() {
+        return readItemStack(0);
+    }
+
+    public void setItemStack(ItemStack stack) {
+        writeItemStack(0, stack);
+    }
+
+    public Vector3f getCursorPosition() {
+        return new Vector3f(readFloat(0), readFloat(1), readFloat(2));
+    }
+
+    public void setCursorPosition(Vector3f cursorPos) {
+        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,86 +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.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.reflection.Reflection;
+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 {
-    private Object blockPosObj;
 
     WrappedPacketInBlockPlace_1_8(final NMSPacket packet) {
         super(packet);
     }
 
-    public int getX() {
-        if (blockPosObj == null) {
-            blockPosObj = readObject(1, NMSUtils.blockPosClass);
-        }
-        try {
-            return (int) Reflection.getMethod(blockPosObj.getClass().getSuperclass(), "getX", 0).invoke(blockPosObj);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-        return 0;
+    public Vector3i getBlockPosition() {
+        return readBlockPosition(1);
     }
 
-
-    public int getY() {
-        if (blockPosObj == null) {
-            blockPosObj = readObject(1, NMSUtils.blockPosClass);
-        }
-        try {
-            return (int) Reflection.getMethod(blockPosObj.getClass().getSuperclass(), "getY", 0).invoke(blockPosObj);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-        return 0;
-    }
-
-    public int getZ() {
-        if (blockPosObj == null) {
-            blockPosObj = readObject(1, NMSUtils.blockPosClass);
-        }
-        try {
-            return (int) Reflection.getMethod(blockPosObj.getClass().getSuperclass(), "getZ", 0).invoke(blockPosObj);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-        return 0;
+    public void setBlockPosition(Vector3i blockPos) {
+        writeBlockPosition(1, blockPos);
     }
 
     public ItemStack getItemStack() {
-        return NMSUtils.toBukkitItemStack(readObject(0, NMSUtils.nmsItemStackClass));
+        return readItemStack(0);
+    }
+
+    public void setItemStack(ItemStack stack) {
+        writeItemStack(0, stack);
     }
 
     public int getFace() {
         return readInt(0);
     }
+
+    public void setFace(int face) {
+        writeInt(0, face);
+    }
+
+    public Vector3f getCursorPosition() {
+        return new Vector3f(readFloat(0), readFloat(1), readFloat(2));
+    }
+
+    public void setCursorPosition(Vector3f cursorPos) {
+        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_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;
@@ -27,85 +21,68 @@ 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.enums.EnumUtil;
 import io.github.retrooper.packetevents.utils.nms.NMSUtils;
-import io.github.retrooper.packetevents.utils.reflection.Reflection;
+import io.github.retrooper.packetevents.utils.player.Direction;
+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 blockPosObj;
+    private Object movingObjPos;
 
     public WrappedPacketInBlockPlace_1_9(final NMSPacket packet) {
         super(packet);
     }
 
-    @Override
-    protected void load() {
-        movingObjectPositionBlockClass = NMSUtils.getNMSClassWithoutException("MovingObjectPositionBlock");
-    }
-
-    public int getX() {
-        if (blockPosObj == null) {
-            if (movingObjectPositionBlockClass == null) {
-                blockPosObj = readObject(0, NMSUtils.blockPosClass);
-            } else {
-                Object movingObjectPos = readObject(0, movingObjectPositionBlockClass);
-                WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjectPos));
-                blockPosObj = movingObjectPosWrapper.readObject(0, NMSUtils.blockPosClass);
-            }
-        }
-        try {
-            return (int) Reflection.getMethod(blockPosObj.getClass().getSuperclass(), "getX", 0).invoke(blockPosObj);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-        return 0;
-    }
-
-    public int getY() {
-        if (blockPosObj == null) {
-            if (movingObjectPositionBlockClass == null) {
-                blockPosObj = readObject(0, NMSUtils.blockPosClass);
-            } else {
-                Object movingObjectPos = readObject(0, movingObjectPositionBlockClass);
-                WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjectPos));
-                blockPosObj = movingObjectPosWrapper.readObject(0, NMSUtils.blockPosClass);
-            }
-        }
-        try {
-            return (int) Reflection.getMethod(blockPosObj.getClass().getSuperclass(), "getY", 0).invoke(blockPosObj);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-        return 0;
-    }
-
-    public int getZ() {
-        if (blockPosObj == null) {
-            if (movingObjectPositionBlockClass == null) {
-                blockPosObj = readObject(0, NMSUtils.blockPosClass);
-            } else {
-                Object movingObjectPos = readObject(0, movingObjectPositionBlockClass);
-                WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjectPos));
-                blockPosObj = movingObjectPosWrapper.readObject(0, NMSUtils.blockPosClass);
-            }
-        }
-        try {
-            return (int) Reflection.getMethod(blockPosObj.getClass().getSuperclass(), "getZ", 0).invoke(blockPosObj);
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-        return 0;
-    }
-
-    public Object getEnumDirectionObject() {
-        if (movingObjectPositionBlockClass == null) {
-            return readObject(0, NMSUtils.enumDirectionClass);
+    public Vector3i getBlockPosition() {
+        if (NMSUtils.movingObjectPositionBlockClass == null) {
+            return readBlockPosition(0);
         } else {
-            Object movingObjectPos = readObject(0, movingObjectPositionBlockClass);
-            WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjectPos));
-            return movingObjectPosWrapper.readObject(0, NMSUtils.enumDirectionClass);
+            if (movingObjPos == null) {
+                movingObjPos = readObject(0, NMSUtils.movingObjectPositionBlockClass);
+            }
+            WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjPos));
+            return movingObjectPosWrapper.readBlockPosition(0);
+        }
+    }
+
+    public void setBlockPosition(Vector3i blockPos) {
+        if (NMSUtils.movingObjectPositionBlockClass == null) {
+            writeBlockPosition(0, blockPos);
+        } else {
+            if (movingObjPos == null) {
+                movingObjPos = readObject(0, NMSUtils.movingObjectPositionBlockClass);
+            }
+            WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjPos));
+            movingObjectPosWrapper.writeBlockPosition(0, blockPos);
+        }
+    }
+
+    public Direction getDirection() {
+        Enum<?> enumConst;
+        if (NMSUtils.movingObjectPositionBlockClass == null) {
+            enumConst = readEnumConstant(0, NMSUtils.enumDirectionClass);
+        } else {
+            if (movingObjPos == null) {
+                movingObjPos = readObject(0, NMSUtils.movingObjectPositionBlockClass);
+            }
+            WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjPos));
+            enumConst = movingObjectPosWrapper.readEnumConstant(0, NMSUtils.enumDirectionClass);
+        }
+        return Direction.values()[enumConst.ordinal()];
+    }
+
+    public void setDirection(Direction direction) {
+        Enum<?> enumConst = EnumUtil.valueByIndex(NMSUtils.enumDirectionClass, direction.ordinal());
+        if (NMSUtils.movingObjectPositionBlockClass == null) {
+            writeEnumConstant(0, enumConst);
+        } else {
+            if (movingObjPos == null) {
+                movingObjPos = readObject(0, NMSUtils.movingObjectPositionBlockClass);
+            }
+            WrappedPacket movingObjectPosWrapper = new WrappedPacket(new NMSPacket(movingObjPos));
+            movingObjectPosWrapper.writeEnumConstant(0, enumConst);
         }
     }
 }