1.8-pre-4!

* WrapperUnsupportedUsageException created, called whenever you use a wrapper that isn't supported on the local server version.

.github/FUNDING.yml

@@ -0,0 +1,5 @@
+# These are supported funding model platforms
+
+github: # Replace with up to 4 GitHub Sponsors-enabled usernames e.g., [user1, user2]
+patreon: retrooper
+custom: ['https://paypal.me/retrooperdev']

.github/ISSUE_TEMPLATE/bug_report.md

@@ -0,0 +1,41 @@
+---
+name: Bug report
+about: Report a bug to help us fix
+title: "[BUG REPORT]"
+labels: bug
+assignees: ''
+
+---
+
+**Describe the bug**
+A clear and concise description of what the bug is.
+
+**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.
+3. ....
+4. See error
+
+**Expected behavior**
+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/ISSUE_TEMPLATE/feature_request.md

@@ -0,0 +1,21 @@
+---
+name: Feature request
+about: Suggest an idea for this project
+title: FEATURE REQUEST
+labels: enhancement
+assignees: ''
+
+---
+
+**Is your feature request related to a problem? Please describe.**
+A clear and concise description of what the problem is. Ex. I'm always frustrated when [...]
+
+**Describe the solution you'd like**
+A clear and concise description of what you want to happen.
+
+**Describe alternatives you've considered to solve your solution without
+us adding this as a feature?**
+A clear and concise description of any alternative solutions or features you've considered.
+
+**Additional context**
+Add any other context or screenshots about the feature request here.

.github/workflows/codeql-analysis.yml

@@ -0,0 +1,67 @@
+# For most projects, this workflow file will not need changing; you simply need
+# to commit it to your repository.
+#
+# You may wish to alter this file to override the set of languages analyzed,
+# or to provide custom queries or build logic.
+#
+# ******** NOTE ********
+# We have attempted to detect the languages in your repository. Please check
+# the `language` matrix defined below to confirm you have the correct set of
+# supported CodeQL languages.
+#
+name: "CodeQL"
+
+on:
+  push:
+    branches: [ master, dev ]
+  pull_request:
+    # The branches below must be a subset of the branches above
+    branches: [ master, dev ]
+  schedule:
+    - cron: '39 0 * * 0'
+
+jobs:
+  analyze:
+    name: Analyze
+    runs-on: ubuntu-latest
+
+    strategy:
+      fail-fast: false
+      matrix:
+        language: [ 'java' ]
+        # CodeQL supports [ 'cpp', 'csharp', 'go', 'java', 'javascript', 'python' ]
+        # Learn more:
+        # https://docs.github.com/en/free-pro-team@latest/github/finding-security-vulnerabilities-and-errors-in-your-code/configuring-code-scanning#changing-the-languages-that-are-analyzed
+
+    steps:
+    - name: Checkout repository
+      uses: actions/checkout@v2
+
+    # Initializes the CodeQL tools for scanning.
+    - name: Initialize CodeQL
+      uses: github/codeql-action/init@v1
+      with:
+        languages: ${{ matrix.language }}
+        # If you wish to specify custom queries, you can do so here or in a config file.
+        # By default, queries listed here will override any specified in a config file.
+        # Prefix the list here with "+" to use these queries and those in the config file.
+        # queries: ./path/to/local/query, your-org/your-repo/queries@main
+
+    # Autobuild attempts to build any compiled languages  (C/C++, C#, or Java).
+    # If this step fails, then you should remove it and run the build manually (see below)
+    - name: Autobuild
+      uses: github/codeql-action/autobuild@v1
+
+    # ℹ️ Command-line programs to run using the OS shell.
+    # 📚 https://git.io/JvXDl
+
+    # ✏️ If the Autobuild fails above, remove it and uncomment the following three lines
+    #    and modify them (or add more) to build your code if your project
+    #    uses a compiled language
+
+    #- run: |
+    #   make bootstrap
+    #   make release
+
+    - name: Perform CodeQL Analysis
+      uses: github/codeql-action/analyze@v1

.gitignore

@@ -0,0 +1,113 @@
+#
+# JetBrains
+#
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+
+#
+# Java
+#
+
+# Compiled class file
+*.class
+
+# Log file
+*.log
+
+# BlueJ files
+*.ctxt
+
+# Mobile Tools for Java (J2ME)
+.mtj.tmp/
+
+# Package Files #
+*.jar
+*.war
+*.nar
+*.ear
+*.zip
+*.tar.gz
+*.rar
+
+# virtual machine crash logs, see http://www.java.com/en/download/help/error_hotspot.xml
+hs_err_pid*
+
+#
+# Maven
+#
+target/
+pom.xml.tag
+pom.xml.releaseBackup
+pom.xml.versionsBackup
+pom.xml.next
+release.properties
+dependency-reduced-pom.xml
+buildNumber.properties
+.mvn/timing.properties
+# https://github.com/takari/maven-wrapper#usage-without-binary-jar
+.mvn/wrapper/maven-wrapper.jar

LICENSE

@@ -1,339 +1,21 @@
-                    GNU GENERAL PUBLIC LICENSE
-                       Version 2, June 1991
+MIT License
 
- Copyright (C) 1989, 1991 Free Software Foundation, Inc.,
- 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
+Copyright (c) 2020 retrooper
 
-                            Preamble
+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 licenses for most software are designed to take away your
-freedom to share and change it.  By contrast, the GNU General Public
-License is intended to guarantee your freedom to share and change free
-software--to make sure the software is free for all its users.  This
-General Public License applies to most of the Free Software
-Foundation's software and to any other program whose authors commit to
-using it.  (Some other Free Software Foundation software is covered by
-the GNU Lesser General Public License instead.)  You can apply it to
-your programs, too.
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
 
