Various bug fixes, support for 1.8->1.15 spigot servers, WrappedPacketPlayInUseEntity wrapper added. More coming soon.

Taken from 
https://jitpack.io/#purplexdev/packetevents

LICENSE

@@ -0,0 +1,339 @@
+                    GNU GENERAL PUBLIC LICENSE
+                       Version 2, June 1991
+
+ 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.
+
+                            Preamble
+
+  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.
+
+  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.

README.md

@@ -0,0 +1,65 @@
+# PacketEvents
+Listen to minecraft packets and send minecraft packets.
+
+Credit to TinyProtocol
+
+PacketEvents coded by purplex.
+
+Coding help discord server: https://discord.gg/ZWTkg4v
+
+Examples can be found at
+me/purplex/packetevents/example/TestExample.java
+
+# Gradle
+
+```gradle
+allprojects {
+        repositories {
+		...
+		maven { url 'https://jitpack.io' }
+	}
+}
+
+dependencies {
+        implementation 'com.github.purplexdev:packetevents:1.0.9'
+}
+```
+
+
+# Maven
+
+```xml
+<repositories>
+        <repository>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
+        </repository>
+    </repositories>
+
+<dependencies>
+        <dependency>
+            <groupId>com.github.purplexdev</groupId>
+            <artifactId>packetevents</artifactId>
+            <version>1.0.9</version>
+        </dependency>
+</dependencies>
+```
+
+# sbt
+
+```
+resolvers += "jitpack" at "https://jitpack.io"
+
+libraryDependencies += "com.github.purplexdev" % "packetevents" % "1.0.9"	
+```
+
+# leiningen
+```
+:repositories [["jitpack" "https://jitpack.io"]]
+
+:dependencies [[com.github.purplexdev/packetevents "1.0.9"]]	
+```
+
+
+
+

pom.xml

@@ -4,13 +4,11 @@
          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>me.retrooper</groupId>
+    <groupId>me.purplex</groupId>
     <artifactId>packetevents</artifactId>
-    <version>1.0.3</version>
+    <version>1.1.2</version>
     <packaging>jar</packaging>
-
     <name>PacketEvents</name>
-
     <properties>
         <java.version>1.8</java.version>
         <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
@@ -19,6 +17,14 @@
     <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>
+            </plugin>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
                 <artifactId>maven-compiler-plugin</artifactId>
@@ -28,22 +34,6 @@
                     <target>${java.version}</target>
                 </configuration>
             </plugin>
-            <plugin>
-                <groupId>org.apache.maven.plugins</groupId>
-                <artifactId>maven-shade-plugin</artifactId>
-                <version>3.1.0</version>
-                <executions>
-                    <execution>
-                        <phase>package</phase>
-                        <goals>
-                            <goal>shade</goal>
-                        </goals>
-                        <configuration>
-                            <createDependencyReducedPom>false</createDependencyReducedPom>
-                        </configuration>
-                    </execution>
-                </executions>
-            </plugin>
         </plugins>
         <resources>
             <resource>
@@ -56,30 +46,140 @@
     <repositories>
         <repository>
             <id>spigot-repo</id>
-            <url>https://hub.spigotmc.org/nexus/content/groups/public/</url>
+            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
         </repository>
         <repository>
-            <id>libraries-mojang</id>
-            <url>https://libraries.minecraft.net/</url>
+            <id>jitpack.io</id>
+            <url>https://jitpack.io</url>
         </repository>
+        <repository>
+            <id>funkemunky-releases</id>
+            <url>https://nexus.funkemunky.cc/content/repositories/releases/</url>
+        </repository>
+
     </repositories>
 
+
     <dependencies>
         <dependency>
-            <groupId>com.mojang</groupId>
-            <artifactId>authlib</artifactId>
-            <version>1.5.21</version>
-            <scope>compile</scope>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.14.1</artifactId>
+            <version>1.14.1</version>
+            <scope>provided</scope>
         </dependency>
         <dependency>
-            <groupId>io.netty</groupId>
-            <artifactId>netty-all</artifactId>
-            <version>4.1.42.Final</version>
-            <scope>compile</scope>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.15.1</artifactId>
+            <version>1.15.1</version>
+            <scope>provided</scope>
         </dependency>
         <dependency>
-            <groupId>org.bukkit</groupId>
-            <artifactId>bukkit</artifactId>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.14.3</artifactId>
+            <version>1.14.3</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.14.2</artifactId>
+            <version>1.14.2</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.15</artifactId>
+            <version>1.15</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.15.2</artifactId>
+            <version>1.15.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.8</artifactId>
+            <version>1.8</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.8.3</artifactId>
+            <version>1.8.3</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.9</artifactId>
+            <version>1.9</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.10.2</artifactId>
+            <version>1.10.2</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.11.1</artifactId>
+            <version>1.11.1</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.11.2</artifactId>
+            <version>1.11.2</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.12.1</artifactId>
+            <version>1.12.1</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.13</artifactId>
+            <version>1.13</version>
+            <scope>provided</scope>
+        </dependency>
+        <dependency>
+            <groupId>org.github.spigot</groupId>
+            <artifactId>1.14</artifactId>
+            <version>1.14</version>
+            <scope>provided</scope>
+        </dependency>
+
+        <!--Bukkit-->
+        <dependency>
+            <groupId>org.spigotmc</groupId>
+            <artifactId>spigot-api</artifactId>
             <version>1.8-R0.1-SNAPSHOT</version>
             <scope>provided</scope>
         </dependency>

src/main/java/com/comphenix/tinyprotocol/Reflection.java

@@ -1,403 +0,0 @@
-package com.comphenix.tinyprotocol;
-
-import java.lang.reflect.Constructor;
-import java.lang.reflect.Field;
-import java.lang.reflect.Method;
-import java.util.Arrays;
-import java.util.regex.Matcher;
-import java.util.regex.Pattern;
-
-import org.bukkit.Bukkit;
-
-/**
- * An utility class that simplifies reflection in Bukkit plugins.
- * 
- * @author Kristian
- */
-public final class Reflection {
-	/**
-	 * An interface for invoking a specific constructor.
-	 */
-	public interface ConstructorInvoker {
-		/**
-		 * Invoke a constructor for a specific class.
-		 * 
-		 * @param arguments - the arguments to pass to the constructor.
-		 * @return The constructed object.
-		 */
-		public Object invoke(Object... arguments);
-	}
-
-	/**
-	 * An interface for invoking a specific method.
-	 */
-	public interface MethodInvoker {
-		/**
-		 * Invoke a method on a specific target object.
-		 * 
-		 * @param target - the target object, or NULL for a static method.
-		 * @param arguments - the arguments to pass to the method.
-		 * @return The return value, or NULL if is void.
-		 */
-		public Object invoke(Object target, Object... arguments);
-	}
-
-	/**
-	 * An interface for retrieving the field content.
-	 * 
-	 * @param <T> - field type.
-	 */
-	public interface FieldAccessor<T> {
-		/**
-		 * Retrieve the content of a field.
-		 * 
-		 * @param target - the target object, or NULL for a static field.
-		 * @return The value of the field.
-		 */
-		public T get(Object target);
-
-		/**
-		 * Set the content of a field.
-		 * 
-		 * @param target - the target object, or NULL for a static field.
-		 * @param value - the new value of the field.
-		 */
-		public void set(Object target, Object value);
-
-		/**
-		 * Determine if the given object has this field.
-		 * 
-		 * @param target - the object to test.
-		 * @return TRUE if it does, FALSE otherwise.
-		 */
-		public boolean hasField(Object target);
-	}
-
-	// Deduce the net.minecraft.server.v* package
-	private static String OBC_PREFIX = Bukkit.getServer().getClass().getPackage().getName();
-	private static String NMS_PREFIX = OBC_PREFIX.replace("org.bukkit.craftbukkit", "net.minecraft.server");
-	private static String VERSION = OBC_PREFIX.replace("org.bukkit.craftbukkit", "").replace(".", "");
-
-	// Variable replacement
-	private static Pattern MATCH_VARIABLE = Pattern.compile("\\{([^\\}]+)\\}");
-
-	private Reflection() {
-		// Seal class
-	}
-
-	/**
-	 * Retrieve a field accessor for a specific field type and name.
-	 * 
-	 * @param target - the target type.
-	 * @param name - the name of the field, or NULL to ignore.
-	 * @param fieldType - a compatible field type.
-	 * @return The field accessor.
-	 */
-	public static <T> FieldAccessor<T> getField(Class<?> target, String name, Class<T> fieldType) {
-		return getField(target, name, fieldType, 0);
-	}
-
-	/**
-	 * Retrieve a field accessor for a specific field type and name.
-	 * 
-	 * @param className - lookup name of the class, see {@link #getClass(String)}.
-	 * @param name - the name of the field, or NULL to ignore.
-	 * @param fieldType - a compatible field type.
-	 * @return The field accessor.
-	 */
-	public static <T> FieldAccessor<T> getField(String className, String name, Class<T> fieldType) {
-		return getField(getClass(className), name, fieldType, 0);
-	}
-
-	/**
-	 * Retrieve a field accessor for a specific field type and name.
-	 * 
-	 * @param target - the target type.
-	 * @param fieldType - a compatible field type.
-	 * @param index - the number of compatible fields to skip.
-	 * @return The field accessor.
-	 */
-	public static <T> FieldAccessor<T> getField(Class<?> target, Class<T> fieldType, int index) {
-		return getField(target, null, fieldType, index);
-	}
-
-	/**
-	 * Retrieve a field accessor for a specific field type and name.
-	 * 
-	 * @param className - lookup name of the class, see {@link #getClass(String)}.
-	 * @param fieldType - a compatible field type.
-	 * @param index - the number of compatible fields to skip.
-	 * @return The field accessor.
-	 */
-	public static <T> FieldAccessor<T> getField(String className, Class<T> fieldType, int index) {
-		return getField(getClass(className), fieldType, index);
-	}
-
-	// Common method
-	private static <T> FieldAccessor<T> getField(Class<?> target, String name, Class<T> fieldType, int index) {
-		for (final Field field : target.getDeclaredFields()) {
-			if ((name == null || field.getName().equals(name)) && fieldType.isAssignableFrom(field.getType()) && index-- <= 0) {
-				field.setAccessible(true);
-
-				// A function for retrieving a specific field value
-				return new FieldAccessor<T>() {
-
-					@Override
-					@SuppressWarnings("unchecked")
-					public T get(Object target) {
-						try {
-							return (T) field.get(target);
-						} catch (IllegalAccessException e) {
-							throw new RuntimeException("Cannot access reflection.", e);
-						}
-					}
-
-					@Override
-					public void set(Object target, Object value) {
-						try {
-							field.set(target, value);
-						} catch (IllegalAccessException e) {
-							throw new RuntimeException("Cannot access reflection.", e);
-						}
-					}
-
-					@Override
-					public boolean hasField(Object target) {
-						// target instanceof DeclaringClass
-						return field.getDeclaringClass().isAssignableFrom(target.getClass());
-					}
-				};
-			}
-		}
-
-		// Search in parent classes
-		if (target.getSuperclass() != null)
-			return getField(target.getSuperclass(), name, fieldType, index);
-
-		throw new IllegalArgumentException("Cannot find field with type " + fieldType);
-	}
-
-	/**
-	 * Search for the first publicly and privately defined method of the given name and parameter count.
-	 * 
-	 * @param className - lookup name of the class, see {@link #getClass(String)}.
-	 * @param methodName - the method name, or NULL to skip.
-	 * @param params - the expected parameters.
-	 * @return An object that invokes this specific method.
-	 * @throws IllegalStateException If we cannot find this method.
-	 */
-	public static MethodInvoker getMethod(String className, String methodName, Class<?>... params) {
-		return getTypedMethod(getClass(className), methodName, null, params);
-	}
-
-	/**
-	 * Search for the first publicly and privately defined method of the given name and parameter count.
-	 * 
-	 * @param clazz - a class to start with.
-	 * @param methodName - the method name, or NULL to skip.
-	 * @param params - the expected parameters.
-	 * @return An object that invokes this specific method.
-	 * @throws IllegalStateException If we cannot find this method.
-	 */
-	public static MethodInvoker getMethod(Class<?> clazz, String methodName, Class<?>... params) {
-		return getTypedMethod(clazz, methodName, null, params);
-	}
-
-	/**
-	 * Search for the first publicly and privately defined method of the given name and parameter count.
-	 * 
-	 * @param clazz - a class to start with.
-	 * @param methodName - the method name, or NULL to skip.
-	 * @param returnType - the expected return type, or NULL to ignore.
-	 * @param params - the expected parameters.
-	 * @return An object that invokes this specific method.
-	 * @throws IllegalStateException If we cannot find this method.
-	 */
-	public static MethodInvoker getTypedMethod(Class<?> clazz, String methodName, Class<?> returnType, Class<?>... params) {
-		for (final Method method : clazz.getDeclaredMethods()) {
-			if ((methodName == null || method.getName().equals(methodName))
-					&& (returnType == null || method.getReturnType().equals(returnType))
-					&& Arrays.equals(method.getParameterTypes(), params)) {
-				method.setAccessible(true);
-
-				return new MethodInvoker() {
-
-					@Override
-					public Object invoke(Object target, Object... arguments) {
-						try {
-							return method.invoke(target, arguments);
-						} catch (Exception e) {
-							throw new RuntimeException("Cannot invoke method " + method, e);
-						}
-					}
-
-				};
-			}
-		}
-
-		// Search in every superclass
-		if (clazz.getSuperclass() != null)
-			return getMethod(clazz.getSuperclass(), methodName, params);
-
-		throw new IllegalStateException(String.format("Unable to find method %s (%s).", methodName, Arrays.asList(params)));
-	}
-
-	/**
-	 * Search for the first publically and privately defined constructor of the given name and parameter count.
-	 * 
-	 * @param className - lookup name of the class, see {@link #getClass(String)}.
-	 * @param params - the expected parameters.
-	 * @return An object that invokes this constructor.
-	 * @throws IllegalStateException If we cannot find this method.
-	 */
-	public static ConstructorInvoker getConstructor(String className, Class<?>... params) {
-		return getConstructor(getClass(className), params);
-	}
-
-	/**
-	 * Search for the first publically and privately defined constructor of the given name and parameter count.
-	 * 
-	 * @param clazz - a class to start with.
-	 * @param params - the expected parameters.
-	 * @return An object that invokes this constructor.
-	 * @throws IllegalStateException If we cannot find this method.
-	 */
-	public static ConstructorInvoker getConstructor(Class<?> clazz, Class<?>... params) {
-		for (final Constructor<?> constructor : clazz.getDeclaredConstructors()) {
-			if (Arrays.equals(constructor.getParameterTypes(), params)) {
-				constructor.setAccessible(true);
-
-				return new ConstructorInvoker() {
-
-					@Override
-					public Object invoke(Object... arguments) {
-						try {
-							return constructor.newInstance(arguments);
-						} catch (Exception e) {
-							throw new RuntimeException("Cannot invoke constructor " + constructor, e);
-						}
-					}
-
-				};
-			}
-		}
-
-		throw new IllegalStateException(String.format("Unable to find constructor for %s (%s).", clazz, Arrays.asList(params)));
-	}
-
-	/**
-	 * Retrieve a class from its full name, without knowing its type on compile time.
-	 * <p>
-	 * This is useful when looking up fields by a NMS or OBC type.
-	 * <p>
-	 * 
-	 * @see {@link #getClass()} for more information.
-	 * @param lookupName - the class name with variables.
-	 * @return The class.
-	 */
-	public static Class<Object> getUntypedClass(String lookupName) {
-		@SuppressWarnings({ "rawtypes", "unchecked" })
-		Class<Object> clazz = (Class) getClass(lookupName);
-		return clazz;
-	}
-
-	/**
-	 * Retrieve a class from its full name.
-	 * <p>
-	 * Strings enclosed with curly brackets - such as {TEXT} - will be replaced according to the following table:
-	 * <p>
-	 * <table border="1">
-	 * <tr>
-	 * <th>Variable</th>
-	 * <th>Content</th>
-	 * </tr>
-	 * <tr>
-	 * <td>{nms}</td>
-	 * <td>Actual package name of net.minecraft.server.VERSION</td>
-	 * </tr>
-	 * <tr>
-	 * <td>{obc}</td>
-	 * <td>Actual pacakge name of org.bukkit.craftbukkit.VERSION</td>
-	 * </tr>
-	 * <tr>
-	 * <td>{version}</td>
-	 * <td>The current Minecraft package VERSION, if any.</td>
-	 * </tr>
-	 * </table>
-	 * 
-	 * @param lookupName - the class name with variables.
-	 * @return The looked up class.
-	 * @throws IllegalArgumentException If a variable or class could not be found.
-	 */
-	public static Class<?> getClass(String lookupName) {
-		return getCanonicalClass(expandVariables(lookupName));
-	}
-
-	/**
-	 * Retrieve a class in the net.minecraft.server.VERSION.* package.
-	 * 
-	 * @param name - the name of the class, excluding the package.
-	 * @throws IllegalArgumentException If the class doesn't exist.
-	 */
-	public static Class<?> getMinecraftClass(String name) {
-		return getCanonicalClass(NMS_PREFIX + "." + name);
-	}
-
-	/**
-	 * Retrieve a class in the org.bukkit.craftbukkit.VERSION.* package.
-	 * 
-	 * @param name - the name of the class, excluding the package.
-	 * @throws IllegalArgumentException If the class doesn't exist.
-	 */
-	public static Class<?> getCraftBukkitClass(String name) {
-		return getCanonicalClass(OBC_PREFIX + "." + name);
-	}
-
-	/**
-	 * Retrieve a class by its canonical name.
-	 * 
-	 * @param canonicalName - the canonical name.
-	 * @return The class.
-	 */
-	private static Class<?> getCanonicalClass(String canonicalName) {
-		try {
-			return Class.forName(canonicalName);
-		} catch (ClassNotFoundException e) {
-			throw new IllegalArgumentException("Cannot find " + canonicalName, e);
-		}
-	}
-
-	/**
-	 * Expand variables such as "{nms}" and "{obc}" to their corresponding packages.
-	 * 
-	 * @param name - the full name of the class.
-	 * @return The expanded string.
-	 */
-	private static String expandVariables(String name) {
-		StringBuffer output = new StringBuffer();
-		Matcher matcher = MATCH_VARIABLE.matcher(name);
-
-		while (matcher.find()) {
-			String variable = matcher.group(1);
-			String replacement = "";
-
-			// Expand all detected variables
-			if ("nms".equalsIgnoreCase(variable))
-				replacement = NMS_PREFIX;
-			else if ("obc".equalsIgnoreCase(variable))
-				replacement = OBC_PREFIX;
-			else if ("version".equalsIgnoreCase(variable))
-				replacement = VERSION;
-			else
-				throw new IllegalArgumentException("Unknown variable: " + variable);
-
-			// Assume the expanded variables are all packages, and append a dot
-			if (replacement.length() > 0 && matcher.end() < name.length() && name.charAt(matcher.end()) != '.')
-				replacement += ".";
-			matcher.appendReplacement(output, Matcher.quoteReplacement(replacement));
-		}
-
-		matcher.appendTail(output);
-		return output.toString();
-	}
-}

src/main/java/com/comphenix/tinyprotocol/TinyProtocol.java