-  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
-this service 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 make restrictions that forbid
-anyone to deny you these rights or to ask you to surrender the rights.
-These restrictions translate to certain responsibilities for you if you
-distribute copies of the software, or if you modify it.
-
-  For example, if you distribute copies of such a program, whether
-gratis or for a fee, you must give the recipients all the rights that
-you have.  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.
-
-  We protect your rights with two steps: (1) copyright the software, and
-(2) offer you this license which gives you legal permission to copy,
-distribute and/or modify the software.
-
-  Also, for each author's protection and ours, we want to make certain
-that everyone understands that there is no warranty for this free
-software.  If the software is modified by someone else and passed on, we
-want its recipients to know that what they have is not the original, so
-that any problems introduced by others will not reflect on the original
-authors' reputations.
-
-  Finally, any free program is threatened constantly by software
-patents.  We wish to avoid the danger that redistributors of a free
-program will individually obtain patent licenses, in effect making the
-program proprietary.  To prevent this, we have made it clear that any
-patent must be licensed for everyone's free use or not licensed at all.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                    GNU GENERAL PUBLIC LICENSE
-   TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION AND MODIFICATION
-
-  0. This License applies to any program or other work which contains
-a notice placed by the copyright holder saying it may be distributed
-under the terms of this General Public License.  The "Program", below,
-refers to any such program or work, and a "work based on the Program"
-means either the Program or any derivative work under copyright law:
-that is to say, a work containing the Program or a portion of it,
-either verbatim or with modifications and/or translated into another
-language.  (Hereinafter, translation is included without limitation in
-the term "modification".)  Each licensee is addressed as "you".
-
-Activities other than copying, distribution and modification are not
-covered by this License; they are outside its scope.  The act of
-running the Program is not restricted, and the output from the Program
-is covered only if its contents constitute a work based on the
-Program (independent of having been made by running the Program).
-Whether that is true depends on what the Program does.
-
-  1. You may copy and distribute 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 and disclaimer of warranty; keep intact all the
-notices that refer to this License and to the absence of any warranty;
-and give any other recipients of the Program a copy of this License
-along with the Program.
-
-You may charge a fee for the physical act of transferring a copy, and
-you may at your option offer warranty protection in exchange for a fee.
-
-  2. You may modify your copy or copies of the Program or any portion
-of it, thus forming a work based on the Program, and copy and
-distribute such modifications or work under the terms of Section 1
-above, provided that you also meet all of these conditions:
-
-    a) You must cause the modified files to carry prominent notices
-    stating that you changed the files and the date of any change.
-
-    b) You must cause any work that you distribute or publish, that in
-    whole or in part contains or is derived from the Program or any
-    part thereof, to be licensed as a whole at no charge to all third
-    parties under the terms of this License.
-
-    c) If the modified program normally reads commands interactively
-    when run, you must cause it, when started running for such
-    interactive use in the most ordinary way, to print or display an
-    announcement including an appropriate copyright notice and a
-    notice that there is no warranty (or else, saying that you provide
-    a warranty) and that users may redistribute the program under
-    these conditions, and telling the user how to view a copy of this
-    License.  (Exception: if the Program itself is interactive but
-    does not normally print such an announcement, your work based on
-    the Program is not required to print an announcement.)
-
-These requirements apply to the modified work as a whole.  If
-identifiable sections of that work are not derived from the Program,
-and can be reasonably considered independent and separate works in
-themselves, then this License, and its terms, do not apply to those
-sections when you distribute them as separate works.  But when you
-distribute the same sections as part of a whole which is a work based
-on the Program, the distribution of the whole must be on the terms of
-this License, whose permissions for other licensees extend to the
-entire whole, and thus to each and every part regardless of who wrote it.
-
-Thus, it is not the intent of this section to claim rights or contest
-your rights to work written entirely by you; rather, the intent is to
-exercise the right to control the distribution of derivative or
-collective works based on the Program.
-
-In addition, mere aggregation of another work not based on the Program
-with the Program (or with a work based on the Program) on a volume of
-a storage or distribution medium does not bring the other work under
-the scope of this License.
-
-  3. You may copy and distribute the Program (or a work based on it,
-under Section 2) in object code or executable form under the terms of
-Sections 1 and 2 above provided that you also do one of the following:
-
-    a) Accompany it with the complete corresponding machine-readable
-    source code, which must be distributed under the terms of Sections
-    1 and 2 above on a medium customarily used for software interchange; or,
-
-    b) Accompany it with a written offer, valid for at least three
-    years, to give any third party, for a charge no more than your
-    cost of physically performing source distribution, a complete
-    machine-readable copy of the corresponding source code, to be
-    distributed under the terms of Sections 1 and 2 above on a medium
-    customarily used for software interchange; or,
-
-    c) Accompany it with the information you received as to the offer
-    to distribute corresponding source code.  (This alternative is
-    allowed only for noncommercial distribution and only if you
-    received the program in object code or executable form with such
-    an offer, in accord with Subsection b above.)
-
-The source code for a work means the preferred form of the work for
-making modifications to it.  For an executable work, complete source
-code means all the source code for all modules it contains, plus any
-associated interface definition files, plus the scripts used to
-control compilation and installation of the executable.  However, as a
-special exception, the source code distributed need not include
-anything that is normally distributed (in either source or binary
-form) with the major components (compiler, kernel, and so on) of the
-operating system on which the executable runs, unless that component
-itself accompanies the executable.
-
-If distribution of executable or object code is made by offering
-access to copy from a designated place, then offering equivalent
-access to copy the source code from the same place counts as
-distribution of the source code, even though third parties are not
-compelled to copy the source along with the object code.
-
-  4. You may not copy, modify, sublicense, or distribute the Program
-except as expressly provided under this License.  Any attempt
-otherwise to copy, modify, sublicense or distribute the Program is
-void, and will automatically terminate your rights under this License.
-However, parties who have received copies, or rights, from you under
-this License will not have their licenses terminated so long as such
-parties remain in full compliance.
-
-  5. You are not required to accept this License, since you have not
-signed it.  However, nothing else grants you permission to modify or
-distribute the Program or its derivative works.  These actions are
-prohibited by law if you do not accept this License.  Therefore, by
-modifying or distributing the Program (or any work based on the
-Program), you indicate your acceptance of this License to do so, and
-all its terms and conditions for copying, distributing or modifying
-the Program or works based on it.
-
-  6. Each time you redistribute the Program (or any work based on the
-Program), the recipient automatically receives a license from the
-original licensor to copy, distribute or modify the Program subject to
-these terms and conditions.  You may not impose any further
-restrictions on the recipients' exercise of the rights granted herein.
-You are not responsible for enforcing compliance by third parties to
-this License.
-
-  7. If, as a consequence of a court judgment or allegation of patent
-infringement or for any other reason (not limited to patent issues),
-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
-distribute so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you
-may not distribute the Program at all.  For example, if a patent
-license would not permit royalty-free redistribution of the Program by
-all those who receive copies directly or indirectly through you, then
-the only way you could satisfy both it and this License would be to
-refrain entirely from distribution of the Program.
-
-If any portion of this section is held invalid or unenforceable under
-any particular circumstance, the balance of the section is intended to
-apply and the section as a whole is intended to apply in other
-circumstances.
-
-It is not the purpose of this section to induce you to infringe any
-patents or other property right claims or to contest validity of any
-such claims; this section has the sole purpose of protecting the
-integrity of the free software distribution system, which is
-implemented by public license practices.  Many people have made
-generous contributions to the wide range of software distributed
-through that system in reliance on consistent application of that
-system; it is up to the author/donor to decide if he or she is willing
-to distribute software through any other system and a licensee cannot
-impose that choice.
-
-This section is intended to make thoroughly clear what is believed to
-be a consequence of the rest of this License.
-
-  8. If the distribution and/or use of the Program is restricted in
-certain countries either by patents or by copyrighted interfaces, the
-original copyright holder who places the Program under this License
-may add an explicit geographical distribution limitation excluding
-those countries, so that distribution is permitted only in or among
-countries not thus excluded.  In such case, this License incorporates
-the limitation as if written in the body of this License.
-
-  9. The Free Software Foundation may publish revised and/or new versions
-of the 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 a version number of this License which applies to it and "any
-later version", you have the option of following the terms and conditions
-either of that version or of any later version published by the Free
-Software Foundation.  If the Program does not specify a version number of
-this License, you may choose any version ever published by the Free Software
-Foundation.
-
-  10. If you wish to incorporate parts of the Program into other free
-programs whose distribution conditions are different, write to the author
-to ask for permission.  For software which is copyrighted by the Free
-Software Foundation, write to the Free Software Foundation; we sometimes
-make exceptions for this.  Our decision will be guided by the two goals
-of preserving the free status of all derivatives of our free software and
-of promoting the sharing and reuse of software generally.
-
-                            NO WARRANTY
-
-  11. BECAUSE THE PROGRAM IS LICENSED FREE OF CHARGE, 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.
-
-  12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR
-REDISTRIBUTE 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.
-
-                     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
-convey 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 2 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, write to the Free Software Foundation, Inc.,
-    51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
-
-Also add information on how to contact you by electronic and paper mail.
-
-If the program is interactive, make it output a short notice like this
-when it starts in an interactive mode:
-
-    Gnomovision version 69, Copyright (C) year name of author
-    Gnomovision 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, the commands you use may
-be called something other than `show w' and `show c'; they could even be
-mouse-clicks or menu items--whatever suits your program.
-
-You should also get your employer (if you work as a programmer) or your
-school, if any, to sign a "copyright disclaimer" for the program, if
-necessary.  Here is a sample; alter the names:
-
-  Yoyodyne, Inc., hereby disclaims all copyright interest in the program
-  `Gnomovision' (which makes passes at compilers) written by James Hacker.
-
-  <signature of Ty Coon>, 1 April 1989
-  Ty Coon, President of Vice
-
-This 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.
+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.

README.md

@@ -1,26 +1,82 @@
-# packetevents by retrooper
+# packetevents
 
-A lightweight spigot packetlistener & packetsender coded by retrooper.
+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.
 
-## Credit
+### Resources
+* [Website](https://packetevents.github.io)
+* [SpigotMC](https://www.spigotmc.org/resources/packetevents-api.80279/)
+* [JavaDoc](https://retrooper.github.io/packetevents)
 
-PacketEvents forked [Atlas](https://github.com/funkemunky/Atlas)' [Packet](https://github.com/funkemunky/Atlas/blob/master/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/tinyprotocol/api/Packet.java) class.
+### 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)
 
-[Find our forked version](https://github.com/retrooper/packetevents/blob/master/src/main/java/io/github/retrooper/packetevents/packet/PacketType.java)
-## About
+### 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)
 
-This packetlistener is **only** supported on spigot servers and has been tested to work on these spigot forks: PaperSpigot, Tuinity
+### 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)
 
-* No dependencies
-
-* Licensed under the GPL2 license.
-
-[![](https://img.shields.io/badge/License-GPLv2-blue.svg)](https://www.gnu.org/licenses/gpl-2.0)
-
-Join my discord server(to talk to me): https://discord.gg/ZWTkg4v
+### 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://jitpack.io/v/retrooper/packetevents.svg)](https://jitpack.io/#retrooper/packetevents)
 
-To learn how to setup this API please click on the link below
-[Setup Guide](https://github.com/retrooper/packetevents/wiki/PacketEvents-Setup-Guide)
-(or just paste this into your browser: https://github.com/retrooper/packetevents/wiki/PacketEvents-Setup-Guide)
+#### 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.
+
+#### 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.
+
+### 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. 

pom.xml

@@ -1,39 +1,55 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+<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.3.7.1</version>
-    <packaging>jar</packaging>
-    <name>packetevents</name>
-    <properties>
-        <java.version>1.8</java.version>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-
+    <version>1.8-pre-4</version>
     <build>
-        <defaultGoal>clean package</defaultGoal>
         <plugins>
             <plugin>
-                <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.7.0</version>
-                <configuration>
-                    <source>1.8</source>
-                    <target>1.8</target>
-                </configuration>
+                <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>3.2.4</version>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                        <configuration>
+                            <minimizeJar>true</minimizeJar>
+                            <createDependencyReducedPom>false</createDependencyReducedPom>
+                            <createTestSourcesJar>false</createTestSourcesJar>
+                            <shadedArtifactAttached>false</shadedArtifactAttached>
+                        </configuration>
+                    </execution>
+                </executions>
             </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
-                <version>3.7.0</version>
                 <configuration>
-                    <source>${java.version}</source>
-                    <target>${java.version}</target>
+                    <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>
@@ -42,6 +58,13 @@
             </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>
@@ -60,33 +83,106 @@
             <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.7.10</artifactId>
-            <version>1.7.10</version>
+            <artifactId>1.16.2</artifactId>
+            <version>1.16.2</version>
             <scope>provided</scope>
         </dependency>
+
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.13.2</artifactId>
+            <version>1.13.2</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.13</artifactId>
+            <version>1.13</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.12.2</artifactId>
+            <version>1.12.2</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.9.4</artifactId>
+            <version>1.9.4</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.9</artifactId>
+            <version>1.9</version>
+            <scope>provided</scope>
+        </dependency>
+
         <dependency>
             <groupId>org.github.spigot</groupId>
             <artifactId>1.8.8</artifactId>
             <version>1.8.8</version>
             <scope>provided</scope>
         </dependency>
+
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.7.10</artifactId>
+            <version>1.7.10</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <dependency>
+            <groupId>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.0.1</version>
+            <version>3.2.0</version>
             <scope>provided</scope>
         </dependency>
 
         <dependency>
             <groupId>com.github.ProtocolSupport</groupId>
             <artifactId>ProtocolSupport</artifactId>
-            <version>4fdd683</version>
+            <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>

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

@@ -1,241 +1,344 @@
+/*
+ * 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;
 
-import io.github.retrooper.packetevents.annotations.NotNull;
-import io.github.retrooper.packetevents.annotations.Nullable;
-import io.github.retrooper.packetevents.annotations.PacketHandler;
-import io.github.retrooper.packetevents.enums.ClientVersion;
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.event.PacketListener;
-import io.github.retrooper.packetevents.event.impl.BukkitMoveEvent;
-import io.github.retrooper.packetevents.event.impl.PacketReceiveEvent;
-import io.github.retrooper.packetevents.event.impl.PlayerInjectEvent;
-import io.github.retrooper.packetevents.event.impl.ServerTickEvent;
+import io.github.retrooper.packetevents.event.impl.PostPlayerInjectEvent;
 import io.github.retrooper.packetevents.event.manager.EventManager;
-import io.github.retrooper.packetevents.handler.NettyPacketHandler;
-import io.github.retrooper.packetevents.packetwrappers.Sendable;
-import io.github.retrooper.packetevents.utils.NMSUtils;
+import io.github.retrooper.packetevents.event.manager.PEEventManager;
+import io.github.retrooper.packetevents.exceptions.PacketEventsLoadFailureException;
+import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
+import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+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.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.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.PlayerMoveEvent;
+import org.bukkit.event.player.PlayerLoginEvent;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.plugin.Plugin;
-import org.bukkit.scheduler.BukkitTask;
+import org.bukkit.plugin.ServicePriority;
+import org.jetbrains.annotations.NotNull;
 
-import java.lang.reflect.InvocationTargetException;
-import java.util.HashMap;
+import java.net.InetSocketAddress;
 import java.util.UUID;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.atomic.AtomicInteger;
 
-public final class PacketEvents implements PacketListener, Listener {
-
-    private static final ServerVersion version = ServerVersion.getVersion();
-    private static final EventManager eventManager = new EventManager();
-    private static final HashMap<UUID, ClientVersion> clientVersionsMap = new HashMap<UUID, ClientVersion>();
-    private static boolean hasRegistered;
+public final class PacketEvents implements Listener, EventManager {
+    //TODO finish unfinished wrappers
     private static PacketEvents instance;
-    private static int currentTick;
-    private static BukkitTask serverTickTask;
+    private final PEVersion version = new PEVersion(1, 7, 9, 4);
+    private final EventManager eventManager = new PEEventManager();
+    private final PlayerUtils playerUtils = new PlayerUtils();
+    private final ServerUtils serverUtils = new ServerUtils();
+    private final UpdateChecker updateChecker = new UpdateChecker();
+    private static Plugin plugin;
+    public static String handlerName;
 
-    public static EventManager getEventManager() {
-        return eventManager;
+    //Executor used for player injecting/ejecting.
+    public ExecutorService injectAndEjectExecutorService;//Initiated in init method
+
+    public PacketProcessorInternal packetProcessorInternal;
+    private boolean loading, loaded, initialized, initializing, terminating;
+    private PacketEventsSettings settings = new PacketEventsSettings();
+    private final ByteBufUtil byteBufUtil = NMSUtils.legacyNettyImportMode ? new ByteBufUtil_7() : new ByteBufUtil_8();
+
+    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);
+            return instance;
+        }
+        return instance = Bukkit.getServicesManager().load(PacketEvents.class);
+    }
+
+    public static PacketEvents get() {
+        return instance;
+    }
+
+    @Deprecated
+    public static PacketEvents getAPI() {
+        return get();
     }
 
 
-    /**
-     * Starts the server tick task and initiates the TinyProtocolHandler
-     *
-     * @param plugin
-     */
-    public static void start(final Plugin plugin) {
-        if (!hasRegistered) {
-            //Register Bukkit and PacketListener
-            getEventManager().registerListener(getInstance());
+    public void load() {
+        if (!loaded && !loading) {
+            loading = true;
+            ServerVersion version = ServerVersion.getVersion();
+            WrappedPacket.version = version;
+            NMSUtils.version = version;
+            EntityFinderUtils.version = version;
 
-            Bukkit.getPluginManager().registerEvents(getInstance(), plugin);
+            try {
+                NMSUtils.load();
+
+                //Load all classes
+                PacketTypeClasses.load();
+
+                EntityFinderUtils.load();
+            } catch (Exception ex) {
+                loading = false;
+                throw new PacketEventsLoadFailureException(ex);
+            }
+            loaded = true;
+            loading = false;
+        }
+    }
+
+    public void loadSettings(PacketEventsSettings settings) {
+        this.settings = settings;
+    }
+
+    public void init(final Plugin plugin) {
+        init(plugin, settings);
+    }
+
+    public void init(final Plugin pl, PacketEventsSettings packetEventsSettings) {
+        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();
 
-            //Start the server tick task
-            final Runnable tickRunnable = new Runnable() {
                 @Override
-                public void run() {
-                    getEventManager().callEvent(new ServerTickEvent(currentTick++, PacketEvents.highlyPreciseMillis()));
+                public Thread newThread(@NotNull Runnable r) {
+                    return new Thread(r, "PacketEvents-inject-eject #" + id.getAndIncrement());
                 }
-            };
-            serverTickTask = Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, tickRunnable, 0L, 1L);
-            hasRegistered = true;
+            });
+
+            //Register Bukkit listener
+            plugin = pl;
+            Bukkit.getPluginManager().registerEvents(this, plugin);
+            handlerName = "pe-" + plugin.getName();
+            packetProcessorInternal = new PacketProcessorInternal();
+            for (final Player p : Bukkit.getOnlinePlayers()) {
+                try {
+                    getPlayerUtils().injectPlayer(p);
+                } catch (Exception ex) {
+                    packetProcessorInternal.rescheduleInjectPlayer(p, 20L);
+                }
+            }
+
+            if (settings.shouldCheckForUpdates()) {
+                Thread thread = new Thread(new Runnable() {
+                    @Override
+                    public void run() {
+                        UpdateChecker.UpdateCheckerStatus status = updateChecker.checkForUpdate();
+                    }
+                }, "PacketEvents-update-check-thread");
+                thread.start();
+            }
+            initialized = true;
+            initializing = false;
+        }
+    }
+
+    public void terminate() {
+        if (initialized && !terminating) {
+            for (Player player : Bukkit.getOnlinePlayers()) {
+                packetProcessorInternal.ejectPlayer(player);
+            }
+            //This might be a little complicated to explain. This is just to support server killing. If we eject async users run into issues on a server kill (never recommended btw)
+            //so we just don't eject and therefore sacrifice reload support.
+            packetProcessorInternal.cleanup();
+
+            getEventManager().unregisterAllListeners();
+            injectAndEjectExecutorService.shutdownNow();
+            initialized = false;
+            terminating = false;
         }
     }
 
     /**
-     * Stop all tasks and unregisters all PacketEvents' listeners
-     */
-    public static void stop() {
-        if (serverTickTask != null) {
-            serverTickTask.cancel();
-        }
-        getEventManager().unregisterAllListeners();
-    }
-
-    /**
-     * Get the server's version
+     * Use {@link #terminate()}. This is deprecated
      *
-     * @return version
+     * @deprecated "Stop" might be misleading and "terminate" sounds better I guess...
      */
-    public static ServerVersion getServerVersion() {
+    @Deprecated
+    public void stop() {
+        terminate();
+    }
+
+    public boolean hasLoaded() {
+        return loaded;
+    }
+
+    public boolean isLoading() {
+        return loading;
+    }
+
+    public boolean isInitializing() {
+        return initializing;
+    }
+
+    @Deprecated
+    public boolean isStopping() {
+        return terminating;
+    }
+
+    public boolean isTerminating() {
+        return terminating;
+    }
+
+    public boolean isInitialized() {
+        return initialized;
+    }
+
+    public Plugin getPlugin() {
+        return plugin;
+    }
+
+    /**
+     * Get the PacketEvents settings.
+     *
+     * @return Configure some settings for the API
+     */
+    public PacketEventsSettings getSettings() {
+        return settings;
+    }
+
+    public PEVersion getVersion() {
         return version;
     }
 
-    /**
-     * Returns the server tick task, you may cancel it if you wish.
-     * To cancel it do PacketEvents.getServerTickTask().cancel();
-     * <p>
-     * This bukkit task runs asynchronously every tick and is started in the start(plugin) function
-     *
-     * @return serverTickTask
-     */
-    public static BukkitTask getServerTickTask() {
-        return serverTickTask;
+    public EventManager getEventManager() {
+        return eventManager;
     }
 
-    /**
-     * Get an instance of the PacketEvents API class
-     *
-     * @return instance
-     */
-    public static PacketEvents getInstance() {
-        return instance == null ? instance = new PacketEvents() : instance;
+    public PlayerUtils getPlayerUtils() {
+        return playerUtils;
     }
 
+    public ServerUtils getServerUtils() {
+        return serverUtils;
+    }
 
-    /**
-     * Get the server's recent TPS values
-     * TPS stands for ticks per second.
-     * See to learn more about TPS<a href="https://apexminecrafthosting.com/what-is-minecraft-tps/">"https://apexminecrafthosting.com/what-is-minecraft-tps/"</a>
-     *
-     * @return recentTPS[]
-     */
-    public static double[] getRecentServerTPS() {
-        double[] tpsArray = new double[0];
-        try {
-            tpsArray = NMSUtils.recentTPS();
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
+    public ByteBufUtil getByteBufUtil() {
+        return byteBufUtil;
+    }
+
+    public UpdateChecker getUpdateChecker() {
+        return updateChecker;
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onLogin(final PlayerLoginEvent e) {
+        if (getSettings().shouldInjectEarly()) {
+            try {
+                packetProcessorInternal.injectPlayer(e.getPlayer());
+            } catch (Exception ex) {
+                packetProcessorInternal.rescheduleInjectPlayer(e.getPlayer(), 20L); //Reschedule to inject one second later
+            }
         }
-        return tpsArray;
     }
 
-    /**
-     * Get the server's current TPS
-     * TPS stands for ticks per second.
-     * See to learn more about TPS <a href="https://apexminecrafthosting.com/what-is-minecraft-tps/">"https://apexminecrafthosting.com/what-is-minecraft-tps/"</a>
-     *
-     * @return {@link PacketEvents#getRecentServerTPS()[0]}
-     */
-    public static double getCurrentServerTPS() {
-        return getRecentServerTPS()[0];
-    }
-
-    /**
-     * Get the player's ping.
-     * Learn more about ping <a href="https://en.wikipedia.org/wiki/Ping_(networking_utility)">https://en.wikipedia.org/wiki/Ping_(networking_utility)</a>
-     *
-     * @param player
-     * @return ping
-     */
-    public static int getPing(@NotNull final Player player) {
-        return NMSUtils.getPlayerPing(player);
-    }
-
-    /**
-     * When to use this(nano / 1 million) vs {@link System#currentTimeMillis()}
-     * This is preciser than System.currentTimeMillis(), System.currentTimeMillis() can be up to 50ms off on some operating systems, but using this isn't cheap.
-     * Java documentation recommend using nano time if you are measuring elapsed time.
-     * In this function nanoTime is divided by 1 million giving us milliseconds.
-     * It is also important to mention that using this method doesn't guarantee thread safety.
-     *
-     * @return nanoTime / 1 million
-     */
-    public static long highlyPreciseMillis() {
-        return System.nanoTime() / 1000000;
-    }
-
-
-    /**
-     * Get the player's version.
-     * Do not call this method in the PlayerInjectEvent, it is safe to call it in the PostPlayerInjectEvent.
-     * The EntityPlayer object is null at that time, resulting in the version lookup to fail.
-     *
-     * @param player
-     * @return ClientVersion
-     */
-
-    @Nullable
-    public static ClientVersion getClientVersion(@NotNull final Player player) {
-        return getClientVersion(player.getUniqueId());
-    }
-
-    public static ClientVersion getClientVersion(@NotNull final UUID uuid) {
-        return clientVersionsMap.get(uuid);
-    }
-
-    /**
-     * Version independent player injection
-     *
-     * @param player
-     */
-    public static void injectPlayer(final Player player) {
-        NettyPacketHandler.injectPlayer(player);
-    }
-
-    /**
-     * Version independant player injection
-     *
-     * @param player
-     */
-    public static void uninjectPlayer(final Player player) {
-        NettyPacketHandler.uninjectPlayer(player);
-    }
-
-
-    /**
-     * Send a wrapped sendable packet to a player
-     *
-     * @param player
-     * @param sendable
-     */
-    public static void sendPacket(final Player player, final Sendable sendable) {
-        NMSUtils.sendSendableWrapper(player, sendable);
-    }
-
-    /**
-     * Do not check the client version in or before the PlayerInjectEvent, use the PostPlayerInjectEvent.
-     * It is not recommended to do much in the PlayerInjectEvent, as some fields in the Player object are be null.
-     * Use the PostPlayerInjectEvent which is only called after the PlayerJoinEvent if the player was injected.
-     *
-     * @param e
-     */
-    @PacketHandler
-    public void onInject(final PlayerInjectEvent e) {
-        clientVersionsMap.put(e.getPlayer().getUniqueId(), e.getClientVersion());
-    }
-
-    @PacketHandler
-    public void onReceive(final PacketReceiveEvent e) {
-    }
-
-    @EventHandler
+    @EventHandler(priority = EventPriority.HIGH)
     public void onJoin(final PlayerJoinEvent e) {
-        injectPlayer(e.getPlayer());
+        final InetSocketAddress address = e.getPlayer().getAddress();
+        boolean viaAvailable = ViaVersionLookupUtils.isAvailable();
+        PacketEvents.get().getPlayerUtils().loginTime.put(e.getPlayer().getUniqueId(), System.currentTimeMillis());
+        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);
+        }
+
+        if (!getSettings().shouldInjectEarly()) {
+            try {
+                packetProcessorInternal.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));
+                }
+            } catch (Exception ex) {
+                packetProcessorInternal.rescheduleInjectPlayer(e.getPlayer(), 20L);
+            }
+        } else {
+            if (!viaAvailable) {
+                PacketEvents.get().getEventManager().callEvent(new PostPlayerInjectEvent(e.getPlayer(), false));
+            }
+        }
     }
 
-    @EventHandler
+
+    @EventHandler(priority = EventPriority.HIGHEST)
     public void onQuit(final PlayerQuitEvent e) {
-        uninjectPlayer(e.getPlayer());
-    }
-
-    @EventHandler
-    public void onMove(final PlayerMoveEvent e) {
-        PacketEvents.getEventManager().callEvent(new BukkitMoveEvent(e));
+        UUID uuid = e.getPlayer().getUniqueId();
+        packetProcessorInternal.ejectPlayer(e.getPlayer());
+        instance.getPlayerUtils().loginTime.remove(uuid);
+        instance.getPlayerUtils().playerPingMap.remove(uuid);
+        instance.getPlayerUtils().playerSmoothedPingMap.remove(uuid);
     }
 }

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

@@ -0,0 +1,51 @@
+/*
+ * 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;
+
+import org.bukkit.plugin.java.JavaPlugin;
+
+public class PacketEventsPlugin extends JavaPlugin {
+    @Override
+    public void onLoad() {
+
+    }
+
+    @Override
+    public void onEnable() {
+        if (PacketEvents.get() == null) {
+            PacketEvents.create(this);
+            PacketEvents.get().getSettings().injectionRescheduling(false);
+            PacketEvents.get().load();
+            PacketEvents.get().init(this);
+        }
+    }
+
+    @Override
+    public void onDisable() {
+        if (PacketEvents.get() != null) {
+            PacketEvents.get().terminate();
+        }
+    }
+}

src/main/java/io/github/retrooper/packetevents/annotations/NotNull.java

@@ -1,16 +0,0 @@
-package io.github.retrooper.packetevents.annotations;
-
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-/**
- * Is for sure not null.
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-public @interface NotNull {
-
-
-}

src/main/java/io/github/retrooper/packetevents/annotations/Nullable.java

@@ -1,16 +0,0 @@
-package io.github.retrooper.packetevents.annotations;
-
-
-import java.lang.annotation.Documented;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-
-/**
- * Could be null.
- */
-@Documented
-@Retention(RetentionPolicy.RUNTIME)
-public @interface Nullable {
-
-
-}

src/main/java/io/github/retrooper/packetevents/annotations/PacketHandler.java

@@ -1,17 +0,0 @@
-package io.github.retrooper.packetevents.annotations;
-
-import java.lang.annotation.ElementType;
-import java.lang.annotation.Retention;
-import java.lang.annotation.RetentionPolicy;
-import java.lang.annotation.Target;
-
-@Target(ElementType.METHOD)
-@Retention(RetentionPolicy.RUNTIME)
-/**
- * Just like Bukkit's @EventHandler, but for packets.
- * Make sure your class implements the PacketListener interface, and is registered!
- */
-public @interface PacketHandler {
-
-
-}

src/main/java/io/github/retrooper/packetevents/enums/ClientVersion.java

@@ -1,104 +0,0 @@
-package io.github.retrooper.packetevents.enums;
-
-public enum ClientVersion {
-    LESS_THAN_V_1_7_10, v_1_7_10, v_1_8, v_1_9, v_1_9_1, v_1_9_2, v_1_9_3, v_1_10, v_1_11, v_1_11_1, v_1_12, v_1_12_1, v_1_12_2,
-    v_1_13, v_1_13_1, v_1_13_2, v_1_14, v_1_14_1, v_1_14_2, v_1_14_3, v_1_14_4, v_1_15, v_1_15_1, v_1_15_2, v_1_16, v_1_16_1, HIGHER_THAN_V_1_16_1, INVALID, ACCESS_FAILURE;
-
-    public static ClientVersion fromProtocolVersion(final int protocolVersion) {
-        int remainder = -1;
-        switch (protocolVersion) {
-            case -1:
-                return ACCESS_FAILURE;
-            case 1:
-            case 2:
-            case 3:
-            case 4:
-                return LESS_THAN_V_1_7_10;
-            case 47://ranging from 1.8->1.8.9
-                return v_1_8;
-            case 107:
-                return v_1_9;
-            case 108:
-                return v_1_9_1;
-            case 109:
-                return v_1_9_2;
-            case 110:
-                return v_1_9_3; //can be 1.9.3 or 1.9.4
-            case 210:
-                return v_1_10; //could be 1.10,1.10.1, 1.10.2
-            case 315:
-                return v_1_11;
-            case 316: //could be 11.1 or 11.2
-                return v_1_11_1;
-            case 335:
-                return v_1_12;
-            case 338:
-                return v_1_12_1;
-            case 340:
-                return v_1_12_2;
-            case 393:
-                return v_1_13;
-            case 401:
-                return v_1_13_1;
-            case 404:
-                return v_1_13_2;
-            case 477:
-                return v_1_14;
-            case 480:
-                return v_1_14_1;
-            case 485:
-                return v_1_14_2;
-            case 490:
-                return v_1_14_3;
-            case 498:
-                return v_1_14_4;
-            case 573:
-                return v_1_15;
-            case 575:
-                return v_1_15_1;
-            case 578:
-                return v_1_15_2;
-            case 735:
-                return v_1_16;
-            case 736:
-                return v_1_16_1;
-            default:
-                remainder = protocolVersion;
-        }
-        if (remainder > 578) {
-            return HIGHER_THAN_V_1_16_1;
-        }
-        return INVALID;
-    }
-
-    /**
-     * Returns if the client's version is more up to date than the argument passed version
-     *
-     * @param version
-     * @return
-     */
-    public boolean isHigherThan(final ClientVersion version) {
-        if (this == version) return false;
-        return !isLowerThan(version);
-    }
-
-    /**
-     * Returns if the client's version is more outdated than the argument passed version
-     *
-     * @param version
-     * @return
-     */
-    public boolean isLowerThan(final ClientVersion version) {
-        if (version == this) return false;
-        final int len = values().length;
-        for (byte i = 0; i < len; i++) {
-            final ClientVersion v = values()[i];
-            if (v == this) {
-                return true;
-            } else if (v == version) {
-                return false;
-            }
-        }
-        return false;
-    }
-}

src/main/java/io/github/retrooper/packetevents/enums/Direction.java

@@ -1,15 +0,0 @@
-package io.github.retrooper.packetevents.enums;
-
-public enum Direction {
-    DOWN, UP, NORTH, SOUTH, WEST, EAST, NORTH_EAST,
-    NORTH_WEST, SOUTH_EAST,
-    SOUTH_WEST, WEST_NORTH_WEST,
-    NORTH_NORTH_WEST, NORTH_NORTH_EAST,
-    EAST_NORTH_EAST, EAST_SOUTH_EAST,
-    SOUTH_SOUTH_EAST, SOUTH_SOUTH_WEST,
-    WEST_SOUTH_WEST, SELF, NULL;
-
-    public static Direction get(final int i) {
-        return values()[i];
-    }
-}

src/main/java/io/github/retrooper/packetevents/enums/ServerVersion.java

@@ -1,95 +0,0 @@
-package io.github.retrooper.packetevents.enums;
-
-import org.bukkit.Bukkit;
-
-/**
- * @author retrooper
- */
-public enum ServerVersion {
-    v_1_7_10, v_1_8, v_1_8_3, v_1_8_8, v_1_9, v_1_9_4, v_1_10, v_1_11, v_1_12, v_1_13, v_1_13_2, v_1_14, v_1_15, v_1_16_1,
-    ERROR, EMPTY;
-
-    private static final ServerVersion[] reversedValues;
-    private static final String nmsVersionSuffix = Bukkit.getServer().getClass().getPackage().getName().replace(".", ",").split(",")[3];
-    private static ServerVersion cachedVersion = ServerVersion.EMPTY;
-
-    static {
-        reversedValues = reverse(values());
-    }
-
-    public static ServerVersion getVersion() {
-        if (cachedVersion != ServerVersion.EMPTY) {
-            return cachedVersion;
-        }
-        for (final ServerVersion val : reversedValues) {
-            String valName = val.name().substring(2).replace("_", ".");
-            if (Bukkit.getBukkitVersion().contains(valName)) {
-                cachedVersion = val;
-                return val;
-            }
-        }
-        return ERROR;
-    }
-
-    private static ServerVersion[] reverse(final ServerVersion[] arr) {
-        ServerVersion[] array = arr.clone();
-        if (array == null) {
-            return null;
-        }
-        int i = 0;
-        int j = array.length - 1;
-        ServerVersion tmp;
-        while (j > i) {
-            tmp = array[j];
-            array[j] = array[i];
-            array[i] = tmp;
-            j--;
-            i++;
-        }
-        return array;
-    }
-
-    public static String getNmsSuffix() {
-        return nmsVersionSuffix;
-    }
-
-    public static String getNMSDirectory() {
-        return "net.minecraft.server." + nmsVersionSuffix;
-    }
-
-    public static String getOBCDirectory() {
-        return "org.bukkit.craftbukkit." + getNmsSuffix();
-    }
-
-    /**
-     * Returns if the current version is more up to date than the argument passed version
-     *
-     * @param version
-     * @return
-     */
-    public boolean isHigherThan(final ServerVersion version) {
-        if (this == version) return false;
-        return !isLowerThan(version);
-    }
-
-    /**
-     * Returns if the current version is more outdated than the argument passed version
-     *
-     * @param version
-     * @return
-     */
-    public boolean isLowerThan(final ServerVersion version) {
-        if (version == this) return false;
-        final int len = values().length;
-        for (byte i = 0; i < len; i++) {
-            final ServerVersion v = values()[i];
-            if (v == this) {
-                return true;
-            } else if (v == version) {
-                return false;
-            }
-        }
-        return false;
-    }
-
-}

src/main/java/io/github/retrooper/packetevents/enums/minecraft/EntityAnimationType.java

@@ -1,19 +0,0 @@
-package io.github.retrooper.packetevents.enums.minecraft;
-
-public enum EntityAnimationType {
-    SWING_MAIN_ARM, DAMAGE, LEAVE_BED, SWING_OFFHAND, CRITICAL_EFFECT, MAGIC_CRITICAL_EFFECT;
-
-    public static final EntityAnimationType get(final int i) {
-        return values()[i];
-    }
-
-    public final int getIndex() {
-        for (int i = 0; i < values().length; i++) {
-            final EntityAnimationType curType = values()[0];
-            if (curType == this) {
-                return i;
-            }
-        }
-        return -1;
-    }
-}

src/main/java/io/github/retrooper/packetevents/enums/minecraft/EntityUseAction.java

@@ -1,9 +0,0 @@
-package io.github.retrooper.packetevents.enums.minecraft;
-
-public enum EntityUseAction {
-    INTERACT, INTERACT_AT, ATTACK, INVALID;
-
-    public static EntityUseAction get(final int i) {
-        return values()[i];
-    }
-}

src/main/java/io/github/retrooper/packetevents/enums/minecraft/Hand.java

@@ -1,6 +0,0 @@
-package io.github.retrooper.packetevents.enums.minecraft;
-
-public enum Hand {
-    MAIN_HAND,
-    OFF_HAND
-}

src/main/java/io/github/retrooper/packetevents/enums/minecraft/PlayerAction.java

@@ -1,25 +0,0 @@
-package io.github.retrooper.packetevents.enums.minecraft;
-
-public enum PlayerAction {
-    START_SNEAKING,
-
-    STOP_SNEAKING,
-
-    STOP_SLEEPING,
-
-    START_SPRINTING,
-
-    STOP_SPRINTING,
-
-    START_RIDING_JUMP,
-
-    STOP_RIDING_JUMP,
-
-    OPEN_INVENTORY,
-
-    START_FALL_FLYING;
-
-    public static PlayerAction get(final int i) {
-        return values()[i];
-    }
-}

src/main/java/io/github/retrooper/packetevents/enums/minecraft/PlayerDigType.java

@@ -1,24 +0,0 @@
-package io.github.retrooper.packetevents.enums.minecraft;
-
-public enum PlayerDigType {
-
-    START_DESTROY_BLOCK,
-
-    ABORT_DESTROY_BLOCK,
-
-    STOP_DESTROY_BLOCK,
-
-    DROP_ALL_ITEMS,
-
-    DROP_ITEM,
-
-    RELEASE_USE_ITEM,
-
-    SWAP_HELD_ITEMS,
-
-    WRONG_PACKET;
-
-    public static PlayerDigType get(final int i) {
-        return values()[i];
-    }
-}

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

@@ -1,23 +1,63 @@
+/*
+ * 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;
 
 
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.enums.ServerVersion;
+import io.github.retrooper.packetevents.event.eventtypes.CallableEvent;
 
 /**
- * Incoming and sent packets are called asynchronously,
- * recommended to avoid non thread safe bukkit operations
+ * An event in both of PacketEvents' event systems.
+ *
+ * @author retrooper
+ * @since 1.2.6
  */
-public class PacketEvent {
-    protected static ServerVersion version = PacketEvents.getServerVersion();
-    protected long timestamp = PacketEvents.highlyPreciseMillis();
+public abstract class PacketEvent implements CallableEvent {
+    private long timestamp = System.currentTimeMillis();
 
     /**
-     * Timestamp of the packet
+     * Timestamp of when the PacketEvent was created.
+     * Basically timestamp of the packet.
      *
-     * @return
+     * @return Packet timestamp in milliseconds.
      */
     public long getTimestamp() {
         return timestamp;
     }
-}
+
+    /**
+     * Setter for the timestamp.
+     *
+     * @param timestamp Packet timestamp in milliseconds.
+     */
+    public void setTimestamp(final long timestamp) {
+        this.timestamp = timestamp;
+    }
+
+    public void callPacketEventExternal(final PacketListenerDynamic listener) {
+        listener.onPacketEventExternal(this);
+    }
+
+    public abstract boolean isInbuilt();
+}

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

@@ -1,4 +1,38 @@
+/*
+ * 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;
 
+/**
+ * The legacy Packet listener.
+ * Implement this interface in your listener if you are using the legacy event system.
+ *
+ * @author retrooper
+ * @see PacketListenerDynamic
+ * @since 1.2.6
+ * @deprecated There is a new and better listener for the new event system.
+ */
+@Deprecated
 public interface PacketListener {
 }

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

@@ -0,0 +1,197 @@
+/*
+ * 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;
+
+import io.github.retrooper.packetevents.event.impl.*;
+import io.github.retrooper.packetevents.event.priority.PacketEventPriority;
+import io.github.retrooper.packetevents.utils.immutableset.ImmutableSetCustom;
+
+/**
+ * Dynamic packet event listener.
+ * Implement whatever event method you need.
+ * Nothing will happen if you don't implement an event method.
+ *
+ * @author retrooper
+ * @since 1.7.7
+ */
+public abstract class PacketListenerDynamic {
+    private final PacketEventPriority priority;
+    public ImmutableSetCustom<Byte> serverSidedStatusAllowance;
+    public ImmutableSetCustom<Byte> serverSidedLoginAllowance;
+    public ImmutableSetCustom<Byte> serverSidedPlayAllowance;
+
+    public ImmutableSetCustom<Byte> clientSidedStatusAllowance;
+    public ImmutableSetCustom<Byte> clientSidedLoginAllowance;
+    public ImmutableSetCustom<Byte> clientSidedPlayAllowance;
+
+    public PacketListenerDynamic(final PacketEventPriority priority) {
+        this.priority = priority;
+        this.serverSidedStatusAllowance = null;
+        this.serverSidedLoginAllowance = null;
+        this.serverSidedPlayAllowance = null;
+
+        this.clientSidedStatusAllowance = null;
+        this.clientSidedLoginAllowance = null;
+        this.clientSidedPlayAllowance = null;
+    }
+
+
+    public PacketListenerDynamic() {
+        this(PacketEventPriority.NORMAL);
+    }
+
+    public final PacketEventPriority getPriority() {
+        return priority;
+    }
+
+    public final void addServerSidedStatusFilter(Byte... statusPacketIDs) {
+        if (this.serverSidedStatusAllowance == null) {
+            this.serverSidedStatusAllowance = new ImmutableSetCustom<>(statusPacketIDs);
+        }
+        else {
+            this.serverSidedStatusAllowance.addAll(statusPacketIDs);
+        }
+    }
+
+    public final void addServerSidedLoginFilter(Byte... loginPacketIDs) {
+        if (this.serverSidedLoginAllowance == null) {
+            this.serverSidedLoginAllowance = new ImmutableSetCustom<>(loginPacketIDs);
+        }
+        else {
+            this.serverSidedLoginAllowance.addAll(loginPacketIDs);
+        }
+    }
+
+    public final void addServerSidedPlayFilter(Byte... playPacketIDs) {
+        if (this.serverSidedPlayAllowance == null) {
+            this.serverSidedPlayAllowance = new ImmutableSetCustom<>(playPacketIDs);
+        }
+        else {
+            this.serverSidedPlayAllowance.addAll(playPacketIDs);
+        }
+    }
+
+    public final void addClientSidedStatusFilter(Byte... statusPacketIDs) {
+        if (this.clientSidedStatusAllowance == null) {
+            this.clientSidedStatusAllowance = new ImmutableSetCustom<>(statusPacketIDs);
+        }
+        else {
+            this.clientSidedStatusAllowance.addAll(statusPacketIDs);
+        }
+    }
+
+    public final void 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();
+        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 filterClientSidedLogin() {
+        this.clientSidedLoginAllowance = new ImmutableSetCustom<>();
+    }
+
+    public final void filterClientSidedPlay() {
+        this.clientSidedPlayAllowance = new ImmutableSetCustom<>();
+    }
+
+    public void onPacketStatusReceive(PacketStatusReceiveEvent event) {
+
+    }
+
+    public void onPacketStatusSend(PacketStatusSendEvent event) {
+    }
+
+    public void onPacketLoginReceive(PacketLoginReceiveEvent event) {
+    }
+
+    public void onPacketLoginSend(PacketLoginSendEvent event) {
+
+    }
+
+    public void onPacketPlayReceive(PacketPlayReceiveEvent event) {
+    }
+
+    public void onPacketPlaySend(PacketPlaySendEvent event) {
+    }
+
+    public void onPostPacketPlayReceive(PostPacketPlayReceiveEvent event) {
+    }
+
+    public void onPostPacketPlaySend(PostPacketPlaySendEvent event) {
+    }
+
+    public void onPostPlayerInject(PostPlayerInjectEvent event) {
+
+    }
+
+    public void onPlayerInject(PlayerInjectEvent event) {
+
+    }
+
+    public void onPlayerEject(PlayerEjectEvent event) {
+    }
+
+    public void onPacketEventExternal(PacketEvent event) {
+
+    }
+}

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

@@ -0,0 +1,45 @@
+/*
+ * 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.annotation;
+
+import java.lang.annotation.ElementType;
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
+import java.lang.annotation.Target;
+
+/**
+ * This is what you override your event listener with on the old event system.
+ * You can specify the event priority of the listener method.
+ *
+ * @author retrooper
+ * @since 1.0
+ * @deprecated Was used for the old event system, the new one doesn't need this anymore.
+ */
+@Target({ElementType.METHOD})
+@Retention(RetentionPolicy.RUNTIME)
+@Deprecated
+public @interface PacketHandler {
+    byte priority() default 2; //NORMAL priority value
+}

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

@@ -0,0 +1,44 @@
+/*
+ * 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.eventtypes;
+
+import io.github.retrooper.packetevents.event.PacketEvent;
+import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.impl.PacketPlayReceiveEvent;
+
+/**
+ * The {@link PacketEvent} implements this interface.
+ * Every inbuilt event should implement the {@link #call(PacketListenerDynamic)} method.
+ * If you are making a custom event, don't implement this.
+ * The {@link PacketListenerDynamic#onPacketEvent(PacketEvent)} method is called for every event,
+ * including custom events.
+ *
+ * @author retrooper
+ * @see PacketPlayReceiveEvent
+ * @since 1.8
+ */
+public interface CallableEvent {
+    void call(PacketListenerDynamic listener);
+}

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

@@ -0,0 +1,71 @@
+/*
+ * 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.eventtypes;
+
+import io.github.retrooper.packetevents.event.impl.PacketPlayReceiveEvent;
+
+/**
+ * Every event that supports cancellation should implement this interface.
+ * PacketEvents' event system lets the highest priority listener be have the highest priority
+ * in deciding whether the event will cancel.
+ * This means an event with a lower priority than the higher priority one would not be able to decide.
+ * Cancelling the event means the action assosiated with the event will be cancelled.
+ * For example, cancelling the {@link PacketPlayReceiveEvent}
+ * will prevent minecraft from processing the incoming packet.
+ *
+ * @author retrooper
+ * @see PacketPlayReceiveEvent
+ * @since 1.7
+ */
+public interface CancellableEvent {
+
+    /**
+     * This method returns if the event will be cancelled.
+     *
+     * @return Will the event be cancelled.
+     */
+    boolean isCancelled();
+
+    /**
+     * Cancel or proceed with the event.
+     *
+     * @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

@@ -0,0 +1,37 @@
+package io.github.retrooper.packetevents.event.eventtypes;
+
+import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
+
+import java.net.InetSocketAddress;
+
+public abstract class CancellableNMSPacketEvent extends NMSPacketEvent implements CancellableEvent {
+    private boolean cancelled;
+
+    public CancellableNMSPacketEvent(Object channel, NMSPacket packet) {
+        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;
+    }
+
+    @Override
+    public void setCancelled(boolean value) {
+        cancelled = value;
+    }
+}

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

@@ -0,0 +1,113 @@
+/*
+ * 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.eventtypes;
+
+import io.github.retrooper.packetevents.event.PacketEvent;
+import io.github.retrooper.packetevents.packettype.PacketType;
+import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
+import io.github.retrooper.packetevents.utils.netty.channel.ChannelUtils;
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
+
+import java.net.InetSocketAddress;
+
+/**
+ * The {@code NMSPacketEvent} abstract class represents an event that has to do with an actual packet.
+ * Don't mix this up with {@link io.github.retrooper.packetevents.event.PacketEvent}.
+ * The PacketEvent class represents an event that belongs to PacketEvent's packet system.
+ *
+ * @author retrooper
+ * @since 1.8
+ */
+public abstract class NMSPacketEvent extends PacketEvent implements CallableEvent {
+    private final InetSocketAddress socketAddress;
+    protected NMSPacket packet;
+    protected boolean cancelled;
+
+    public NMSPacketEvent(Object channel, NMSPacket packet) {
+        this.socketAddress = ChannelUtils.getSocketAddress(channel);
+        this.packet = packet;
+    }
+
+    public NMSPacketEvent(InetSocketAddress address, NMSPacket packet) {
+        this.socketAddress = address;
+        this.packet = packet;
+    }
+
+    /**
+     * Get the associated player's socket address.
+     *
+     * @return Socket address of the associated player.
+     */
+    public final InetSocketAddress getSocketAddress() {
+        return socketAddress;
+    }
+
+    /**
+     * 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.
+     * 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.
+     *
+     * @return Name of the packet.
+     */
+    @Deprecated
+    public final String getPacketName() {
+        return ClassUtil.getClassSimpleName(packet.getRawNMSPacket().getClass());
+    }
+
+    /**
+     * Get the NMS packet.
+     *
+     * @return Get NMS packet.
+     */
+    public final NMSPacket getNMSPacket() {
+        return packet;
+    }
+
+    /**
+     * Update the NMS Packet.
+     *
+     * @param packet NMS Object
+     */
+    public final void setNMSPacket(NMSPacket packet) {
+        this.packet = packet;
+    }
+
+    /**
+     * Get the Packet ID.
+     *
+     * @return Packet ID.
+     */
+    public abstract byte getPacketId();
+
+    @Override
+    public boolean isInbuilt() {
+        return true;
+    }
+}

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

@@ -0,0 +1,44 @@
+/*
+ * 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.eventtypes;
+
+import io.github.retrooper.packetevents.event.impl.PacketPlayReceiveEvent;
+import org.bukkit.entity.Player;
+
+/**
+ * Every event that has an associated player is recommended to implement this interface.
+ *
+ * @author retrooper
+ * @see PacketPlayReceiveEvent
+ * @since 1.6.9
+ */
+public interface PlayerEvent {
+    /**
+     * Associated player.
+     *
+     * @return Player.
+     */
+    Player getPlayer();
+}

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

@@ -1,35 +0,0 @@
-package io.github.retrooper.packetevents.event.impl;
-
-import io.github.retrooper.packetevents.event.PacketEvent;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-import org.bukkit.event.player.PlayerMoveEvent;
-
-public final class BukkitMoveEvent extends PacketEvent {
-    private final Player player;
-    private final Location to, from;
-
-    public BukkitMoveEvent(final Player player, final Location to, final Location from) {
-        this.player = player;
-        this.to = to;
-        this.from = from;
-    }
-
-    public BukkitMoveEvent(final PlayerMoveEvent e) {
-        this.player = e.getPlayer();
-        this.to = e.getTo();
-        this.from = e.getFrom();
-    }
-
-    public Player getPlayer() {
-        return player;
-    }
-
-    public Location getFrom() {
-        return from;
-    }
-
-    public Location getTo() {
-        return to;
-    }
-}

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

@@ -0,0 +1,73 @@
+/*
+ * 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.impl;
+
+import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+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.
+ * 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 PacketLoginReceiveEvent extends CancellableNMSPacketEvent {
+    public PacketLoginReceiveEvent(final Object channel, final 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) {
+        if (listener.clientSidedLoginAllowance == null || listener.clientSidedLoginAllowance.contains(getPacketId())) {
+            listener.onPacketLoginReceive(this);
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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.impl;
+
+import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+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 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.
+ * 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 PacketLoginSendEvent(Object channel, NMSPacket packet) {
+        super(channel, packet);
+    }
+
+    public PacketLoginSendEvent(InetSocketAddress address, NMSPacket packet) {
+        super(address, packet);
+    }
+
+    @Override
+    public byte getPacketId() {
+        return PacketType.Login.Server.packetIds.getOrDefault(packet.getRawNMSPacket().getClass(), PacketType.INVALID);
+    }
+
+    @Override
+    public void call(PacketListenerDynamic listener) {
+        if (listener.serverSidedLoginAllowance == null||listener.serverSidedLoginAllowance.contains(getPacketId())) {
+            listener.onPacketLoginSend(this);
+        }
+    }
+}

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

@@ -0,0 +1,94 @@
+/*
+ * 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.impl;
+
+import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+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;
+
+/**
+ * The {@code PacketPlayReceiveEvent} event is fired whenever the a PLAY packet is
+ * received from any connected client.
+ * Cancelling this event will result in preventing minecraft from processing the incoming packet.
+ * It would be as if the player never sent the packet from the server's view.
+ *
+ * @author retrooper
+ * @see <a href="https://wiki.vg/Protocol#Play">https://wiki.vg/Protocol#Play</a>
+ * @since 1.2.6
+ */
+public final class PacketPlayReceiveEvent extends CancellableNMSPacketEvent implements PlayerEvent {
+    private final Player player;
+
+    public PacketPlayReceiveEvent(final Player player, final Object channel, final NMSPacket packet) {
+        super(channel, packet);
+        this.player = player;
+    }
+
+    /**
+     * This method returns the bukkit player object of the packet sender.
+     * The player object might be null during early packets.
+     *
+     * @return Packet sender.
+     */
+    @NotNull
+    @Override
+    public Player getPlayer() {
+        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) {
+        if (listener.clientSidedPlayAllowance == null || listener.clientSidedPlayAllowance.contains(getPacketId())) {
+            listener.onPacketPlayReceive(this);
+        }
+    }
+}

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

@@ -0,0 +1,85 @@
+/*
+ * 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.impl;
+
+import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+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;
+
+/**
+ * The {@code PacketPlaySendEvent} event is fired whenever the a PLAY packet is about to be sent.
+ * Cancelling this event will result in preventing minecraft from sending the packet.
+ * The player won't receive the packet if you cancel it.
+ *
+ * @author retrooper
+ * @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 {
+    private final Player player;
+
+    public PacketPlaySendEvent(final Player player, final Object channel, final NMSPacket packet) {
+        super(channel, packet);
+        this.player = player;
+    }
+
+    /**
+     * This method returns the bukkit player object of the packet receiver.
+     * The player object might be null during early packets.
+     *
+     * @return Packet receiver.
+     */
+    @NotNull
+    @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) {
+        if (listener.serverSidedPlayAllowance == null || listener.serverSidedPlayAllowance.contains(getPacketId())) {
+            listener.onPacketPlaySend(this);
+        }
+    }
+}
+

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

@@ -1,62 +0,0 @@
-package io.github.retrooper.packetevents.event.impl;
-
-import io.github.retrooper.packetevents.event.PacketEvent;
-import org.bukkit.entity.Player;
-
-public final class PacketReceiveEvent extends PacketEvent {
-    private final Player player;
-    private final String name;
-    private final Object packet;
-    private boolean cancelled;
-
-    public PacketReceiveEvent(final Player player, final String packetName, final Object packet) {
-        this.player = player;
-        this.name = packetName;
-        this.packet = packet;
-    }
-
-    /**
-     * Get the player sending the packet
-     *
-     * @return
-     */
-    public Player getPlayer() {
-        return this.player;
-    }
-
-    /**
-     * Get the packet's name (NMS packet class simple name)
-     *
-     * @return
-     */
-    public String getPacketName() {
-        return this.name;
-    }
-
-    /**
-     * Get the raw NMS packet object
-     *
-     * @return packet object
-     */
-    public Object getNMSPacket() {
-        return this.packet;
-    }
-
-    /**
-     * Returns if the packet has been cancelled
-     *
-     * @return cancelled
-     */
-    public boolean isCancelled() {
-        return cancelled;
-    }
-
-    /**
-     * Cancel the packet
-     *
-     * @param cancelled
-     */
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-}

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

@@ -1,47 +0,0 @@
-package io.github.retrooper.packetevents.event.impl;
-
-import io.github.retrooper.packetevents.event.PacketEvent;
-import org.bukkit.entity.Player;
-
-
-public final class PacketSendEvent extends PacketEvent {
-    private final Player player;
-    private final String name;
-    private final Object packet;
-    private boolean cancelled;
-
-    public PacketSendEvent(final Player player, final String packetName, final Object packet) {
-        this.player = player;
-        this.name = packetName;
-        this.packet = packet;
-        this.cancelled = false;
-    }
-
-
-    public Player getPlayer() {
-        return this.player;
-    }
-
-    public String getPacketName() {
-        return this.name;
-    }
-
-
-    /**
-     * Get the raw NMS packet object
-     *
-     * @return packet object
-     */
-    public Object getNMSPacket() {
-        return this.packet;
-    }
-
-    public boolean isCancelled() {
-        return cancelled;
-    }
-
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-}
-

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

@@ -0,0 +1,73 @@
+/*
+ * 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.impl;
+
+import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+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.
+ * 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 PacketStatusReceiveEvent extends CancellableNMSPacketEvent {
+    public PacketStatusReceiveEvent(final Object channel, final NMSPacket packet) {
+        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) {
+        if (listener.clientSidedStatusAllowance == null || listener.clientSidedStatusAllowance.contains(getPacketId())) {
+            listener.onPacketStatusReceive(this);
+        }
+    }
+}

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

@@ -0,0 +1,75 @@
+/*
+ * 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.impl;
+
+import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+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.packetwrappers.NMSPacket;
+
+import java.net.InetSocketAddress;
+
+/**
+ * The {@code PacketStatusSendEvent} event is fired whenever the server wants to send a STATUS packet to the 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.
+ * 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 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);
+    }
+
+    @Override
+    public void call(PacketListenerDynamic listener) {
+        if (listener.serverSidedStatusAllowance == null || listener.serverSidedStatusAllowance.contains(getPacketId())) {
+            listener.onPacketStatusSend(this);
+        }
+    }
+}

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

@@ -0,0 +1,109 @@
+/*
+ * 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.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.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
+ * @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>
+ * @since 1.6.9
+ */
+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) {
+        this.player = player;
+        this.async = isAsync;
+    }
+
+    @Override
+    public void cancel() {
+        cancelled = true;
+    }
+
+    @Override
+    public void uncancel() {
+        cancelled = false;
+    }
+
+    @Override
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+    @Override
+    public void setCancelled(boolean value) {
+        cancelled = value;
+    }
+
+    /**
+     * This method returns the bukkit player object of the player being ejected.
+     * The player object is guaranteed to NOT be null.
+     *
+     * @return Ejected player.
+     */
+    @NotNull
+    @Override
+    public Player getPlayer() {
+        return player;
+    }
+
+    /**
+     * 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()
+     */
+    public boolean isAsync() {
+        return async;
+    }
+
+    @Override
+    public void call(PacketListenerDynamic listener) {
+        listener.onPlayerEject(this);
+    }
+
+    @Override
+    public boolean isInbuilt() {
+        return true;
+    }
+}

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

@@ -1,37 +1,125 @@
+/*
+ * 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.impl;
 
-import io.github.retrooper.packetevents.enums.ClientVersion;
+import io.github.retrooper.packetevents.PacketEvents;
 import io.github.retrooper.packetevents.event.PacketEvent;
-import io.github.retrooper.packetevents.utils.VersionLookupUtils;
+import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+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;
 
-public final class PlayerInjectEvent extends PacketEvent {
+import java.net.InetSocketAddress;
+
+/**
+ * The {@code PlayerInjectEvent} event is fired whenever a player is injected.
+ * A player is injected by PacketEvents whenever they join the server.
+ * This class implements {@link CancellableEvent} and {@link PlayerEvent}.
+ *
+ * @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>
+ * @since 1.6.9
+ */
+public final class PlayerInjectEvent extends PacketEvent implements CancellableEvent, PlayerEvent {
     private final Player player;
-    private final ClientVersion clientVersion;
+    private final InetSocketAddress address;
+    private final boolean async;
     private boolean cancelled;
 
-    public PlayerInjectEvent(final Player player) {
+    public PlayerInjectEvent(final Player player, final boolean isAsync) {
         this.player = player;
-        this.clientVersion = ClientVersion.fromProtocolVersion(VersionLookupUtils.getProtocolVersion(player));
+        this.address = ChannelUtils.getSocketAddress(PacketEvents.get().packetProcessorInternal.getChannel(player));
+        this.async = isAsync;
     }
 
+    @Override
+    public void cancel() {
+        cancelled = true;
+    }
+
+    @Override
+    public void uncancel() {
+        cancelled = false;
+    }
+
+    @Override
     public boolean isCancelled() {
         return cancelled;
     }
 
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-
-    public void cancel() {
-        setCancelled(true);
-    }
-
-    public ClientVersion getClientVersion() {
-        return clientVersion;
+    @Override
+    public void setCancelled(boolean value) {
+        cancelled = value;
     }
 
+    /**
+     * This method returns the bukkit player object of the player being injected.
+     * This player might not be fully initialized.
+     *
+     * @return Injected Player.
+     */
+    @Nullable
+    @Override
     public Player getPlayer() {
         return player;
     }
+
+    /**
+     * This method returns the socket address injecting player.
+     *
+     * @return Socket address of the injecting player.
+     */
+    @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()
+     */
+    public boolean isAsync() {
+        return async;
+    }
+
+    @Override
+    public void call(PacketListenerDynamic listener) {
+        listener.onPlayerInject(this);
+    }
+
+    @Override
+    public boolean isInbuilt() {
+        return true;
+    }
 }

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

@@ -1,29 +0,0 @@
-package io.github.retrooper.packetevents.event.impl;
-
-import io.github.retrooper.packetevents.event.PacketEvent;
-import org.bukkit.entity.Player;
-
-public final class PlayerUninjectEvent extends PacketEvent {
-    private final Player player;
-    private boolean cancelled;
-
-    public PlayerUninjectEvent(final Player player) {
-        this.player = player;
-    }
-
-    public void cancel() {
-        setCancelled(true);
-    }
-
-    public boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    public void setCancelled(final boolean val) {
-        this.cancelled = val;
-    }
-
-    public Player getPlayer() {
-        return player;
-    }
-}

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

@@ -0,0 +1,84 @@
+/*
+ * 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.impl;
+
+import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+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.
+ *
+ * @author retrooper
+ * @see <a href="https://wiki.vg/Protocol#Serverbound_4">https://wiki.vg/Protocol#Serverbound_4</a>
+ * @since 1.7
+ */
+public class PostPacketPlayReceiveEvent extends NMSPacketEvent implements PlayerEvent {
+    private final Player player;
+
+    public PostPacketPlayReceiveEvent(final Player player, final Object channel, final NMSPacket packet) {
+        super(channel, packet);
+        this.player = player;
+    }
+
+    /**
+     * This method returns the bukkit player object of the packet sender.
+     * @return Packet sender.
+     */
+    @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) {
+        if (listener.clientSidedPlayAllowance == null || listener.clientSidedPlayAllowance.contains(getPacketId())) {
+            listener.onPostPacketPlayReceive(this);
+        }
+    }
+}

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

@@ -0,0 +1,84 @@
+/*
+ * 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.impl;
+
+import io.github.retrooper.packetevents.event.PacketListenerDynamic;
+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.
+ *
+ * @author retrooper
+ * @see <a href="https://wiki.vg/Protocol#Clientbound_4">https://wiki.vg/Protocol#Clientbound_4</a>
+ * @since 1.7
+ */
+public class PostPacketPlaySendEvent extends NMSPacketEvent implements PlayerEvent {
+    private final Player player;
+
+    public PostPacketPlaySendEvent(final Player player, final Object channel, final NMSPacket packet) {
+        super(channel, packet);
+        this.player = player;
+    }
+
+    /**
+     * This method returns the bukkit player object of the packet sender.
+     * @return Packet receiver.
+     */
+    @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) {
+        if (listener.serverSidedPlayAllowance == null || listener.serverSidedPlayAllowance.contains(getPacketId())) {
+            listener.onPostPacketPlaySend(this);
+        }
+    }
+}

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

@@ -0,0 +1,115 @@
+/*
+ * 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.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.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 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.
+ *
+ * @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>
+ * @since 1.3
+ */
+public class PostPlayerInjectEvent extends PacketEvent implements PlayerEvent {
+    private final Player player;
+    private final boolean async;
+
+    public PostPlayerInjectEvent(Player player, boolean async) {
+        this.player = player;
+        this.async = async;
+    }
+
+    /**
+     * This method returns the bukkit player object of the player that has been injected.
+     * The player is guaranteed to not be null.
+     *
+     * @return Injected Player.
+     */
+    @NotNull
+    @Override
+    public Player getPlayer() {
+        return player;
+    }
+
+    /**
+     * This method returns the cached netty channel of the player.
+     *
+     * @return Netty channel of the injected player.
+     */
+    @NotNull
+    public Object getChannel() {
+        return PacketEvents.get().packetProcessorInternal.getChannel(player);
+    }
+
+    @NotNull
+    public InetSocketAddress getSocketAddress() {
+        return ChannelUtils.getSocketAddress(getChannel());
+    }
+
+    /**
+     * This method returns the ClientVersion of the injected player.
+     *
+     * @return ClientVersion of injected player.
+     * @see ClientVersion
+     */
+    @NotNull
+    public ClientVersion getClientVersion() {
+        return PacketEvents.get().getPlayerUtils().getClientVersion(player);
+    }
+
+    /**
+     * Has the event been called async or sync?
+     *
+     * @return Was the event call in an async context?
+     */
+    public boolean isAsync() {
+        return async;
+    }
+
+    @Override
+    public void call(PacketListenerDynamic listener) {
+        listener.onPostPlayerInject(this);
+    }
+
+    @Override
+    public boolean isInbuilt() {
+        return true;
+    }
+}

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

@@ -1,33 +0,0 @@
-package io.github.retrooper.packetevents.event.impl;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.event.PacketEvent;
-
-public final class ServerTickEvent extends PacketEvent {
-    private final int tick;
-    private final double tps;
-
-    public ServerTickEvent(final int tick, final long timestamp) {
-        this.tick = tick;
-        this.timestamp = timestamp;
-        this.tps = PacketEvents.getCurrentServerTPS();
-    }
-
-    public ServerTickEvent(final int tick) {
-        this.tick = tick;
-        this.tps = PacketEvents.getCurrentServerTPS();
-    }
-
-
-    public long getTimestamp() {
-        return timestamp;
-    }
-
-    public int getCurrentTick() {
-        return tick;
-    }
-
-    public double getCurrentServerTPS() {
-        return tps;
-    }
-}

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

@@ -1,59 +1,158 @@
+/*
+ * 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.annotations.PacketHandler;
+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.PacketListenerDynamic;
+import io.github.retrooper.packetevents.event.annotation.PacketHandler;
+import io.github.retrooper.packetevents.event.eventtypes.CancellableEvent;
+import io.github.retrooper.packetevents.event.priority.PacketEventPriority;
 
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.util.ArrayList;
-import java.util.HashMap;
-import java.util.List;
+import java.util.*;
+import java.util.logging.Level;
 
-public final class EventManager {
+/**
+ * This is the event manager interface.
+ * Every method is already implemented, we just use this
+ * to have less code duplications.
+ * You can either call event manager methods in the
+ * {@link io.github.retrooper.packetevents.PacketEvents} instance or with an instance of the
+ * {@link PEEventManager} stored in {@link PacketEvents}.
+ *
+ * @author retrooper
+ * @see PacketEvents#getEventManager()
+ * @since 1.0
+ */
+public interface EventManager {
 
-    private final HashMap<PacketListener, List<Method>> registeredMethods = new HashMap<PacketListener, List<Method>>();
+    /**
+     * Call a packet event.
+     * This will let all listeners(new and deprecated listeners) process the event.
+     * It isn't recommended to use a mix of both listeners(new and deprecated),
+     * but it will work and they are compatible.
+     *
+     * @param event {@link PacketEvent}
+     * @return Same event manager instance.
+     */
+    default EventManager callEvent(PacketEvent event) {
+        //The dynamic event manager calls the legacy event manager.
+        PEEventManager.EVENT_MANAGER_DYNAMIC.callEvent(event);
+        return this;
+    }
 
-    public void callEvent(final PacketEvent e) {
-        for (final PacketListener listener : registeredMethods.keySet()) {
-            //Annotated methods
-            final List<Method> methods = registeredMethods.get(listener);
-            for (final Method method : methods) {
-                final Class<?> parameterType = method.getParameterTypes()[0];
-                if (parameterType.equals(PacketEvent.class)
-                        || parameterType.isInstance(e)) {
-                    try {
-                        method.invoke(listener, e);
-                    } catch (IllegalAccessException | InvocationTargetException ex) {
-                        ex.printStackTrace();
-                    }
-                }
-            }
+    /**
+     * Register a deprecated event listener.
+     * Not recommended to use the deprecated event listener.
+     *
+     * @param listener {@link PacketListener}
+     * @return Same event manager instance.
+     */
+    @Deprecated
+    default EventManager registerListener(PacketListener listener) {
+        if (listener != null) {
+            PEEventManager.EVENT_MANAGER_LEGACY.registerListener(listener);
         }
+        return this;
     }
 
-    public void registerListener(final PacketListener e) {
-        final List<Method> methods = new ArrayList<Method>();
-        for (final Method m : e.getClass().getMethods()) {
-            if (m.isAnnotationPresent(PacketHandler.class)
-                    && m.getParameterTypes().length == 1) {
-                methods.add(m);
-            }
-        }
-        if (!methods.isEmpty()) {
-            registeredMethods.put(e, methods);
+    /**
+     * Register multiple deprecated event listeners with one method.
+     * Not recommended to use the deprecated event listener.
+     *
+     * @param listeners {@link PacketListener}
+     * @return Same event manager instance.
+     */
+    @Deprecated
+    default EventManager registerListeners(PacketListener... listeners) {
+        PEEventManager.EVENT_MANAGER_LEGACY.registerListeners(listeners);
+        return this;
+    }
+
+    /**
+     * Unregister a deprecated event listener.
+     * Not recommended to use the deprecated event listener.
+     *
+     * @param listener {@link PacketListener}
+     * @return Same event manager instance.
+     */
+    @Deprecated
+    default EventManager unregisterListener(PacketListener listener) {
+        PEEventManager.EVENT_MANAGER_LEGACY.unregisterListener(listener);
+        return this;
+    }
+
+    /**
+     * Unregister multiple deprecated event listeners with one method.
+     * Not recommended to use the deprecated event listener.
+     *
+     * @param listeners {@link PacketListener}
+     * @return Same event manager instance.
+     */
+    @Deprecated
+    default EventManager unregisterListeners(PacketListener... listeners) {
+        PEEventManager.EVENT_MANAGER_LEGACY.unregisterListeners(listeners);
+        return this;
+    }
+
+    /**
+     * Register the dynamic event listener.
+     *
+     * @param listener {@link PacketListenerDynamic}
+     * @return Same event manager instance.
+     */
+    default EventManager registerListener(PacketListenerDynamic listener) {
+        if (listener != null) {
+            PEEventManager.EVENT_MANAGER_DYNAMIC.registerListener(listener);
         }
+        return this;
     }
 
-    public void unregisterListener(final PacketListener e) {
-        registeredMethods.remove(e);
+    /**
+     * Register multiple dynamic event listeners with one method.
+     *
+     * @param listeners {@link PacketListenerDynamic}
+     * @return Same event manager instance.
+     */
+    default EventManager registerListeners(PacketListenerDynamic... listeners) {
+        PEEventManager.EVENT_MANAGER_DYNAMIC.registerListeners(listeners);
+        return this;
     }
 
-    public void unregisterAllListeners() {
-        registeredMethods.clear();
-    }
-
-    public boolean isRegistered(final PacketListener listener) {
-        return registeredMethods.containsKey(listener);
+    /**
+     * Unregister all registered event listeners.
+     * All the deprecated and the dynamic listeners will be unregistered.
+     *
+     * @return Same event manager instance.
+     */
+    default EventManager unregisterAllListeners() {
+        PEEventManager.EVENT_MANAGER_DYNAMIC.unregisterAllListeners();
+        PEEventManager.EVENT_MANAGER_LEGACY.unregisterAllListeners();
+        return this;
     }
 }

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

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

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

@@ -0,0 +1,166 @@
+/*
+ * 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.PacketListener;
+import io.github.retrooper.packetevents.event.annotation.PacketHandler;
+import io.github.retrooper.packetevents.event.eventtypes.CancellableEvent;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.Map;
+
+@Deprecated
+class EventManagerLegacy {
+    /**
+     * Map storing all all legacy packet event listeners.
+     * The key is an individual listener, the values are the key's event methods.
+     */
+
+    private final Map<PacketListener, HashSet<Method>> staticRegisteredMethods = new HashMap<>();
+
+    /**
+     * 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
+     * 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.
+     * This downside of this system is the event listeners aren't executed in any particular order, just
+     * in the order they were registered.
+     * This system is also slower than the other event system.
+     *
+     * @param event         {@link PacketEvent}
+     * @param eventPriority Priority the legacy listeners should beat to decide cancellation of the event.
+     */
+    @Deprecated
+    public void callEvent(final PacketEvent event, byte eventPriority) {
+        boolean isCancelled = false;
+        if (event instanceof CancellableEvent) {
+            isCancelled = ((CancellableEvent) event).isCancelled();
+        }
+        //STATIC LISTENERS
+        for (final PacketListener listener : staticRegisteredMethods.keySet()) {
+            HashSet<Method> methods = staticRegisteredMethods.get(listener);
+
+            for (Method method : methods) {
+                Class<?> parameterType = method.getParameterTypes()[0];
+                if (parameterType.equals(PacketEvent.class)
+                        || parameterType.isInstance(event)) {
+
+                    PacketHandler annotation = method.getAnnotation(PacketHandler.class);
+                    try {
+                        method.invoke(listener, event);
+                    } catch (IllegalAccessException | InvocationTargetException ex) {
+                        ex.printStackTrace();
+                    }
+                    if (event instanceof CancellableEvent) {
+                        CancellableEvent ce = (CancellableEvent) event;
+                        if (annotation.priority() >= eventPriority) {
+                            eventPriority = annotation.priority();
+                            isCancelled = ce.isCancelled();
+                        }
+                    }
+                }
+            }
+        }
+        if (event instanceof CancellableEvent) {
+            CancellableEvent ce = (CancellableEvent) event;
+            ce.setCancelled(isCancelled);
+        }
+    }
+
+    /**
+     * Register a legacy packet event listener.
+     * Not recommended to use the deprecated event listener.
+     *
+     * @param listener {@link PacketListener}
+     */
+    @Deprecated
+    public void registerListener(final PacketListener listener) {
+        final HashSet<Method> methods = new HashSet<>();
+        for (final Method m : listener.getClass().getDeclaredMethods()) {
+            if (!m.isAccessible()) {
+                m.setAccessible(true);
+            }
+            if (m.isAnnotationPresent(PacketHandler.class)
+                    && m.getParameterTypes().length == 1) {
+                methods.add(m);
+            }
+        }
+
+        if (!methods.isEmpty()) {
+            staticRegisteredMethods.put(listener, methods);
+        }
+    }
+
+    /**
+     * Register multiple legacy packet event listeners with one method.
+     * Not recommended to use the deprecated event listener.
+     *
+     * @param listeners {@link PacketListener}
+     */
+    @Deprecated
+    public void registerListeners(final PacketListener... listeners) {
+        for (final PacketListener listener : listeners) {
+            registerListener(listener);
+        }
+    }
+
+    /**
+     * Unregister a legacy packet event listener.
+     * Not recommended to use the deprecated event listener.
+     *
+     * @param listener {@link PacketListener}
+     */
+    @Deprecated
+    public void unregisterListener(final PacketListener listener) {
+        staticRegisteredMethods.remove(listener);
+    }
+
+    /**
+     * Unregister multiple legacy packet event listeners with one method.
+     * Not recommended to use the deprecated event listener.
+     *
+     * @param listeners {@link PacketListener}
+     */
+    @Deprecated
+    public void unregisterListeners(final PacketListener... listeners) {
+        for (final PacketListener listener : listeners) {
+            unregisterListener(listener);
+        }
+    }
+
+    /**
+     * Unregister all legacy packet event listeners.
+     */
+    @Deprecated
+    public void unregisterAllListeners() {
+        staticRegisteredMethods.clear();
+    }
+}

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

@@ -0,0 +1,38 @@
+/*
+ * 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;
+
+/**
+ * Class storing a static instance of the dynamic and the legacy event manager.
+ *
+ * @author retrooper
+ * @since 1.8
+ */
+public class PEEventManager implements EventManager {
+
+    public static final EventManagerLegacy EVENT_MANAGER_LEGACY = new EventManagerLegacy();
+    public static final EventManagerDynamic EVENT_MANAGER_DYNAMIC = new EventManagerDynamic();
+
+}

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

@@ -0,0 +1,107 @@
+/*
+ * 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.priority;
+
+/**
+ * Event priority enum for the new event system.
+ * The event priority counts for the whole {@link io.github.retrooper.packetevents.event.PacketListenerDynamic}
+ * and not for just one event.
+ * The priority can be specified in the PacketListenerDynamic constructor.
+ * If you don't specify a priority in the constructor, it will use the {@link #NORMAL} priority.
+ *
+ * @author retrooper
+ * @since 1.6.9
+ */
+public enum PacketEventPriority {
+    /**
+     * The weakest event priority.
+     * The first to be processed(IN THE DYNAMIC EVENT SYSTEM ONLY).
+     * 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),
+
+    /**
+     * A weak event priority.
+     * Second to be processed(IN THE DYNAMIC EVENT SYSTEM ONLY).
+     * 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),
+
+    /**
+     * Default event priority.
+     * Third to be processed(IN THE DYNAMIC EVENT SYSTEM ONLY).
+     * Use this if you don't really care/know when you process or just want to
+     * be in the middle.
+     */
+    NORMAL((byte) 2),
+
+    /**
+     * 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),
+
+    /**
+     * Second most powerful event priority.
+     * Fifth to be processed(IN THE DYNAMIC EVENT SYSTEM ONLY).
+     * Use this if you prefer to be one of the last to process,
+     * but don't mind if some other listener really needs to process after you.
+     * Also use this if you prefer deciding if the event cancelled or not, but don't
+     * mind if some other listener urgently needs to decide over you.
+     * {@link PacketEventPriority#MONITOR} is rarely ever recommended to use.
+     */
+    HIGHEST((byte) 4),
+
+    /**
+     * Most powerful event priority.
+     * Last(Sixth) to be processed(IN THE DYNAMIC EVENT SYSTEM ONLY).
+     * Use this if you urgently need to be the last to process
+     * or urgently need to be the final decider whether the event has cancelled or not.
+     * This is rarely recommended.
+     */
+    MONITOR((byte) 5);
+
+    final byte priorityValue;
+
+    PacketEventPriority(byte priorityValue) {
+        this.priorityValue = priorityValue;
+    }
+
+    public byte getPriorityValue() {
+        return priorityValue;
+    }
+
+    public static PacketEventPriority getPacketEventPriority(byte bytePriority) {
+        for (PacketEventPriority priority : values()) {
+            if (priority.priorityValue == bytePriority) {
+                return priority;
+            }
+        }
+        return NORMAL;
+    }
+}

src/main/java/io/github/retrooper/packetevents/example/MainExample.java

@@ -1,21 +0,0 @@
-package io.github.retrooper.packetevents.example;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import org.bukkit.plugin.java.JavaPlugin;
-
-public class MainExample extends JavaPlugin {
-
-    @Override
-    public void onEnable() {
-        PacketEvents.start(this);
-
-        PacketEvents.getServerTickTask().cancel();
-
-    }
-
-    @Override
-    public void onDisable() {
-        PacketEvents.stop();
-    }
-
-}

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

@@ -0,0 +1,51 @@
+/*
+ * 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.exceptions;
+
+/**
+ * An exception thrown by PacketEvents when the {@link io.github.retrooper.packetevents.PacketEvents#load}
+ * method fails to execute without any exceptions.
+ * Resulting in PacketEvents failing to load.
+ *
+ * @author retrooper
+ * @since 1.7.6
+ */
+public class PacketEventsLoadFailureException extends RuntimeException {
+    public PacketEventsLoadFailureException(String message) {
+        super(message);
+    }
+
+    public PacketEventsLoadFailureException(String message, Throwable cause) {
+        super(message, cause);
+    }
+
+    public PacketEventsLoadFailureException() {
+        this("PacketEvents failed to load...");
+    }
+
+    public PacketEventsLoadFailureException(Throwable cause) {
+        this("PacketEvents failed to load...", cause);
+    }
+}

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

@@ -0,0 +1,46 @@
+/*
+ * 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.exceptions;
+
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
+
+/**
+ * An exception thrown by PacketEvents when a wrapper fails
+ * to find a field.
+ *
+ * @author retrooper
+ * @see io.github.retrooper.packetevents.packetwrappers.WrappedPacket#read(int, Class)
+ * @see io.github.retrooper.packetevents.packetwrappers.WrappedPacket#write(Class, int, Object)
+ * @since 1.6.9
+ */
+public class WrapperFieldNotFoundException extends RuntimeException {
+    public WrapperFieldNotFoundException(String message) {
+        super(message);
+    }
+
+    public WrapperFieldNotFoundException(Class<?> packetClass, Class<?> type, int index) {
+        this("PacketEvents failed to find a " + ClassUtil.getClassSimpleName(type) + " indexed " + index + " by its type in the " + packetClass.getName() + " class!");
+    }
+}

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

@@ -0,0 +1,48 @@
+/*
+ * 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.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/NettyPacketHandler.java

@@ -1,63 +0,0 @@
-package io.github.retrooper.packetevents.handler;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.event.impl.PacketReceiveEvent;
-import io.github.retrooper.packetevents.event.impl.PacketSendEvent;
-import io.github.retrooper.packetevents.event.impl.PlayerInjectEvent;
-import io.github.retrooper.packetevents.event.impl.PlayerUninjectEvent;
-import org.bukkit.entity.Player;
-
-import java.util.concurrent.Future;
-
-public class NettyPacketHandler {
-    public static final String handlerName = "packet_handler";
-    private static final ServerVersion version = PacketEvents.getServerVersion();
-
-    public static void injectPlayer(final Player player) {
-        final PlayerInjectEvent injectEvent = new PlayerInjectEvent(player);
-        PacketEvents.getEventManager().callEvent(injectEvent);
-        if (!injectEvent.isCancelled()) {
-            if (version.isLowerThan(ServerVersion.v_1_8)) {
-                NettyPacketHandler_7.injectPlayer(player);
-            } else {
-                NettyPacketHandler_8.injectPlayer(player);
-            }
-        }
-    }
-
-    public static Future<?> uninjectPlayer(final Player player) {
-        final PlayerUninjectEvent uninjectEvent = new PlayerUninjectEvent(player);
-        PacketEvents.getEventManager().callEvent(uninjectEvent);
-        if (!uninjectEvent.isCancelled()) {
-            if (version.isLowerThan(ServerVersion.v_1_8)) {
-                return NettyPacketHandler_7.uninjectPlayer(player);
-            } else {
-                return NettyPacketHandler_8.uninjectPlayer(player);
-            }
-        }
-        return null;
-    }
-
-    public static Object write(final Player sender, final Object packet) {
-        final String packetName = packet.getClass().getSimpleName();
-        final PacketSendEvent packetSendEvent = new PacketSendEvent(sender, packetName, packet);
-        PacketEvents.getEventManager().callEvent(packetSendEvent);
-        if (!packetSendEvent.isCancelled()) {
-            return packet;
-        }
-        return null;
-    }
-
-    public static Object read(final Player receiver, final Object packet) {
-        final String packetName = packet.getClass().getSimpleName();
-        final PacketReceiveEvent packetReceiveEvent = new PacketReceiveEvent(receiver, packetName, packet);
-        PacketEvents.getEventManager().callEvent(packetReceiveEvent);
-        if (!packetReceiveEvent.isCancelled()) {
-            return packet;
-        }
-        return null;
-    }
-
-
-}

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

@@ -1,44 +0,0 @@
-package io.github.retrooper.packetevents.handler;
-
-import io.github.retrooper.packetevents.utils.NMSUtils;
-import net.minecraft.util.io.netty.channel.*;
-import org.bukkit.entity.Player;
-
-import java.util.concurrent.Future;
-
-final class NettyPacketHandler_7 {
-
-    public static void injectPlayer(final Player player) {
-        final ChannelDuplexHandler channelDuplexHandler = new ChannelDuplexHandler() {
-            @Override
-            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-                Object packet = NettyPacketHandler.read(player, msg);
-                if (packet == null) {
-                    return;
-                }
-                super.channelRead(ctx, msg);
-            }
-
-            @Override
-            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
-                Object packet = NettyPacketHandler.write(player, msg);
-                if (packet == null) {
-                    return;
-                }
-                super.write(ctx, msg, promise);
-            }
-        };
-        final ChannelPipeline pipeline = ((Channel) NMSUtils.getChannel(player)).pipeline();
-        pipeline.addBefore(NettyPacketHandler.handlerName, player.getName(), channelDuplexHandler);
-    }
-
-    public static Future<?> uninjectPlayer(final Player player) {
-        final Channel channel = (Channel) NMSUtils.getChannel(player);
-        return channel.eventLoop().submit(new Runnable() {
-            @Override
-            public void run() {
-                channel.pipeline().remove(player.getName());
-            }
-        });
-    }
-}

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

@@ -1,47 +0,0 @@
-package io.github.retrooper.packetevents.handler;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-import io.netty.channel.*;
-import org.bukkit.entity.Player;
-
-import java.util.concurrent.Future;
-
-final class NettyPacketHandler_8 {
-    private static final ServerVersion version = PacketEvents.getServerVersion();
-
-    public static void injectPlayer(final Player player) {
-        final ChannelDuplexHandler channelDuplexHandler = new ChannelDuplexHandler() {
-            @Override
-            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-                Object packet = NettyPacketHandler.read(player, msg);
-                if (packet == null) {
-                    return;
-                }
-                super.channelRead(ctx, msg);
-            }
-
-            @Override
-            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
-                Object packet = NettyPacketHandler.write(player, msg);
-                if (packet == null) {
-                    return;
-                }
-                super.write(ctx, msg, promise);
-            }
-        };
-        final ChannelPipeline pipeline = ((Channel) NMSUtils.getChannel(player)).pipeline();
-        pipeline.addBefore(NettyPacketHandler.handlerName, player.getName(), channelDuplexHandler);
-    }
-
-    public static Future<?> uninjectPlayer(final Player player) {
-        final Channel channel = (Channel) NMSUtils.getChannel(player);
-        return channel.eventLoop().submit(new Runnable() {
-            @Override
-            public void run() {
-                channel.pipeline().remove(player.getName());
-            }
-        });
-    }
-}

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

@@ -0,0 +1,43 @@
+package io.github.retrooper.packetevents.injector;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+public interface ChannelInjector {
+    default void prepare() {
+
+    }
+
+    default void cleanup() {
+
+    }
+
+    default void cleanupAsync() {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                cleanup();
+            }
+        });
+    }
+
+    void injectPlayerSync(Player player);
+
+    void injectPlayersSync(List<Player> players);
+
+    void ejectPlayerSync(Player player);
+
+    void ejectPlayersSync(List<Player> players);
+
+    void injectPlayerAsync(Player player);
+
+    void injectPlayersAsync(List<Player> players);
+
+    void ejectPlayerAsync(Player player);
+
+    void ejectPlayersAsync(List<Player> players);
+
+    void sendPacket(Object channel, Object rawNMSPacket);
+}

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

@@ -0,0 +1,87 @@
+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.utils.nms.NMSUtils;
+import org.bukkit.entity.Player;
+
+import java.util.List;
+
+public class GlobalChannelInjector implements ChannelInjector {
+    private final ChannelInjector injector;
+
+    public GlobalChannelInjector() {
+        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();
+        }
+    }
+
+    @Override
+    public void prepare() {
+        injector.prepare();
+    }
+
+    @Override
+    public void cleanup() {
+        injector.cleanup();
+    }
+
+    @Override
+    public void cleanupAsync() {
+        injector.cleanupAsync();
+    }
+
+    @Override
+    public void injectPlayerSync(Player player) {
+        injector.injectPlayerSync(player);
+    }
+
+    @Override
+    public void injectPlayersSync(List<Player> players) {
+        injector.injectPlayersSync(players);
+    }
+
+    @Override
+    public void ejectPlayerSync(Player player) {
+        injector.ejectPlayerSync(player);
+    }
+
+    @Override
+    public void ejectPlayersSync(List<Player> players) {
+        injector.ejectPlayersSync(players);
+    }
+
+    @Override
+    public void injectPlayerAsync(Player player) {
+        injector.injectPlayerAsync(player);
+    }
+
+    @Override
+    public void injectPlayersAsync(List<Player> players) {
+        injector.injectPlayersAsync(players);
+    }
+
+    @Override
+    public void ejectPlayerAsync(Player player) {
+        injector.ejectPlayerAsync(player);
+    }
+
+    @Override
+    public void ejectPlayersAsync(List<Player> players) {
+        injector.ejectPlayersAsync(players);
+    }
+
+    @Override
+    public void sendPacket(Object channel, Object rawNMSPacket) {
+        injector.sendPacket(channel, rawNMSPacket);
+    }
+}

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

@@ -0,0 +1,396 @@
+/*
+ * 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();
+        if (networkMarkers == null) {
+            networkMarkers = new ArrayList<>();
+        }
+        firstChannelInitializer = new ChannelInitializer<Channel>() {
+            @Override
+            protected void initChannel(final Channel channel) {
+                synchronized (networkMarkers) {
+                    channel.eventLoop().execute(new Runnable() {
+                        @Override
+                        public void run() {
+                            if (PacketEvents.get().getServerUtils().getVersion().isNewerThan(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;
+        if (channel == null) {
+            return null;
+        } else if (channel.pipeline() == null) {
+            return null;
+        }
+        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) {
+            try {
+                channel.pipeline().remove(handlerName);
+            }
+            catch (NoSuchElementException ignored) {
+
+            }
+        }
+    }
+
+    /**
+     * Inject a player on the current thread.
+     *
+     * @param player Target player.
+     */
+    @Override
+    public void injectPlayerSync(Player player) {
+        Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+        if (channel != null) {
+            injectChannel(channel).player = player;
+        } else {
+            throw new IllegalStateException("Channel of " + player.getName() + " is null!");
+        }
+    }
+
+    @Override
+    public void injectPlayersSync(List<Player> players) {
+        for (Player player : players) {
+            injectPlayerSync(player);
+        }
+    }
+
+    /**
+     * Eject a player on the current thread.
+     *
+     * @param player Target player.
+     */
+    @Override
+    public void ejectPlayerSync(Player player) {
+        Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+        ejectChannel(channel);
+        PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
+        PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
+    }
+
+    @Override
+    public void ejectPlayersSync(List<Player> players) {
+        for (Player player : players) {
+            ejectPlayerSync(player);
+        }
+    }
+
+    /**
+     * 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().packetProcessorInternal.getChannel(player);
+                if (channel != null) {
+                    injectChannel(channel).player = player;
+                } else {
+                    PacketEvents.get().packetProcessorInternal.rescheduleInjectPlayer(player,  20L);
+                }
+            }
+        });
+    }
+
+    @Override
+    public void injectPlayersAsync(List<Player> players) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                for (Player player : players) {
+                    PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+                        @Override
+                        public void run() {
+                            Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+                            if (channel != null) {
+                                injectChannel(channel).player = player;
+                            } else {
+                                PacketEvents.get().packetProcessorInternal.rescheduleInjectPlayer(player,  20L);
+                            }
+                        }
+                    });
+                }
+            }
+        });
+    }
+
+    /**
+     * 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().packetProcessorInternal.getChannel(player);
+                ejectChannel(channel);
+                PacketEvents.get().packetProcessorInternal.keepAliveMap.remove(player.getUniqueId());
+                PacketEvents.get().packetProcessorInternal.channelMap.remove(player.getName());
+                PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
+                PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
+            }
+        });
+    }
+
+    @Override
+    public void ejectPlayersAsync(List<Player> players) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                for (Player player : players) {
+                    Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+                    ejectChannel(channel);
+                    PacketEvents.get().packetProcessorInternal.keepAliveMap.remove(player.getUniqueId());
+                    PacketEvents.get().packetProcessorInternal.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().packetProcessorInternal.read(player, ctx.channel(), packet);
+            if (packet != null) {
+                super.channelRead(ctx, packet);
+                PacketEvents.get().packetProcessorInternal.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().packetProcessorInternal.write(player, ctx.channel(), packet);
+            if (packet != null) {
+                super.write(ctx, packet, promise);
+                PacketEvents.get().packetProcessorInternal.postWrite(player, ctx.channel(), packet);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,386 @@
+/*
+ * 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.netty.channel.*;
+import org.bukkit.entity.Player;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.NoSuchElementException;
+import java.util.concurrent.Future;
+
+/**
+ * 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();
+        if (networkMarkers == null) {
+            networkMarkers = new ArrayList<>();
+        }
+        firstChannelInitializer = new ChannelInitializer<Channel>() {
+            @Override
+            protected void initChannel(final Channel channel) {
+                synchronized (networkMarkers) {
+                    channel.eventLoop().execute(new Runnable() {
+                        @Override
+                        public void run() {
+                            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;
+        if (channel == null) {
+            return null;
+        } else if (channel.pipeline() == null) {
+            return null;
+        }
+        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) {
+            try {
+                channel.pipeline().remove(handlerName);
+            }
+            catch (NoSuchElementException ignored) {
+                //Doesn't matter
+            }
+        }
+    }
+
+    /**
+     * Inject a player on the current thread.
+     *
+     * @param player Target player.
+     */
+    @Override
+    public void injectPlayerSync(Player player) {
+        Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+        if (channel != null) {
+            injectChannel(channel).player = player;
+        } else {
+            throw new IllegalStateException("Channel of " + player.getName() + " is null!");
+        }
+    }
+
+    @Override
+    public void injectPlayersSync(List<Player> players) {
+        for (Player player : players) {
+            injectPlayerSync(player);
+        }
+    }
+
+    /**
+     * Eject a player on the current thread.
+     *
+     * @param player Target player.
+     */
+    @Override
+    public void ejectPlayerSync(Player player) {
+        Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+        ejectChannel(channel);
+        PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
+        PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
+    }
+
+    @Override
+    public void ejectPlayersSync(List<Player> players) {
+        for (Player player : players) {
+            ejectPlayerSync(player);
+        }
+    }
+
+    /**
+     * 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().packetProcessorInternal.getChannel(player);
+                if (channel != null) {
+                    injectChannel(channel).player = player;
+                } else {
+                    PacketEvents.get().packetProcessorInternal.rescheduleInjectPlayer(player,  20L);
+                }
+            }
+        });
+    }
+
+    @Override
+    public void injectPlayersAsync(List<Player> players) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                for (Player player : players) {
+                    PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+                        @Override
+                        public void run() {
+                            Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+                            if (channel != null) {
+                                injectChannel(channel).player = player;
+                            } else {
+                                PacketEvents.get().packetProcessorInternal.rescheduleInjectPlayer(player,  20L);
+                            }
+                        }
+                    });
+                }
+            }
+        });
+    }
+
+    /**
+     * 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().packetProcessorInternal.getChannel(player);
+                ejectChannel(channel);
+                PacketEvents.get().packetProcessorInternal.keepAliveMap.remove(player.getUniqueId());
+                PacketEvents.get().packetProcessorInternal.channelMap.remove(player.getName());
+                PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
+                PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
+            }
+        });
+    }
+
+    @Override
+    public void ejectPlayersAsync(List<Player> players) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                for (Player player : players) {
+                    Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+                    ejectChannel(channel);
+                    PacketEvents.get().packetProcessorInternal.keepAliveMap.remove(player.getUniqueId());
+                    PacketEvents.get().packetProcessorInternal.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().packetProcessorInternal.read(player, ctx.channel(), packet);
+            if (packet != null) {
+                super.channelRead(ctx, packet);
+                PacketEvents.get().packetProcessorInternal.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().packetProcessorInternal.write(player, ctx.channel(), packet);
+            if (packet != null) {
+                super.write(ctx, packet, promise);
+                PacketEvents.get().packetProcessorInternal.postWrite(player, ctx.channel(), packet);
+            }
+        }
+    }
+}

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

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,155 @@
+/*
+ * 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;
+
+import java.util.List;
+import java.util.NoSuchElementException;
+
+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().packetProcessorInternal.read(player, ctx.channel(), packet);
+                if (packet != null) {
+                    super.channelRead(ctx, packet);
+                    PacketEvents.get().packetProcessorInternal.postRead(player, ctx.channel(), packet);
+                }
+            }
+
+            @Override
+            public void write(ChannelHandlerContext ctx, Object packet, ChannelPromise promise) throws Exception {
+                packet = PacketEvents.get().packetProcessorInternal.write(player, ctx.channel(), packet);
+                if (packet != null) {
+                    super.write(ctx, packet, promise);
+                    PacketEvents.get().packetProcessorInternal.postWrite(player, ctx.channel(), packet);
+                }
+            }
+        };
+        final Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+        channel.pipeline().addBefore("packet_handler", PacketEvents.handlerName, channelDuplexHandler);
+    }
+
+    @Override
+    public void injectPlayersSync(List<Player> players) {
+        for (Player player : players) {
+            injectPlayerSync(player);
+        }
+    }
+
+    @Override
+    public void ejectPlayerSync(Player player) {
+        final Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.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 ejectPlayersSync(List<Player> players) {
+        for (Player player : players) {
+            ejectPlayerSync(player);
+        }
+    }
+
+    @Override
+    public void injectPlayerAsync(Player player) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                injectPlayerSync(player);
+            }
+        });
+    }
+
+    @Override
+    public void injectPlayersAsync(List<Player> players) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                for (Player player : players) {
+                    injectPlayerSync(player);
+                }
+            }
+        });
+    }
+
+    @Override
+    public void ejectPlayerAsync(Player player) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                final Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+                if (channel.pipeline().get(PacketEvents.handlerName) != null) {
+                    try {
+                        channel.pipeline().remove(PacketEvents.handlerName);
+                    }
+                    catch (NoSuchElementException ignored) {
+                        //Doesn't matter
+                    }
+                }
+                PacketEvents.get().packetProcessorInternal.keepAliveMap.remove(player.getUniqueId());
+                PacketEvents.get().packetProcessorInternal.channelMap.remove(player.getName());
+                PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
+                PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
+            }
+        });
+    }
+
+    @Override
+    public void ejectPlayersAsync(List<Player> players) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                for (Player player : players) {
+                    final Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+                    if (channel.pipeline().get(PacketEvents.handlerName) != null) {
+                        channel.pipeline().remove(PacketEvents.handlerName);
+                    }
+                    PacketEvents.get().packetProcessorInternal.keepAliveMap.remove(player.getUniqueId());
+                    PacketEvents.get().packetProcessorInternal.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

@@ -0,0 +1,163 @@
+/*
+ * 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.List;
+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().packetProcessorInternal.read(player, ctx.channel(), packet);
+                if (packet != null) {
+                    super.channelRead(ctx, packet);
+                    PacketEvents.get().packetProcessorInternal.postRead(player, ctx.channel(), packet);
+                }
+            }
+
+            @Override
+            public void write(ChannelHandlerContext ctx, Object packet, ChannelPromise promise) throws Exception {
+                packet = PacketEvents.get().packetProcessorInternal.write(player, ctx.channel(), packet);
+                if (packet != null) {
+                    super.write(ctx, packet, promise);
+                    PacketEvents.get().packetProcessorInternal.postWrite(player, ctx.channel(), packet);
+                }
+            }
+        };
+        final Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+        channel.pipeline().addBefore("packet_handler", PacketEvents.handlerName, channelDuplexHandler);
+    }
+
+    @Override
+    public void injectPlayersSync(List<Player> players) {
+        for (Player player : players) {
+            injectPlayerSync(player);
+        }
+    }
+
+    @Override
+    public void ejectPlayerSync(Player player) {
+        final Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.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 ejectPlayersSync(List<Player> players) {
+        for (Player player : players) {
+            ejectPlayersSync(players);
+        }
+    }
+
+    @Override
+    public void injectPlayerAsync(Player player) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                injectPlayerSync(player);
+            }
+        });
+    }
+
+    @Override
+    public void injectPlayersAsync(List<Player> players) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                 for (Player player : players) {
+                    injectPlayerSync(player);
+                }
+            }
+        });
+
+    }
+
+    @Override
+    public void ejectPlayerAsync(Player player) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                final Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+                if (channel.pipeline().get(PacketEvents.handlerName) != null) {
+                    try {
+                        channel.pipeline().remove(PacketEvents.handlerName);
+                    } catch (NoSuchElementException ignored) {
+
+                    }
+                }
+                PacketEvents.get().packetProcessorInternal.keepAliveMap.remove(player.getUniqueId());
+                PacketEvents.get().packetProcessorInternal.channelMap.remove(player.getName());
+                PacketEvents.get().getPlayerUtils().clientVersionsMap.remove(player.getAddress());
+                PacketEvents.get().getPlayerUtils().tempClientVersionMap.remove(player.getAddress());
+            }
+        });
+    }
+
+    @Override
+    public void ejectPlayersAsync(List<Player> players) {
+        PacketEvents.get().injectAndEjectExecutorService.execute(new Runnable() {
+            @Override
+            public void run() {
+                for (Player player : players) {
+                    final Channel channel = (Channel) PacketEvents.get().packetProcessorInternal.getChannel(player);
+                    if (channel.pipeline().get(PacketEvents.handlerName) != null) {
+                        try {
+                            channel.pipeline().remove(PacketEvents.handlerName);
+                        } catch (NoSuchElementException ignored) {
+
+                        }
+                    }
+                    PacketEvents.get().packetProcessorInternal.keepAliveMap.remove(player.getUniqueId());
+                    PacketEvents.get().packetProcessorInternal.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

@@ -0,0 +1,7 @@
+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/mojang/GameProfile.java

@@ -1,84 +0,0 @@
-package io.github.retrooper.packetevents.mojang;
-
-import com.mojang.authlib.properties.PropertyMap;
-
-import java.util.UUID;
-
-public final class GameProfile {
-    private final UUID id;
-    private final String name;
-    private final PropertyMap properties = new PropertyMap();
-    private boolean legacy;
-
-    public GameProfile(UUID id, String name) {
-        if (id == null && name.isEmpty()) {
-            throw new IllegalArgumentException("Name and ID cannot both be blank");
-        } else {
-            this.id = id;
-            this.name = name;
-        }
-    }
-
-    public UUID getId() {
-        return this.id;
-    }
-
-    public String getName() {
-        return this.name;
-    }
-
-    public PropertyMap getProperties() {
-        return this.properties;
-    }
-
-    public boolean isComplete() {
-        return this.id != null && !getName().isEmpty();
-    }
-
-
-    public boolean isLegacy() {
-        return this.legacy;
-    }
-
-    public boolean equals(com.mojang.authlib.GameProfile profile) {
-        if (profile != null) {
-            return profile.getId() != null && getId() != null && profile.getId() == getId()
-                    && profile.getName() != null && getName() != null && profile.getName().equals(getName());
-        }
-        return false;
-    }
-
-    @Override
-    public boolean equals(Object o) {
-        if (this == o) {
-            return true;
-        } else if (o != null && this.getClass() == o.getClass()) {
-            GameProfile that = (GameProfile) o;
-            if (this.id != null) {
-                if (!this.id.equals(that.id)) {
-                    return false;
-                }
-            } else if (that.id != null) {
-                return false;
-            }
-
-            if (this.name != null) {
-                return this.name.equals(that.name);
-            } else return that.name == null;
-        } else {
-            return false;
-        }
-    }
-
-    @Override
-    public int hashCode() {
-        int result = this.id != null ? this.id.hashCode() : 0;
-        result = 31 * result + (this.name != null ? this.name.hashCode() : 0);
-        return result;
-    }
-
-    @Override
-    public String toString() {
-        return "id: " + id + ", name: " + name + ", legacy: " + legacy;
-    }
-}

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

@@ -1,178 +0,0 @@
-package io.github.retrooper.packetevents.packet;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-public final class PacketType {
-    private static final ServerVersion version = PacketEvents.getServerVersion();
-
-
-    public static final class Util {
-        private static Class<?> packetPlayInFlying, packetPlayInPosition, packetPlayInPositionLook, packetPlayInLook, packetPlayInUseEntity;
-
-        static {
-            try {
-                //Only exists in 1.7->1.8.8 & 1.16 protocol
-                packetPlayInFlying = NMSUtils.getNMSClass(Client.FLYING);
-            } catch (ClassNotFoundException e) {
-                //That is fine, they are on 1.9->1.15.2
-            }
-            try {
-                packetPlayInPosition = NMSUtils.getNMSClass(Client.POSITION);
-                packetPlayInPositionLook = NMSUtils.getNMSClass(Client.POSITION_LOOK);
-                packetPlayInLook = NMSUtils.getNMSClass(Client.LOOK);
-
-            } catch (ClassNotFoundException e) {
-                packetPlayInPosition = Reflection.getSubClass(packetPlayInFlying, Client.POSITION);
-                packetPlayInPositionLook = Reflection.getSubClass(packetPlayInFlying, Client.POSITION_LOOK);
-                packetPlayInLook = Reflection.getSubClass(packetPlayInFlying, Client.LOOK);
-            }
-
-            try {
-                packetPlayInUseEntity = NMSUtils.getNMSClass(Client.USE_ENTITY);
-            } catch (ClassNotFoundException e) {
-                e.printStackTrace();
-            }
-        }
-
-        /**
-         * Is this NMS packet an instance of the "PacketPlayInFlying" packet?
-         * Supports 1.9->1.15.2 too!
-         *
-         * @param nmsPacket
-         * @return If the nms packet provided is an instanceof the "PacketPlayInFlying" packet in the 1.8 protocol & 1.16 protocol!
-         */
-        public static boolean isInstanceOfFlyingPacket(final Object nmsPacket) {
-            //1.7->1.8.8
-            if (packetPlayInFlying != null) {
-                return packetPlayInFlying.isInstance(nmsPacket);
-            } else {
-                //1.9->1.15.2
-                return isInstanceOfPositionOrPositionLook(nmsPacket) || isInstanceOfPositionLookPacket(nmsPacket);
-            }
-        }
-
-        /**
-         * Is this NMS packet an instance of the "PacketPlayInPosition" packet?
-         *
-         * @param nmsPacket
-         * @return nmsPacket instanceof PacketPlayInPosition
-         */
-        public static boolean isInstanceOfPositionPacket(final Object nmsPacket) {
-            return packetPlayInPosition.isInstance(nmsPacket);
-        }
-
-        /**
-         * Is this NMS packet an instance of the "PacketPlayInPositionLook" packet?
-         *
-         * @param nmsPacket
-         * @return nmsPacket instanceof PacketPlayInPositionLook
-         */
-        public static boolean isInstanceOfPositionLookPacket(final Object nmsPacket) {
-            return packetPlayInPositionLook.isInstance(nmsPacket);
-        }
-
-        /**
-         * Is this NMS Packet an instanceof the "PacketPlayInPosition" or "PacketPlayInPositionLook"
-         *
-         * @param nmsPacket
-         * @return nmsPacket instanceof PacketPlayInPosition || nmsPacket instanceof PacketPlayInPositionLook
-         */
-        public static boolean isInstanceOfPositionOrPositionLook(final Object nmsPacket) {
-            return isInstanceOfPositionPacket(nmsPacket) || isInstanceOfPositionLookPacket(nmsPacket);
-        }
-
-        /**
-         * Is this NMS Packet an instance of the "PacketPlayInLook" packet?
-         *
-         * @param nmsPacket
-         * @return nmsPacket instanceof PacketPlayInLook
-         */
-        public static boolean isInstanceOfLook(final Object nmsPacket) {
-            return packetPlayInLook.isInstance(nmsPacket);
-        }
-
-        public static boolean isInstanceOfUseEntity(final Object nmsPacket) {
-            return packetPlayInUseEntity.isInstance(nmsPacket);
-        }
-    }
-
-    public static final class Client {
-        private static final String c = "PacketPlayIn";
-        /*
-         * Only exists in 1.7.10->1.8.8 & 1.16+
-         */
-        public static final String FLYING = c + "Flying";
-
-
-        public static final String POSITION = c + "Position";
-
-        public static final String POSITION_LOOK = c + "PositionLook";
-
-        public static final String LOOK = c + "Look";
-        public static final String CLIENT_COMMAND = c + "ClientCommand";
-
-        public static final String TRANSACTION = c + "Transaction";
-        public static final String BLOCK_DIG = c + "BlockDig";
-        public static final String ENTITY_ACTION = c + "EntityAction";
-        public static final String USE_ENTITY = c + "UseEntity";
-        public static final String WINDOW_CLICK = c + "WindowClick";
-        public static final String STEER_VEHICLE = c + "SteerVehicle";
-        public static final String CUSTOM_PAYLOAD = c + "CustomPayload";
-        public static final String ARM_ANIMATION = c + "ArmAnimation";
-        /**
-         * The packet name of the block place depending on your server version, "PacketPlayInBlockPlace" or "PacketPlayInUseItem"
-         */
-        public static final String BLOCK_PLACE = c + ((ServerVersion.getVersion().isHigherThan(ServerVersion.v_1_8_8)) ? "UseItem" : "BlockPlace");
-
-        public static final String ABILITIES = c + "Abilities";
-        public static final String HELD_ITEM_SLOT = c + "HeldItemSlot";
-        public static final String CLOSE_WINDOW = c + "CloseWindow";
-        public static final String TAB_COMPLETE = c + "TabComplete";
-        public static final String CHAT = c + "Chat";
-        public static final String SET_CREATIVE_SLOT = c + "SetCreativeSlot";
-
-        public static final String KEEP_ALIVE = c + "KeepAlive";
-    }
-
-    public static final class Server {
-        private static final String s = "PacketPlayOut";
-
-        public static final String ANIMATION = s + "Animation";
-        public static final String KEEP_ALIVE = s + "KeepAlive";
-        public static final String CHAT = s + "Chat";
-        public static final String POSITION = s + "Position";
-        public static final String TRANSACTION = s + "Transaction";
-        public static final String NAMED_ENTITY_SPAWN = s + "NamedEntitySpawn";
-        public static final String SPAWN_ENTITY_LIVING = s + "SpawnEntityLiving";
-        public static final String SPAWN_ENTITY = s + "SpawnEntity";
-        public static final String CUSTOM_PAYLOAD = s + "CustomPayload";
-        public static final String ABILITIES = s + "Abilities";
-        public static final String ENTITY_METADATA = s + "EntityMetadata";
-        public static final String ENTITY_VELOCITY = s + "EntityVelocity";
-        public static final String ENTITY_DESTROY = s + "EntityDestroy";
-        public static final String ENTITY_HEAD_ROTATION = s + "EntityHeadRotation";
-        public static final String BLOCK_CHANGE = s + "BlockChange";
-        public static final String CLOSE_WINDOW = s + "CloseWindow";
-        public static final String HELD_ITEM_SLOT = s + "HeldItemSlot";
-        public static final String TAB_COMPLETE = s + "TabComplete";
-        public static final String RESPAWN = s + "Respawn";
-        public static final String WORLD_PARTICLES = s + "WorldParticles";
-        public static final String COMMANDS = s + "Commands";
-        public static final String OPEN_WINDOW = s + "OpenWindow";
-        public static final String LOGIN = s + "Login";
-        public static final String SERVER_DIFFICULTY = s + "ServerDifficulty";
-    }
-
-    public static final class Login {
-        public static final String HANDSHAKE = "PacketHandshakingInSetProtocol";
-        public static final String PING = "PacketStatusInPing";
-        public static final String START = "PacketStatusInStart";
-        public static final String SUCCESS = "PacketLoginOutSuccess";
-        public static final String ENCRYPTION_BEGIN_IN = "PacketLoginInEncryptionBegin";
-        public static final String ENCRYPTION_BEGIN_OUT = "PacketLoginOutEncryptionBegin";
-    }
-
-}

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

@@ -0,0 +1,437 @@
+/*
+ * 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.packettype;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.utils.server.ServerVersion;
+
+import java.util.HashMap;
+import java.util.Map;
+
+/**
+ * Packet Type IDs.
+ * This is the Packet ID system, it is recommended to use this over packet comparisons by packet name.
+ * This is also faster than comparing packet names.
+ *
+ * @author retrooper
+ * @since 1.6.8
+ */
+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;
+    /**
+     * Status Packet IDs.
+     *
+     * @author retrooper
+     * @see <a href="https://wiki.vg/Protocol#Status">https://wiki.vg/Protocol#Status</a>
+     * @since 1.7
+     */
+    public static class Status {
+        /**
+         * Server-bound (client-sided) Status Packet IDs.
+         *
+         * @author retrooper
+         * @see <a href="https://wiki.vg/Protocol#Serverbound_2">https://wiki.vg/Protocol#Serverbound_2</a>
+         * @since 1.8
+         */
+        public static class Client {
+            public static final byte START = 0, PING = 1;
+            public static final Map<Class<?>, Byte> packetIds = new HashMap<>();
+
+            /**
+             * 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);
+            }
+        }
+
+        /**
+         * Client-bound (server-sided) Status Packet IDs.
+         *
+         * @author retrooper
+         * @see <a href="https://wiki.vg/Protocol#Clientbound_2">https://wiki.vg/Protocol#Clientbound_2</a>
+         * @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<>();
+
+            /**
+             * 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);
+            }
+        }
+    }
+
+    /**
+     * Login Packet IDs.
+     *
+     * @author retrooper
+     * @see <a href="https://wiki.vg/Protocol#Login">https://wiki.vg/Protocol#Login</a>
+     * @since 1.7
+     */
+    public static class Login {
+        /**
+         * Server-bound (client-sided) Login Packet IDs.
+         *
+         * @author retrooper
+         * @see <a href="https://wiki.vg/Protocol#Serverbound_3">https://wiki.vg/Protocol#Serverbound_3</a>
+         * @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;
+
+            /**
+             * 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);
+            }
+        }
+
+        /**
+         * Client-bound (server-sided) Login Packet IDs.
+         *
+         * @author retrooper
+         * @see <a href="https://wiki.vg/Protocol#Clientbound_3">https://wiki.vg/Protocol#Clientbound_3</a>
+         * @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;
+
+            /**
+             * 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);
+            }
+        }
+    }
+
+    /**
+     * Play Packet IDs.
+     *
+     * @author retrooper
+     * @see <a href="https://wiki.vg/Protocol#Play">https://wiki.vg/Protocol#Play</a>
+     * @since 1.8
+     */
+    public static class Play {
+        /**
+         * Server-bound (client-sided) Play Packet IDs.
+         *
+         * @author retrooper
+         * @see <a href="https://wiki.vg/Protocol#Serverbound_4">https://wiki.vg/Protocol#Serverbound_4</a>
+         * @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;
+
+            /**
+             * 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);
+            }
+
+            /**
+             * Server-bound Play Packet Type utility.
+             * Save a few lines of code by using this.
+             *
+             * @author retrooper
+             * @since 1.8
+             */
+            public static class Util {
+                /**
+                 * Is the play packet a PacketPlayInFlying, PacketPlayInPosition, PacketPlayInPositionLook
+                 * or a PacketPlayInLook packet?
+                 *
+                 * @param packetID Play Packet ID.
+                 * @return Is the Packet ID an instance of the PacketPlayInFlying packet?
+                 */
+                public static boolean isInstanceOfFlying(final byte packetID) {
+                    return packetID == FLYING
+                            || packetID == POSITION
+                            || packetID == POSITION_LOOK
+                            || packetID == LOOK;
+                }
+
+                /**
+                 * Is this the packet where the client places a block?
+                 * On 1.7.10 - 1.8.8 the client sends a PacketPlayInBlockPlace packet when actually placing the block.
+                 * On 1.9 - now the client sends a PacketPlayInUseItem packet when placing the block and the
+                 * PacketPlayInBlockPlace has a different use.
+                 * This method is a nice utility supporting all these versions letting you know
+                 * if the client played a block.
+                 * The {@link io.github.retrooper.packetevents.packetwrappers.play.in.blockplace.WrappedPacketInBlockPlace} wrapper
+                 * only works on an actual block place.
+                 * Use this method before using the wrapper to support all minecraft versions.
+                 *
+                 * @param packetID Play Packet ID.
+                 * @return Has the client placed a block?
+                 */
+                public static boolean isBlockPlace(final byte packetID) {
+                    final ServerVersion version = PacketEvents.get().getServerUtils().getVersion();
+                    return version.isNewerThan(ServerVersion.v_1_8_8) ?
+                            packetID == Client.USE_ITEM
+                            : packetID == Client.BLOCK_PLACE;
+                }
+            }
+        }
+
+        /**
+         * Client-bound (server-sided) Play Packet IDs.
+         *
+         * @author retrooper
+         * @see <a href="https://wiki.vg/Protocol#Clientbound_4">https://wiki.vg/Protocol#Clientbound_4</a>
+         * @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;
+
+            /**
+             * 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);
+            }
+
+            /**
+             * Client-bound Play Packet Type utility.
+             * Save a few lines of code by using this.
+             *
+             * @author retrooper
+             * @since 1.8
+             */
+            public static class Util {
+                /**
+                 * Is the play packet a PacketPlayOutEntity, PacketPlayOutRelEntityMove, PacketPlayOutRelEntityMoveLook
+                 * or a PacketPlayOutEntityLook packet?
+                 *
+                 * @param packetID Play Packet ID.
+                 * @return Is the Packet ID an instance of the PacketPlayOutEntity packet?
+                 */
+                public static boolean isInstanceOfEntity(final byte packetID) {
+                    return packetID == ENTITY || packetID == REL_ENTITY_MOVE ||
+                            packetID == REL_ENTITY_MOVE_LOOK || packetID == ENTITY_LOOK;
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,319 @@
+/*
+ * 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.packettype;
+
+import io.github.retrooper.packetevents.utils.nms.NMSUtils;
+import io.github.retrooper.packetevents.utils.reflection.SubclassUtil;
+
+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();
+    }
+
+    public static class Status {
+        public static class Client {
+            public static Class<?> START, PING;
+
+            public static void load() {
+                Client.START = NMSUtils.getNMSClassWithoutException("PacketStatusInStart");
+                Client.PING = NMSUtils.getNMSClassWithoutException("PacketStatusInPing");
+                PacketType.Status.Client.init();
+            }
+        }
+
+        public static class Server {
+            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();
+            }
+        }
+    }
+
+    public static class Login {
+        public static class Client {
+            public static Class<?> HANDSHAKE, 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();
+            }
+        }
+
+        public static class Server {
+            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();
+            }
+        }
+    }
+
+    public static class Play {
+        public static class Client {
+            private static final String PREFIX = "PacketPlayIn";
+            public static Class<?> FLYING, POSITION, POSITION_LOOK, LOOK, 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,
+                    CLOSE_WINDOW, TAB_COMPLETE, CHAT, SET_CREATIVE_SLOT,
+                    KEEP_ALIVE, SETTINGS, ENCHANT_ITEM, TELEPORT_ACCEPT,
+                    TILE_NBT_QUERY, DIFFICULTY_CHANGE, B_EDIT, ENTITY_NBT_QUERY,
+                    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;
+
+            /**
+             * 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");
+                }
+
+                try {
+                    SETTINGS = NMSUtils.getNMSClass(PREFIX + "Settings");
+                    ENCHANT_ITEM = NMSUtils.getNMSClass(PREFIX + "EnchantItem");
+
+                    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");
+
+                    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");
+                    //1.8+
+                    RESOURCE_PACK_STATUS = NMSUtils.getNMSClassWithoutException(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) {
+                    e.printStackTrace();
+                }
+
+                try {
+                    BLOCK_PLACE = NMSUtils.getNMSClass(PREFIX + "BlockPlace");
+                    USE_ITEM = NMSUtils.getNMSClass(PREFIX + "UseItem");
+                } catch (ClassNotFoundException ignored) {
+                }
+
+                PacketType.Play.Client.init();
+            }
+        }
+
+        public static class Server {
+            private static final String s = "PacketPlayOut";
+            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,
+                    BLOCK_CHANGE, BOSS, SERVER_DIFFICULTY, CHAT, MULTI_BLOCK_CHANGE,
+                    TAB_COMPLETE, COMMANDS, TRANSACTION, CLOSE_WINDOW,
+                    WINDOW_ITEMS, WINDOW_DATA, SET_SLOT, SET_COOLDOWN,
+                    CUSTOM_PAYLOAD, CUSTOM_SOUND_EFFECT, KICK_DISCONNECT, ENTITY_STATUS,
+                    EXPLOSION, UNLOAD_CHUNK, GAME_STATE_CHANGE, OPEN_WINDOW_HORSE,
+                    KEEP_ALIVE, MAP_CHUNK, WORLD_EVENT, WORLD_PARTICLES,
+                    LIGHT_UPDATE, LOGIN, MAP, OPEN_WINDOW_MERCHANT,
+                    REL_ENTITY_MOVE, REL_ENTITY_MOVE_LOOK, ENTITY_LOOK, ENTITY,
+                    VEHICLE_MOVE, OPEN_BOOK, OPEN_WINDOW, OPEN_SIGN_EDITOR,
+                    AUTO_RECIPE, ABILITIES, COMBAT_EVENT, PLAYER_INFO,
+                    LOOK_AT, POSITION, RECIPES, ENTITY_DESTROY,
+                    REMOVE_ENTITY_EFFECT, RESOURCE_PACK_SEND, RESPAWN, ENTITY_HEAD_ROTATION,
+                    SELECT_ADVANCEMENT_TAB, WORLD_BORDER, CAMERA, HELD_ITEM_SLOT,
+                    VIEW_CENTRE, VIEW_DISTANCE, SCOREBOARD_DISPLAY_OBJECTIVE, ENTITY_METADATA,
+                    ATTACH_ENTITY, ENTITY_VELOCITY, ENTITY_EQUIPMENT, EXPERIENCE,
+                    UPDATE_HEALTH, SCOREBOARD_OBJECTIVE, MOUNT, SCOREBOARD_TEAM,
+                    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;
+
+            /**
+             * 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 (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");
+                }
+                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

@@ -0,0 +1,43 @@
+/*
+ * 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;
+
+import io.github.retrooper.packetevents.utils.reflection.ClassUtil;
+
+public class NMSPacket {
+    private final Object rawNMSPacket;
+
+    public NMSPacket(Object rawNMSPacket) {
+        this.rawNMSPacket = rawNMSPacket;
+    }
+
+    public Object getRawNMSPacket() {
+        return rawNMSPacket;
+    }
+
+    public String getName() {
+        return ClassUtil.getClassSimpleName(rawNMSPacket.getClass());
+    }
+}

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

@@ -1,5 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers;
-
-public interface Sendable {
-    Object asNMSPacket();
-}

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

@@ -0,0 +1,32 @@
+/*
+ * 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

@@ -0,0 +1,306 @@
+/*
+ * 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;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.event.annotation.PacketHandler;
+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.utils.reflection.ClassUtil;
+import io.github.retrooper.packetevents.utils.server.ServerVersion;
+
+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.*;
+import java.util.concurrent.ConcurrentHashMap;
+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];
+    public static ServerVersion version;
+    protected NMSPacket packet;
+    private final Class<?> packetClass;
+
+    public WrappedPacket() {
+        packet = null;
+        packetClass = null;
+        load0();
+    }
+
+    public WrappedPacket(final NMSPacket packet) {
+        this(packet, packet.getRawNMSPacket().getClass());
+    }
+
+    public WrappedPacket(final NMSPacket packet, Class<?> packetClass) {
+        if (packetClass.getSuperclass().equals(PacketTypeClasses.Play.Client.FLYING)) {
+            packetClass = PacketTypeClasses.Play.Client.FLYING;
+        } else if (packetClass.getSuperclass().equals(PacketTypeClasses.Play.Server.ENTITY)) {
+            packetClass = PacketTypeClasses.Play.Server.ENTITY;
+        }
+        this.packetClass = packetClass;
+        this.packet = packet;
+        load0();
+    }
+
+    private void load0() {
+        if (!isSupported()) {
+            throw new WrapperUnsupportedUsageException(getClass());
+        }
+        final Class<? extends WrappedPacket> clazz = getClass();
+        if (!LOADED_WRAPPERS.containsKey(clazz)) {
+            try {
+                load();
+            }
+            catch (Exception ex) {
+                String wrapperName = ClassUtil.getClassSimpleName(getClass());
+                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, true);
+        }
+    }
+
+    protected void load() {
+
+    }
+
+
+    @Override
+    public boolean readBoolean(int index) {
+        return read(index, boolean.class);
+    }
+
+    @Override
+    public byte readByte(int index) {
+        return read(index, byte.class);
+    }
+
+    @Override
+    public short readShort(int index) {
+        return read(index, short.class);
+    }
+
+    @Override
+    public int readInt(int index) {
+        return read(index, int.class);
+    }
+
+    @Override
+    public long readLong(int index) {
+        return read(index, long.class);
+    }
+
+    @Override
+    public float readFloat(int index) {
+        return read(index, float.class);
+    }
+
+    @Override
+    public double readDouble(int index) {
+        return read(index, double.class);
+    }
+
+    @Override
+    public boolean[] readBooleanArray(int index) {
+        return read(index, boolean[].class);
+    }
+
+    @Override
+    public byte[] readByteArray(int index) {
+        return read(index, byte[].class);
+    }
+
+    @Override
+    public short[] readShortArray(int index) {
+        return read(index, short[].class);
+    }
+
+    @Override
+    public int[] readIntArray(int index) {
+        return read(index, int[].class);
+    }
+
+    @Override
+    public long[] readLongArray(int index) {
+        return read(index, long[].class);
+    }
+
+    @Override
+    public float[] readFloatArray(int index) {
+        return read(index, float[].class);
+    }
+
+    @Override
+    public double[] readDoubleArray(int index) {
+        return read(index, double[].class);
+    }
+
+    @Override
+    public String[] readStringArray(int index) {
+        return read(index, String[].class); // JavaImpact: Can we be sure that returning the original array is okay? retrooper: Yes
+    }
+
+    @Override
+    public String readString(int index) {
+        return read(index, String.class);
+    }
+
+    public Object readAnyObject(int index) {
+        try {
+            Field f = packetClass.getDeclaredFields()[index];
+            if (!f.isAccessible()) {
+                f.setAccessible(true);
+            }
+            try {
+                return f.get(packet.getRawNMSPacket());
+            } catch (IllegalAccessException | NullPointerException | ArrayIndexOutOfBoundsException e) {
+                e.printStackTrace();
+            }
+        } catch (ArrayIndexOutOfBoundsException e) {
+            throw new WrapperFieldNotFoundException("PacketEvents failed to find any field indexed " + index + " in the " + ClassUtil.getClassSimpleName(packetClass) + " class!");
+        }
+        return null;
+    }
+
+    public Object readObject(int index, Class<?> type) {
+        return read(index, type);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <T> T read(int index, Class<? extends T> type) {
+        Field field = getField(type, index);
+        try {
+            return (T) field.get(packet.getRawNMSPacket());
+        } catch (IllegalAccessException | NullPointerException e) {
+            throw new WrapperFieldNotFoundException(packetClass, type, index);
+        }
+    }
+
+    @Override
+    public void writeBoolean(int index, boolean value) {
+        write(boolean.class, index, value);
+    }
+
+    @Override
+    public void writeByte(int index, byte value) {
+        write(byte.class, index, value);
+    }
+
+    @Override
+    public void writeShort(int index, short value) {
+        write(short.class, index, value);
+    }
+
+    @Override
+    public void writeInt(int index, int value) {
+        write(int.class, index, value);
+    }
+
+    @Override
+    public void writeLong(int index, long value) {
+        write(long.class, index, value);
+    }
+
+    @Override
+    public void writeFloat(int index, float value) {
+        write(float.class, index, value);
+    }
+
+    @Override
+    public void writeDouble(int index, double value) {
+        write(double.class, index, value);
+    }
+
+    @Override
+    public void writeString(int index, String value) {
+        write(String.class, index, value);
+    }
+
+    @Override
+    public void writeObject(int index, Object value) {
+        write(value.getClass(), index, value);
+    }
+
+    public void write(Class<?> type, int index, Object value) throws WrapperFieldNotFoundException {
+        Field field = getField(type, index);
+        if (field == null) {
+            throw new WrapperFieldNotFoundException(packetClass, type, index);
+        }
+        try {
+            field.set(packet.getRawNMSPacket(), value);
+        } catch (IllegalAccessException | NullPointerException e) {
+            e.printStackTrace();
+        }
+    }
+
+    private Field getField(Class<?> type, int index) {
+        Map<Class<?>, Field[]> cached = FIELD_CACHE.computeIfAbsent(packetClass, k -> new HashMap<>());
+        Field[] fields = cached.computeIfAbsent(type, typeClass -> getFields(typeClass, packetClass.getDeclaredFields()));
+        return fields[index];
+    }
+
+    private Field[] getFields(Class<?> type, Field[] fields) {
+        List<Field> ret = new ArrayList<>();
+        for (Field field : fields) {
+            if (field.getType().equals(type)) {
+                if (!field.isAccessible()) {
+                    field.setAccessible(true);
+                }
+                ret.add(field);
+            }
+        }
+        return ret.toArray(EMPTY_FIELD_ARRAY);
+    }
+
+    /**
+     * 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})
+    @Retention(RetentionPolicy.RUNTIME)
+    public @interface SupportedVersions {
+        ServerVersion[] versions() default {};
+    }
+}

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

@@ -0,0 +1,64 @@
+/*
+ * 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

@@ -0,0 +1,47 @@
+/*
+ * 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/WrappedPacket.java

@@ -1,37 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.api;
-
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import org.bukkit.entity.Player;
-
-public class WrappedPacket {
-    protected static ServerVersion version = ServerVersion.getVersion();
-    protected final Player player;
-    protected Object packet;
-
-    public WrappedPacket(final Object packet) {
-        this.player = null;
-        if (packet == null) return;
-        this.packet = packet;
-        try {
-            setup();
-        } catch (final Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    public WrappedPacket(final Player player, final Object packet) {
-        this.player = player;
-        if (packet == null) return;
-        this.packet = packet;
-        try {
-            setup();
-        } catch (final Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-    protected void setup() {
-
-    }
-
-}

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

@@ -1,67 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.abilities;
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-public final class WrappedPacketInAbilities extends WrappedPacket {
-    private static Class<?> abilitiesClass;
-
-    static {
-
-        try {
-            abilitiesClass = NMSUtils.getNMSClass("PacketPlayInAbilities");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private boolean isVulnerable;
-    private boolean isFlying;
-    private boolean allowFly;
-    private boolean instantBuild;
-    private float flySpeed;
-    private float walkSpeed;
-
-    public WrappedPacketInAbilities(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        try {
-            this.isVulnerable = Reflection.getField(abilitiesClass, boolean.class, 0).getBoolean(packet);
-            this.isFlying = Reflection.getField(abilitiesClass, boolean.class, 1).getBoolean(packet);
-            this.allowFly = Reflection.getField(abilitiesClass, boolean.class, 2).getBoolean(packet);
-            this.instantBuild = Reflection.getField(abilitiesClass, boolean.class, 3).getBoolean(packet);
-            this.flySpeed = Reflection.getField(abilitiesClass, float.class, 0).getFloat(packet);
-            this.walkSpeed = Reflection.getField(abilitiesClass, float.class, 1).getFloat(packet);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public boolean isVulnerable() {
-        return isVulnerable;
-    }
-
-    public boolean isFlying() {
-        return isFlying;
-    }
-
-    public boolean isFlightAllowed() {
-        return allowFly;
-    }
-
-    public boolean canInstantlyBuild() {
-        return instantBuild;
-    }
-
-    public float getFlySpeed() {
-        return flySpeed;
-    }
-
-    public float getWalkSpeed() {
-        return walkSpeed;
-    }
-}

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

@@ -1,97 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.blockdig;
-
-import io.github.retrooper.packetevents.enums.Direction;
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.enums.minecraft.PlayerDigType;
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-import io.github.retrooper.packetevents.utils.vector.Vector3i;
-import net.minecraft.server.v1_8_R3.PacketPlayInBlockDig;
-import org.bukkit.block.Block;
-
-import java.lang.reflect.Field;
-
-public final class WrappedPacketInBlockDig extends WrappedPacket {
-    private static Class<?> blockDigClass, blockPositionClass, enumDirectionClass, digTypeClass;
-
-    static {
-
-        try {
-            blockDigClass = NMSUtils.getNMSClass("PacketPlayInBlockDig");
-            if (version.isHigherThan(ServerVersion.v_1_7_10)) {
-                blockPositionClass = NMSUtils.getNMSClass("BlockPosition");
-                enumDirectionClass = NMSUtils.getNMSClass("EnumDirection");
-            }
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-
-        try {
-            digTypeClass = NMSUtils.getNMSClass("EnumPlayerDigType");
-        }
-        catch(ClassNotFoundException e) {
-            //It is probably a subclass
-            digTypeClass = Reflection.getSubClass(blockDigClass, "EnumPlayerDigType");
-        }
-    }
-
-    private Vector3i blockPosition;
-    private Direction direction;
-    private PlayerDigType digType;
-
-    public WrappedPacketInBlockDig(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        Direction enumDirection = null;
-        PlayerDigType enumDigType = null;
-        //1.7.10
-        try {
-            if (version.isLowerThan(ServerVersion.v_1_8)) {
-                setupCoordinates(blockDigClass, packet);
-                enumDirection = Direction.get(Reflection.getField(digTypeClass, int.class, 3).getInt(packet));
-                enumDigType = PlayerDigType.get(Reflection.getField(digTypeClass, int.class, 4).getInt(packet));
-            } else {
-                //1.8+
-                final Object blockPosObj = Reflection.getField(blockDigClass, blockPositionClass, 0).get(packet);
-                final Object enumDirectionObj = Reflection.getField(blockDigClass, enumDirectionClass, 0).get(packet);
-                final Object digTypeObj = Reflection.getField(blockDigClass, digTypeClass, 0).get(packet);
-
-                Class<?> blockPosSuper = blockPositionClass;
-                setupCoordinates(blockPosSuper, blockPosObj);
-
-                enumDirection = Direction.valueOf(((Enum) enumDirectionObj).name());
-                enumDigType = PlayerDigType.valueOf(((Enum) digTypeObj).name());
-            }
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        this.direction = enumDirection;
-        this.digType = enumDigType;
-    }
-
-    private void setupCoordinates(final Class<?> cls, final Object object) throws IllegalAccessException {
-        final int x = Reflection.getField(cls, int.class, 0).getInt(object);
-        final int y = Reflection.getField(cls, int.class, 1).getInt(object);
-        final int z = Reflection.getField(cls, int.class, 2).getInt(object);
-
-        this.blockPosition = new Vector3i(x, y, z);
-    }
-
-    public Vector3i getBlockPosition() {
-        return blockPosition;
-    }
-
-    public Direction getDirection() {
-        return direction;
-    }
-
-    public PlayerDigType getDigType() {
-        return digType;
-    }
-
-
-}

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

@@ -1,64 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.blockplace;
-
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.utils.vector.Vector3i;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-
-
-public final class WrappedPacketInBlockPlace extends WrappedPacket {
-    static {
-        if (version.isHigherThan(ServerVersion.v_1_7_10)) {
-            WrappedPacketInBlockPlace_1_8.initStatic();
-        }
-    }
-
-    private Vector3i blockPosition;
-    private ItemStack itemStack;
-
-    public WrappedPacketInBlockPlace(final Player player, final Object packet) {
-        super(player, packet);
-    }
-
-    @Override
-    protected void setup() {
-        //1.7.10
-        Vector3i position = null;
-        ItemStack itemStack = null;
-        try {
-            if (version.isHigherThan(ServerVersion.v_1_8_8)) {
-                final WrappedPacketInBlockPlace_1_9 blockPlace_1_9 = new WrappedPacketInBlockPlace_1_9(getPlayer(), packet);
-                final Block block = blockPlace_1_9.getBlock();
-                position = new Vector3i(block.getX(), block.getY(), block.getZ());
-                itemStack = new ItemStack(block.getType());
-            } else if (version.isHigherThan(ServerVersion.v_1_7_10)) {
-                final WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
-                position = blockPlace_1_8.getBlockPosition();
-                itemStack = blockPlace_1_8.getItemStack();
-            } else {
-                final WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(getPlayer(), packet);
-                position = blockPlace_1_7_10.getBlockPosition();
-                this.itemStack = blockPlace_1_7_10.getItemStack();
-            }
-        } catch (IllegalArgumentException e) {
-            e.printStackTrace();
-        }
-        this.blockPosition = position;
-        this.itemStack = itemStack;
-    }
-
-    public Player getPlayer() {
-        return this.player;
-    }
-
-    public Vector3i getBlockPosition() {
-        return blockPosition;
-    }
-
-    public ItemStack getItemStack() {
-        return itemStack;
-    }
-
-}

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

@@ -1,42 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.blockplace;
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.utils.vector.Vector3i;
-import net.minecraft.server.v1_7_R4.PacketPlayInBlockPlace;
-import org.bukkit.entity.Player;
-import org.bukkit.inventory.ItemStack;
-
-final class WrappedPacketInBlockPlace_1_7_10 extends WrappedPacket {
-    private Vector3i blockPosition;
-    private ItemStack itemStack;
-    private int blockFace;
-
-    WrappedPacketInBlockPlace_1_7_10(final Player player, final Object packet) {
-        super(player, packet);
-    }
-
-
-    @Override
-    protected void setup() {
-        final PacketPlayInBlockPlace blockPlace = (PacketPlayInBlockPlace) packet;
-
-        this.blockPosition = new Vector3i(blockPlace.c(), blockPlace.d(), blockPlace.e());
-
-        this.blockFace = blockPlace.d();
-
-        net.minecraft.server.v1_7_R4.ItemStack stack = blockPlace.getItemStack();
-        this.itemStack = org.bukkit.craftbukkit.v1_7_R4.inventory.CraftItemStack.asBukkitCopy(stack);
-    }
-
-    public Vector3i getBlockPosition() {
-        return blockPosition;
-    }
-
-    public ItemStack getItemStack() {
-        return itemStack;
-    }
-
-    public int getBlockFace() {
-        return blockFace;
-    }
-}

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

@@ -1,56 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.blockplace;
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-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 static Class<?> blockPlaceClass, blockPositionClass;
-    private Vector3i blockPosition;
-    private ItemStack itemStack;
-
-    WrappedPacketInBlockPlace_1_8(final Object packet) {
-        super(packet);
-    }
-
-    protected static void initStatic() {
-        try {
-            blockPlaceClass = NMSUtils.getNMSClass("PacketPlayInBlockPlace");
-
-            blockPositionClass = NMSUtils.getNMSClass("BlockPosition");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-    }
-
-    @Override
-    protected void setup() {
-        try {
-            Object nmsBlockPos = Reflection.getField(blockPlaceClass, blockPositionClass, 1).get(packet);
-
-            final int[] coords = new int[3];
-            for (int i = 0; i < 3; i++) {
-                final String s = "get" + (i == 0 ? "X" : i == 1 ? "Y" : "Z");
-                coords[i] = (int) Reflection.getMethod(blockPositionClass.getSuperclass(), s, 0).invoke(nmsBlockPos);
-            }
-
-            this.blockPosition = new Vector3i(coords[0], coords[1], coords[2]);
-
-            this.itemStack = NMSUtils.toBukkitItemStack(Reflection.getField(blockPlaceClass, NMSUtils.nmsItemStackClass, 0).get(packet));
-        } catch (IllegalAccessException | InvocationTargetException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public Vector3i getBlockPosition() {
-        return blockPosition;
-    }
-
-    public ItemStack getItemStack() {
-        return itemStack;
-    }
-}

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

@@ -1,37 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.blockplace;
-
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.BlockIteratorUtils;
-import org.bukkit.Material;
-import org.bukkit.block.Block;
-import org.bukkit.entity.Player;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-import java.util.HashSet;
-
-final class WrappedPacketInBlockPlace_1_9 extends WrappedPacket {
-    private Block block;
-
-    public WrappedPacketInBlockPlace_1_9(final Player player, final Object packet) {
-        super(player, packet);
-    }
-
-
-    @Override
-    protected void setup() {
-       this.block = BlockIteratorUtils.getBlockLookingAt(getPlayer(), 3);
-    }
-
-    public Player getPlayer() {
-        return this.player;
-    }
-
-    public Block getBlock() {
-        return block;
-    }
-
-
-}

src/main/java/io/github/retrooper/packetevents/packetwrappers/in/chat/WrappedPacketInChat.java

@@ -1,38 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.chat;
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-public final class WrappedPacketInChat extends WrappedPacket {
-    private static Class<?> chatPacketClass;
-
-    static {
-        try {
-            chatPacketClass = NMSUtils.getNMSClass("PacketPlayInChat");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private String message;
-
-    public WrappedPacketInChat(Object packet) {
-        super(packet);
-    }
-
-
-    @Override
-    protected void setup() {
-        try {
-            final Object obj = Reflection.getField(chatPacketClass, String.class, 0).get(packet);
-            this.message = obj.toString();
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public String getMessage() {
-        return message;
-    }
-}

src/main/java/io/github/retrooper/packetevents/packetwrappers/in/entityaction/WrappedPacketInEntityAction.java

@@ -1,93 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.entityaction;
-
-import io.github.retrooper.packetevents.annotations.Nullable;
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.enums.minecraft.PlayerAction;
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-import org.bukkit.entity.Entity;
-
-public final class WrappedPacketInEntityAction extends WrappedPacket {
-    private static Class<?> entityActionClass;
-    @Nullable
-    private static Class<?> enumPlayerActionClass;
-    static {
-        try {
-            entityActionClass = NMSUtils.getNMSClass("PacketPlayInEntityAction");
-            if (version.isHigherThan(ServerVersion.v_1_7_10)) {
-                for (final Class<?> sub : entityActionClass.getDeclaredClasses()) {
-                    if (sub.getSimpleName().equals("EnumPlayerAction")) {
-                        enumPlayerActionClass = sub;
-                        break;
-                    }
-                }
-            } 
-            else {
-               enumPlayerActionClass = NMSUtils.getNMSClass("EnumPlayerAction");
-            } 
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private Entity entity;
-    private int entityId;
-    private PlayerAction action;
-    private int jumpBoost;
-
-    public WrappedPacketInEntityAction(final Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        try {
-            final int entityId = Reflection.getField(entityActionClass, int.class, 0).getInt(packet);
-            final int jumpBoost;
-            if(version.isLowerThan(ServerVersion.v_1_8)) {
-                jumpBoost = Reflection.getField(entityActionClass, int.class, 2).getInt(packet)
-            }
-            else {
-                jumpBoost = Reflection.getField(entityActionClass, int.class, 1).getInt(packet)
-            }
-
-            int animationIndex = -1;
-
-            //1.7.10
-            if (version.isLowerThan(ServerVersion.v_1_8)) {
-                animationIndex = Reflection.getField(entityActionClass, int.class, 1).getInt(packet);
-            } else {
-                final Object enumObj = Reflection.getField(entityActionClass, enumPlayerActionClass, 0).get(packet);
-                 
-                this.action = PlayerAction.valueOf(enumObj.toString());
-            }
-
-
-            this.entityId = entityId;
-            this.jumpBoost = jumpBoost;
-            if(animationIndex != -1) {
-                this.action = PlayerAction.get(animationIndex);
-            }
-            this.entity = NMSUtils.getEntityById(this.entityId);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public Entity getEntity() {
-        return entity;
-    }
-
-    public int getEntityId() {
-        return entityId;
-    }
-
-    public PlayerAction getAction() {
-        return action;
-    }
-
-    public int getJumpBoost() {
-        return jumpBoost;
-    }
-}

src/main/java/io/github/retrooper/packetevents/packetwrappers/in/flying/WrappedPacketInFlying.java

@@ -1,163 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.flying;
-
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-public class WrappedPacketInFlying extends WrappedPacket {
-    private static Class<?> flyingClass;
-
-    static {
-
-        try {
-            flyingClass = NMSUtils.getNMSClass("PacketPlayInFlying");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private double x;
-    private double y;
-    private double z;
-    private float yaw;
-    private float pitch;
-    private boolean onGround;
-    private boolean isPosition;
-    private boolean isLook;
-
-    public WrappedPacketInFlying(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        try {
-            //x, y, z, yaw pitch, onGround, isPosition, isLook
-            this.x = Reflection.getField(flyingClass, double.class, 0).getDouble(packet);
-            this.y = Reflection.getField(flyingClass, double.class, 1).getDouble(packet);
-            this.z = Reflection.getField(flyingClass, double.class, 2).getDouble(packet);
-
-            this.yaw = Reflection.getField(flyingClass, float.class, 0).getFloat(packet);
-            this.pitch = Reflection.getField(flyingClass, float.class, 1).getFloat(packet);
-
-            this.onGround = Reflection.getField(flyingClass, boolean.class, 0).getBoolean(packet);
-
-            this.isPosition = Reflection.getField(flyingClass, boolean.class, 1).getBoolean(packet);
-            this.isLook = Reflection.getField(flyingClass, boolean.class, 2).getBoolean(packet);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public final double getX() {
-        return x;
-    }
-
-    public final double getY() {
-        return y;
-    }
-
-    public final double getZ() {
-        return z;
-    }
-
-    public final float getYaw() {
-        return yaw;
-    }
-
-    public final float getPitch() {
-        return pitch;
-    }
-
-    public final boolean isOnGround() {
-        return onGround;
-    }
-
-    public boolean isPosition() {
-        return isPosition;
-    }
-
-    public boolean isLook() {
-        return isLook;
-    }
-
-    public static class WrappedPacketInPosition extends WrappedPacketInFlying {
-        public WrappedPacketInPosition(Object packet) {
-            super(packet);
-        }
-
-        @Override
-        public boolean isPosition() {
-            try {
-                return Reflection.getField(flyingClass, boolean.class, 1).getBoolean(packet);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-            return true;
-        }
-
-        @Override
-        public boolean isLook() {
-            try {
-                return Reflection.getField(flyingClass, boolean.class, 2).getBoolean(packet);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-            return false;
-        }
-    }
-
-    public static class WrappedPacketInPosition_Look extends WrappedPacketInFlying {
-        public WrappedPacketInPosition_Look(Object packet) {
-            super(packet);
-        }
-
-        @Override
-        public boolean isPosition() {
-            try {
-                return Reflection.getField(flyingClass, boolean.class, 1).getBoolean(packet);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-            return true;
-        }
-
-        @Override
-        public boolean isLook() {
-            try {
-                return Reflection.getField(flyingClass, boolean.class, 2).getBoolean(packet);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-            return true;
-        }
-    }
-
-    public static class WrappedPacketInLook extends WrappedPacketInFlying {
-
-        public WrappedPacketInLook(Object packet) {
-            super(packet);
-        }
-        @Override
-        public boolean isPosition() {
-            try {
-                return Reflection.getField(flyingClass, boolean.class, 1).getBoolean(packet);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-            return false;
-        }
-
-        @Override
-        public boolean isLook() {
-            try {
-                return Reflection.getField(flyingClass, boolean.class, 2).getBoolean(packet);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-            return true;
-        }
-    }
-
-}

src/main/java/io/github/retrooper/packetevents/packetwrappers/in/keepalive/WrappedPacketInKeepAlive.java

@@ -1,47 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.keepalive;
-
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-public final class WrappedPacketInKeepAlive extends WrappedPacket {
-    private static Class<?> keepAliveClass;
-
-    static {
-        try {
-            keepAliveClass = NMSUtils.getNMSClass("PacketPlayInKeepAlive");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private long id;
-
-    public WrappedPacketInKeepAlive(final Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        try {
-            if (version.isHigherThan(ServerVersion.v_1_12)) {
-                this.id = Reflection.getField(keepAliveClass, long.class, 0).getLong(packet);
-            } else {
-                this.id = Reflection.getField(keepAliveClass, int.class, 0).getInt(packet);
-            }
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    /**
-     * Cast this long to an integer if you are using 1.7.10->1.12.2!
-     * In 1.13.2->1.15.2 a long is sent
-     *
-     * @return
-     */
-    public long getId() {
-        return id;
-    }
-}

src/main/java/io/github/retrooper/packetevents/packetwrappers/in/transaction/WrappedPacketInTransaction.java

@@ -1,49 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.transaction;
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-public final class WrappedPacketInTransaction extends WrappedPacket {
-    private static Class<?> packetClass;
-
-    static {
-        try {
-            packetClass = NMSUtils.getNMSClass("PacketPlayInTransaction");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private int windowId;
-    private short actionNumber;
-    private boolean accepted;
-
-    public WrappedPacketInTransaction(final Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        try {
-            this.windowId = Reflection.getField(packetClass, int.class, 0).getInt(packet);
-            this.actionNumber = Reflection.getField(packetClass, short.class, 0).getShort(packet);
-            this.accepted = Reflection.getField(packetClass, boolean.class, 0).getBoolean(packet);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-
-    }
-
-    public int getWindowId() {
-        return windowId;
-    }
-
-    public short getActionNumber() {
-        return actionNumber;
-    }
-
-    public boolean isAccepted() {
-        return accepted;
-    }
-}

src/main/java/io/github/retrooper/packetevents/packetwrappers/in/useentity/WrappedPacketInUseEntity.java

@@ -1,65 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.in.useentity;
-
-import io.github.retrooper.packetevents.enums.minecraft.EntityUseAction;
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-import org.bukkit.entity.Entity;
-
-public final class WrappedPacketInUseEntity extends WrappedPacket {
-    private static Class<?> useEntityClass, entityClass, enumEntityUseActionClass;
-
-    static {
-
-        try {
-            useEntityClass = NMSUtils.getNMSClass("PacketPlayInUseEntity");
-            entityClass = NMSUtils.getNMSClass("Entity");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-
-        try {
-            enumEntityUseActionClass = NMSUtils.getNMSClass("EnumEntityUseAction");
-        } catch (ClassNotFoundException e) {
-            //That is fine, it is probably a subclass
-            for (final Class<?> sub : useEntityClass.getDeclaredClasses()) {
-                if (sub.getSimpleName().equals("EnumEntityUseAction")) {
-                    enumEntityUseActionClass = sub;
-                    break;
-                }
-            }
-        }
-    }
-
-    private int entityId;
-    private Entity entity;
-    private EntityUseAction action;
-
-    public WrappedPacketInUseEntity(final Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        try {
-            this.entityId = Reflection.getField(useEntityClass, int.class, 0).getInt(packet);
-            this.entity = NMSUtils.getEntityById(this.entityId);
-            final Object useActionEnum = Reflection.getField(useEntityClass, enumEntityUseActionClass, 0).get(packet);
-            this.action = EntityUseAction.valueOf(useActionEnum.toString());
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public Entity getEntity() {
-        return entity;
-    }
-
-    public int getEntityId() {
-        return entityId;
-    }
-
-    public EntityUseAction getAction() {
-        return action;
-    }
-}

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

@@ -0,0 +1,66 @@
+/*
+ * 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.custompayload;
+
+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;
+
+public class WrappedPacketLoginInCustomPayload extends WrappedPacket {
+    private static Class<?> byteBufClass;
+    private static Class<?> packetDataSerializerClass;
+
+    public WrappedPacketLoginInCustomPayload(NMSPacket packet) {
+        super(packet);
+    }
+
+    @Override
+    protected void load() {
+        packetDataSerializerClass = NMSUtils.getNMSClassWithoutException("PacketDataSerializer");
+        try {
+            byteBufClass = NMSUtils.getNettyClass("buffer.ByteBuf");
+        } catch (ClassNotFoundException ignored) {
+        }
+    }
+
+    public int getMessageId() {
+        return readInt(0);
+    }
+
+    public byte[] getData() {
+        Object dataSerializer = readObject(0, packetDataSerializerClass);
+        WrappedPacket byteBufWrapper = new WrappedPacket(new NMSPacket(dataSerializer));
+        Object byteBuf = byteBufWrapper.readObject(0, byteBufClass);
+        return PacketEvents.get().getByteBufUtil().getBytes(byteBuf);
+    }
+
+    @Override
+    public boolean isSupported() {
+        return version.isNewerThan(ServerVersion.v_1_12_2);
+    }
+}
+

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

@@ -0,0 +1,48 @@
+/*
+ * 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.encryptionbegin;
+
+import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
+import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
+import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+
+public class WrappedPacketLoginInEncryptionBegin extends WrappedPacket {
+    public WrappedPacketLoginInEncryptionBegin(NMSPacket packet) {
+        super(packet);
+    }
+
+    public byte[] getPublicKey() {
+        return readByteArray(0);
+    }
+
+    public byte[] getVerifyToken() {
+        return readByteArray(1);
+    }
+
+    @Override
+    public boolean isSupported() {
+        return PacketTypeClasses.Login.Client.ENCRYPTION_BEGIN != null;
+    }
+}

src/main/java/io/github/retrooper/packetevents/packetwrappers/login/in/handshake/WrappedPacketLoginInHandshake.java

@@ -0,0 +1,52 @@
+/*
+ * 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

@@ -0,0 +1,47 @@
+/*
+ * 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.start;
+
+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.gameprofile.GameProfileUtil;
+import io.github.retrooper.packetevents.utils.gameprofile.WrappedGameProfile;
+import io.github.retrooper.packetevents.utils.nms.NMSUtils;
+
+public class WrappedPacketLoginInStart extends WrappedPacket {
+    public WrappedPacketLoginInStart(NMSPacket packet) {
+        super(packet);
+    }
+
+    public WrappedGameProfile getGameProfile() {
+        return GameProfileUtil.getWrappedGameProfile(readObject(0, NMSUtils.gameProfileClass));
+    }
+
+    @Override
+    public boolean isSupported() {
+        return PacketTypeClasses.Login.Client.START != null;
+    }
+}

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

@@ -0,0 +1,124 @@
+/*
+ * 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.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.utils.nms.NMSUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+public class WrappedPacketLoginOutCustomPayload extends WrappedPacket implements SendableWrapper {
+    private static Constructor<?> constructor;
+    private static Constructor<?> packetDataSerializerConstructor;
+    private static Class<?> byteBufClass;
+    private static Class<?> packetDataSerializerClass;
+    private int messageID;
+    private String channelName;
+    private byte[] data;
+
+    public WrappedPacketLoginOutCustomPayload(NMSPacket packet) {
+        super(packet);
+    }
+
+    @Override
+    protected void load() {
+        Class<?> packetClass = PacketTypeClasses.Login.Server.CUSTOM_PAYLOAD;
+        if (packetClass != null) {
+            packetDataSerializerClass = NMSUtils.getNMSClassWithoutException("PacketDataSerializer");
+            try {
+                byteBufClass = NMSUtils.getNettyClass("buffer.ByteBuf");
+            } catch (ClassNotFoundException ex) {
+                ex.printStackTrace();
+            }
+
+            try {
+                if (packetDataSerializerClass != null) {
+                    packetDataSerializerConstructor = packetDataSerializerClass.getConstructor(byteBufClass);
+                }
+            } catch (NoSuchMethodException e) {
+                e.printStackTrace();
+            }
+
+            try {
+                constructor = packetClass.getConstructor();
+            } catch (NoSuchMethodException e3) {
+                throw new IllegalStateException("PacketEvents is unable to resolve the PacketPlayOutCustomPayload constructor.");
+            }
+        }
+    }
+
+    public int getMessageId() {
+        if (packet != null) {
+            return readInt(0);
+        }
+        return messageID;
+    }
+
+    public String getChannelName() {
+        if (packet != null) {
+            Object minecraftKey = readObject(0, NMSUtils.minecraftKeyClass);
+           return NMSUtils.getStringFromMinecraftKey(minecraftKey);
+        }
+        return channelName;
+    }
+
+    public byte[] getData() {
+        if (packet != null) {
+            Object dataSerializer = readObject(0, packetDataSerializerClass);
+            WrappedPacket byteBufWrapper = new WrappedPacket(new NMSPacket(dataSerializer));
+            Object byteBuf = byteBufWrapper.readObject(0, byteBufClass);
+            return PacketEvents.get().getByteBufUtil().getBytes(byteBuf);
+        }
+        return data;
+    }
+
+    @Override
+    public Object asNMSPacket() {
+        Object byteBufObject = PacketEvents.get().getByteBufUtil().wrappedBuffer(data);
+        try {
+            Object minecraftKey = NMSUtils.generateMinecraftKey(channelName);
+            Object dataSerializer = packetDataSerializerConstructor.newInstance(byteBufObject);
+            Object packetInstance = constructor.newInstance();
+            WrappedPacket packetWrapper = new WrappedPacket(new NMSPacket(packetInstance));
+            packetWrapper.writeInt(0, messageID);
+            packetWrapper.writeObject(0, minecraftKey);
+            packetWrapper.writeObject(0, dataSerializer);
+            return packetInstance;
+        } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    @Override
+    public boolean isSupported() {
+        return PacketTypeClasses.Login.Server.CUSTOM_PAYLOAD != null;
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ * 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.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.utils.nms.NMSUtils;
+
+public class WrappedPacketLoginOutDisconnect extends WrappedPacket {
+    public WrappedPacketLoginOutDisconnect(NMSPacket packet) {
+        super(packet);
+    }
+
+    public String getReason() {
+        Object iChatBaseComponent = readObject(0, NMSUtils.iChatBaseComponentClass);
+        return WrappedPacketOutChat.toStringFromIChatBaseComponent(iChatBaseComponent);
+    }
+
+    @Override
+    public boolean isSupported() {
+        return PacketTypeClasses.Login.Server.DISCONNECT != null;
+    }
+}

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

@@ -0,0 +1,54 @@
+/*
+ * 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.out.encryptionbegin;
+
+import io.github.retrooper.packetevents.packettype.PacketTypeClasses;
+import io.github.retrooper.packetevents.packetwrappers.NMSPacket;
+import io.github.retrooper.packetevents.packetwrappers.WrappedPacket;
+
+import java.security.PublicKey;
+
+public class WrappedPacketLoginOutEncryptionBegin extends WrappedPacket {
+    public WrappedPacketLoginOutEncryptionBegin(NMSPacket packet) {
+        super(packet);
+    }
+
+    public String getEncodedString() {
+        return readString(0);
+    }
+
+    public PublicKey getPublicKey() {
+        return (PublicKey) readObject(1, PublicKey.class);
+    }
+
+    public byte[] getByteArray() {
+        return readByteArray(0);
+    }
+
+    @Override
+    public boolean isSupported() {
+        return PacketTypeClasses.Login.Server.ENCRYPTION_BEGIN != null;
+    }
+}

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

@@ -0,0 +1,85 @@
+/*
+ * 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.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 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;
+
+    public WrappedPacketLoginOutSetCompression(NMSPacket packet) {
+        super(packet);
+    }
+
+    public WrappedPacketLoginOutSetCompression(int threshold) {
+        this.threshold = threshold;
+    }
+
+    @Override
+    protected void load() {
+        try {
+            if (PacketTypeClasses.Login.Server.SET_COMPRESSION != null) {
+                constructor = PacketTypeClasses.Login.Server.SET_COMPRESSION.getConstructor(int.class);
+            }
+        } catch (NoSuchMethodException e) {
+            //probably 1.7.10
+        }
+    }
+
+    /**
+     * Maximum size of a packet before it can be compressed.
+     *
+     * @return threshold Threshold
+     */
+    public int getThreshold() {
+        if (packet != null) {
+            return readInt(0);
+        }
+        return threshold;
+    }
+
+    @Override
+    public Object asNMSPacket() {
+        try {
+            return constructor.newInstance(threshold);
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    @Override
+    public boolean isSupported() {
+        return PacketTypeClasses.Login.Server.SET_COMPRESSION != null;
+    }
+}

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

@@ -0,0 +1,47 @@
+/*
+ * 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.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.utils.gameprofile.GameProfileUtil;
+import io.github.retrooper.packetevents.utils.gameprofile.WrappedGameProfile;
+import io.github.retrooper.packetevents.utils.nms.NMSUtils;
+
+public class WrappedPacketLoginOutSuccess extends WrappedPacket {
+    public WrappedPacketLoginOutSuccess(NMSPacket packet) {
+        super(packet);
+    }
+
+    public WrappedGameProfile getGameProfile() {
+        return GameProfileUtil.getWrappedGameProfile(readObject(0, NMSUtils.gameProfileClass));
+    }
+
+    @Override
+    public boolean isSupported() {
+        return PacketTypeClasses.Login.Server.SUCCESS != null;
+    }
+}

src/main/java/io/github/retrooper/packetevents/packetwrappers/out/abilities/PlayerAbilitiesUtils.java

@@ -1,38 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.out.abilities;
-
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-
-final class PlayerAbilitiesUtils {
-    public static Class<?> playerAbilitiesClass;
-    public static Constructor<?> playerAbilitiesConstructor;
-
-    static {
-        try {
-            playerAbilitiesClass = NMSUtils.getNMSClass("PlayerAbilities");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-        try {
-            playerAbilitiesConstructor = playerAbilitiesClass.getConstructor();
-        } catch (NoSuchMethodException e) {
-            e.printStackTrace();
-        }
-    }
-
-    public static Object getPlayerAbilities(final boolean isVulnerable, final boolean isFlying, final boolean allowFlight, final boolean canBuildInstantly,
-                                            final float flySpeed, final float walkSpeed) throws IllegalAccessException, InvocationTargetException, InstantiationException {
-        final Object instance = playerAbilitiesConstructor.newInstance();
-        Reflection.getField(playerAbilitiesClass, boolean.class, 0).setBoolean(instance, isVulnerable);
-        Reflection.getField(playerAbilitiesClass, boolean.class, 1).setBoolean(instance, isFlying);
-        Reflection.getField(playerAbilitiesClass, boolean.class, 2).setBoolean(instance, allowFlight);
-        Reflection.getField(playerAbilitiesClass, boolean.class, 3).setBoolean(instance, canBuildInstantly);
-
-        Reflection.getField(playerAbilitiesClass, float.class, 0).setFloat(instance, flySpeed);
-        Reflection.getField(playerAbilitiesClass, float.class, 1).setFloat(instance, walkSpeed);
-        return instance;
-    }
-}

src/main/java/io/github/retrooper/packetevents/packetwrappers/out/abilities/WrappedPacketOutAbilities.java

@@ -1,96 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.out.abilities;
-
-import io.github.retrooper.packetevents.packetwrappers.Sendable;
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.reflectionutils.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.InvocationTargetException;
-
-public final class WrappedPacketOutAbilities extends WrappedPacket implements Sendable {
-    private static Class<?> packetClass;
-    private static Constructor<?> packetConstructor;
-
-    static {
-        try {
-            packetClass = NMSUtils.getNMSClass("PacketPlayOutAbilities");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-
-        try {
-            packetConstructor = packetClass.getConstructor(PlayerAbilitiesUtils.playerAbilitiesClass);
-        } catch (NoSuchMethodException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private boolean vulnerable, flying, allowFlight, instantBuild;
-    private float flySpeed, walkSpeed;
-
-    public WrappedPacketOutAbilities(final Object packet) {
-        super(packet);
-    }
-
-    public WrappedPacketOutAbilities(final boolean isVulnerable, final boolean isFlying, final boolean allowFlight, final boolean canBuildInstantly,
-                                     final float flySpeed, final float walkSpeed) {
-        super(null);
-        this.vulnerable = isVulnerable;
-        this.flying = isFlying;
-        this.allowFlight = allowFlight;
-        this.instantBuild = canBuildInstantly;
-        this.flySpeed = flySpeed;
-        this.walkSpeed = walkSpeed;
-    }
-
-    @Override
-    protected void setup() {
-        try {
-            this.vulnerable = Reflection.getField(packetClass, boolean.class, 0).getBoolean(packet);
-            this.flying = Reflection.getField(packetClass, boolean.class, 1).getBoolean(packet);
-            this.allowFlight = Reflection.getField(packetClass, boolean.class, 2).getBoolean(packet);
-            this.instantBuild = Reflection.getField(packetClass, boolean.class, 3).getBoolean(packet);
-
-            this.flySpeed = Reflection.getField(packetClass, float.class, 0).getFloat(packet);
-            this.walkSpeed = Reflection.getField(packetClass, float.class, 0).getFloat(packet);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-
-    }
-
-    public boolean isVulnerable() {
-        return vulnerable;
-    }
-
-    public boolean isFlying() {
-        return flying;
-    }
-
-    public boolean isFlightAllowed() {
-        return allowFlight;
-    }
-
-    public boolean canInstantlyBuild() {
-        return instantBuild;
-    }
-
-    public float getFlySpeed() {
-        return flySpeed;
-    }
-
-    public float getWalkSpeed() {
-        return walkSpeed;
-    }
-
-    @Override
-    public Object asNMSPacket() {
-        try {
-            return packetConstructor.newInstance(PlayerAbilitiesUtils.getPlayerAbilities(vulnerable, flying, allowFlight, instantBuild, flySpeed, walkSpeed));
-        } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        return null;
-    }
-}