@@ -1,522 +0,0 @@
-package com.comphenix.tinyprotocol;
-
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelDuplexHandler;
-import io.netty.channel.ChannelFuture;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelInboundHandlerAdapter;
-import io.netty.channel.ChannelInitializer;
-import io.netty.channel.ChannelPipeline;
-import io.netty.channel.ChannelPromise;
-
-import java.util.Collections;
-import java.util.List;
-import java.util.Map;
-import java.util.NoSuchElementException;
-import java.util.Set;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.logging.Level;
-
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.server.PluginDisableEvent;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.scheduler.BukkitRunnable;
-
-import com.comphenix.tinyprotocol.Reflection.FieldAccessor;
-import com.comphenix.tinyprotocol.Reflection.MethodInvoker;
-import com.google.common.collect.Lists;
-import com.google.common.collect.MapMaker;
-import com.mojang.authlib.GameProfile;
-
-/**
- * Represents a very tiny alternative to ProtocolLib.
- * <p>
- * It now supports intercepting packets during login and status ping (such as OUT_SERVER_PING)!
- * 
- * @author Kristian
- */
-public abstract class TinyProtocol {
-	private static final AtomicInteger ID = new AtomicInteger(0);
-
-	// Used in order to lookup a channel
-	private static final MethodInvoker getPlayerHandle = Reflection.getMethod("{obc}.entity.CraftPlayer", "getHandle");
-	private static final FieldAccessor<Object> getConnection = Reflection.getField("{nms}.EntityPlayer", "playerConnection", Object.class);
-	private static final FieldAccessor<Object> getManager = Reflection.getField("{nms}.PlayerConnection", "networkManager", Object.class);
-	private static final FieldAccessor<Channel> getChannel = Reflection.getField("{nms}.NetworkManager", Channel.class, 0);
-
-	// Looking up ServerConnection
-	private static final Class<Object> minecraftServerClass = Reflection.getUntypedClass("{nms}.MinecraftServer");
-	private static final Class<Object> serverConnectionClass = Reflection.getUntypedClass("{nms}.ServerConnection");
-	private static final FieldAccessor<Object> getMinecraftServer = Reflection.getField("{obc}.CraftServer", minecraftServerClass, 0);
-	private static final FieldAccessor<Object> getServerConnection = Reflection.getField(minecraftServerClass, serverConnectionClass, 0);
-	private static final MethodInvoker getNetworkMarkers = Reflection.getTypedMethod(serverConnectionClass, null, List.class, serverConnectionClass);
-
-	// Packets we have to intercept
-	private static final Class<?> PACKET_LOGIN_IN_START = Reflection.getMinecraftClass("PacketLoginInStart");
-	private static final FieldAccessor<GameProfile> getGameProfile = Reflection.getField(PACKET_LOGIN_IN_START, GameProfile.class, 0);
-
-	// Speedup channel lookup
-	private Map<String, Channel> channelLookup = new MapMaker().weakValues().makeMap();
-	private Listener listener;
-
-	// Channels that have already been removed
-	private Set<Channel> uninjectedChannels = Collections.newSetFromMap(new MapMaker().weakKeys().<Channel, Boolean>makeMap());
-
-	// List of network markers
-	private List<Object> networkManagers;
-
-	// Injected channel handlers
-	private List<Channel> serverChannels = Lists.newArrayList();
-	private ChannelInboundHandlerAdapter serverChannelHandler;
-	private ChannelInitializer<Channel> beginInitProtocol;
-	private ChannelInitializer<Channel> endInitProtocol;
-
-	// Current handler name
-	private String handlerName;
-
-	protected volatile boolean closed;
-	protected Plugin plugin;
-
-	/**
-	 * Construct a new instance of TinyProtocol, and start intercepting packets for all connected clients and future clients.
-	 * <p>
-	 * You can construct multiple instances per plugin.
-	 * 
-	 * @param plugin - the plugin.
-	 */
-	public TinyProtocol(final Plugin plugin) {
-		this.plugin = plugin;
-
-		// Compute handler name
-		this.handlerName = getHandlerName();
-
-		// Prepare existing players
-		registerBukkitEvents();
-
-		try {
-			registerChannelHandler();
-			registerPlayers(plugin);
-		} catch (IllegalArgumentException ex) {
-			// Damn you, late bind
-			plugin.getLogger().info("[TinyProtocol] Delaying server channel injection due to late bind.");
-
-			new BukkitRunnable() {
-				@Override
-				public void run() {
-					registerChannelHandler();
-					registerPlayers(plugin);
-					plugin.getLogger().info("[TinyProtocol] Late bind injection successful.");
-				}
-			}.runTask(plugin);
-		}
-	}
-
-	private void createServerChannelHandler() {
-		// Handle connected channels
-		endInitProtocol = new ChannelInitializer<Channel>() {
-
-			@Override
-			protected void initChannel(Channel channel) throws Exception {
-				try {
-					// This can take a while, so we need to stop the main thread from interfering
-					synchronized (networkManagers) {
-						// Stop injecting channels
-						if (!closed) {
-							channel.eventLoop().submit(() -> injectChannelInternal(channel));
-						}
-					}
-				} catch (Exception e) {
-					plugin.getLogger().log(Level.SEVERE, "Cannot inject incomming channel " + channel, e);
-				}
-			}
-
-		};
-
-		// This is executed before Minecraft's channel handler
-		beginInitProtocol = new ChannelInitializer<Channel>() {
-
-			@Override
-			protected void initChannel(Channel channel) throws Exception {
-				channel.pipeline().addLast(endInitProtocol);
-			}
-
-		};
-
-		serverChannelHandler = new ChannelInboundHandlerAdapter() {
-	
-			@Override
-			public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-				Channel channel = (Channel) msg;
-
-				// Prepare to initialize ths channel
-				channel.pipeline().addFirst(beginInitProtocol);
-				ctx.fireChannelRead(msg);
-			}
-
-		};
-	}
-
-	/**
-	 * Register bukkit events.
-	 */
-	private void registerBukkitEvents() {
-		listener = new Listener() {
-
-			@EventHandler(priority = EventPriority.LOWEST)
-			public final void onPlayerLogin(PlayerLoginEvent e) {
-				if (closed)
-					return;
-
-				Channel channel = getChannel(e.getPlayer());
-
-				// Don't inject players that have been explicitly uninjected
-				if (!uninjectedChannels.contains(channel)) {
-					injectPlayer(e.getPlayer());
-				}
-			}
-
-			@EventHandler
-			public final void onPluginDisable(PluginDisableEvent e) {
-				if (e.getPlugin().equals(plugin)) {
-					close();
-				}
-			}
-
-		};
-
-		plugin.getServer().getPluginManager().registerEvents(listener, plugin);
-	}
-
-	@SuppressWarnings("unchecked")
-	private void registerChannelHandler() {
-		Object mcServer = getMinecraftServer.get(Bukkit.getServer());
-		Object serverConnection = getServerConnection.get(mcServer);
-		boolean looking = true;
-
-		// We need to synchronize against this list
-		networkManagers = (List<Object>) getNetworkMarkers.invoke(null, serverConnection);
-		createServerChannelHandler();
-
-		// Find the correct list, or implicitly throw an exception
-		for (int i = 0; looking; i++) {
-			List<Object> list = Reflection.getField(serverConnection.getClass(), List.class, i).get(serverConnection);
-
-			for (Object item : list) {
-				if (!ChannelFuture.class.isInstance(item))
-					break;
-
-				// Channel future that contains the server connection
-				Channel serverChannel = ((ChannelFuture) item).channel();
-
-				serverChannels.add(serverChannel);
-				serverChannel.pipeline().addFirst(serverChannelHandler);
-				looking = false;
-			}
-		}
-	}
-
-	private void unregisterChannelHandler() {
-		if (serverChannelHandler == null)
-			return;
-
-		for (Channel serverChannel : serverChannels) {
-			final ChannelPipeline pipeline = serverChannel.pipeline();
-
-			// Remove channel handler
-			serverChannel.eventLoop().execute(new Runnable() {
-
-				@Override
-				public void run() {
-					try {
-						pipeline.remove(serverChannelHandler);
-					} catch (NoSuchElementException e) {
-						// That's fine
-					}
-				}
-
-			});
-		}
-	}
-
-	private void registerPlayers(Plugin plugin) {
-		for (Player player : plugin.getServer().getOnlinePlayers()) {
-			injectPlayer(player);
-		}
-	}
-
-	/**
-	 * Invoked when the server is starting to send a packet to a player.
-	 * <p>
-	 * Note that this is not executed on the main thread.
-	 * 
-	 * @param receiver - the receiving player, NULL for early login/status packets.
-	 * @param channel - the channel that received the packet. Never NULL.
-	 * @param packet - the packet being sent.
-	 * @return The packet to send instead, or NULL to cancel the transmission.
-	 */
-	public Object onPacketOutAsync(Player receiver, Channel channel, Object packet) {
-		return packet;
-	}
-
-	/**
-	 * Invoked when the server has received a packet from a given player.
-	 * <p>
-	 * Use {@link Channel#remoteAddress()} to get the remote address of the client.
-	 * 
-	 * @param sender - the player that sent the packet, NULL for early login/status packets.
-	 * @param channel - channel that received the packet. Never NULL.
-	 * @param packet - the packet being received.
-	 * @return The packet to recieve instead, or NULL to cancel.
-	 */
-	public Object onPacketInAsync(Player sender, Channel channel, Object packet) {
-		return packet;
-	}
-
-	/**
-	 * Send a packet to a particular player.
-	 * <p>
-	 * Note that {@link #onPacketOutAsync(Player, Channel, Object)} will be invoked with this packet.
-	 * 
-	 * @param player - the destination player.
-	 * @param packet - the packet to send.
-	 */
-	public void sendPacket(Player player, Object packet) {
-		sendPacket(getChannel(player), packet);
-	}
-
-	/**
-	 * Send a packet to a particular client.
-	 * <p>
-	 * Note that {@link #onPacketOutAsync(Player, Channel, Object)} will be invoked with this packet.
-	 * 
-	 * @param channel - client identified by a channel.
-	 * @param packet - the packet to send.
-	 */
-	public void sendPacket(Channel channel, Object packet) {
-		channel.pipeline().writeAndFlush(packet);
-	}
-
-	/**
-	 * Pretend that a given packet has been received from a player.
-	 * <p>
-	 * Note that {@link #onPacketInAsync(Player, Channel, Object)} will be invoked with this packet.
-	 * 
-	 * @param player - the player that sent the packet.
-	 * @param packet - the packet that will be received by the server.
-	 */
-	public void receivePacket(Player player, Object packet) {
-		receivePacket(getChannel(player), packet);
-	}
-
-	/**
-	 * Pretend that a given packet has been received from a given client.
-	 * <p>
-	 * Note that {@link #onPacketInAsync(Player, Channel, Object)} will be invoked with this packet.
-	 * 
-	 * @param channel - client identified by a channel.
-	 * @param packet - the packet that will be received by the server.
-	 */
-	public void receivePacket(Channel channel, Object packet) {
-		channel.pipeline().context("encoder").fireChannelRead(packet);
-	}
-
-	/**
-	 * Retrieve the name of the channel injector, default implementation is "tiny-" + plugin name + "-" + a unique ID.
-	 * <p>
-	 * Note that this method will only be invoked once. It is no longer necessary to override this to support multiple instances.
-	 * 
-	 * @return A unique channel handler name.
-	 */
-	protected String getHandlerName() {
-		return "tiny-" + plugin.getName() + "-" + ID.incrementAndGet();
-	}
-
-	/**
-	 * Add a custom channel handler to the given player's channel pipeline, allowing us to intercept sent and received packets.
-	 * <p>
-	 * This will automatically be called when a player has logged in.
-	 * 
-	 * @param player - the player to inject.
-	 */
-	public void injectPlayer(Player player) {
-		injectChannelInternal(getChannel(player)).player = player;
-	}
-
-	/**
-	 * Add a custom channel handler to the given channel.
-	 * 
-	 * @param channel - the channel to inject.
-	 * @return The intercepted channel, or NULL if it has already been injected.
-	 */
-	public void injectChannel(Channel channel) {
-		injectChannelInternal(channel);
-	}
-
-	/**
-	 * Add a custom channel handler to the given channel.
-	 * 
-	 * @param channel - the channel to inject.
-	 * @return The packet interceptor.
-	 */
-	private PacketInterceptor injectChannelInternal(Channel channel) {
-		try {
-			PacketInterceptor interceptor = (PacketInterceptor) channel.pipeline().get(handlerName);
-
-			// Inject our packet interceptor
-			if (interceptor == null) {
-				interceptor = new PacketInterceptor();
-				channel.pipeline().addBefore("packet_handler", handlerName, interceptor);
-				uninjectedChannels.remove(channel);
-			}
-
-			return interceptor;
-		} catch (IllegalArgumentException e) {
-			// Try again
-			return (PacketInterceptor) channel.pipeline().get(handlerName);
-		}
-	}
-
-	/**
-	 * Retrieve the Netty channel associated with a player. This is cached.
-	 * 
-	 * @param player - the player.
-	 * @return The Netty channel.
-	 */
-	public Channel getChannel(Player player) {
-		Channel channel = channelLookup.get(player.getName());
-
-		// Lookup channel again
-		if (channel == null) {
-			Object connection = getConnection.get(getPlayerHandle.invoke(player));
-			Object manager = getManager.get(connection);
-
-			channelLookup.put(player.getName(), channel = getChannel.get(manager));
-		}
-
-		return channel;
-	}
-
-	/**
-	 * Uninject a specific player.
-	 * 
-	 * @param player - the injected player.
-	 */
-	public void uninjectPlayer(Player player) {
-		uninjectChannel(getChannel(player));
-	}
-
-	/**
-	 * Uninject a specific channel.
-	 * <p>
-	 * This will also disable the automatic channel injection that occurs when a player has properly logged in.
-	 * 
-	 * @param channel - the injected channel.
-	 */
-	public void uninjectChannel(final Channel channel) {
-		// No need to guard against this if we're closing
-		if (!closed) {
-			uninjectedChannels.add(channel);
-		}
-
-		// See ChannelInjector in ProtocolLib, line 590
-		channel.eventLoop().execute(new Runnable() {
-
-			@Override
-			public void run() {
-				channel.pipeline().remove(handlerName);
-			}
-
-		});
-	}
-
-	/**
-	 * Determine if the given player has been injected by TinyProtocol.
-	 * 
-	 * @param player - the player.
-	 * @return TRUE if it is, FALSE otherwise.
-	 */
-	public boolean hasInjected(Player player) {
-		return hasInjected(getChannel(player));
-	}
-
-	/**
-	 * Determine if the given channel has been injected by TinyProtocol.
-	 * 
-	 * @param channel - the channel.
-	 * @return TRUE if it is, FALSE otherwise.
-	 */
-	public boolean hasInjected(Channel channel) {
-		return channel.pipeline().get(handlerName) != null;
-	}
-
-	/**
-	 * Cease listening for packets. This is called automatically when your plugin is disabled.
-	 */
-	public final void close() {
-		if (!closed) {
-			closed = true;
-
-			// Remove our handlers
-			for (Player player : plugin.getServer().getOnlinePlayers()) {
-				uninjectPlayer(player);
-			}
-
-			// Clean up Bukkit
-			HandlerList.unregisterAll(listener);
-			unregisterChannelHandler();
-		}
-	}
-
-	/**
-	 * Channel handler that is inserted into the player's channel pipeline, allowing us to intercept sent and received packets.
-	 * 
-	 * @author Kristian
-	 */
-	private final class PacketInterceptor extends ChannelDuplexHandler {
-		// Updated by the login event
-		public volatile Player player;
-
-		@Override
-		public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-			// Intercept channel
-			final Channel channel = ctx.channel();
-			handleLoginStart(channel, msg);
-
-			try {
-				msg = onPacketInAsync(player, channel, msg);
-			} catch (Exception e) {
-				plugin.getLogger().log(Level.SEVERE, "Error in onPacketInAsync().", e);
-			}
-
-			if (msg != null) {
-				super.channelRead(ctx, msg);
-			}
-		}
-
-		@Override
-		public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
-			try {
-				msg = onPacketOutAsync(player, ctx.channel(), msg);
-			} catch (Exception e) {
-				plugin.getLogger().log(Level.SEVERE, "Error in onPacketOutAsync().", e);
-			}
-
-			if (msg != null) {
-				super.write(ctx, msg, promise);
-			}
-		}
-
-		private void handleLoginStart(Channel channel, Object packet) {
-			if (PACKET_LOGIN_IN_START.isInstance(packet)) {
-				GameProfile profile = getGameProfile.get(packet);
-				channelLookup.put(profile.getName(), channel);
-			}
-		}
-	}
-}

src/main/java/me/purplex/packetevents/Main.java

@@ -1,43 +1,25 @@
 package me.purplex.packetevents;
 
-import com.comphenix.tinyprotocol.*;
-import io.netty.channel.Channel;
-import me.purplex.packetevents.bukkitevent.ServerTickEvent;
-import me.purplex.packetevents.events.PacketReceiveEvent;
+import me.purplex.packetevents.customlistener.injector.PacketInjector;
+import me.purplex.packetevents.events.packetevent.ServerTickEvent;
 import me.purplex.packetevents.example.TestExample;
 import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
 import org.bukkit.event.*;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.plugin.java.JavaPlugin;
 
 public class Main extends JavaPlugin implements Listener {
 
-    public TinyProtocol protocol;
+    private static Main instance;
+    private static PacketInjector packetInjector;
+
     @Override
     public void onEnable() {
+        instance = this;
         Bukkit.getPluginManager().registerEvents(this, this);
-        //PacketEvents.getPacketManager().registerPacketListener(new TestExample());
-        protocol = new TinyProtocol(this) {
-            @Override
-            public Object onPacketInAsync(Player p, Channel channel, Object packet) {
-                if(packet == null)  return super.onPacketInAsync(p, channel, null);
-                if(p == null)  return super.onPacketInAsync(null, channel, packet);
-                if(channel == null)  return super.onPacketInAsync(p, null, packet);
-                String packetName = packet.getClass().getSimpleName();
-                PacketEvents.getPacketManager().callPacketReceiveEvent(new PacketReceiveEvent(p, packetName, packet));
-                return super.onPacketInAsync(p, channel, packet);
-            }
-
-            @Override
-            public Object onPacketOutAsync(Player p, Channel channel, Object packet) {
-                if(packet == null)  return super.onPacketInAsync(p, channel, null);
-                if(p == null)  return super.onPacketInAsync(null, channel, packet);
-                if(channel == null)  return super.onPacketInAsync(p, null, packet);
-                String packetName = packet.getClass().getSimpleName();
-                PacketEvents.getPacketManager().callPacketReceiveEvent(new PacketReceiveEvent(p, packetName, packet));
-                return super.onPacketOutAsync(p, channel, packet);
-            }
-        };
+        packetInjector = new PacketInjector();
+        PacketEvents.getPacketManager().registerPacketListener(new TestExample());
 
         Bukkit.getScheduler().scheduleAsyncRepeatingTask(this, new Runnable() {
             @Override
@@ -45,13 +27,31 @@ public class Main extends JavaPlugin implements Listener {
                 long now = System.currentTimeMillis();
                 PacketEvents.getPacketManager().callServerTickEvent(new ServerTickEvent(now));
             }
-        },  0L, 1L);
+        }, 0L, 1L);
 
     }
+
     @Override
     public void onDisable() {
 
     }
 
+    @EventHandler
+    public void onJoin(PlayerJoinEvent e) {
+        packetInjector.injectPlayer(e.getPlayer());
+
+    }
+
+    @EventHandler
+    public void onQuit(PlayerQuitEvent e) {
+
+        packetInjector.uninjectPlayer(e.getPlayer());
+
+    }
+
+    public static Main getInstance() {
+        return instance;
+    }
+
 
 }

src/main/java/me/purplex/packetevents/PacketEvents.java

@@ -1,13 +1,18 @@
 package me.purplex.packetevents;
 
-import me.purplex.packetevents.events.PacketManager;
+import me.purplex.packetevents.enums.ServerVersion;
+import me.purplex.packetevents.events.manager.PacketManager;
 
 public class PacketEvents {
     private static PacketManager packetManager;
 
+    public static ServerVersion getServerVersion() {
+        return ServerVersion.getVersion();
+    }
+
 
     public static PacketManager getPacketManager() {
-        if(packetManager == null) {
+        if (packetManager == null) {
             packetManager = new PacketManager();
         }
         return packetManager;

src/main/java/me/purplex/packetevents/customlistener/injector/PacketInjector.java

@@ -0,0 +1,118 @@
+package me.purplex.packetevents.customlistener.injector;
+
+
+import io.netty.channel.*;
+import me.purplex.packetevents.PacketEvents;
+import me.purplex.packetevents.enums.ServerVersion;
+import me.purplex.packetevents.events.packetevent.*;
+import org.bukkit.entity.Player;
+
+
+public class PacketInjector {
+    private final static ServerVersion version = ServerVersion.getVersion();
+
+    public void injectPlayer(Player player)  {
+        ChannelDuplexHandler channelDuplexHandler = new ChannelDuplexHandler() {
+            @Override
+            public void channelRead(ChannelHandlerContext ctx, Object packet) {
+                String packetName = packet.getClass().getSimpleName();
+                PacketReceiveEvent e = new PacketReceiveEvent(player, packetName, packet);
+                PacketEvents.getPacketManager().callPacketReceiveEvent(e);
+                if(e.isCancelled()) {
+                    return;
+                }
+                try {
+                    super.channelRead(ctx, packet);
+                } catch (Exception exception) {
+                    exception.printStackTrace();
+                }
+            }
+
+            @Override
+            public void write(ChannelHandlerContext ctx, Object packet, ChannelPromise promise)  {
+                String packetName = packet.getClass().getSimpleName();
+                PacketSendEvent e = new PacketSendEvent(player, packetName, packet);
+                PacketEvents.getPacketManager().callPacketSendEvent(e);
+                if(e.isCancelled()) {
+                    return;
+                }
+                try {
+                    super.write(ctx, packet, promise);
+                } catch (Exception exception) {
+                    exception.printStackTrace();
+                }
+            }
+        };
+        Channel channel = getChannel(player);
+        ChannelPipeline pipeline = channel.pipeline();
+        pipeline.addBefore("packet_handler", player.getName(), channelDuplexHandler);
+    }
+
+    public void uninjectPlayer(Player player) {
+        Channel channel = getChannel(player);
+        channel.eventLoop().submit(()->{
+           channel.pipeline().remove(player.getName());
+           return null;
+        });
+    }
+
+    public Channel getChannel(Player player) {
+        Channel channel = null;
+        if (version == ServerVersion.v_1_8) {
+            net.minecraft.server.v1_8_R1.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_8_R1.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            try {
+                channel = (Channel) networkManager.getClass().getField("i").get(networkManager);
+            } catch (IllegalAccessException | NoSuchFieldException e) {
+                e.printStackTrace();
+            }
+        }
+        else if(version == ServerVersion.v_1_8_3) {
+            net.minecraft.server.v1_8_R2.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_8_R2.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.k;
+        }
+        else if(version == ServerVersion.v_1_8_8) {
+            net.minecraft.server.v1_8_R3.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.channel;
+        }
+        else if(version == ServerVersion.v_1_9) {
+            net.minecraft.server.v1_9_R1.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.channel;
+        }
+        else if(version == ServerVersion.v_1_9_4) {
+            net.minecraft.server.v1_9_R2.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_9_R2.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.channel;
+        }
+        else if(version == ServerVersion.v_1_10) {
+            net.minecraft.server.v1_10_R1.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_10_R1.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.channel;
+        }
+        else if(version == ServerVersion.v_1_11) {
+            net.minecraft.server.v1_11_R1.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_11_R1.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.channel;
+        }
+        else if(version == ServerVersion.v_1_12) {
+            net.minecraft.server.v1_12_R1.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_12_R1.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.channel;
+        }
+        else if(version == ServerVersion.v_1_13) {
+            net.minecraft.server.v1_13_R1.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_13_R1.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.channel;
+        }
+        else if(version == ServerVersion.v_1_13_2) {
+            net.minecraft.server.v1_13_R2.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_13_R2.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.channel;
+        }
+        else if(version == ServerVersion.v_1_14) {
+            net.minecraft.server.v1_14_R1.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_14_R1.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.channel;
+        }
+        else if(version == ServerVersion.v_1_15) {
+            net.minecraft.server.v1_15_R1.NetworkManager networkManager = ((org.bukkit.craftbukkit.v1_15_R1.entity.CraftPlayer) player).getHandle().playerConnection.networkManager;
+            channel = networkManager.channel;
+        }
+        else {
+            System.err.println("Version unsupported, please contact purplex#0001 and tell him what version your server is running on! Make sure you are using paperspigot or spigot.");
+        }
+        return channel;
+    }
+}

src/main/java/me/purplex/packetevents/enums/EntityUseAction.java

@@ -0,0 +1,5 @@
+package me.purplex.packetevents.enums;
+
+public enum EntityUseAction {
+    INTERACT, INTERACT_AT, ATTACK, INVALID;
+}

src/main/java/me/purplex/packetevents/enums/PlayerAction.java

@@ -0,0 +1,21 @@
+package me.purplex.packetevents.enums;
+
+public enum PlayerAction {
+    START_SNEAKING,
+
+    STOP_SNEAKING,
+
+    STOP_SLEEPING,
+
+    START_SPRINTING,
+
+    STOP_SPRINTING,
+
+    START_RIDING_JUMP,
+
+    STOP_RIDING_JUMP,
+
+    OPEN_INVENTORY,
+
+    START_FALL_FLYING;
+}

src/main/java/me/purplex/packetevents/enums/PlayerDigType.java

@@ -0,0 +1,23 @@
+package me.purplex.packetevents.enums;
+
+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;
+
+
+
+}

src/main/java/me/purplex/packetevents/enums/ServerVersion.java

@@ -0,0 +1,24 @@
+package me.purplex.packetevents.enums;
+
+import org.apache.commons.lang.ArrayUtils;
+import org.bukkit.Bukkit;
+
+
+public enum ServerVersion
+{
+    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,
+    ERROR;
+
+    public static ServerVersion getVersion() {
+        ServerVersion[] vals = values();
+        ArrayUtils.reverse(vals);
+        for(ServerVersion val : vals) {
+            String valName = val.name().substring(2).replace("_", ".");
+            if(Bukkit.getBukkitVersion().contains(valName)) {
+                return val;
+            }
+        }
+        return ERROR;
+    }
+}
+

src/main/java/me/purplex/packetevents/events/PacketEvent.java

@@ -1,4 +1,6 @@
 package me.purplex.packetevents.events;
 
+
 public class PacketEvent {
+
 }

src/main/java/me/purplex/packetevents/events/PacketListener.java

@@ -1,4 +0,0 @@
-package me.purplex.packetevents.events;
-
-public interface PacketListener  {
-}

src/main/java/me/purplex/packetevents/events/PacketReceiveEvent.java

@@ -1,34 +0,0 @@
-package me.purplex.packetevents.events;
-
-import org.bukkit.entity.Player;
-
-public class PacketReceiveEvent extends PacketEvent {
-
-    private Player player;
-    private String name;
-    private Object packet;
-    private long timestamp;
-    public PacketReceiveEvent(Player player, String packetName, Object packet) {
-        this.player = player;
-        this.name = packetName;
-        this.packet = packet;
-        this.timestamp = (System.nanoTime() / 1000000);
-    }
-
-
-    public Player getPlayer() {
-        return this.player;
-    }
-
-    public String getPacketName() {
-        return this.name;
-    }
-
-    public Object getPacket() {
-        return this.packet;
-    }
-
-    public long getTimestamp() {
-        return timestamp;
-    }
-}

src/main/java/me/purplex/packetevents/events/PacketSendEvent.java

@@ -1,35 +0,0 @@
-package me.purplex.packetevents.events;
-
-import org.bukkit.entity.Player;
-
-public class PacketSendEvent extends PacketEvent {
-
-    private Player player;
-    private String name;
-    private Object packet;
-    private long timestamp;
-    public PacketSendEvent(Player player, String packetName, Object packet) {
-        this.player = player;
-        this.name = packetName;
-        this.packet = packet;
-        this.timestamp = (System.nanoTime() / 1000000);
-    }
-
-
-    public Player getPlayer() {
-        return this.player;
-    }
-
-    public String getPacketName() {
-        return this.name;
-    }
-
-    public Object getPacket() {
-        return this.packet;
-    }
-
-    public long getTimestamp() {
-        return timestamp;
-    }
-}
-

src/main/java/me/purplex/packetevents/events/eventmanager/PacketEventManager.java

@@ -1,16 +1,19 @@
-package me.purplex.packetevents.events;
+package me.purplex.packetevents.events.eventmanager;
 
-import me.purplex.packetevents.bukkitevent.ServerTickEvent;
+import me.purplex.packetevents.events.packetevent.ServerTickEvent;
+import me.purplex.packetevents.events.listener.PacketListener;
+import me.purplex.packetevents.events.packetevent.PacketReceiveEvent;
+import me.purplex.packetevents.events.packetevent.PacketSendEvent;
 
 import java.util.LinkedList;
 
 public interface PacketEventManager {
     public LinkedList<PacketListener> packetListeners = new LinkedList<>();
-    public LinkedList<PacketReceiveEvent> packetReiveEvents = new LinkedList<>();
     public void callPacketReceiveEvent(PacketReceiveEvent e);
     public void callPacketSendEvent(PacketSendEvent e);
 
     public void registerPacketListener(PacketListener e);
+    public void unregisterPacketListener(PacketListener e);
 
     public void callServerTickEvent(ServerTickEvent e);
 

src/main/java/me/purplex/packetevents/events/handler/PacketHandler.java

@@ -1,4 +1,4 @@
-package me.purplex.packetevents.events;
+package me.purplex.packetevents.events.handler;
 
 import java.lang.annotation.ElementType;
 import java.lang.annotation.Retention;

src/main/java/me/purplex/packetevents/events/listener/PacketListener.java

@@ -0,0 +1,4 @@
+package me.purplex.packetevents.events.listener;
+
+public interface PacketListener  {
+}

src/main/java/me/purplex/packetevents/events/manager/PacketManager.java

@@ -1,7 +1,11 @@
-package me.purplex.packetevents.events;
-
-import me.purplex.packetevents.bukkitevent.ServerTickEvent;
+package me.purplex.packetevents.events.manager;
 
+import me.purplex.packetevents.events.packetevent.ServerTickEvent;
+import me.purplex.packetevents.events.eventmanager.PacketEventManager;
+import me.purplex.packetevents.events.handler.PacketHandler;
+import me.purplex.packetevents.events.listener.PacketListener;
+import me.purplex.packetevents.events.packetevent.PacketReceiveEvent;
+import me.purplex.packetevents.events.packetevent.PacketSendEvent;
 import java.lang.reflect.Method;
 
 public class PacketManager implements PacketEventManager {
@@ -47,6 +51,12 @@ public class PacketManager implements PacketEventManager {
         this.packetListeners.add(e);
     }
 
+    @Override
+    public void unregisterPacketListener(PacketListener e) {
+        this.packetListeners.remove(e);
+    }
+
+
     @Override
     public void callServerTickEvent(ServerTickEvent e) {
         for (PacketListener listener : this.packetListeners) {

src/main/java/me/purplex/packetevents/events/packetevent/PacketReceiveEvent.java

@@ -0,0 +1,79 @@
+package me.purplex.packetevents.events.packetevent;
+
+
+import me.purplex.packetevents.PacketEvents;
+import me.purplex.packetevents.enums.ServerVersion;
+import me.purplex.packetevents.events.PacketEvent;
+import org.bukkit.entity.Player;
+
+public class PacketReceiveEvent extends PacketEvent {
+    private final Player player;
+    private final String name;
+    private final Object packet;
+    private final long timestamp;
+    private boolean cancelled;
+    public final ServerVersion version;
+
+    public PacketReceiveEvent(Player player, String packetName, Object packet) {
+        this.version = PacketEvents.getServerVersion();
+        this.player = player;
+        this.name = packetName;
+        this.packet = packet;
+        this.timestamp = (System.nanoTime() / 1000000);
+        this.cancelled = false;
+    }
+
+    /**
+     * 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 packet object
+     *
+     * @return packet
+     */
+    public Object getPacket() {
+        return this.packet;
+    }
+
+    /**
+     * The time the packet was received(ms)
+     *
+     * @return
+     */
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+    /**
+     * Cancel the packet
+     *
+     * @param cancelled
+     */
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    /**
+     * Returns if the packet has been cancelled
+     *
+     * @return cancelled
+     */
+    public boolean isCancelled() {
+        return cancelled;
+    }
+}

src/main/java/me/purplex/packetevents/events/packetevent/PacketSendEvent.java

@@ -0,0 +1,270 @@
+package me.purplex.packetevents.events.packetevent;
+
+import me.purplex.packetevents.PacketEvents;
+import me.purplex.packetevents.enums.ServerVersion;
+import me.purplex.packetevents.events.PacketEvent;
+import org.bukkit.entity.Player;
+
+public class PacketSendEvent extends PacketEvent {
+    private final Player player;
+    private final String name;
+    private final Object packet;
+    private final long timestamp;
+    private boolean cancelled;
+    public final ServerVersion version;
+
+    public PacketSendEvent(Player player, String packetName, Object packet) {
+        this.version = PacketEvents.getServerVersion();
+        this.player = player;
+        this.name = packetName;
+        this.packet = packet;
+        this.timestamp = (System.nanoTime() / 1000000);
+        this.cancelled = false;
+    }
+
+
+    public Player getPlayer() {
+        return this.player;
+    }
+
+    public String getPacketName() {
+        return this.name;
+    }
+
+    /**
+     * Get the raw packet object
+     *
+     * @return nmsPacket
+     */
+    public Object getPacket() {
+        return this.packet;
+    }
+
+
+
+    public long getTimestamp() {
+        return timestamp;
+    }
+
+
+    public void setCancelled(boolean cancelled) {
+        this.cancelled = cancelled;
+    }
+
+    public boolean isCancelled() {
+        return cancelled;
+    }
+
+
+/*
+    /**
+     * Get the player's ping in the EntityPlayer's class
+     * @return ping
+     * @throws VersionNotFoundException
+
+    public int getPing() throws VersionNotFoundException {
+        int ping;
+        if (version == ServerVersion.v_1_8) {
+            net.minecraft.server.v1_8_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R1.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        } else if (version == ServerVersion.v_1_8_3) {
+            net.minecraft.server.v1_8_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R2.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        } else if (version == ServerVersion.v_1_8_8) {
+            net.minecraft.server.v1_8_R3.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        } else if (version == ServerVersion.v_1_9) {
+            net.minecraft.server.v1_9_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        } else if (version == ServerVersion.v_1_9_4) {
+            net.minecraft.server.v1_9_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_9_R2.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        } else if (version == ServerVersion.v_1_10_2) {
+            net.minecraft.server.v1_10_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_10_R1.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        } else if (version == ServerVersion.v_1_11_1 || version == ServerVersion.v_1_11_2) {
+            net.minecraft.server.v1_11_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_11_R1.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        }  else if (version == ServerVersion.v_1_12_1 || version == ServerVersion.v_1_12_2) {
+            net.minecraft.server.v1_12_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_12_R1.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        } else if (version == ServerVersion.v_1_13) {
+            net.minecraft.server.v1_13_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_13_R1.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        }
+        else if(version == ServerVersion.v_1_13_2) {
+            net.minecraft.server.v1_13_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_13_R2.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        }
+        else if (version == ServerVersion.v_1_14 || version == ServerVersion.v_1_14_1) {
+            net.minecraft.server.v1_14_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_14_R1.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        } else if (version == ServerVersion.v_1_15_1) {
+            net.minecraft.server.v1_15_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_15_R1.entity.CraftPlayer)player).getHandle();
+            ping = ePlayer.ping;
+        } else {
+            throw new VersionNotFoundException();
+        }
+        return ping;
+    }
+
+
+    /**
+     * Get the motX variable in the EntityPlayer class
+     *
+     * @return motX
+
+    public double getMotX() throws VersionNotFoundException {
+        double motX;
+        if (version == ServerVersion.v_1_8) {
+            net.minecraft.server.v1_8_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R1.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.motX;
+        } else if (version == ServerVersion.v_1_8_3) {
+            net.minecraft.server.v1_8_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R2.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.motX;
+        } else if (version == ServerVersion.v_1_8_8) {
+            net.minecraft.server.v1_8_R3.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.motX;
+        } else if (version == ServerVersion.v_1_9) {
+            net.minecraft.server.v1_9_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.motX;
+        } else if (version == ServerVersion.v_1_9_4) {
+            net.minecraft.server.v1_9_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_9_R2.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.motX;
+        } else if (version == ServerVersion.v_1_10_2) {
+            net.minecraft.server.v1_10_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_10_R1.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.motX;
+        } else if (version == ServerVersion.v_1_11_1 || version == ServerVersion.v_1_11_2) {
+            net.minecraft.server.v1_11_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_11_R1.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.motX;
+        }  else if (version == ServerVersion.v_1_12_1 || version == ServerVersion.v_1_12_2) {
+            net.minecraft.server.v1_12_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_12_R1.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.motX;
+        } else if (version == ServerVersion.v_1_13) {
+            net.minecraft.server.v1_13_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_13_R1.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.motX;
+        }
+        else if(version == ServerVersion.v_1_13_2) {
+            net.minecraft.server.v1_13_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_13_R2.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.motX;
+        }
+        else if (version == ServerVersion.v_1_14 || version == ServerVersion.v_1_14_1) {
+            net.minecraft.server.v1_14_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_14_R1.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.getMot().getX();
+        } else if (version == ServerVersion.v_1_15_1) {
+            net.minecraft.server.v1_15_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_15_R1.entity.CraftPlayer)player).getHandle();
+            motX = ePlayer.getMot().getX();
+        } else {
+            throw new VersionNotFoundException();
+        }
+        return motX;
+    }
+
+
+
+    /**
+     * Get the motY variable in the EntityPlayer class
+     *
+     * @return motY
+
+    public double getMotY() throws VersionNotFoundException {
+        double motY;
+        if (version == ServerVersion.v_1_8) {
+            net.minecraft.server.v1_8_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R1.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.motY;
+        } else if (version == ServerVersion.v_1_8_3) {
+            net.minecraft.server.v1_8_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R2.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.motY;
+        } else if (version == ServerVersion.v_1_8_8) {
+            net.minecraft.server.v1_8_R3.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.motY;
+        } else if (version == ServerVersion.v_1_9) {
+            net.minecraft.server.v1_9_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.motY;
+        } else if (version == ServerVersion.v_1_9_4) {
+            net.minecraft.server.v1_9_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_9_R2.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.motY;
+        } else if (version == ServerVersion.v_1_10_2) {
+            net.minecraft.server.v1_10_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_10_R1.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.motY;
+        } else if (version == ServerVersion.v_1_11_1 || version == ServerVersion.v_1_11_2) {
+            net.minecraft.server.v1_11_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_11_R1.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.motY;
+        }  else if (version == ServerVersion.v_1_12_1 || version == ServerVersion.v_1_12_2) {
+            net.minecraft.server.v1_12_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_12_R1.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.motY;
+        } else if (version == ServerVersion.v_1_13) {
+            net.minecraft.server.v1_13_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_13_R1.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.motY;
+        }
+        else if(version == ServerVersion.v_1_13_2) {
+            net.minecraft.server.v1_13_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_13_R2.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.motY;
+        }
+        else if (version == ServerVersion.v_1_14 || version == ServerVersion.v_1_14_1) {
+            net.minecraft.server.v1_14_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_14_R1.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.getMot().getY();
+        } else if (version == ServerVersion.v_1_15_1) {
+            net.minecraft.server.v1_15_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_15_R1.entity.CraftPlayer)player).getHandle();
+            motY = ePlayer.getMot().getY();
+        } else {
+            throw new VersionNotFoundException();
+        }
+        return motY;
+    }
+
+    /**
+     * Get the motZ variable in the EntityPlayer class
+     *
+     * @return motZ
+
+    public double getMotZ() throws VersionNotFoundException {
+        double motZ;
+        if (version == ServerVersion.v_1_8) {
+            net.minecraft.server.v1_8_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R1.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.motZ;
+        } else if (version == ServerVersion.v_1_8_3) {
+            net.minecraft.server.v1_8_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R2.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.motZ;
+        } else if (version == ServerVersion.v_1_8_8) {
+            net.minecraft.server.v1_8_R3.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.motZ;
+        } else if (version == ServerVersion.v_1_9) {
+            net.minecraft.server.v1_9_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.motZ;
+        } else if (version == ServerVersion.v_1_9_4) {
+            net.minecraft.server.v1_9_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_9_R2.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.motZ;
+        } else if (version == ServerVersion.v_1_10_2) {
+            net.minecraft.server.v1_10_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_10_R1.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.motZ;
+        } else if (version == ServerVersion.v_1_11_1 || version == ServerVersion.v_1_11_2) {
+            net.minecraft.server.v1_11_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_11_R1.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.motZ;
+        }  else if (version == ServerVersion.v_1_12_1 || version == ServerVersion.v_1_12_2) {
+            net.minecraft.server.v1_12_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_12_R1.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.motZ;
+        } else if (version == ServerVersion.v_1_13) {
+            net.minecraft.server.v1_13_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_13_R1.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.motZ;
+        }
+        else if(version == ServerVersion.v_1_13_2) {
+            net.minecraft.server.v1_13_R2.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_13_R2.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.motZ;
+        }
+        else if (version == ServerVersion.v_1_14 || version == ServerVersion.v_1_14_1) {
+            net.minecraft.server.v1_14_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_14_R1.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.getMot().getZ();
+        } else if (version == ServerVersion.v_1_15_1) {
+            net.minecraft.server.v1_15_R1.EntityPlayer ePlayer = ((org.bukkit.craftbukkit.v1_15_R1.entity.CraftPlayer)player).getHandle();
+            motZ = ePlayer.getMot().getZ();
+        } else {
+            throw new VersionNotFoundException();
+        }
+        return motZ;
+    }
+    */
+
+
+}
+

src/main/java/me/purplex/packetevents/events/packetevent/ServerTickEvent.java

@@ -1,4 +1,4 @@
-package me.purplex.packetevents.bukkitevent;
+package me.purplex.packetevents.events.packetevent;
 
 import me.purplex.packetevents.events.PacketEvent;
 

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/WrappedPacketPlayInUseEntity.java

@@ -0,0 +1,99 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_10.WrappedPacketPlayInUseEntity_1_10;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_11.WrappedPacketPlayInUseEntity_1_11;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_12.WrappedPacketPlayInUseEntity_1_12;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_13.WrappedPacketPlayInUseEntity_1_13;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_13_2.WrappedPacketPlayInUseEntity_1_13_2;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_14.WrappedPacketPlayInUseEntity_1_14;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_15.WrappedPacketPlayInUseEntity_1_15;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_8.WrappedPacketPlayInUseEntity_1_8;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_8_3.WrappedPacketPlayInUseEntity_1_8_3;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_8_8.WrappedPacketPlayInUseEntity_1_8_8;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_9.WrappedPacketPlayInUseEntity_1_9;
+import me.purplex.packetevents.events.packetevent.packet.impl.in._1_9_4.WrappedPacketPlayInUseEntity_1_9_4;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        if (version == ServerVersion.v_1_8) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_8(packet).getEntity();
+        } else if (version == ServerVersion.v_1_8_3) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_8_3(packet).getEntity();
+        } else if (version == ServerVersion.v_1_8_8) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_8_8(packet).getEntity();
+        } else if (version == ServerVersion.v_1_9) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_9(packet).getEntity();
+        } else if (version == ServerVersion.v_1_9_4) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_9_4(packet).getEntity();
+        } else if (version == ServerVersion.v_1_10) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_10(packet).getEntity();
+        } else if (version == ServerVersion.v_1_11) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_11(packet).getEntity();
+        } else if (version == ServerVersion.v_1_12) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_12(packet).getEntity();
+        } else if (version == ServerVersion.v_1_13) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_13(packet).getEntity();
+        } else if (version == ServerVersion.v_1_13_2) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_13_2(packet).getEntity();
+        } else if (version == ServerVersion.v_1_14) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_14(packet).getEntity();
+        } else if (version == ServerVersion.v_1_15) {
+            this.entity = new WrappedPacketPlayInUseEntity_1_15(packet).getEntity();
+        }
+    }
+
+    private void setupAction() {
+        if (version == ServerVersion.v_1_8) {
+            this.action = new WrappedPacketPlayInUseEntity_1_8(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_8_3) {
+            this.action = new WrappedPacketPlayInUseEntity_1_8_3(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_8_8) {
+            this.action = new WrappedPacketPlayInUseEntity_1_8_8(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_9) {
+            this.action = new WrappedPacketPlayInUseEntity_1_9(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_9_4) {
+            this.action = new WrappedPacketPlayInUseEntity_1_9_4(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_10) {
+            this.action = new WrappedPacketPlayInUseEntity_1_10(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_11) {
+            this.action = new WrappedPacketPlayInUseEntity_1_11(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_12) {
+            this.action = new WrappedPacketPlayInUseEntity_1_12(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_13) {
+            this.action = new WrappedPacketPlayInUseEntity_1_13(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_13_2) {
+            this.action = new WrappedPacketPlayInUseEntity_1_13_2(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_14) {
+            this.action = new WrappedPacketPlayInUseEntity_1_14(packet).getEntityUseAction();
+        } else if (version == ServerVersion.v_1_15) {
+            this.action = new WrappedPacketPlayInUseEntity_1_15(packet).getEntityUseAction();
+        }
+    }
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_10/WrappedPacketPlayInUseEntity_1_10.java

@@ -0,0 +1,54 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_10;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_10 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_10(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        net.minecraft.server.v1_10_R1.PacketPlayInUseEntity packet = (net.minecraft.server.v1_10_R1.PacketPlayInUseEntity) getRawPacket();
+        net.minecraft.server.v1_10_R1.WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            org.bukkit.craftbukkit.v1_10_R1.CraftWorld craftWorld = (org.bukkit.craftbukkit.v1_10_R1.CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_10_R1.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+
+    }
+
+    private void setupAction() {
+        net.minecraft.server.v1_10_R1.PacketPlayInUseEntity packet = (net.minecraft.server.v1_10_R1.PacketPlayInUseEntity) getRawPacket();
+        String name = packet.a().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_11/WrappedPacketPlayInUseEntity_1_11.java

@@ -0,0 +1,54 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_11;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_11 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_11(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        net.minecraft.server.v1_11_R1.PacketPlayInUseEntity packet = (net.minecraft.server.v1_11_R1.PacketPlayInUseEntity) getRawPacket();
+        net.minecraft.server.v1_11_R1.WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            org.bukkit.craftbukkit.v1_11_R1.CraftWorld craftWorld = (org.bukkit.craftbukkit.v1_11_R1.CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_11_R1.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+
+    }
+
+    private void setupAction() {
+        net.minecraft.server.v1_11_R1.PacketPlayInUseEntity packet = (net.minecraft.server.v1_11_R1.PacketPlayInUseEntity) getRawPacket();
+        String name = packet.a().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_12/WrappedPacketPlayInUseEntity_1_12.java

@@ -0,0 +1,54 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_12;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_12 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_12(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        net.minecraft.server.v1_12_R1.PacketPlayInUseEntity packet = (net.minecraft.server.v1_12_R1.PacketPlayInUseEntity) getRawPacket();
+        net.minecraft.server.v1_12_R1.WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            org.bukkit.craftbukkit.v1_12_R1.CraftWorld craftWorld = (org.bukkit.craftbukkit.v1_12_R1.CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_12_R1.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+
+    }
+
+    private void setupAction() {
+        net.minecraft.server.v1_12_R1.PacketPlayInUseEntity packet = (net.minecraft.server.v1_12_R1.PacketPlayInUseEntity) getRawPacket();
+        String name = packet.a().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_13/WrappedPacketPlayInUseEntity_1_13.java

@@ -0,0 +1,57 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_13;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import net.minecraft.server.v1_13_R1.PacketPlayInUseEntity;
+import net.minecraft.server.v1_13_R1.WorldServer;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.craftbukkit.v1_13_R1.CraftWorld;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_13 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_13(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        PacketPlayInUseEntity packet = (PacketPlayInUseEntity) getRawPacket();
+        WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            CraftWorld craftWorld = (CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_13_R1.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+
+    }
+
+    private void setupAction() {
+        PacketPlayInUseEntity packet = (PacketPlayInUseEntity) getRawPacket();
+        String name = packet.b().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_13_2/WrappedPacketPlayInUseEntity_1_13_2.java

@@ -0,0 +1,56 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_13_2;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.craftbukkit.v1_13_R2.CraftWorld;
+import org.bukkit.entity.Entity;
+import net.minecraft.server.v1_13_R2.PacketPlayInUseEntity;
+import net.minecraft.server.v1_13_R2.WorldServer;
+public class WrappedPacketPlayInUseEntity_1_13_2 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_13_2(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        PacketPlayInUseEntity packet = (net.minecraft.server.v1_13_R2.PacketPlayInUseEntity) getRawPacket();
+        WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            CraftWorld craftWorld = (CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_13_R2.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+
+    }
+
+    private void setupAction() {
+        PacketPlayInUseEntity packet = (PacketPlayInUseEntity) getRawPacket();
+        String name = packet.b().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_14/WrappedPacketPlayInUseEntity_1_14.java

@@ -0,0 +1,56 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_14;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import net.minecraft.server.v1_14_R1.PacketPlayInUseEntity;
+import net.minecraft.server.v1_14_R1.WorldServer;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_14 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_14(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        PacketPlayInUseEntity packet = (PacketPlayInUseEntity) getRawPacket();
+        WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            org.bukkit.craftbukkit.v1_14_R1.CraftWorld craftWorld = (org.bukkit.craftbukkit.v1_14_R1.CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_14_R1.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+
+    }
+
+    private void setupAction() {
+        PacketPlayInUseEntity packet = (PacketPlayInUseEntity) getRawPacket();
+        String name = packet.b().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_15/WrappedPacketPlayInUseEntity_1_15.java

@@ -0,0 +1,57 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_15;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import net.minecraft.server.v1_15_R1.PacketPlayInUseEntity;
+import net.minecraft.server.v1_15_R1.WorldServer;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.craftbukkit.v1_15_R1.CraftWorld;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_15 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_15(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        PacketPlayInUseEntity packet = (PacketPlayInUseEntity) getRawPacket();
+        WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            CraftWorld craftWorld = (CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_15_R1.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+
+    }
+
+    private void setupAction() {
+        PacketPlayInUseEntity packet = (PacketPlayInUseEntity) getRawPacket();
+        String name = packet.b().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_8/WrappedPacketPlayInUseEntity_1_8.java

@@ -0,0 +1,57 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_8;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_8 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_8(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        if (version == ServerVersion.v_1_8) {
+            net.minecraft.server.v1_8_R1.PacketPlayInUseEntity packet = (net.minecraft.server.v1_8_R1.PacketPlayInUseEntity) getRawPacket();
+            net.minecraft.server.v1_8_R1.WorldServer worldServer = null;
+            for (World bukkitWorld : Bukkit.getWorlds()) {
+                org.bukkit.craftbukkit.v1_8_R1.CraftWorld craftWorld = (org.bukkit.craftbukkit.v1_8_R1.CraftWorld) bukkitWorld;
+                worldServer = craftWorld.getHandle();
+                if (packet.a(worldServer) != null) {
+                    break;
+                }
+            }
+            net.minecraft.server.v1_8_R1.Entity entity = packet.a(worldServer);
+            this.entity = entity.getBukkitEntity();
+        }
+    }
+
+    private void setupAction() {
+        net.minecraft.server.v1_8_R1.PacketPlayInUseEntity packet = (net.minecraft.server.v1_8_R1.PacketPlayInUseEntity) getRawPacket();
+        String name = packet.a().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+}
+
+

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_8_3/WrappedPacketPlayInUseEntity_1_8_3.java

@@ -0,0 +1,56 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_8_3;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_8_3 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_8_3(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        net.minecraft.server.v1_8_R2.PacketPlayInUseEntity packet = (net.minecraft.server.v1_8_R2.PacketPlayInUseEntity) getRawPacket();
+        net.minecraft.server.v1_8_R2.WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            org.bukkit.craftbukkit.v1_8_R2.CraftWorld craftWorld = (org.bukkit.craftbukkit.v1_8_R2.CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_8_R2.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+
+    }
+
+    private void setupAction() {
+        net.minecraft.server.v1_8_R2.PacketPlayInUseEntity packet = (net.minecraft.server.v1_8_R2.PacketPlayInUseEntity) getRawPacket();
+        String name = packet.a().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+}
+
+

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_8_8/PacketPlayInAbilities_1_8_8.java

@@ -0,0 +1,27 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_8_8;
+
+import java.lang.Object;
+
+public class PacketPlayInAbilities_1_8_8 {
+    private Object packet;
+
+    public PacketPlayInAbilities_1_8_8(Object packet) {
+        this.packet = packet;
+        setupFields();
+    }
+
+    private void setupA() {
+
+    }
+
+    private void setupFields() {
+        setupA();
+    }
+
+    public boolean a;
+    public boolean isFlying;
+    public boolean c;
+    public boolean d;
+    public float e;
+    public float f;
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_8_8/WrappedPacketPlayInUseEntity_1_8_8.java

@@ -0,0 +1,54 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_8_8;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_8_8 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_8_8(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        net.minecraft.server.v1_8_R3.PacketPlayInUseEntity packet = (net.minecraft.server.v1_8_R3.PacketPlayInUseEntity) getRawPacket();
+        net.minecraft.server.v1_8_R3.WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            org.bukkit.craftbukkit.v1_8_R3.CraftWorld craftWorld = (org.bukkit.craftbukkit.v1_8_R3.CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_8_R3.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+    }
+
+    private void setupAction() {
+        net.minecraft.server.v1_8_R3.PacketPlayInUseEntity packet = (net.minecraft.server.v1_8_R3.PacketPlayInUseEntity) getRawPacket();
+        String name = packet.a().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_9/WrappedPacketPlayInUseEntity_1_9.java

@@ -0,0 +1,56 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_9;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_9 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_9(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        net.minecraft.server.v1_9_R1.PacketPlayInUseEntity packet = (net.minecraft.server.v1_9_R1.PacketPlayInUseEntity) getRawPacket();
+        net.minecraft.server.v1_9_R1.WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            org.bukkit.craftbukkit.v1_9_R1.CraftWorld craftWorld = (org.bukkit.craftbukkit.v1_9_R1.CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_9_R1.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+
+    }
+
+    private void setupAction() {
+        if (version == ServerVersion.v_1_8) {
+            net.minecraft.server.v1_9_R1.PacketPlayInUseEntity packet = (net.minecraft.server.v1_9_R1.PacketPlayInUseEntity) getRawPacket();
+            String name = packet.a().name();
+            this.action = EntityUseAction.valueOf(name);
+        }
+    }
+}

src/main/java/me/purplex/packetevents/events/packetevent/packet/impl/in/_1_9_4/WrappedPacketPlayInUseEntity_1_9_4.java

@@ -0,0 +1,54 @@
+package me.purplex.packetevents.events.packetevent.packet.impl.in._1_9_4;
+
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import org.bukkit.Bukkit;
+import org.bukkit.World;
+import org.bukkit.entity.Entity;
+
+public class WrappedPacketPlayInUseEntity_1_9_4 {
+    private final ServerVersion version;
+    private Entity entity;
+    private EntityUseAction action;
+    private final Object packet;
+
+    public WrappedPacketPlayInUseEntity_1_9_4(Object packet) {
+        this.version = ServerVersion.getVersion();
+        this.packet = packet;
+        setupEntity();
+        setupAction();
+    }
+
+    private Object getRawPacket() {
+        return this.packet;
+    }
+
+    public Entity getEntity() {
+        return entity;
+    }
+
+    public EntityUseAction getEntityUseAction() {
+        return action;
+    }
+
+    private void setupEntity() {
+        net.minecraft.server.v1_9_R2.PacketPlayInUseEntity packet = (net.minecraft.server.v1_9_R2.PacketPlayInUseEntity) getRawPacket();
+        net.minecraft.server.v1_9_R2.WorldServer worldServer = null;
+        for (World bukkitWorld : Bukkit.getWorlds()) {
+            org.bukkit.craftbukkit.v1_9_R2.CraftWorld craftWorld = (org.bukkit.craftbukkit.v1_9_R2.CraftWorld) bukkitWorld;
+            worldServer = craftWorld.getHandle();
+            if (packet.a(worldServer) != null) {
+                break;
+            }
+        }
+        net.minecraft.server.v1_9_R2.Entity entity = packet.a(worldServer);
+        this.entity = entity.getBukkitEntity();
+
+    }
+
+    private void setupAction() {
+        net.minecraft.server.v1_9_R2.PacketPlayInUseEntity packet = (net.minecraft.server.v1_9_R2.PacketPlayInUseEntity) getRawPacket();
+        String name = packet.a().name();
+        this.action = EntityUseAction.valueOf(name);
+    }
+}

src/main/java/me/purplex/packetevents/example/TestExample.java

@@ -1,54 +1,54 @@
 package me.purplex.packetevents.example;
 
-import me.purplex.packetevents.bukkitevent.ServerTickEvent;
-import me.purplex.packetevents.events.PacketHandler;
-import me.purplex.packetevents.events.PacketListener;
-import me.purplex.packetevents.events.PacketReceiveEvent;
-import me.purplex.packetevents.events.PacketSendEvent;
+import me.purplex.packetevents.enums.EntityUseAction;
+import me.purplex.packetevents.enums.ServerVersion;
+import me.purplex.packetevents.events.packetevent.ServerTickEvent;
+import me.purplex.packetevents.events.handler.PacketHandler;
+import me.purplex.packetevents.events.listener.PacketListener;
+import me.purplex.packetevents.events.packetevent.*;
+import me.purplex.packetevents.events.packetevent.packet.impl.in.WrappedPacketPlayInUseEntity;
 import me.purplex.packetevents.packets.Packet;
-import org.bukkit.Bukkit;
+import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 
 public class TestExample implements PacketListener {
     /**
      * How to register a packet listener?
-     *
-     *  PacketEvents.getPacketManager().registerPacketListener(new TestExample());
+     * <p>
+     * PacketEvents.getPacketManager().registerPacketListener(new TestExample());
      */
 
     private int tick;
 
+    private static ServerVersion serverVersion = ServerVersion.getVersion();
 
     @PacketHandler
     public void onPacketReceive(PacketReceiveEvent e) {
+        Player p = e.getPlayer();
         //ONLY CLIENT PACKETS ALLOWED HERE!
-        if(e.getPacketName().equals(Packet.Client.USE_ENTITY)) {
-            e.getPlayer().sendMessage("You have attacked an entity!");
-        }
-        else if(e.getPacketName().equals(Packet.Client.ARM_ANIMATION)) {
-            e.getPlayer().sendMessage("You swung your arm.");
-        }
-        else if(e.getPacketName().equals(Packet.Client.POSITION)) {
-            e.getPlayer().sendMessage("You updated your position!");
+
+        //System.out.println(e.getPacket().getClass().getSimpleName());
+        if (e.getPacketName().equals(Packet.Client.USE_ENTITY)) {
+            WrappedPacketPlayInUseEntity packet = new WrappedPacketPlayInUseEntity(e.getPacket());
+            Entity entity = packet.getEntity();
+            if (packet.getEntityUseAction() == EntityUseAction.ATTACK) {
+                double dist = entity.getLocation().distanceSquared(p.getLocation());
+                //p.sendMessage("dist: " + dist);
+            }
         }
+
     }
 
-    @PacketHandler
-    public void onPacketSend(PacketSendEvent e) {
-        //ONLY SERVER PACKETS ALLOWED HERE!
-        if(e.getPacketName().equals(Packet.Server.ENTITY_VELOCITY)) {
-            e.getPlayer().sendMessage("You took velocity!");
-        }
-    }
 
     @PacketHandler
     public void onServerTick(ServerTickEvent e) {
         //CALLED EVERY TICK
         tick++;
-        if(tick % 20 == 0) {
-            for(Player p : Bukkit.getOnlinePlayers()) {
+        if (tick % 20 == 0) {
+            /*for (Player p : Bukkit.getOnlinePlayers()) {
                 p.sendMessage("One second has passed!");
-            }
+            }*/
         }
     }
+
 }

src/main/java/me/purplex/packetevents/packets/Packet.java

@@ -4,6 +4,8 @@ public abstract class Packet {
     public static class Client {
         private static final String CLIENT = "PacketPlayIn";
         public static final String KEEP_ALIVE = CLIENT + "KeepAlive";
+
+        @Deprecated
         public static final String FLYING = CLIENT + "Flying";
         public static final String POSITION = CLIENT + "Position";
         public static final String POSITION_LOOK = CLIENT + "PositionLook";
@@ -36,6 +38,7 @@ public abstract class Packet {
     public static class Server {
         private static final String SERVER = "PacketPlayOut";
 
+        public static final String ANIMATION = SERVER + "Animation";
         public static final String KEEP_ALIVE = SERVER + "KeepAlive";
         public static final String CHAT = SERVER + "Chat";
         public static final String POSITION = SERVER + "Position";
@@ -57,11 +60,14 @@ public abstract class Packet {
         public static final String WORLD_PARTICLE = SERVER + "WorldParticles";
         public static final String COMMANDS = SERVER + "Commands";
         public static final String OPEN_WINDOW = SERVER + "OpenWindow";
+        public static final String LOGIN = SERVER + "Login";
+        public static final String SERVER_DIFFICULTY = SERVER + "ServerDifficulty";
     }
 
     public static 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";
     }
 }