Merge pull request #570 from D3lta-2-1/fabric

Fabric server side support added

.github/workflows/build.yml

@@ -0,0 +1,39 @@
+# Automatically build the project and run any configured tests for every push
+# and submitted pull request. This can help catch issues that only occur on
+# certain platforms or Java versions, and provides a first line of defence
+# against bad commits.
+
+name: build
+on: [pull_request, push]
+
+jobs:
+  build:
+    strategy:
+      matrix:
+        # Use these Java versions
+        java: [
+          17,    # Current Java LTS & minimum supported by Minecraft
+        ]
+        # and run on both Linux and Windows
+        os: [ubuntu-20.04, windows-2022]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - name: checkout repository
+        uses: actions/checkout@v2
+      - name: validate gradle wrapper
+        uses: gradle/wrapper-validation-action@v1
+      - name: setup jdk ${{ matrix.java }}
+        uses: actions/setup-java@v1
+        with:
+          java-version: ${{ matrix.java }}
+      - name: make gradle wrapper executable
+        if: ${{ runner.os != 'Windows' }}
+        run: chmod +x ./gradlew
+      - name: build
+        run: ./gradlew build
+      - name: capture build artifacts
+        if: ${{ runner.os == 'Linux' && matrix.java == '17' }} # Only upload artifacts built from latest java on one OS
+        uses: actions/upload-artifact@v2
+        with:
+          name: Artifacts
+          path: build/libs/

.gitignore

@@ -0,0 +1,33 @@
+# gradle
+
+.gradle/
+build/
+out/
+classes/
+
+# eclipse
+
+*.launch
+
+# idea
+
+.idea/
+*.iml
+*.ipr
+*.iws
+
+# vscode
+
+.settings/
+.vscode/
+bin/
+.classpath
+.project
+
+# macos
+
+*.DS_Store
+
+# fabric
+
+run/

LICENSE

@@ -671,4 +671,4 @@ into proprietary programs.  If your program is a subroutine library, you
 may consider it more useful to permit linking proprietary applications with
 the library.  If this is what you want to do, use the GNU Lesser General
 Public License instead of this License.  But first, please read
-<https://www.gnu.org/licenses/why-not-lgpl.html>.
+<https://www.gnu.org/licenses/why-not-lgpl.html>.

README.md

@@ -1,68 +1,9 @@
-# packetevents by purplex
+# Fabric Example Mod
 
-PacketListener coded by purplex.
-
-Licensed with the GPL3 license.
-
-[![](https://img.shields.io/badge/License-GPLv3-blue.svg)](https://www.gnu.org/licenses/gpl-3.0)
-
-Coding help discord server: https://discord.gg/ZWTkg4v
-
-How to use with **Gradle, Maven, sbt and leiningen**.
-
-The lastest stable version is displayed below. 
-
-[![](https://jitpack.io/v/purplexdev/packetevents.svg)](https://jitpack.io/#purplexdev/packetevents)
-
-# Gradle
-
-```gradle
-allprojects {
-        repositories {
-		...
-		maven { url 'https://jitpack.io' }
-	}
-}
-
-dependencies {
-        implementation 'com.github.purplexdev:packetevents:1.1.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.1.9</version>
-        </dependency>
-</dependencies>
-```
-
-# sbt
-
-```
-resolvers += "jitpack" at "https://jitpack.io"
-
-libraryDependencies += "com.github.purplexdev" % "packetevents" % "1.1.9"	
-```
-
-# leiningen
-```
-:repositories [["jitpack" "https://jitpack.io"]]
-
-:dependencies [[com.github.purplexdev/packetevents "1.1.9"]]	
-```
+## Setup
 
+For setup instructions please see the [fabric wiki page](https://fabricmc.net/wiki/tutorial:setup) that relates to the IDE that you are using.
 
+## License
 
+This template is available under the CC0 license. Feel free to learn from it and incorporate it in your own projects.

build.gradle

@@ -0,0 +1,93 @@
+plugins {
+	id 'fabric-loom' version '0.11-SNAPSHOT'
+	id 'maven-publish'
+}
+
+version = project.mod_version
+group = project.maven_group
+
+project.ext.adventureVersion = '4.10.1'
+project.ext.adventureDependencies=["net.kyori:adventure-api:${adventureVersion}",
+								   "net.kyori:adventure-text-serializer-gson:${adventureVersion}",
+								   "net.kyori:adventure-text-serializer-legacy:${adventureVersion}",
+								   "net.kyori:adventure-text-serializer-gson-legacy-impl:${adventureVersion}",
+		                           "net.kyori:adventure-key:${adventureVersion}",
+		                           "net.kyori:adventure-nbt:${adventureVersion}",
+                                   "net.kyori:examination-api:1.3.0",
+                                   "net.kyori:examination-string:1.3.0"]
+
+repositories {
+	mavenCentral()
+	maven { url 'https://repo.codemc.io/repository/maven-snapshots/' }
+	maven {
+		name = 'ParchmentMC'
+		url = 'https://maven.parchmentmc.org'
+	}
+}
+
+dependencies {
+	modImplementation 'com.github.retrooper.packetevents:netty-common:2.0.0-SNAPSHOT'
+	include('com.github.retrooper.packetevents:netty-common:2.0.0-SNAPSHOT')
+	modImplementation(adventureDependencies)
+	include(adventureDependencies)
+
+	// To change the versions see the gradle.properties file
+	minecraft "com.mojang:minecraft:${project.minecraft_version}"
+
+	mappings loom.layered() {
+		officialMojangMappings()
+		parchment("org.parchmentmc.data:parchment-${project.parchment_minecraft_version}:${project.parchment_mappings}")
+	}
+
+	modImplementation "net.fabricmc:fabric-loader:${project.loader_version}"
+
+	// Fabric API. This is technically optional, but you probably want it anyway.
+	modImplementation "net.fabricmc.fabric-api:fabric-api:${project.fabric_version}"
+}
+
+configurations.all {
+	resolutionStrategy.cacheChangingModulesFor 0, 'seconds'
+}
+
+processResources {
+	inputs.property "version", project.version
+
+	filesMatching("fabric.mod.json") {
+		expand "version": project.version
+	}
+}
+
+tasks.withType(JavaCompile).configureEach {
+	// Minecraft 1.18 (1.18-pre2) upwards uses Java 17.
+	it.options.release = 17
+}
+
+java {
+	// Loom will automatically attach sourcesJar to a RemapSourcesJar task and to the "build" task
+	// if it is present.
+	// If you remove this line, sources will not be generated.
+	withSourcesJar()
+}
+
+jar {
+	from("LICENSE") {
+		rename { "${it}_${project.archivesBaseName}"}
+	}
+}
+
+// configure the maven publication
+publishing {
+	publications {
+		mavenJava(MavenPublication) {
+			from components.java
+		}
+	}
+
+	// See https://docs.gradle.org/current/userguide/publishing_maven.html for information on how to set up publishing.
+	repositories {
+		// Add repositories to publish to here.
+		// Notice: This block does NOT have the same function as the block in the top level.
+		// The repositories here will be used for publishing your artifact, not for
+		// retrieving dependencies.
+	}
+}

gradle.properties

@@ -0,0 +1,18 @@
+# Done to increase the memory available to gradle.
+org.gradle.jvmargs=-Xmx1G
+
+# Fabric Properties
+	# check these on https://fabricmc.net/develop
+	minecraft_version=1.19.4
+	parchment_mappings=2023.03.12
+	parchment_minecraft_version=1.19.3
+	loader_version=0.14.18
+
+# Mod Properties
+	mod_version = 2.0.0
+	maven_group = io.github.retrooper
+	archives_base_name = packetevents
+
+# Dependencies
+    fabric_version=0.77.0+1.19.4
+

gradle/wrapper/gradle-wrapper.properties

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

gradlew

@@ -0,0 +1,234 @@
+#!/bin/sh
+
+#
+# Copyright © 2015-2021 the original authors.
+#
+# Licensed under the Apache License, Version 2.0 (the "License");
+# you may not use this file except in compliance with the License.
+# You may obtain a copy of the License at
+#
+#      https://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing, software
+# distributed under the License is distributed on an "AS IS" BASIS,
+# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+# See the License for the specific language governing permissions and
+# limitations under the License.
+#
+
+##############################################################################
+#
+#   Gradle start up script for POSIX generated by Gradle.
+#
+#   Important for running:
+#
+#   (1) You need a POSIX-compliant shell to run this script. If your /bin/sh is
+#       noncompliant, but you have some other compliant shell such as ksh or
+#       bash, then to run this script, type that shell name before the whole
+#       command line, like:
+#
+#           ksh Gradle
+#
+#       Busybox and similar reduced shells will NOT work, because this script
+#       requires all of these POSIX shell features:
+#         * functions;
+#         * expansions «$var», «${var}», «${var:-default}», «${var+SET}»,
+#           «${var#prefix}», «${var%suffix}», and «$( cmd )»;
+#         * compound commands having a testable exit status, especially «case»;
+#         * various built-in commands including «command», «set», and «ulimit».
+#
+#   Important for patching:
+#
+#   (2) This script targets any POSIX shell, so it avoids extensions provided
+#       by Bash, Ksh, etc; in particular arrays are avoided.
+#
+#       The "traditional" practice of packing multiple parameters into a
+#       space-separated string is a well documented source of bugs and security
+#       problems, so this is (mostly) avoided, by progressively accumulating
+#       options in "$@", and eventually passing that to Java.
+#
+#       Where the inherited environment variables (DEFAULT_JVM_OPTS, JAVA_OPTS,
+#       and GRADLE_OPTS) rely on word-splitting, this is performed explicitly;
+#       see the in-line comments for details.
+#
+#       There are tweaks for specific operating systems such as AIX, CygWin,
+#       Darwin, MinGW, and NonStop.
+#
+#   (3) This script is generated from the Groovy template
+#       https://github.com/gradle/gradle/blob/master/subprojects/plugins/src/main/resources/org/gradle/api/internal/plugins/unixStartScript.txt
+#       within the Gradle project.
+#
+#       You can find Gradle at https://github.com/gradle/gradle/.
+#
+##############################################################################
+
+# Attempt to set APP_HOME
+
+# Resolve links: $0 may be a link
+app_path=$0
+
+# Need this for daisy-chained symlinks.
+while
+    APP_HOME=${app_path%"${app_path##*/}"}  # leaves a trailing /; empty if no leading path
+    [ -h "$app_path" ]
+do
+    ls=$( ls -ld "$app_path" )
+    link=${ls#*' -> '}
+    case $link in             #(
+      /*)   app_path=$link ;; #(
+      *)    app_path=$APP_HOME$link ;;
+    esac
+done
+
+APP_HOME=$( cd "${APP_HOME:-./}" && pwd -P ) || exit
+
+APP_NAME="Gradle"
+APP_BASE_NAME=${0##*/}
+
+# Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+DEFAULT_JVM_OPTS='"-Xmx64m" "-Xms64m"'
+
+# Use the maximum available, or set MAX_FD != -1 to use that value.
+MAX_FD=maximum
+
+warn () {
+    echo "$*"
+} >&2
+
+die () {
+    echo
+    echo "$*"
+    echo
+    exit 1
+} >&2
+
+# OS specific support (must be 'true' or 'false').
+cygwin=false
+msys=false
+darwin=false
+nonstop=false
+case "$( uname )" in                #(
+  CYGWIN* )         cygwin=true  ;; #(
+  Darwin* )         darwin=true  ;; #(
+  MSYS* | MINGW* )  msys=true    ;; #(
+  NONSTOP* )        nonstop=true ;;
+esac
+
+CLASSPATH=$APP_HOME/gradle/wrapper/gradle-wrapper.jar
+
+
+# Determine the Java command to use to start the JVM.
+if [ -n "$JAVA_HOME" ] ; then
+    if [ -x "$JAVA_HOME/jre/sh/java" ] ; then
+        # IBM's JDK on AIX uses strange locations for the executables
+        JAVACMD=$JAVA_HOME/jre/sh/java
+    else
+        JAVACMD=$JAVA_HOME/bin/java
+    fi
+    if [ ! -x "$JAVACMD" ] ; then
+        die "ERROR: JAVA_HOME is set to an invalid directory: $JAVA_HOME
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+    fi
+else
+    JAVACMD=java
+    which java >/dev/null 2>&1 || die "ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+
+Please set the JAVA_HOME variable in your environment to match the
+location of your Java installation."
+fi
+
+# Increase the maximum file descriptors if we can.
+if ! "$cygwin" && ! "$darwin" && ! "$nonstop" ; then
+    case $MAX_FD in #(
+      max*)
+        MAX_FD=$( ulimit -H -n ) ||
+            warn "Could not query maximum file descriptor limit"
+    esac
+    case $MAX_FD in  #(
+      '' | soft) :;; #(
+      *)
+        ulimit -n "$MAX_FD" ||
+            warn "Could not set maximum file descriptor limit to $MAX_FD"
+    esac
+fi
+
+# Collect all arguments for the java command, stacking in reverse order:
+#   * args from the command line
+#   * the main class name
+#   * -classpath
+#   * -D...appname settings
+#   * --module-path (only if needed)
+#   * DEFAULT_JVM_OPTS, JAVA_OPTS, and GRADLE_OPTS environment variables.
+
+# For Cygwin or MSYS, switch paths to Windows format before running java
+if "$cygwin" || "$msys" ; then
+    APP_HOME=$( cygpath --path --mixed "$APP_HOME" )
+    CLASSPATH=$( cygpath --path --mixed "$CLASSPATH" )
+
+    JAVACMD=$( cygpath --unix "$JAVACMD" )
+
+    # Now convert the arguments - kludge to limit ourselves to /bin/sh
+    for arg do
+        if
+            case $arg in                                #(
+              -*)   false ;;                            # don't mess with options #(
+              /?*)  t=${arg#/} t=/${t%%/*}              # looks like a POSIX filepath
+                    [ -e "$t" ] ;;                      #(
+              *)    false ;;
+            esac
+        then
+            arg=$( cygpath --path --ignore --mixed "$arg" )
+        fi
+        # Roll the args list around exactly as many times as the number of
+        # args, so each arg winds up back in the position where it started, but
+        # possibly modified.
+        #
+        # NB: a `for` loop captures its iteration list before it begins, so
+        # changing the positional parameters here affects neither the number of
+        # iterations, nor the values presented in `arg`.
+        shift                   # remove old arg
+        set -- "$@" "$arg"      # push replacement arg
+    done
+fi
+
+# Collect all arguments for the java command;
+#   * $DEFAULT_JVM_OPTS, $JAVA_OPTS, and $GRADLE_OPTS can contain fragments of
+#     shell script including quotes and variable substitutions, so put them in
+#     double quotes to make sure that they get re-expanded; and
+#   * put everything else in single quotes, so that it's not re-expanded.
+
+set -- \
+        "-Dorg.gradle.appname=$APP_BASE_NAME" \
+        -classpath "$CLASSPATH" \
+        org.gradle.wrapper.GradleWrapperMain \
+        "$@"
+
+# Use "xargs" to parse quoted args.
+#
+# With -n1 it outputs one arg per line, with the quotes and backslashes removed.
+#
+# In Bash we could simply go:
+#
+#   readarray ARGS < <( xargs -n1 <<<"$var" ) &&
+#   set -- "${ARGS[@]}" "$@"
+#
+# but POSIX shell has neither arrays nor command substitution, so instead we
+# post-process each arg (as a line of input to sed) to backslash-escape any
+# character that might be a shell metacharacter, then use eval to reverse
+# that process (while maintaining the separation between arguments), and wrap
+# the whole thing up as a single "set" statement.
+#
+# This will of course break if any of these variables contains a newline or
+# an unmatched quote.
+#
+
+eval "set -- $(
+        printf '%s\n' "$DEFAULT_JVM_OPTS $JAVA_OPTS $GRADLE_OPTS" |
+        xargs -n1 |
+        sed ' s~[^-[:alnum:]+,./:=@_]~\\&~g; ' |
+        tr '\n' ' '
+    )" '"$@"'
+
+exec "$JAVACMD" "$@"

gradlew.bat

@@ -0,0 +1,89 @@
+@rem
+@rem Copyright 2015 the original author or authors.
+@rem
+@rem Licensed under the Apache License, Version 2.0 (the "License");
+@rem you may not use this file except in compliance with the License.
+@rem You may obtain a copy of the License at
+@rem
+@rem      https://www.apache.org/licenses/LICENSE-2.0
+@rem
+@rem Unless required by applicable law or agreed to in writing, software
+@rem distributed under the License is distributed on an "AS IS" BASIS,
+@rem WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+@rem See the License for the specific language governing permissions and
+@rem limitations under the License.
+@rem
+
+@if "%DEBUG%" == "" @echo off
+@rem ##########################################################################
+@rem
+@rem  Gradle startup script for Windows
+@rem
+@rem ##########################################################################
+
+@rem Set local scope for the variables with windows NT shell
+if "%OS%"=="Windows_NT" setlocal
+
+set DIRNAME=%~dp0
+if "%DIRNAME%" == "" set DIRNAME=.
+set APP_BASE_NAME=%~n0
+set APP_HOME=%DIRNAME%
+
+@rem Resolve any "." and ".." in APP_HOME to make it shorter.
+for %%i in ("%APP_HOME%") do set APP_HOME=%%~fi
+
+@rem Add default JVM options here. You can also use JAVA_OPTS and GRADLE_OPTS to pass JVM options to this script.
+set DEFAULT_JVM_OPTS="-Xmx64m" "-Xms64m"
+
+@rem Find java.exe
+if defined JAVA_HOME goto findJavaFromJavaHome
+
+set JAVA_EXE=java.exe
+%JAVA_EXE% -version >NUL 2>&1
+if "%ERRORLEVEL%" == "0" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is not set and no 'java' command could be found in your PATH.
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:findJavaFromJavaHome
+set JAVA_HOME=%JAVA_HOME:"=%
+set JAVA_EXE=%JAVA_HOME%/bin/java.exe
+
+if exist "%JAVA_EXE%" goto execute
+
+echo.
+echo ERROR: JAVA_HOME is set to an invalid directory: %JAVA_HOME%
+echo.
+echo Please set the JAVA_HOME variable in your environment to match the
+echo location of your Java installation.
+
+goto fail
+
+:execute
+@rem Setup the command line
+
+set CLASSPATH=%APP_HOME%\gradle\wrapper\gradle-wrapper.jar
+
+
+@rem Execute Gradle
+"%JAVA_EXE%" %DEFAULT_JVM_OPTS% %JAVA_OPTS% %GRADLE_OPTS% "-Dorg.gradle.appname=%APP_BASE_NAME%" -classpath "%CLASSPATH%" org.gradle.wrapper.GradleWrapperMain %*
+
+:end
+@rem End local scope for the variables with windows NT shell
+if "%ERRORLEVEL%"=="0" goto mainEnd
+
+:fail
+rem Set variable GRADLE_EXIT_CONSOLE if you need the _script_ return code instead of
+rem the _cmd.exe /c_ return code!
+if  not "" == "%GRADLE_EXIT_CONSOLE%" exit 1
+exit /b 1
+
+:mainEnd
+if "%OS%"=="Windows_NT" endlocal
+
+:omega

pom.xml

@@ -1,193 +0,0 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         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.purplex</groupId>
-    <artifactId>packetevents</artifactId>
-    <version>1.2</version>
-    <packaging>jar</packaging>
-    <name>packetevents</name>
-    <properties>
-        <java.version>1.8</java.version>
-        <project.build.sourceEncoding>UTF-8</project.build.sourceEncoding>
-    </properties>
-
-    <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>
-                <version>3.7.0</version>
-                <configuration>
-                    <source>${java.version}</source>
-                    <target>${java.version}</target>
-                </configuration>
-            </plugin>
-        </plugins>
-        <resources>
-            <resource>
-                <directory>src/main/resources</directory>
-                <filtering>true</filtering>
-            </resource>
-        </resources>
-    </build>
-
-    <repositories>
-        <repository>
-            <id>spigot-repo</id>
-            <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
-        </repository>
-        <repository>
-            <id>jitpack.io</id>
-            <url>https://jitpack.io</url>
-        </repository>
-        <repository>
-            <id>funkemunky-releases</id>
-            <url>https://nexus.funkemunky.cc/content/repositories/releases/</url>
-        </repository>
-
-    </repositories>
-
-
-    <dependencies>
-        <dependency>
-            <groupId>org.github.spigot</groupId>
-            <artifactId>1.14.1</artifactId>
-            <version>1.14.1</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <groupId>org.github.spigot</groupId>
-            <artifactId>1.15.1</artifactId>
-            <version>1.15.1</version>
-            <scope>provided</scope>
-        </dependency>
-        <dependency>
-            <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.7.10</artifactId>
-            <version>1.7.10</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>
-
-        <!--Spigot API-->
-        <dependency>
-            <groupId>org.spigotmc</groupId>
-            <artifactId>spigot-api</artifactId>
-            <version>1.8-R0.1-SNAPSHOT</version>
-            <scope>provided</scope>
-        </dependency>
-    </dependencies>
-</project>

settings.gradle

@@ -0,0 +1,10 @@
+pluginManagement {
+    repositories {
+        maven {
+            name = 'Fabric'
+            url = 'https://maven.fabricmc.net/'
+        }
+        mavenCentral()
+        gradlePluginPortal()
+    }
+}

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

@@ -0,0 +1,21 @@
+package io.github.retrooper.packetevents;
+
+import io.netty.channel.ChannelPipeline;
+
+public class ChannelUtilities {
+    public static boolean pipelineContainsSplitterAndPrepender(ChannelPipeline pipeline)
+    {
+        boolean containsSplitter = false;
+        boolean containsPrepender = false;
+        for(var handler : pipeline) {
+            PacketEventsMod.LOGGER.info(handler.getClass().getName());
+            if(handler.getKey().equals("splitter")) {
+                containsSplitter = true;
+            }
+            if(handler.getKey().equals("prepender")) {
+                containsPrepender = true;
+            }
+        }
+        return containsSplitter && containsPrepender;
+    }
+}

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

@@ -0,0 +1,62 @@
+package io.github.retrooper.packetevents;
+
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.event.PacketListenerAbstract;
+import com.github.retrooper.packetevents.event.PacketSendEvent;
+import io.github.retrooper.packetevents.factory.fabric.FabricPacketEventsBuilder;
+import io.github.retrooper.packetevents.factory.fabric.ServerInstanceManager;
+import io.github.retrooper.packetevents.mixin.ClientPacketListenerAccessor;
+import io.github.retrooper.packetevents.mixin.ConnectionAccessor;
+import io.github.retrooper.packetevents.mixin.ServerGamePacketListenerImplAccessor;
+import net.fabricmc.api.ClientModInitializer;
+import net.fabricmc.api.ModInitializer;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
+import net.fabricmc.fabric.api.networking.v1.ServerPlayConnectionEvents;
+import net.fabricmc.loader.api.entrypoint.PreLaunchEntrypoint;
+import net.minecraft.client.Minecraft;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+public class PacketEventsMod implements PreLaunchEntrypoint, ModInitializer, ClientModInitializer {
+    //single player world are locked on loading, don't know why
+    public static final Logger LOGGER = LoggerFactory.getLogger("packetevents");
+
+    @Override
+    public void onPreLaunch() {
+        PacketEvents.setAPI(FabricPacketEventsBuilder.build("packetevents"));
+        PacketEvents.getAPI().getSettings().debug(true).bStats(true);
+        PacketEvents.getAPI().load();
+        //TODO Test if userconnectevent and userdisconnectevent work.
+        //especially disconnect
+    }
+
+    @Override
+    public void onInitialize() {
+        ServerInstanceManager.init();
+        PacketEvents.getAPI().init();
+        ServerPlayConnectionEvents.JOIN.register((handler, sender, server) -> {
+            var connection = ((ServerGamePacketListenerImplAccessor)handler).getConnection();
+            var channel = ((ConnectionAccessor)connection).getChannel();
+            if(ChannelUtilities.pipelineContainsSplitterAndPrepender(channel.pipeline()))
+                PacketEvents.getAPI().getInjector().setPlayer(channel, handler.player);
+        });
+
+        PacketEvents.getAPI().getEventManager().registerListener(new PacketListenerAbstract() {
+            @Override
+            public void onPacketSend(PacketSendEvent event) {
+                //System.out.println("Packet send: " + event.getPacketType());
+                //System.out.println("player: " + event.getPlayer());
+            }
+        });
+    }
+
+    @Override
+    public void onInitializeClient() {
+        ClientPlayConnectionEvents.JOIN.register((handler, sender, client) -> {
+            var connection = ((ClientPacketListenerAccessor)handler).getConnection();
+            var channel = ((ConnectionAccessor)connection).getChannel();
+            if(ChannelUtilities.pipelineContainsSplitterAndPrepender(channel.pipeline()))
+                PacketEvents.getAPI().getInjector().setPlayer(channel, Minecraft.getInstance().player);
+        });
+    }
+}

src/main/java/io/github/retrooper/packetevents/factory/fabric/FabricPacketEventsBuilder.java

@@ -0,0 +1,270 @@
+package io.github.retrooper.packetevents.factory.fabric;
+
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.PacketEventsAPI;
+import com.github.retrooper.packetevents.injector.ChannelInjector;
+import com.github.retrooper.packetevents.manager.InternalPacketListener;
+import com.github.retrooper.packetevents.manager.player.PlayerManager;
+import com.github.retrooper.packetevents.manager.protocol.ProtocolManager;
+import com.github.retrooper.packetevents.manager.server.ServerManager;
+import com.github.retrooper.packetevents.manager.server.ServerVersion;
+import com.github.retrooper.packetevents.netty.NettyManager;
+import com.github.retrooper.packetevents.protocol.ProtocolVersion;
+import com.github.retrooper.packetevents.protocol.packettype.PacketType;
+import com.github.retrooper.packetevents.protocol.player.User;
+import com.github.retrooper.packetevents.settings.PacketEventsSettings;
+import com.github.retrooper.packetevents.util.LogManager;
+import com.github.retrooper.packetevents.util.reflection.ReflectionObject;
+import io.github.retrooper.packetevents.PacketEventsMod;
+import io.github.retrooper.packetevents.handler.ServerPacketDecoder;
+import io.github.retrooper.packetevents.handler.ServerPacketEncoder;
+import io.github.retrooper.packetevents.impl.netty.NettyManagerImpl;
+import io.github.retrooper.packetevents.impl.netty.manager.player.PlayerManagerAbstract;
+import io.github.retrooper.packetevents.impl.netty.manager.protocol.ProtocolManagerAbstract;
+import io.github.retrooper.packetevents.impl.netty.manager.server.ServerManagerAbstract;
+import io.netty.channel.Channel;
+import net.kyori.adventure.text.format.NamedTextColor;
+import net.minecraft.SharedConstants;
+import net.minecraft.client.player.LocalPlayer;
+import net.minecraft.network.Connection;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.world.entity.player.Player;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+
+import java.util.UUID;
+import java.util.logging.Level;
+import java.util.regex.Pattern;
+
+public class FabricPacketEventsBuilder {
+    private static final Pattern STRIP_COLOR_PATTERN = Pattern.compile("(?i)" + '\u00A7' + "[0-9A-FK-ORX]");
+    private static PacketEventsAPI<MinecraftServer> INSTANCE;
+
+    public static void clearBuildCache() {
+        INSTANCE = null;
+    }
+
+    public static PacketEventsAPI<MinecraftServer> build(String modId) {
+        if (INSTANCE == null) {
+            INSTANCE = buildNoCache(modId);
+        }
+        return INSTANCE;
+    }
+
+    public static PacketEventsAPI<MinecraftServer> build(String modId, PacketEventsSettings settings) {
+        if (INSTANCE == null) {
+            INSTANCE = buildNoCache(modId, settings);
+        }
+        return INSTANCE;
+    }
+
+
+    public static PacketEventsAPI<MinecraftServer> buildNoCache(String modId) {
+        return buildNoCache(modId, new PacketEventsSettings());
+    }
+
+    public static PacketEventsAPI<MinecraftServer> buildNoCache(String modId, PacketEventsSettings inSettings) {
+        return new PacketEventsAPI<>() {
+            private final PacketEventsSettings settings = inSettings;
+            //TODO Implement platform version
+            private final ProtocolManager protocolManager = new ProtocolManagerAbstract() {
+                @Override
+                public ProtocolVersion getPlatformVersion() {
+                    return ProtocolVersion.UNKNOWN;
+                }
+            };
+            private final ServerManager serverManager = new ServerManagerAbstract() {
+                private static ServerVersion VERSION;
+
+                @Override
+                public ServerVersion getVersion() {
+                    //TODO Not perfect, as this is on the client! Might be inaccurate by a few patch versions.
+                    if (VERSION == null) {
+                        int targetPV = SharedConstants.getProtocolVersion();
+                        for (ServerVersion version : ServerVersion.reversedValues()) {
+                            if (version.getProtocolVersion() == targetPV) {
+                                VERSION = version;
+                            }
+                        }
+                    }
+                    return VERSION;
+                }
+            };
+
+            private final PlayerManagerAbstract playerManager = new PlayerManagerAbstract() {
+                @Override
+                public int getPing(@NotNull Object player) {
+                    UUID id = ((Player) player).getGameProfile().getId();
+                    try {
+                        var minecraft = getPlugin();
+                        if(minecraft == null)
+                            return ((LocalPlayer) player).connection.getPlayerInfo(id).getLatency();
+                        else {
+                            var playerManager = minecraft.getPlayerList();
+                            var playerEntity = playerManager.getPlayer(id);
+                            return playerEntity.latency;
+                        }
+                    } catch (Exception ex) {
+                        PacketEvents.getAPI().getLogManager().debug("Failed to get ping for player " + id);
+                        return -1;
+                    }
+                }
+
+                @Override
+                public Object getChannel(@NotNull Object player) {
+                    Connection connection = ((LocalPlayer) player).connection.getConnection();
+                    ReflectionObject reflectConnection = new ReflectionObject(connection);
+                    return reflectConnection.readObject(0, Channel.class);
+                }
+            };
+
+            private final ChannelInjector injector = new ChannelInjector() {
+                @Override
+                   public boolean isServerBound() {
+                    return true;
+                }
+
+                @Override
+                public void inject() {
+
+                }
+
+                @Override
+                public void uninject() {
+
+                }
+
+                @Override
+                public void updateUser(Object ch, User user) {
+                    Channel channel = (Channel) ch;
+                    ServerPacketDecoder decoder = (ServerPacketDecoder) channel.pipeline().get(PacketEvents.DECODER_NAME);
+                    decoder.user = user;
+                    ServerPacketEncoder encoder = (ServerPacketEncoder) channel.pipeline().get(PacketEvents.ENCODER_NAME);
+                    encoder.user = user;
+                }
+
+                @Override
+                public void setPlayer(Object ch, Object player) {
+                    Channel channel = (Channel) ch;
+                    ServerPacketDecoder decoder = (ServerPacketDecoder) channel.pipeline().get(PacketEvents.DECODER_NAME);
+                    decoder.player = (Player) player;
+
+                    ServerPacketEncoder encoder = (ServerPacketEncoder) channel.pipeline().get(PacketEvents.ENCODER_NAME);
+                    encoder.player = (Player) player;
+                }
+            };
+            private final NettyManager nettyManager = new NettyManagerImpl();
+            private final LogManager logManager = new LogManager() {
+                @Override
+                protected void log(Level level, @Nullable NamedTextColor color, String message) {
+                    //First we must strip away the color codes that might be in this message
+                    message = STRIP_COLOR_PATTERN.matcher(message).replaceAll("");
+                    PacketEventsMod.LOGGER.info(message);
+                }
+            };
+            private boolean loaded;
+            private boolean initialized;
+
+            @Override
+            public void load() {
+                if (!loaded) {
+                    final String id = modId.toLowerCase();
+                    //Resolve server version and cache
+                    PacketEvents.IDENTIFIER = "pe-" + id;
+                    PacketEvents.ENCODER_NAME = "pe-encoder-" + id;
+                    PacketEvents.DECODER_NAME = "pe-decoder-" + id;
+                    PacketEvents.CONNECTION_HANDLER_NAME = "pe-connection-handler-" + id;
+                    PacketEvents.SERVER_CHANNEL_HANDLER_NAME = "pe-connection-initializer-" + id;
+
+                    injector.inject();
+
+                    loaded = true;
+
+                    //Register internal packet listener (should be the first listener)
+                    //This listener doesn't do any modifications to the packets, just reads data
+                    getEventManager().registerListener(new InternalPacketListener());
+                }
+            }
+
+            @Override
+            public boolean isLoaded() {
+                return loaded;
+            }
+
+            @Override
+            public void init() {
+                //Load if we haven't loaded already
+                load();
+                if (!initialized) {
+                    if (settings.shouldCheckForUpdates()) {
+                        getUpdateChecker().handleUpdateCheck();
+                    }
+
+                    if (settings.isbStatsEnabled()) {
+                        //TODO Cross-platform metrics?
+                    }
+
+                    PacketType.Play.Client.load();
+                    PacketType.Play.Server.load();
+                    initialized = true;
+                }
+            }
+
+            @Override
+            public boolean isInitialized() {
+                return initialized;
+            }
+
+            @Override
+            public void terminate() {
+                if (initialized) {
+                    //Eject the injector if needed(depends on the injector implementation)
+                    injector.uninject();
+                    //Unregister all our listeners
+                    getEventManager().unregisterAllListeners();
+                    initialized = false;
+                }
+            }
+
+            @Override
+            public MinecraftServer getPlugin() {
+                return ServerInstanceManager.getServerInstance();
+            }
+
+            @Override
+            public ProtocolManager getProtocolManager() {
+                return protocolManager;
+            }
+
+            @Override
+            public ServerManager getServerManager() {
+                return serverManager;
+            }
+
+            @Override
+            public LogManager getLogManager() {
+                return logManager;
+            }
+
+            @Override
+            public PlayerManager getPlayerManager() {
+                return playerManager;
+            }
+
+            @Override
+            public ChannelInjector getInjector() {
+                return injector;
+            }
+
+            @Override
+            public PacketEventsSettings getSettings() {
+                return settings;
+            }
+
+            @Override
+            public NettyManager getNettyManager() {
+                return nettyManager;
+            }
+        };
+    }
+}

src/main/java/io/github/retrooper/packetevents/factory/fabric/ServerInstanceManager.java

@@ -0,0 +1,16 @@
+package io.github.retrooper.packetevents.factory.fabric;
+
+import net.fabricmc.fabric.api.event.lifecycle.v1.ServerLifecycleEvents;
+import net.minecraft.server.MinecraftServer;
+
+public class ServerInstanceManager {
+    private static MinecraftServer serverInstance;
+
+    public static void init() {
+        ServerLifecycleEvents.SERVER_STARTED.register(server -> serverInstance = server);
+        ServerLifecycleEvents.SERVER_STOPPED.register(server -> serverInstance = null);
+    }
+    public static MinecraftServer getServerInstance() {
+        return serverInstance;
+    }
+}

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

@@ -0,0 +1,31 @@
+package io.github.retrooper.packetevents.handler;
+
+import com.github.retrooper.packetevents.protocol.player.User;
+import com.github.retrooper.packetevents.util.PacketEventsImplHelper;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import java.util.List;
+
+@ChannelHandler.Sharable
+public class ClientPacketDecoder extends ServerPacketDecoder {
+    public ClientPacketDecoder(User user) {
+         super(user);
+    }
+
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
+        if (msg.isReadable()) {
+            ByteBuf outputBuffer = ctx.alloc().buffer().writeBytes(msg);
+            boolean recompress = handleCompression(ctx, outputBuffer);
+            PacketEventsImplHelper.handleClientBoundPacket(ctx.channel(), user, player, outputBuffer, false);
+            //TODO hasTasksAfter
+            if (outputBuffer.isReadable()) {
+                if (recompress) {
+                    recompress(ctx, outputBuffer);
+                }
+                out.add(outputBuffer.retain());
+            }
+        }
+    }
+}

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

@@ -0,0 +1,22 @@
+package io.github.retrooper.packetevents.handler;
+
+import com.github.retrooper.packetevents.protocol.player.User;
+import com.github.retrooper.packetevents.util.PacketEventsImplHelper;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+
+@ChannelHandler.Sharable
+public class ClientPacketEncoder extends ServerPacketEncoder {
+    public ClientPacketEncoder(User user) {
+        super(user);
+    }
+
+    @Override
+    protected void encode(ChannelHandlerContext ctx, ByteBuf msg, ByteBuf out) throws Exception {
+        if (msg.isReadable()) {
+            PacketEventsImplHelper.handleServerBoundPacket(ctx.channel(), user, player, msg, false);
+            out.writeBytes(msg);
+        }
+    }
+}

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

@@ -0,0 +1,104 @@
+package io.github.retrooper.packetevents.handler;
+
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.protocol.player.User;
+import com.github.retrooper.packetevents.util.PacketEventsImplHelper;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToMessageDecoder;
+import net.minecraft.world.entity.player.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+@ChannelHandler.Sharable
+public class PacketDecoder extends MessageToMessageDecoder<ByteBuf> {
+    private static Method DECOMPRESSOR_METHOD, COMPRESSOR_METHOD;
+    public User user;
+    public Player player;
+    public boolean checkedCompression;
+
+    public PacketDecoder(User user) {
+        this.user = user;
+    }
+
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
+        if (msg.isReadable()) {
+            ByteBuf outputBuffer = ctx.alloc().buffer().writeBytes(msg);
+            boolean recompress = handleCompression(ctx, outputBuffer);
+
+            PacketEventsImplHelper.handleClientBoundPacket(ctx.channel(), user, player, outputBuffer, false);
+            //TODO hasTasksAfter
+            if (outputBuffer.isReadable()) {
+                if (recompress) {
+                    recompress(ctx, outputBuffer);
+                }
+                out.add(outputBuffer.retain());
+            }
+        }
+    }
+
+    @Override
+    public void channelInactive(@NotNull ChannelHandlerContext ctx) throws Exception {
+        super.channelInactive(ctx);
+    }
+
+
+    protected boolean handleCompression(ChannelHandlerContext ctx, ByteBuf buffer) {
+        if (checkedCompression) return false;
+        if (ctx.pipeline().names().indexOf("decompress") > ctx.pipeline().names().indexOf(PacketEvents.DECODER_NAME)) {
+            // Need to decompress this packet due to bad order
+            ChannelHandler decompressor = ctx.pipeline().get("decompress");
+            //CompressionDecoder
+            try {
+                if (DECOMPRESSOR_METHOD == null) {
+                    DECOMPRESSOR_METHOD = decompressor.getClass().getDeclaredMethod("decode", ChannelHandlerContext.class, ByteBuf.class, List.class);
+                }
+                List<?> list = new ArrayList<>(1);
+                DECOMPRESSOR_METHOD.invoke(decompressor, ctx, buffer, list);
+                ByteBuf decompressed = (ByteBuf) list.get(0);
+                if (buffer != decompressed) {
+                    try {
+                        buffer.clear().writeBytes(decompressed);
+                    } finally {
+                        decompressed.release();
+                    }
+                }
+                //Relocate handlers
+                PacketDecoder decoder = (PacketDecoder) ctx.pipeline().remove(PacketEvents.DECODER_NAME);
+                ctx.pipeline().addAfter("decompress", PacketEvents.DECODER_NAME, decoder);
+                PacketEncoder encoder = (PacketEncoder) ctx.pipeline().remove(PacketEvents.ENCODER_NAME);
+                ctx.pipeline().addAfter("compress", PacketEvents.ENCODER_NAME, encoder);
+                checkedCompression = true;
+                return true;
+            } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+        return false;
+    }
+
+    protected void recompress(ChannelHandlerContext ctx, ByteBuf buffer) {
+        ByteBuf compressed = ctx.alloc().buffer();
+        try {
+            ChannelHandler compressor = ctx.pipeline().get("compress");
+            if (COMPRESSOR_METHOD == null) {
+                COMPRESSOR_METHOD = compressor.getClass().getDeclaredMethod("encode", ChannelHandlerContext.class, ByteBuf.class, ByteBuf.class);
+            }
+            COMPRESSOR_METHOD.invoke(compressor, ctx, buffer, compressed);
+        } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        try {
+            buffer.clear().writeBytes(compressed);
+            PacketEvents.getAPI().getLogManager().debug("Recompressed packet!");
+        } finally {
+            compressed.release();
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+package io.github.retrooper.packetevents.handler;
+
+import com.github.retrooper.packetevents.protocol.player.User;
+import com.github.retrooper.packetevents.util.PacketEventsImplHelper;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import io.netty.handler.codec.EncoderException;
+import io.netty.handler.codec.MessageToByteEncoder;
+import io.netty.util.ReferenceCountUtil;
+import net.minecraft.world.entity.player.Player;
+
+@ChannelHandler.Sharable
+public class PacketEncoder extends MessageToByteEncoder<ByteBuf> {
+    public User user;
+    public Player player;
+
+    public PacketEncoder(User user) {
+        this.user = user;
+    }
+
+    @Override
+    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
+        ByteBuf buf = null;
+        try {
+            if (acceptOutboundMessage(msg)) {
+                ByteBuf in = (ByteBuf) msg;
+                buf = allocateBuffer(ctx, in, true);
+                try {
+                    encode(ctx, in, buf);
+                } finally {
+                    ReferenceCountUtil.release(in);
+                }
+                if (buf.isReadable()) {
+                    ctx.write(buf, promise);
+                } else {
+                    buf.release();
+                    //We cancelled this packet, do not pass it on to the next handler.
+                    //ctx.write(Unpooled.EMPTY_BUFFER, promise);
+                }
+                buf = null;
+            } else {
+                ctx.write(msg, promise);
+            }
+        } catch (EncoderException e) {
+            throw e;
+        } catch (Throwable e) {
+            throw new EncoderException(e);
+        } finally {
+            if (buf != null) {
+                buf.release();
+            }
+        }
+    }
+
+    @Override
+    protected void encode(ChannelHandlerContext ctx, ByteBuf msg, ByteBuf out) throws Exception {
+        if (msg.isReadable()) {
+            PacketEventsImplHelper.handleServerBoundPacket(ctx.channel(), user, player, msg, false);
+            out.writeBytes(msg);
+        }
+    }
+}

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

@@ -0,0 +1,104 @@
+package io.github.retrooper.packetevents.handler;
+
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.protocol.player.User;
+import com.github.retrooper.packetevents.util.PacketEventsImplHelper;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToMessageDecoder;
+import net.minecraft.world.entity.player.Player;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+import java.util.ArrayList;
+import java.util.List;
+
+@ChannelHandler.Sharable
+public class ServerPacketDecoder extends MessageToMessageDecoder<ByteBuf> {
+    private static Method DECOMPRESSOR_METHOD, COMPRESSOR_METHOD;
+    public User user;
+    public Player player;
+    public boolean checkedCompression;
+
+    public ServerPacketDecoder(User user) {
+        this.user = user;
+    }
+
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf msg, List<Object> out) throws Exception {
+        if (msg.isReadable()) {
+            ByteBuf outputBuffer = ctx.alloc().buffer().writeBytes(msg);
+            boolean recompress = handleCompression(ctx, outputBuffer);
+
+            PacketEventsImplHelper.handleServerBoundPacket(ctx.channel(), user, player, outputBuffer, false);
+            //TODO hasTasksAfter
+            if (outputBuffer.isReadable()) {
+                if (recompress) {
+                    recompress(ctx, outputBuffer);
+                }
+                out.add(outputBuffer.retain());
+            }
+        }
+    }
+
+    @Override
+    public void channelInactive(@NotNull ChannelHandlerContext ctx) throws Exception {
+        super.channelInactive(ctx);
+    }
+
+
+    protected boolean handleCompression(ChannelHandlerContext ctx, ByteBuf buffer) {
+        if (checkedCompression) return false;
+        if (ctx.pipeline().names().indexOf("decompress") > ctx.pipeline().names().indexOf(PacketEvents.DECODER_NAME)) {
+            // Need to decompress this packet due to bad order
+            ChannelHandler decompressor = ctx.pipeline().get("decompress");
+            //CompressionDecoder
+            try {
+                if (DECOMPRESSOR_METHOD == null) {
+                    DECOMPRESSOR_METHOD = decompressor.getClass().getDeclaredMethod("decode", ChannelHandlerContext.class, ByteBuf.class, List.class);
+                }
+                List<?> list = new ArrayList<>(1);
+                DECOMPRESSOR_METHOD.invoke(decompressor, ctx, buffer, list);
+                ByteBuf decompressed = (ByteBuf) list.get(0);
+                if (buffer != decompressed) {
+                    try {
+                        buffer.clear().writeBytes(decompressed);
+                    } finally {
+                        decompressed.release();
+                    }
+                }
+                //Relocate handlers
+                ServerPacketDecoder decoder = (ServerPacketDecoder) ctx.pipeline().remove(PacketEvents.DECODER_NAME);
+                ctx.pipeline().addAfter("decompress", PacketEvents.DECODER_NAME, decoder);
+                ServerPacketEncoder encoder = (ServerPacketEncoder) ctx.pipeline().remove(PacketEvents.ENCODER_NAME);
+                ctx.pipeline().addAfter("compress", PacketEvents.ENCODER_NAME, encoder);
+                checkedCompression = true;
+                return true;
+            } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException e) {
+                e.printStackTrace();
+            }
+        }
+        return false;
+    }
+
+    protected void recompress(ChannelHandlerContext ctx, ByteBuf buffer) {
+        ByteBuf compressed = ctx.alloc().buffer();
+        try {
+            ChannelHandler compressor = ctx.pipeline().get("compress");
+            if (COMPRESSOR_METHOD == null) {
+                COMPRESSOR_METHOD = compressor.getClass().getDeclaredMethod("encode", ChannelHandlerContext.class, ByteBuf.class, ByteBuf.class);
+            }
+            COMPRESSOR_METHOD.invoke(compressor, ctx, buffer, compressed);
+        } catch (InvocationTargetException | NoSuchMethodException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        try {
+            buffer.clear().writeBytes(compressed);
+            PacketEvents.getAPI().getLogManager().debug("Recompressed packet!");
+        } finally {
+            compressed.release();
+        }
+    }
+}

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

@@ -0,0 +1,64 @@
+package io.github.retrooper.packetevents.handler;
+
+import com.github.retrooper.packetevents.protocol.player.User;
+import com.github.retrooper.packetevents.util.PacketEventsImplHelper;
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.channel.ChannelPromise;
+import io.netty.handler.codec.EncoderException;
+import io.netty.handler.codec.MessageToByteEncoder;
+import io.netty.util.ReferenceCountUtil;
+import net.minecraft.world.entity.player.Player;
+
+@ChannelHandler.Sharable
+public class ServerPacketEncoder extends MessageToByteEncoder<ByteBuf> {
+    public User user;
+    public Player player;
+
+    public ServerPacketEncoder(User user) {
+        this.user = user;
+    }
+
+    @Override
+    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) {
+        ByteBuf buf = null;
+        try {
+            if (acceptOutboundMessage(msg)) {
+                ByteBuf in = (ByteBuf) msg;
+                buf = allocateBuffer(ctx, in, true);
+                try {
+                    encode(ctx, in, buf);
+                } finally {
+                    ReferenceCountUtil.release(in);
+                }
+                if (buf.isReadable()) {
+                    ctx.write(buf, promise);
+                } else {
+                    buf.release();
+                    //We cancelled this packet, do not pass it on to the next handler.
+                    //ctx.write(Unpooled.EMPTY_BUFFER, promise);
+                }
+                buf = null;
+            } else {
+                ctx.write(msg, promise);
+            }
+        } catch (EncoderException e) {
+            throw e;
+        } catch (Throwable e) {
+            throw new EncoderException(e);
+        } finally {
+            if (buf != null) {
+                buf.release();
+            }
+        }
+    }
+
+    @Override
+    protected void encode(ChannelHandlerContext ctx, ByteBuf msg, ByteBuf out) throws Exception {
+        if (msg.isReadable()) {
+            PacketEventsImplHelper.handleClientBoundPacket(ctx.channel(), user, player, msg, false);
+            out.writeBytes(msg);
+        }
+    }
+}

src/main/java/io/github/retrooper/packetevents/mixin/ClientPacketListenerAccessor.java

@@ -0,0 +1,12 @@
+package io.github.retrooper.packetevents.mixin;
+
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.network.Connection;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(ClientPacketListener.class)
+public interface ClientPacketListenerAccessor {
+    @Accessor
+    Connection getConnection();
+}

src/main/java/io/github/retrooper/packetevents/mixin/ConnectionAccessor.java

@@ -0,0 +1,11 @@
+package io.github.retrooper.packetevents.mixin;
+
+import io.netty.channel.Channel;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+
+@Mixin(net.minecraft.network.Connection.class)
+public interface ConnectionAccessor {
+    @Accessor
+    Channel getChannel();
+}

src/main/java/io/github/retrooper/packetevents/mixin/PacketEventsInjectorMixin.java

@@ -0,0 +1,67 @@
+package io.github.retrooper.packetevents.mixin;
+
+import com.github.retrooper.packetevents.PacketEvents;
+import com.github.retrooper.packetevents.manager.protocol.ProtocolManager;
+import com.github.retrooper.packetevents.netty.channel.ChannelHelper;
+import com.github.retrooper.packetevents.protocol.ConnectionState;
+import com.github.retrooper.packetevents.protocol.player.ClientVersion;
+import com.github.retrooper.packetevents.protocol.player.User;
+import com.github.retrooper.packetevents.protocol.player.UserProfile;
+import io.github.retrooper.packetevents.ChannelUtilities;
+import io.github.retrooper.packetevents.PacketEventsMod;
+import io.github.retrooper.packetevents.handler.ServerPacketDecoder;
+import io.github.retrooper.packetevents.handler.ServerPacketEncoder;
+import io.github.retrooper.packetevents.handler.ClientPacketDecoder;
+import io.github.retrooper.packetevents.handler.ClientPacketEncoder;
+import io.netty.channel.Channel;
+import io.netty.channel.ChannelHandlerContext;
+import net.minecraft.network.protocol.PacketFlow;
+import org.spongepowered.asm.mixin.Final;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+
+@Mixin(net.minecraft.network.Connection.class)
+public class PacketEventsInjectorMixin {
+
+    @Shadow @Final
+    private PacketFlow receiving;
+
+    @Inject(method = "channelActive", at = @At("HEAD"))
+    private void channelActive(ChannelHandlerContext ctx, CallbackInfo info) {
+
+        Channel channel = ctx.channel();
+        User user = new User(channel, ConnectionState.HANDSHAKING, ClientVersion.getLatest(),
+                new UserProfile(null, null));
+        ProtocolManager.USERS.put(channel, user);
+        ServerPacketDecoder decoder;
+        ServerPacketEncoder encoder;
+        if(receiving == PacketFlow.CLIENTBOUND) {
+            PacketEventsMod.LOGGER.info("Connected as Client!");
+            decoder = new ClientPacketDecoder(user);
+            encoder = new ClientPacketEncoder(user);
+        }
+        else
+        {
+
+            PacketEventsMod.LOGGER.info("Connected as Server!");
+            decoder = new ServerPacketDecoder(user);
+            encoder = new ServerPacketEncoder(user);
+        }
+
+        if(ChannelUtilities.pipelineContainsSplitterAndPrepender(channel.pipeline()))
+        {
+            channel.pipeline().addAfter("splitter", PacketEvents.DECODER_NAME, decoder);
+            channel.pipeline().addAfter("prepender", PacketEvents.ENCODER_NAME, encoder);
+        }
+        PacketEventsMod.LOGGER.info("Pipeline: " + ChannelHelper.pipelineHandlerNamesAsString(channel));
+    }
+
+    @Inject(method = "channelInactive", at = @At("HEAD"))
+    private void channelInactive(ChannelHandlerContext ctx, CallbackInfo info) {
+        PacketEventsMod.LOGGER.debug("Disconnected!");
+    }
+}

src/main/java/io/github/retrooper/packetevents/mixin/ServerGamePacketListenerImplAccessor.java

@@ -0,0 +1,12 @@
+package io.github.retrooper.packetevents.mixin;
+
+import net.minecraft.server.network.ServerGamePacketListenerImpl;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.gen.Accessor;
+import net.minecraft.network.Connection;
+
+@Mixin(ServerGamePacketListenerImpl.class)
+public interface ServerGamePacketListenerImplAccessor {
+    @Accessor
+    Connection getConnection();
+}

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

@@ -1,80 +0,0 @@
-package me.purplex.packetevents;
-
-import me.purplex.packetevents.enums.ServerVersion;
-import me.purplex.packetevents.injector.PacketInjector;
-import me.purplex.packetevents.packetevent.impl.ServerTickEvent;
-import me.purplex.packetevents.packetevent.manager.PacketManager;
-import org.bukkit.Bukkit;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerJoinEvent;
-import org.bukkit.event.player.PlayerQuitEvent;
-import org.bukkit.plugin.java.JavaPlugin;
-
-import java.util.concurrent.*;
-
-public class PacketEvents implements Listener {
-    private static PacketEvents instance;
-    private static PacketInjector packetInjector = new PacketInjector();
-    public static ExecutorService executor = Executors.newCachedThreadPool();
-    private static final PacketManager packetManager = new PacketManager();
-
-    public static ServerVersion getServerVersion() {
-        return ServerVersion.getVersion();
-    }
-
-    private static int asyncRepeatingTask;
-
-    private static boolean serverTickEventActive = false;
-
-
-    public static PacketManager getPacketManager() {
-        return packetManager;
-    }
-
-    public static void setup(JavaPlugin plugin, boolean serverTickEventEnabled) {
-        serverTickEventActive = serverTickEventEnabled;
-        Bukkit.getPluginManager().registerEvents(getInstance(), plugin);
-
-        if (serverTickEventEnabled) {
-            asyncRepeatingTask = Bukkit.getScheduler().scheduleAsyncRepeatingTask(plugin, new Runnable() {
-                @Override
-                public void run() {
-                    long now = System.currentTimeMillis();
-                    PacketEvents.getPacketManager().callEvent(new ServerTickEvent(now));
-                }
-            }, 0L, 1L);
-        }
-    }
-
-    public static void cleanup(JavaPlugin plugin) {
-        if (serverTickEventActive) {
-            Bukkit.getScheduler().cancelTasks(plugin);
-        }
-    }
-
-
-    @EventHandler
-    public void onJoin(PlayerJoinEvent e) {
-        if (executor == null) {
-            executor = Executors.newCachedThreadPool();
-            packetInjector.injectPlayer(e.getPlayer());
-            System.out.println("Failed to inject " + e.getPlayer().getName() + " asynchronously!");
-        }
-        executor.submit(new Runnable() {
-            @Override
-            public void run() {
-                packetInjector.injectPlayer(e.getPlayer());
-            }
-        });
-    }
-
-    @EventHandler
-    public void onQuit(PlayerQuitEvent e) {
-        packetInjector.uninjectPlayer(e.getPlayer());
-    }
-
-    public static PacketEvents getInstance() {
-        return instance == null ? instance = new PacketEvents() : instance;
-    }
-}

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

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

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

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

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

@@ -1,24 +0,0 @@
-package me.purplex.packetevents.enums;
-
-import org.apache.commons.lang.ArrayUtils;
-import org.bukkit.Bukkit;
-
-
-public enum ServerVersion
-{
-    v_1_7_10, v_1_8, v_1_8_3, v_1_8_8, v_1_9, v_1_9_4, v_1_10, v_1_11, v_1_12, v_1_13, v_1_13_2, v_1_14, v_1_15,
-    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/example/CustomMoveEvent.java

@@ -1,60 +0,0 @@
-package me.purplex.packetevents.example;
-
-import me.purplex.packetevents.packetevent.PacketEvent;
-import org.bukkit.Location;
-import org.bukkit.entity.Player;
-
-/**
- * Example packetevent
- * Make sure to initiate the super timestamp variable,
- * if you want to use the getTimestamp() function
- */
-public class CustomMoveEvent extends PacketEvent {
-    private final Player player;
-    private Location to, from;
-    private boolean cancelled;
-
-    public CustomMoveEvent(final Player player, final Location to, final Location from) {
-        this.player = player;
-        this.to = to;
-        this.from = from;
-        this.cancelled = false;
-
-        //IMPORTANT to initialize the timestamp variable
-        this.timestamp = (System.nanoTime() / 1000000);
-    }
-
-    @Override
-    public long getTimestamp() {
-        return super.getTimestamp();
-    }
-
-    public void setCancelled(boolean cancelled) {
-        this.cancelled = cancelled;
-    }
-
-    public boolean isCancelled() {
-        return this.cancelled;
-    }
-
-    public Player getPlayer() {
-        return player;
-    }
-
-    public Location getTo() {
-        return to;
-    }
-
-    public Location getFrom() {
-        return from;
-    }
-
-    public void setTo(Location loc) {
-        this.to = loc;
-    }
-
-    public void setFrom(Location loc) {
-        this.from = from;
-    }
-
-}

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

@@ -1,29 +0,0 @@
-package me.purplex.packetevents.example;
-
-import me.purplex.packetevents.PacketEvents;
-import org.bukkit.plugin.java.JavaPlugin;
-
-public class MainExample extends JavaPlugin {
-    @Override
-    public void onEnable() {
-        /**
-         * Starts the servertickevent repeating task (if enabled)
-         * and registers onJoin and onQuit events to inject and uninject players.
-         *
-         * First argument is the JavaPlugin instance to register these events and start the task with,
-         * Second argument enables server tick event
-         */
-        PacketEvents.setup(this, true);
-
-        PacketEvents.getPacketManager().registerListener(new TestExample());
-    }
-
-    @Override
-    public void onDisable() {
-        /**
-         * Stops server tick event task if enabled
-         */
-        PacketEvents.cleanup(this);
-    }
-
-}

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

@@ -1,158 +0,0 @@
-package me.purplex.packetevents.example;
-
-import me.purplex.packetevents.PacketEvents;
-import me.purplex.packetevents.enums.EntityUseAction;
-import me.purplex.packetevents.enums.PlayerDigType;
-import me.purplex.packetevents.packetevent.PacketEvent;
-import me.purplex.packetevents.packetevent.impl.PacketReceiveEvent;
-import me.purplex.packetevents.packetevent.impl.PacketSendEvent;
-import me.purplex.packetevents.packetevent.impl.ServerTickEvent;
-import me.purplex.packetevents.packetevent.handler.PacketHandler;
-import me.purplex.packetevents.packetevent.listener.PacketListener;
-import me.purplex.packetevents.packetevent.packet.Packet;
-import me.purplex.packetevents.packetwrappers.in.*;
-import org.bukkit.Location;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerMoveEvent;
-
-/**
- * Implementing PacketListener to listen to packets and packetevents' custom events.
- * Implementing org.bukkit.event.Listener to listen to bukkit's events
- */
-public class TestExample implements PacketListener, Listener {
-    /**
-     * How to register a packet listener?
-     * <p>
-     * PacketEvents.getPacketManager().registerListener(new TestExample());
-     */
-
-    /**
-     * How to unregister a packet listener?
-     * PacketEvents.getPacketManager().unregisterListener(new TestExample());
-     */
-
-    private int tick;
-
-    /**
-     * Only listen to the onPacketReceive
-     * @param e
-     */
-    @PacketHandler
-    public void onPacketReceive(PacketReceiveEvent e) {
-        final Player p = e.getPlayer();
-        final long timestamp = e.getTimestamp();
-        //ONLY CLIENT PACKETS ALLOWED HERE!
-        switch (e.getPacketName()) {
-            case Packet.Client.USE_ENTITY:
-                final WrappedPacketPlayInUseEntity useEntity = new WrappedPacketPlayInUseEntity(e.getPacket());
-                final Entity entity = useEntity.entity;
-                if (useEntity.action == EntityUseAction.ATTACK) {
-                    final double dist = entity.getLocation().distanceSquared(p.getLocation());
-                    //p.sendMessage("dist: " + dist);
-                }
-                break;
-            case Packet.Client.ABILITIES:
-                //1.8 packet style
-                final WrappedPacketPlayInAbilities abilities = new WrappedPacketPlayInAbilities(e.getPacket());
-                final boolean a = abilities.a;
-                final boolean b = abilities.b;
-                final boolean c = abilities.c;
-                final boolean d = abilities.d;
-                final float eFloat = abilities.e;
-                final float fFloat = abilities.f;
-                break;
-            case Packet.Client.BLOCK_DIG:
-                //Custom PlayerDigType enum
-                final WrappedPacketPlayInBlockDig blockDig = new WrappedPacketPlayInBlockDig(e.getPacket());
-                final PlayerDigType type = blockDig.digType;
-                break;
-            case Packet.Client.FLYING:
-                final WrappedPacketPlayInFlying flying = new WrappedPacketPlayInFlying(e.getPacket());
-                final float pitch = flying.pitch;
-                final float yaw = flying.yaw;
-                final boolean hasPos = flying.hasPos;
-                final boolean hasLook = flying.hasLook;
-                break;
-            case Packet.Client.POSITION:
-                final WrappedPacketPlayInFlying.WrappedPacketPlayInPosition position =
-                        new WrappedPacketPlayInFlying.WrappedPacketPlayInPosition(e.getPacket());
-                final boolean isPos = position.hasPos; //true
-                break;
-            case Packet.Client.POSITION_LOOK:
-                final WrappedPacketPlayInFlying.WrappedPacketPlayInPosition_Look position_look =
-                        new WrappedPacketPlayInFlying.WrappedPacketPlayInPosition_Look(e.getPacket());
-                final boolean isLook = position_look.hasLook; //true
-                break;
-            case Packet.Client.CHAT:
-                final WrappedPacketPlayInChat chat = new WrappedPacketPlayInChat(e.getPacket());
-                final String message = chat.message;
-                //System.out.println("YOU SAID: " + message);
-        }
-    }
-
-    @PacketHandler
-    public void onPacketSend(PacketSendEvent e) {
-        if(e.getPacketName().equals(Packet.Server.KEEP_ALIVE)) {
-
-        }
-    }
-
-    @PacketHandler
-    public void onCustomMove(CustomMoveEvent e) {
-
-    }
-
-    /**
-     * Another way to listen to packets
-     * @param e
-     */
-    @PacketHandler
-    public void onPacket(PacketEvent e) {
-        if(e instanceof PacketSendEvent) {
-            final PacketSendEvent p = (PacketSendEvent)e;
-            final Player targetPlayer = p.getPlayer();
-            final Object rawNMSPacket = p.getPacket();
-            final long timestamp = p.getTimestamp();
-        }
-        else if(e instanceof CustomMoveEvent){
-            final CustomMoveEvent event = (CustomMoveEvent)e;
-            final Player player = event.getPlayer();
-            final Location to = event.getTo();
-            final Location from = event.getFrom();
-        }
-    }
-
-
-    /**
-     * Update the CustomMoveEvent event
-     * @param e
-     */
-    @EventHandler
-    public void onMove(PlayerMoveEvent e) {
-        CustomMoveEvent customMoveEvent = new CustomMoveEvent(e.getPlayer(),e.getTo(), e.getFrom());
-        e.setCancelled(customMoveEvent.isCancelled());
-        PacketEvents.getPacketManager().callEvent(customMoveEvent);
-
-        if(e.getTo() != customMoveEvent.getTo()) {
-            e.setTo(customMoveEvent.getTo());
-        }
-        if(e.getFrom() != customMoveEvent.getFrom()) {
-            e.setFrom(customMoveEvent.getFrom());
-        }
-    }
-
-    /**
-     * Only listen to server tick (if enabled)
-     * @param e
-     */
-    @PacketHandler
-    public void onServerTick(ServerTickEvent e) {
-        if (tick++ % 20 == 0) {
-           //one second passed
-        }
-    }
-
-}

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

@@ -1,106 +0,0 @@
-package me.purplex.packetevents.injector;
-
-
-import io.netty.channel.*;
-import me.purplex.packetevents.PacketEvents;
-import me.purplex.packetevents.enums.ServerVersion;
-import me.purplex.packetevents.injector.channels._1_10.Channel_1_10;
-import me.purplex.packetevents.injector.channels._1_11.Channel_1_11;
-import me.purplex.packetevents.injector.channels._1_12.Channel_1_12;
-import me.purplex.packetevents.injector.channels._1_13.Channel_1_13;
-import me.purplex.packetevents.injector.channels._1_13_2.Channel_1_13_2;
-import me.purplex.packetevents.injector.channels._1_14.Channel_1_14;
-import me.purplex.packetevents.injector.channels._1_15.Channel_1_15;
-import me.purplex.packetevents.injector.channels._1_7_10.Channel_1_7_10;
-import me.purplex.packetevents.injector.channels._1_8.Channel_1_8;
-import me.purplex.packetevents.injector.channels._1_8_3.Channel_1_8_3;
-import me.purplex.packetevents.injector.channels._1_8_8.Channel_1_8_8;
-import me.purplex.packetevents.injector.channels._1_9.Channel_1_9;
-import me.purplex.packetevents.injector.channels._1_9_4.Channel_1_9_4;
-import me.purplex.packetevents.packetevent.impl.PacketReceiveEvent;
-import me.purplex.packetevents.packetevent.impl.PacketSendEvent;
-import org.bukkit.entity.Player;
-
-
-public class PacketInjector {
-    private final static ServerVersion version;
-
-    static {
-        version = ServerVersion.getVersion();
-    }
-
-    public void injectPlayer(Player player) {
-        ChannelDuplexHandler channelDuplexHandler = new ChannelDuplexHandler() {
-            @Override
-            public void channelRead(ChannelHandlerContext ctx, Object packet) throws Exception {
-                String packetName = packet.getClass().getSimpleName();
-                PacketReceiveEvent e = new PacketReceiveEvent(player, packetName, packet);
-                PacketEvents.getPacketManager().callEvent(e);
-                if (e.isCancelled()) {
-                    return;
-                }
-                super.channelRead(ctx, packet);
-
-            }
-
-            @Override
-            public void write(ChannelHandlerContext ctx, Object packet, ChannelPromise promise) throws Exception {
-                String packetName = packet.getClass().getSimpleName();
-                PacketSendEvent e = new PacketSendEvent(player, packetName, packet);
-                PacketEvents.getPacketManager().callEvent(e);
-                if (e.isCancelled()) {
-                    return;
-                }
-                super.write(ctx, packet, promise);
-            }
-        };
-        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(new Runnable() {
-            @Override
-            public void run() {
-                channel.pipeline().remove(player.getName());
-            }
-        });
-    }
-
-    public Channel getChannel(Player player) {
-        Channel channel = null;
-        if (version == ServerVersion.v_1_7_10) {
-            channel = new Channel_1_7_10().getChannel(player);
-        } else if (version == ServerVersion.v_1_8) {
-            channel = new Channel_1_8().getChannel(player);
-        } else if (version == ServerVersion.v_1_8_3) {
-            channel = new Channel_1_8_3().getChannel(player);
-        } else if (version == ServerVersion.v_1_8_8) {
-            channel = new Channel_1_8_8().getChannel(player);
-        } else if (version == ServerVersion.v_1_9) {
-            channel = new Channel_1_9().getChannel(player);
-        } else if (version == ServerVersion.v_1_9_4) {
-            channel = new Channel_1_9_4().getChannel(player);
-        } else if (version == ServerVersion.v_1_10) {
-            channel = new Channel_1_10().getChannel(player);
-        } else if (version == ServerVersion.v_1_11) {
-            channel = new Channel_1_11().getChannel(player);
-        } else if (version == ServerVersion.v_1_12) {
-            channel = new Channel_1_12().getChannel(player);
-        } else if (version == ServerVersion.v_1_13) {
-            channel = new Channel_1_13().getChannel(player);
-        } else if (version == ServerVersion.v_1_13_2) {
-            channel = new Channel_1_13_2().getChannel(player);
-        } else if (version == ServerVersion.v_1_14) {
-            channel = new Channel_1_14().getChannel(player);
-        } else if (version == ServerVersion.v_1_15) {
-            channel = new Channel_1_15().getChannel(player);
-        } else {
-            String err = "Version unsupported, please contact purplex(creator) through his discord server (http://discord.gg/2uZY5A4) and tell him what version your server is running on! Make sure you are using spigot!";
-            throw new IllegalStateException(err);
-        }
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_10/Channel_1_10.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_10;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_10_R1.EntityPlayer;
-import net.minecraft.server.v1_10_R1.NetworkManager;
-import org.bukkit.craftbukkit.v1_10_R1.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_10 {
-
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = networkManager.channel;
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_11/Channel_1_11.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_11;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_11_R1.EntityPlayer;
-import net.minecraft.server.v1_11_R1.NetworkManager;
-import org.bukkit.craftbukkit.v1_11_R1.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_11 {
-
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = networkManager.channel;
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_12/Channel_1_12.java

@@ -1,16 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_12;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_12_R1.EntityPlayer;
-import net.minecraft.server.v1_12_R1.NetworkManager;
-import org.bukkit.craftbukkit.v1_12_R1.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_12 {
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = networkManager.channel;
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_13/Channel_1_13.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_13;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_13_R1.EntityPlayer;
-import net.minecraft.server.v1_13_R1.NetworkManager;
-import org.bukkit.craftbukkit.v1_13_R1.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_13 {
-
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = networkManager.channel;
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_13_2/Channel_1_13_2.java

@@ -1,16 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_13_2;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_13_R2.EntityPlayer;
-import net.minecraft.server.v1_13_R2.NetworkManager;
-import org.bukkit.craftbukkit.v1_13_R2.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_13_2 {
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = networkManager.channel;
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_14/Channel_1_14.java

@@ -1,16 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_14;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_14_R1.EntityPlayer;
-import net.minecraft.server.v1_14_R1.NetworkManager;
-import org.bukkit.craftbukkit.v1_14_R1.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_14 {
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = networkManager.channel;
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_15/Channel_1_15.java

@@ -1,16 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_15;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_15_R1.EntityPlayer;
-import net.minecraft.server.v1_15_R1.NetworkManager;
-import org.bukkit.craftbukkit.v1_15_R1.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_15 {
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = networkManager.channel;
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_7_10/Channel_1_7_10.java

@@ -1,33 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_7_10;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_7_R4.EntityPlayer;
-import net.minecraft.server.v1_7_R4.NetworkManager;
-import org.bukkit.craftbukkit.v1_7_R4.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-import java.lang.reflect.Field;
-
-public class Channel_1_7_10 {
-
-    private static Field field;
-    static {
-        try {
-            field = NetworkManager.class.getDeclaredField("m");
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-        field.setAccessible(true);
-    }
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = null;
-        try {
-            channel = (Channel) field.get(networkManager);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_8/Channel_1_8.java

@@ -1,34 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_8;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_8_R1.EntityPlayer;
-import net.minecraft.server.v1_8_R1.NetworkManager;
-import org.bukkit.craftbukkit.v1_8_R1.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-import java.lang.reflect.Field;
-
-public class Channel_1_8 {
-
-    private static Field field;
-    static {
-        try {
-            field = NetworkManager.class.getDeclaredField("i");
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-        field.setAccessible(true);
-    }
-
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = null;
-        try {
-            channel = (Channel) field.get(networkManager);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_8_3/Channel_1_8_3.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_8_3;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_8_R2.EntityPlayer;
-import net.minecraft.server.v1_8_R2.NetworkManager;
-import org.bukkit.craftbukkit.v1_8_R2.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_8_3 {
-
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = networkManager.k;
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_8_8/Channel_1_8_8.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_8_8;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_8_R3.EntityPlayer;
-import net.minecraft.server.v1_8_R3.NetworkManager;
-import org.bukkit.craftbukkit.v1_8_R3.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_8_8 {
-
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = networkManager.channel;
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_9/Channel_1_9.java

@@ -1,18 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_9;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_9_R1.EntityPlayer;
-import net.minecraft.server.v1_9_R1.NetworkManager;
-import org.bukkit.craftbukkit.v1_9_R1.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_9 {
-
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        entityPlayer.playerConnection.networkManager.sendPacket(null);
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-        Channel channel = networkManager.channel;
-        return channel;
-    }
-}

src/main/java/me/purplex/packetevents/injector/channels/_1_9_4/Channel_1_9_4.java

@@ -1,18 +0,0 @@
-package me.purplex.packetevents.injector.channels._1_9_4;
-
-import io.netty.channel.Channel;
-import net.minecraft.server.v1_9_R2.EntityPlayer;
-import net.minecraft.server.v1_9_R2.NetworkManager;
-import org.bukkit.craftbukkit.v1_9_R2.entity.CraftPlayer;
-import org.bukkit.entity.Player;
-
-public class Channel_1_9_4 {
-
-    public Channel getChannel(Player p) {
-        EntityPlayer entityPlayer = ((CraftPlayer)p).getHandle();
-        NetworkManager networkManager = entityPlayer.playerConnection.networkManager;
-
-        Channel channel = networkManager.channel;
-        return channel;
-    }
-}

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

@@ -1,20 +0,0 @@
-package me.purplex.packetevents.packetevent;
-
-
-import me.purplex.packetevents.enums.ServerVersion;
-
-public class PacketEvent {
-    protected long timestamp;
-    protected static ServerVersion version;
-    static {
-        version = ServerVersion.getVersion();
-    }
-
-    /**
-     * Timestamp of the packet
-     * @return
-     */
-    public long getTimestamp() {
-        return timestamp;
-    }
-}

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

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

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

@@ -1,65 +0,0 @@
-package me.purplex.packetevents.packetevent.impl;
-
-
-import me.purplex.packetevents.packetevent.PacketEvent;
-import org.bukkit.entity.Player;
-
-public class PacketReceiveEvent extends PacketEvent {
-    private final Player player;
-    private final String name;
-    private final Object packet;
-    private boolean cancelled;
-
-    public PacketReceiveEvent(Player player, String packetName, Object packet) {
-        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;
-    }
-
-    /**
-     * 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/packetevent/impl/PacketSendEvent.java

@@ -1,259 +0,0 @@
-package me.purplex.packetevents.packetevent.impl;
-
-import me.purplex.packetevents.packetevent.PacketEvent;
-import org.bukkit.entity.Player;
-
-public class PacketSendEvent extends PacketEvent {
-    private final Player player;
-    private final String name;
-    private final Object packet;
-    private boolean cancelled;
-
-    public PacketSendEvent(Player player, String packetName, Object packet) {
-        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 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/packetevent/impl/ServerTickEvent.java

@@ -1,19 +0,0 @@
-package me.purplex.packetevents.packetevent.impl;
-
-
-import me.purplex.packetevents.packetevent.PacketEvent;
-
-public class ServerTickEvent extends PacketEvent {
-
-    private final long timestamp;
-    public ServerTickEvent(long timestamp) {
-        this.timestamp = timestamp;
-    }
-
-
-
-    public long getTimestamp() {
-        return timestamp;
-    }
-
-}

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

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

src/main/java/me/purplex/packetevents/packetevent/manager/PacketEventManager.java

@@ -1,21 +0,0 @@
-package me.purplex.packetevents.packetevent.manager;
-
-import me.purplex.packetevents.packetevent.PacketEvent;
-import me.purplex.packetevents.packetevent.listener.PacketListener;
-import me.purplex.packetevents.packetwrappers.api.WrappedPacket;
-import org.bukkit.entity.Player;
-
-import java.util.LinkedList;
-
-public interface PacketEventManager {
-    public LinkedList<PacketListener> packetListeners = new LinkedList<>();
-    public void callEvent(PacketEvent e);
-
-    public void registerListener(PacketListener e);
-    public void unregisterListener(PacketListener e);
-
-    public void unregisterAllListeners(PacketListener e);
-
-    //public void sendPacket(Player player, WrappedPacket packet);
-
-}

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

@@ -1,59 +0,0 @@
-package me.purplex.packetevents.packetevent.manager;
-
-import me.purplex.packetevents.packetevent.PacketEvent;
-import me.purplex.packetevents.packetevent.impl.ServerTickEvent;
-import me.purplex.packetevents.packetevent.manager.PacketEventManager;
-import me.purplex.packetevents.packetevent.handler.PacketHandler;
-import me.purplex.packetevents.packetevent.listener.PacketListener;
-import me.purplex.packetevents.packetevent.impl.PacketReceiveEvent;
-import me.purplex.packetevents.packetevent.impl.PacketSendEvent;
-import me.purplex.packetevents.packetwrappers.api.WrappedPacket;
-import org.bukkit.entity.Player;
-
-import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
-
-public class PacketManager implements PacketEventManager {
-    @Override
-    public void callEvent(PacketEvent e) {
-        for (PacketListener listener : this.packetListeners) {
-            Method[] methods = listener.getClass().getMethods();
-            for (Method m : methods) {
-                if (m.isAnnotationPresent(PacketHandler.class)) {
-
-                    if (m.getParameterTypes()[0].getSimpleName().equals(e.getClass().getSimpleName())) {
-                        try {
-                            m.invoke(listener, e);
-                        } catch (IllegalAccessException ex) {
-                            ex.printStackTrace();
-                        } catch (InvocationTargetException ex) {
-                            ex.printStackTrace();
-                        }
-                    }
-
-                }
-            }
-        }
-    }
-
-    @Override
-    public void registerListener(PacketListener e) {
-        this.packetListeners.add(e);
-    }
-
-    @Override
-    public void unregisterListener(PacketListener e) {
-        this.packetListeners.remove(e);
-    }
-
-    @Override
-    public void unregisterAllListeners(PacketListener e) {
-        this.packetListeners.clear();
-    }
-
-    /*@Override
-    public void sendPacket(Player player, WrappedPacket packet) {
-
-    }*/
-
-}

src/main/java/me/purplex/packetevents/packetevent/packet/Packet.java

@@ -1,73 +0,0 @@
-package me.purplex.packetevents.packetevent.packet;
-
-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";
-        public static final String LOOK = CLIENT + "Look";
-        @Deprecated
-        public static final String LEGACY_POSITION = FLYING + "$" + CLIENT + "Position";
-        @Deprecated
-        public static final String LEGACY_POSITION_LOOK = FLYING + "$" + CLIENT + "PositionLook";
-        @Deprecated
-        public static final String LEGACY_LOOK = FLYING + "$" + CLIENT + "Look";
-        public static final String TRANSACTION = CLIENT + "Transaction";
-        public static final String BLOCK_DIG = CLIENT + "BlockDig";
-        public static final String ENTITY_ACTION = CLIENT + "EntityAction";
-        public static final String USE_ENTITY = CLIENT + "UseEntity";
-        public static final String WINDOW_CLICK = CLIENT + "WindowClick";
-        public static final String STEER_VEHICLE = CLIENT + "SteerVehicle";
-        public static final String CUSTOM_PAYLOAD = CLIENT + "CustomPayload";
-        public static final String ARM_ANIMATION = CLIENT + "ArmAnimation";
-        public static final String BLOCK_PLACE_1_9 = CLIENT + "BlockPlace1_9";
-        public static final String BLOCK_PLACE = CLIENT + "BlockPlace";
-        public static final String ABILITIES = CLIENT + "Abilities";
-        public static final String HELD_ITEM_SLOT = CLIENT + "HeldItemSlot";
-        public static final String CLOSE_WINDOW = CLIENT + "CloseWindow";
-        public static final String TAB_COMPLETE = CLIENT + "TabComplete";
-        public static final String CHAT = CLIENT + "Chat";
-        public static final String CREATIVE_SLOT = CLIENT + "SetCreativeSlot";
-        public static final String CLIENT_COMMAND = CLIENT + "ClientCommand";
-    }
-
-    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";
-        public static final String TRANSACTION = SERVER + "Transaction";
-        public static final String NAMED_ENTITY_SPAWN = SERVER + "NamedEntitySpawn";
-        public static final String SPAWN_ENTITY_LIVING = SERVER + "SpawnEntityLiving";
-        public static final String SPAWN_ENTITY = SERVER + "SpawnEntity";
-        public static final String CUSTOM_PAYLOAD = SERVER + "CustomPayload";
-        public static final String ABILITIES = SERVER + "Abilities";
-        public static final String ENTITY_METADATA = SERVER + "EntityMetadata";
-        public static final String ENTITY_VELOCITY = SERVER + "EntityVelocity";
-        public static final String ENTITY_DESTROY = SERVER + "EntityDestroy";
-        public static final String ENTITY_HEAD_ROTATION = SERVER + "EntityHeadRotation";
-        public static final String BLOCK_CHANGE = SERVER + "BlockChange";
-        public static final String CLOSE_WINDOW = SERVER + "CloseWindow";
-        public static final String HELD_ITEM = SERVER + "HeldItemSlot";
-        public static final String TAB_COMPLETE = SERVER + "TabComplete";
-        public static final String RESPAWN = SERVER + "Respawn";
-        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";
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/api/WrappedPacket.java

@@ -1,16 +0,0 @@
-package me.purplex.packetevents.packetwrappers.api;
-
-import me.purplex.packetevents.enums.ServerVersion;
-
-public class WrappedPacket {
-    protected Object packet;
-    protected static ServerVersion version = ServerVersion.getVersion();
-    public WrappedPacket(Object packet) {
-        this.packet = packet;
-        setup();
-    }
-
-    protected void setup() {
-
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/api/sendable/WrappedServerPacket.java

@@ -1,12 +0,0 @@
-package me.purplex.packetevents.packetwrappers.api.sendable;
-
-import org.bukkit.entity.Player;
-
-/**
- * Unfinished
- */
-public class WrappedServerPacket {
-    public WrappedServerPacket(Player target) {
-
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/api/version/WrappedVersionPacket.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.packetwrappers.api.version;
-
-import me.purplex.packetevents.enums.ServerVersion;
-
-public abstract class WrappedVersionPacket {
-    protected final Object packet;
-    protected static ServerVersion version;
-    static {
-        version = ServerVersion.getVersion();
-    }
-    public  WrappedVersionPacket(Object packet) {
-        this.packet = packet;
-        setup();
-    }
-
-    protected abstract void setup();
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/WrappedPacketPlayInAbilities.java

@@ -1,130 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in;
-
-
-import me.purplex.packetevents.enums.ServerVersion;
-import me.purplex.packetevents.packetwrappers.api.WrappedPacket;
-import me.purplex.packetevents.packetwrappers.in._1_10.WrappedPacketPlayInAbilities_1_10;
-import me.purplex.packetevents.packetwrappers.in._1_11.WrappedPacketPlayInAbilities_1_11;
-import me.purplex.packetevents.packetwrappers.in._1_12.WrappedPacketPlayInAbilities_1_12;
-import me.purplex.packetevents.packetwrappers.in._1_13.WrappedPacketPlayInAbilities_1_13;
-import me.purplex.packetevents.packetwrappers.in._1_13_2.WrappedPacketPlayInAbilities_1_13_2;
-import me.purplex.packetevents.packetwrappers.in._1_14.WrappedPacketPlayInAbilities_1_14;
-import me.purplex.packetevents.packetwrappers.in._1_15.WrappedPacketPlayInAbilities_1_15;
-import me.purplex.packetevents.packetwrappers.in._1_7_10.WrappedPacketPlayInAbilities_1_7_10;
-import me.purplex.packetevents.packetwrappers.in._1_8.WrappedPacketPlayInAbilities_1_8;
-import me.purplex.packetevents.packetwrappers.in._1_8_3.WrappedPacketPlayInAbilities_1_8_3;
-import me.purplex.packetevents.packetwrappers.in._1_8_8.WrappedPacketPlayInAbilities_1_8_8;
-import me.purplex.packetevents.packetwrappers.in._1_9.WrappedPacketPlayInAbilities_1_9;
-import me.purplex.packetevents.packetwrappers.in._1_9_4.WrappedPacketPlayInAbilities_1_9_4;
-
-public class WrappedPacketPlayInAbilities extends WrappedPacket {
-
-    public boolean a;
-    public boolean b;
-    public boolean c;
-    public boolean d;
-    public float e;
-    public float f;
-
-    public WrappedPacketPlayInAbilities(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        if(version == ServerVersion.v_1_7_10) {
-            WrappedPacketPlayInAbilities_1_7_10 p = new WrappedPacketPlayInAbilities_1_7_10(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.d = p.d;
-            this.e = p.e;
-        }
-        else if (version == ServerVersion.v_1_8) {
-            WrappedPacketPlayInAbilities_1_8 p = new WrappedPacketPlayInAbilities_1_8(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_8_3) {
-            WrappedPacketPlayInAbilities_1_8_3 p = new WrappedPacketPlayInAbilities_1_8_3(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_8_8) {
-            WrappedPacketPlayInAbilities_1_8_8 p = new WrappedPacketPlayInAbilities_1_8_8(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_9) {
-            WrappedPacketPlayInAbilities_1_9 p = new WrappedPacketPlayInAbilities_1_9(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_9_4) {
-            WrappedPacketPlayInAbilities_1_9_4 p = new WrappedPacketPlayInAbilities_1_9_4(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_10) {
-            WrappedPacketPlayInAbilities_1_10 p = new WrappedPacketPlayInAbilities_1_10(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_11) {
-            WrappedPacketPlayInAbilities_1_11 p = new WrappedPacketPlayInAbilities_1_11(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_12) {
-            WrappedPacketPlayInAbilities_1_12 p = new WrappedPacketPlayInAbilities_1_12(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_13) {
-            WrappedPacketPlayInAbilities_1_13 p = new WrappedPacketPlayInAbilities_1_13(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_13_2) {
-            WrappedPacketPlayInAbilities_1_13_2 p = new WrappedPacketPlayInAbilities_1_13_2(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_14) {
-            WrappedPacketPlayInAbilities_1_14 p = new WrappedPacketPlayInAbilities_1_14(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        } else if (version == ServerVersion.v_1_15) {
-            WrappedPacketPlayInAbilities_1_15 p = new WrappedPacketPlayInAbilities_1_15(packet);
-            this.a = p.a;
-            this.b = p.b;
-            this.c = p.c;
-            this.e = p.e;
-            this.f = p.f;
-        }
-    }
-
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/WrappedPacketPlayInBlockDig.java

@@ -1,73 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in;
-
-import me.purplex.packetevents.enums.PlayerDigType;
-import me.purplex.packetevents.enums.ServerVersion;
-import me.purplex.packetevents.packetwrappers.api.WrappedPacket;
-import me.purplex.packetevents.packetwrappers.in._1_10.WrappedPacketPlayInBlockDig_1_10;
-import me.purplex.packetevents.packetwrappers.in._1_11.WrappedPacketPlayInBlockDig_1_11;
-import me.purplex.packetevents.packetwrappers.in._1_12.WrappedPacketPlayInBlockDig_1_12;
-import me.purplex.packetevents.packetwrappers.in._1_13.WrappedPacketPlayInBlockDig_1_13;
-import me.purplex.packetevents.packetwrappers.in._1_13_2.WrappedPacketPlayInBlockDig_1_13_2;
-import me.purplex.packetevents.packetwrappers.in._1_14.WrappedPacketPlayInBlockDig_1_14;
-import me.purplex.packetevents.packetwrappers.in._1_15.WrappedPacketPlayInBlockDig_1_15;
-import me.purplex.packetevents.packetwrappers.in._1_7_10.WrappedPacketPlayInBlockDig_1_7_10;
-import me.purplex.packetevents.packetwrappers.in._1_8.WrappedPacketPlayInBlockDig_1_8;
-import me.purplex.packetevents.packetwrappers.in._1_8_3.WrappedPacketPlayInBlockDig_1_8_3;
-import me.purplex.packetevents.packetwrappers.in._1_8_8.WrappedPacketPlayInBlockDig_1_8_8;
-import me.purplex.packetevents.packetwrappers.in._1_9.WrappedPacketPlayInBlockDig_1_9;
-import me.purplex.packetevents.packetwrappers.in._1_9_4.WrappedPacketPlayInBlockDig_1_9_4;
-
-public class WrappedPacketPlayInBlockDig extends WrappedPacket {
-
-    public PlayerDigType digType;
-
-    public WrappedPacketPlayInBlockDig(Object packet) {
-        super(packet);
-    }
-
-
-    @Override
-    public void setup() {
-        if(version == ServerVersion.v_1_7_10) {
-            WrappedPacketPlayInBlockDig_1_7_10 p = new WrappedPacketPlayInBlockDig_1_7_10(this.packet);
-            this.digType = p.digType;
-        }
-        else if (version == ServerVersion.v_1_8) {
-            WrappedPacketPlayInBlockDig_1_8 p = new WrappedPacketPlayInBlockDig_1_8(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_8_3) {
-            WrappedPacketPlayInBlockDig_1_8_3 p = new WrappedPacketPlayInBlockDig_1_8_3(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_8_8) {
-            WrappedPacketPlayInBlockDig_1_8_8 p = new WrappedPacketPlayInBlockDig_1_8_8(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_9) {
-            WrappedPacketPlayInBlockDig_1_9 p = new WrappedPacketPlayInBlockDig_1_9(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_9_4) {
-            WrappedPacketPlayInBlockDig_1_9_4 p = new WrappedPacketPlayInBlockDig_1_9_4(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_10) {
-            WrappedPacketPlayInBlockDig_1_10 p = new WrappedPacketPlayInBlockDig_1_10(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_11) {
-            WrappedPacketPlayInBlockDig_1_11 p = new WrappedPacketPlayInBlockDig_1_11(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_12) {
-            WrappedPacketPlayInBlockDig_1_12 p = new WrappedPacketPlayInBlockDig_1_12(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_13) {
-            WrappedPacketPlayInBlockDig_1_13 p = new WrappedPacketPlayInBlockDig_1_13(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_13_2) {
-            WrappedPacketPlayInBlockDig_1_13_2 p = new WrappedPacketPlayInBlockDig_1_13_2(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_14) {
-            WrappedPacketPlayInBlockDig_1_14 p = new WrappedPacketPlayInBlockDig_1_14(packet);
-            this.digType = p.digType;
-        } else if (version == ServerVersion.v_1_15) {
-            WrappedPacketPlayInBlockDig_1_15 p = new WrappedPacketPlayInBlockDig_1_15(packet);
-            this.digType = p.digType;
-        }
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/WrappedPacketPlayInChat.java

@@ -1,69 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in;
-
-import me.purplex.packetevents.enums.ServerVersion;
-import me.purplex.packetevents.packetwrappers.api.WrappedPacket;
-import me.purplex.packetevents.packetwrappers.in._1_10.WrappedPacketPlayInChat_1_10;
-import me.purplex.packetevents.packetwrappers.in._1_11.WrappedPacketPlayInChat_1_11;
-import me.purplex.packetevents.packetwrappers.in._1_12.WrappedPacketPlayInChat_1_12;
-import me.purplex.packetevents.packetwrappers.in._1_13.WrappedPacketPlayInChat_1_13;
-import me.purplex.packetevents.packetwrappers.in._1_13_2.WrappedPacketPlayInChat_1_13_2;
-import me.purplex.packetevents.packetwrappers.in._1_14.WrappedPacketPlayInChat_1_14;
-import me.purplex.packetevents.packetwrappers.in._1_15.WrappedPacketPlayInChat_1_15;
-import me.purplex.packetevents.packetwrappers.in._1_7_10.WrappedPacketPlayInChat_1_7_10;
-import me.purplex.packetevents.packetwrappers.in._1_8.WrappedPacketPlayInChat_1_8;
-import me.purplex.packetevents.packetwrappers.in._1_8_3.WrappedPacketPlayInChat_1_8_3;
-import me.purplex.packetevents.packetwrappers.in._1_8_8.WrappedPacketPlayInChat_1_8_8;
-import me.purplex.packetevents.packetwrappers.in._1_9.WrappedPacketPlayInChat_1_9;
-import me.purplex.packetevents.packetwrappers.in._1_9_4.WrappedPacketPlayInChat_1_9_4;
-
-public class WrappedPacketPlayInChat extends WrappedPacket {
-    public String message;
-    public WrappedPacketPlayInChat(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        if(version == ServerVersion.v_1_7_10) {
-            WrappedPacketPlayInChat_1_7_10 p = new WrappedPacketPlayInChat_1_7_10(this.packet);
-            this.message = p.message;
-        }
-        else if (version == ServerVersion.v_1_8) {
-            WrappedPacketPlayInChat_1_8 p = new WrappedPacketPlayInChat_1_8(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_8_3) {
-            WrappedPacketPlayInChat_1_8_3 p = new WrappedPacketPlayInChat_1_8_3(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_8_8) {
-            WrappedPacketPlayInChat_1_8_8 p = new WrappedPacketPlayInChat_1_8_8(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_9) {
-            WrappedPacketPlayInChat_1_9 p = new WrappedPacketPlayInChat_1_9(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_9_4) {
-            WrappedPacketPlayInChat_1_9_4 p = new WrappedPacketPlayInChat_1_9_4(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_10) {
-            WrappedPacketPlayInChat_1_10 p = new WrappedPacketPlayInChat_1_10(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_11) {
-            WrappedPacketPlayInChat_1_11 p = new WrappedPacketPlayInChat_1_11(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_12) {
-            WrappedPacketPlayInChat_1_12 p = new WrappedPacketPlayInChat_1_12(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_13) {
-            WrappedPacketPlayInChat_1_13 p = new WrappedPacketPlayInChat_1_13(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_13_2) {
-            WrappedPacketPlayInChat_1_13_2 p = new WrappedPacketPlayInChat_1_13_2(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_14) {
-            WrappedPacketPlayInChat_1_14 p = new WrappedPacketPlayInChat_1_14(packet);
-            this.message = p.message;
-        } else if (version == ServerVersion.v_1_15) {
-            WrappedPacketPlayInChat_1_15 p = new WrappedPacketPlayInChat_1_15(packet);
-            this.message = p.message;
-        }
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/WrappedPacketPlayInFlying.java

@@ -1,439 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in;
-
-import me.purplex.packetevents.enums.ServerVersion;
-import me.purplex.packetevents.packetwrappers.api.WrappedPacket;
-import me.purplex.packetevents.packetwrappers.in._1_10.WrappedPacketPlayInFlying_1_10;
-import me.purplex.packetevents.packetwrappers.in._1_11.WrappedPacketPlayInFlying_1_11;
-import me.purplex.packetevents.packetwrappers.in._1_12.WrappedPacketPlayInFlying_1_12;
-import me.purplex.packetevents.packetwrappers.in._1_13.WrappedPacketPlayInFlying_1_13;
-import me.purplex.packetevents.packetwrappers.in._1_13_2.WrappedPacketPlayInFlying_1_13_2;
-import me.purplex.packetevents.packetwrappers.in._1_14.WrappedPacketPlayInFlying_1_14;
-import me.purplex.packetevents.packetwrappers.in._1_15.WrappedPacketPlayInFlying_1_15;
-import me.purplex.packetevents.packetwrappers.in._1_7_10.WrappedPacketPlayInFlying_1_7_10;
-import me.purplex.packetevents.packetwrappers.in._1_8.WrappedPacketPlayInFlying_1_8;
-import me.purplex.packetevents.packetwrappers.in._1_8_3.WrappedPacketPlayInFlying_1_8_3;
-import me.purplex.packetevents.packetwrappers.in._1_8_8.WrappedPacketPlayInFlying_1_8_8;
-import me.purplex.packetevents.packetwrappers.in._1_9.WrappedPacketPlayInFlying_1_9;
-import me.purplex.packetevents.packetwrappers.in._1_9_4.WrappedPacketPlayInFlying_1_9_4;
-
-public class WrappedPacketPlayInFlying extends WrappedPacket {
-
-    public double x;
-    public double y;
-    public double z;
-    public float yaw;
-    public float pitch;
-    public boolean f;
-    public boolean hasPos;
-    public boolean hasLook;
-
-    public WrappedPacketPlayInFlying(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup(){
-        if(version == ServerVersion.v_1_7_10) {
-            WrappedPacketPlayInFlying_1_7_10 p = new WrappedPacketPlayInFlying_1_7_10(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version == ServerVersion.v_1_8) {
-            WrappedPacketPlayInFlying_1_8 p = new WrappedPacketPlayInFlying_1_8(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version == ServerVersion.v_1_8_3) {
-            WrappedPacketPlayInFlying_1_8_3 p = new WrappedPacketPlayInFlying_1_8_3(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version == ServerVersion.v_1_8_8) {
-            WrappedPacketPlayInFlying_1_8_8 p = new WrappedPacketPlayInFlying_1_8_8(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version == ServerVersion.v_1_9) {
-            WrappedPacketPlayInFlying_1_9 p = new WrappedPacketPlayInFlying_1_9(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version == ServerVersion.v_1_9_4) {
-            WrappedPacketPlayInFlying_1_9_4 p = new WrappedPacketPlayInFlying_1_9_4(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version == ServerVersion.v_1_10) {
-            WrappedPacketPlayInFlying_1_10 p = new WrappedPacketPlayInFlying_1_10(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version== ServerVersion.v_1_11) {
-            WrappedPacketPlayInFlying_1_11 p = new WrappedPacketPlayInFlying_1_11(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version == ServerVersion.v_1_12) {
-            WrappedPacketPlayInFlying_1_12 p = new WrappedPacketPlayInFlying_1_12(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version== ServerVersion.v_1_13) {
-            WrappedPacketPlayInFlying_1_13 p = new WrappedPacketPlayInFlying_1_13(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version == ServerVersion.v_1_13_2) {
-            WrappedPacketPlayInFlying_1_13_2 p = new WrappedPacketPlayInFlying_1_13_2(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version == ServerVersion.v_1_14) {
-            WrappedPacketPlayInFlying_1_14 p = new WrappedPacketPlayInFlying_1_14(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-        else if(version == ServerVersion.v_1_15) {
-            WrappedPacketPlayInFlying_1_15 p = new WrappedPacketPlayInFlying_1_15(packet);
-            this.x = p.x;
-            this.y = p.y;
-            this.z = p.z;
-            this.yaw = p.yaw;
-            this.pitch = p.pitch;
-            this.f = p.f;
-            this.hasPos = p.hasPos;
-            this.hasLook = p.hasLook;
-        }
-    }
-
-    public static class WrappedPacketPlayInPosition extends WrappedPacketPlayInFlying {
-
-        public WrappedPacketPlayInPosition(Object packet) {
-            super(packet);
-        }
-
-        @Override
-        protected void setup() {
-            if(version == ServerVersion.v_1_7_10) {
-                WrappedPacketPlayInFlying_1_7_10.WrappedPacketPlayInPosition_1_7_10 p
-                        = new WrappedPacketPlayInFlying_1_7_10.WrappedPacketPlayInPosition_1_7_10(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_8) {
-                WrappedPacketPlayInFlying_1_8.WrappedPacketPlayInPosition_1_8 p
-                        = new WrappedPacketPlayInFlying_1_8.WrappedPacketPlayInPosition_1_8(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_8_3) {
-                WrappedPacketPlayInFlying_1_8_3.WrappedPacketPlayInPosition_1_8_3 p
-                        = new WrappedPacketPlayInFlying_1_8_3.WrappedPacketPlayInPosition_1_8_3(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_8_8) {
-                WrappedPacketPlayInFlying_1_8_8.WrappedPacketPlayInPosition_1_8_8 p
-                        = new WrappedPacketPlayInFlying_1_8_8.WrappedPacketPlayInPosition_1_8_8(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_9) {
-                WrappedPacketPlayInFlying_1_9.WrappedPacketPlayInPosition_1_9 p
-                        = new WrappedPacketPlayInFlying_1_9.WrappedPacketPlayInPosition_1_9(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_9_4) {
-                WrappedPacketPlayInFlying_1_9_4.WrappedPacketPlayInPosition_1_9_4 p
-                        = new WrappedPacketPlayInFlying_1_9_4.WrappedPacketPlayInPosition_1_9_4(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_10) {
-                WrappedPacketPlayInFlying_1_10.WrappedPacketPlayInPosition_1_10 p
-                        = new WrappedPacketPlayInFlying_1_10.WrappedPacketPlayInPosition_1_10(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version== ServerVersion.v_1_11) {
-                WrappedPacketPlayInFlying_1_11.WrappedPacketPlayInPosition_1_11 p
-                        = new WrappedPacketPlayInFlying_1_11.WrappedPacketPlayInPosition_1_11(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_12) {
-                WrappedPacketPlayInFlying_1_12.WrappedPacketPlayInPosition_1_12 p
-                        = new WrappedPacketPlayInFlying_1_12.WrappedPacketPlayInPosition_1_12(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version== ServerVersion.v_1_13) {
-                WrappedPacketPlayInFlying_1_13.WrappedPacketPlayInPosition_1_13 p
-                        = new WrappedPacketPlayInFlying_1_13.WrappedPacketPlayInPosition_1_13(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_13_2) {
-                WrappedPacketPlayInFlying_1_13_2.WrappedPacketPlayInPosition_1_13_2 p
-                        = new WrappedPacketPlayInFlying_1_13_2.WrappedPacketPlayInPosition_1_13_2(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_14) {
-                WrappedPacketPlayInFlying_1_14.WrappedPacketPlayInPosition_1_14 p
-                        = new WrappedPacketPlayInFlying_1_14.WrappedPacketPlayInPosition_1_14(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_15) {
-                WrappedPacketPlayInFlying_1_15.WrappedPacketPlayInPosition_1_15 p
-                        = new WrappedPacketPlayInFlying_1_15.WrappedPacketPlayInPosition_1_15(packet);
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-        }
-
-
-    }
-
-    public static class WrappedPacketPlayInPosition_Look extends WrappedPacketPlayInFlying {
-
-        public WrappedPacketPlayInPosition_Look(Object packet) {
-            super(packet);
-        }
-
-        @Override
-        protected void setup() {
-            if(version == ServerVersion.v_1_7_10) {
-                WrappedPacketPlayInFlying_1_7_10.WrappedPacketPlayInPosition_Look_1_7_10 p
-                        = new WrappedPacketPlayInFlying_1_7_10.WrappedPacketPlayInPosition_Look_1_7_10(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_8) {
-                WrappedPacketPlayInFlying_1_8.WrappedPacketPlayInPosition_Look_1_8 p
-                        = new WrappedPacketPlayInFlying_1_8.WrappedPacketPlayInPosition_Look_1_8(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_8_3) {
-                WrappedPacketPlayInFlying_1_8_3.WrappedPacketPlayInPosition_Look_1_8_3 p
-                        = new WrappedPacketPlayInFlying_1_8_3.WrappedPacketPlayInPosition_Look_1_8_3(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_8_8) {
-                WrappedPacketPlayInFlying_1_8_8.WrappedPacketPlayInPosition_Look_1_8_8 p
-                        = new WrappedPacketPlayInFlying_1_8_8.WrappedPacketPlayInPosition_Look_1_8_8(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_9) {
-                WrappedPacketPlayInFlying_1_9.WrappedPacketPlayInPosition_Look_1_9 p
-                        = new WrappedPacketPlayInFlying_1_9.WrappedPacketPlayInPosition_Look_1_9(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_9_4) {
-                WrappedPacketPlayInFlying_1_9_4.WrappedPacketPlayInPosition_Look_1_9_4 p
-                        = new WrappedPacketPlayInFlying_1_9_4.WrappedPacketPlayInPosition_Look_1_9_4(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_10) {
-                WrappedPacketPlayInFlying_1_10.WrappedPacketPlayInPosition_Look_1_10 p
-                        = new WrappedPacketPlayInFlying_1_10.WrappedPacketPlayInPosition_Look_1_10(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version== ServerVersion.v_1_11) {
-                WrappedPacketPlayInFlying_1_11.WrappedPacketPlayInPosition_Look_1_11 p
-                        = new WrappedPacketPlayInFlying_1_11.WrappedPacketPlayInPosition_Look_1_11(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_12) {
-                WrappedPacketPlayInFlying_1_12.WrappedPacketPlayInPosition_Look_1_12 p
-                        = new WrappedPacketPlayInFlying_1_12.WrappedPacketPlayInPosition_Look_1_12(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version== ServerVersion.v_1_13) {
-                WrappedPacketPlayInFlying_1_13.WrappedPacketPlayInPosition_Look_1_13 p
-                        = new WrappedPacketPlayInFlying_1_13.WrappedPacketPlayInPosition_Look_1_13(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_13_2) {
-                WrappedPacketPlayInFlying_1_13_2.WrappedPacketPlayInPosition_Look_1_13_2 p
-                        = new WrappedPacketPlayInFlying_1_13_2.WrappedPacketPlayInPosition_Look_1_13_2(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_14) {
-                WrappedPacketPlayInFlying_1_14.WrappedPacketPlayInPosition_Look_1_14 p
-                        = new WrappedPacketPlayInFlying_1_14.WrappedPacketPlayInPosition_Look_1_14(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-            else if(version == ServerVersion.v_1_15) {
-                WrappedPacketPlayInFlying_1_15.WrappedPacketPlayInPosition_Look_1_15 p
-                        = new WrappedPacketPlayInFlying_1_15.WrappedPacketPlayInPosition_Look_1_15(packet);
-                this.x = p.x;
-                this.y = p.y;
-                this.z = p.z;
-                this.yaw = p.yaw;
-                this.pitch = p.pitch;
-                this.f = p.f;
-                this.hasPos = p.hasPos;
-                this.hasLook = p.hasLook;
-            }
-        }
-    }
-
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/WrappedPacketPlayInUseEntity.java

@@ -1,89 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in;
-
-import me.purplex.packetevents.enums.EntityUseAction;
-import me.purplex.packetevents.enums.ServerVersion;
-import me.purplex.packetevents.packetwrappers.api.WrappedPacket;
-import me.purplex.packetevents.packetwrappers.in._1_10.WrappedPacketPlayInUseEntity_1_10;
-import me.purplex.packetevents.packetwrappers.in._1_11.WrappedPacketPlayInUseEntity_1_11;
-import me.purplex.packetevents.packetwrappers.in._1_12.WrappedPacketPlayInUseEntity_1_12;
-import me.purplex.packetevents.packetwrappers.in._1_13.WrappedPacketPlayInUseEntity_1_13;
-import me.purplex.packetevents.packetwrappers.in._1_13_2.WrappedPacketPlayInUseEntity_1_13_2;
-import me.purplex.packetevents.packetwrappers.in._1_14.WrappedPacketPlayInUseEntity_1_14;
-import me.purplex.packetevents.packetwrappers.in._1_15.WrappedPacketPlayInUseEntity_1_15;
-import me.purplex.packetevents.packetwrappers.in._1_7_10.WrappedPacketPlayInUseEntity_1_7_10;
-import me.purplex.packetevents.packetwrappers.in._1_8.WrappedPacketPlayInUseEntity_1_8;
-import me.purplex.packetevents.packetwrappers.in._1_8_3.WrappedPacketPlayInUseEntity_1_8_3;
-import me.purplex.packetevents.packetwrappers.in._1_8_8.WrappedPacketPlayInUseEntity_1_8_8;
-import me.purplex.packetevents.packetwrappers.in._1_9.WrappedPacketPlayInUseEntity_1_9;
-import me.purplex.packetevents.packetwrappers.in._1_9_4.WrappedPacketPlayInUseEntity_1_9_4;
-import org.bukkit.entity.Entity;
-import org.bukkit.entity.Player;
-
-public class WrappedPacketPlayInUseEntity extends WrappedPacket {
-
-    public Entity entity;
-    public EntityUseAction action;
-
-    public WrappedPacketPlayInUseEntity(Object packet) {
-        super(packet);
-    }
-
-
-    @Override
-    protected void setup() {
-        if(version == ServerVersion.v_1_7_10) {
-            WrappedPacketPlayInUseEntity_1_7_10 p = new WrappedPacketPlayInUseEntity_1_7_10(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        }
-        else if (version == ServerVersion.v_1_8) {
-            WrappedPacketPlayInUseEntity_1_8 p = new WrappedPacketPlayInUseEntity_1_8(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_8_3) {
-            WrappedPacketPlayInUseEntity_1_8_3 p = new WrappedPacketPlayInUseEntity_1_8_3(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_8_8) {
-            WrappedPacketPlayInUseEntity_1_8_8 p = new WrappedPacketPlayInUseEntity_1_8_8(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_9) {
-            WrappedPacketPlayInUseEntity_1_9 p = new WrappedPacketPlayInUseEntity_1_9(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_9_4) {
-            WrappedPacketPlayInUseEntity_1_9_4 p = new WrappedPacketPlayInUseEntity_1_9_4(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_10) {
-            WrappedPacketPlayInUseEntity_1_10 p = new WrappedPacketPlayInUseEntity_1_10(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_11) {
-            WrappedPacketPlayInUseEntity_1_11 p = new WrappedPacketPlayInUseEntity_1_11(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_12) {
-            WrappedPacketPlayInUseEntity_1_12 p = new WrappedPacketPlayInUseEntity_1_12(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_13) {
-            WrappedPacketPlayInUseEntity_1_13 p = new WrappedPacketPlayInUseEntity_1_13(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_13_2) {
-            WrappedPacketPlayInUseEntity_1_13_2 p = new WrappedPacketPlayInUseEntity_1_13_2(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_14) {
-            WrappedPacketPlayInUseEntity_1_14 p = new WrappedPacketPlayInUseEntity_1_14(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        } else if (version == ServerVersion.v_1_15) {
-            WrappedPacketPlayInUseEntity_1_15 p = new WrappedPacketPlayInUseEntity_1_15(packet);
-            this.entity = p.getEntity();
-            this.action = p.getEntityUseAction();
-        }
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_10/WrappedPacketPlayInAbilities_1_10.java

@@ -1,49 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_10;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_10_R1.PacketPlayInAbilities;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInAbilities_1_10 extends WrappedVersionPacket {
-
-    public boolean a;
-    public boolean b;
-    public boolean c;
-    public boolean d;
-    public float e;
-    public float f;
-
-    public WrappedPacketPlayInAbilities_1_10(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInAbilities p = (PacketPlayInAbilities) packet;
-        this.a = p.a();
-        this.b = p.isFlying();
-        this.c = p.c();
-        this.d = p.d();
-        try {
-            this.e = fieldE.getFloat(p);
-            this.f = fieldF.getFloat(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private static Field fieldE;
-    private static Field fieldF;
-
-    static {
-        try {
-            fieldE = PacketPlayInAbilities.class.getDeclaredField("e");
-            fieldE.setAccessible(true);
-            fieldF = PacketPlayInAbilities.class.getDeclaredField("f");
-            fieldF.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_10/WrappedPacketPlayInBlockDig_1_10.java

@@ -1,21 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_10;
-
-import me.purplex.packetevents.enums.PlayerDigType;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_10_R1.PacketPlayInBlockDig;
-
-public class WrappedPacketPlayInBlockDig_1_10 extends WrappedVersionPacket {
-
-    public PlayerDigType digType;
-
-    public WrappedPacketPlayInBlockDig_1_10(Object packet) {
-       super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInBlockDig p = (PacketPlayInBlockDig)packet;
-        String name = p.c().name();
-        this.digType = PlayerDigType.valueOf(name);
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_10/WrappedPacketPlayInChat_1_10.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_10;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_10_R1.PacketPlayInChat;
-
-public class WrappedPacketPlayInChat_1_10 extends WrappedVersionPacket {
-    public String message;
-    public WrappedPacketPlayInChat_1_10(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInChat p = (PacketPlayInChat)packet;
-        this.message = p.a();
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_10/WrappedPacketPlayInFlying_1_10.java

@@ -1,107 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_10;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_10_R1.PacketPlayInFlying;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInFlying_1_10 extends WrappedVersionPacket {
-
-    public double x;
-    public double y;
-    public double z;
-    public float yaw;
-    public float pitch;
-    public boolean f;
-    public boolean hasPos;
-    public boolean hasLook;
-
-    public WrappedPacketPlayInFlying_1_10(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInFlying p = (PacketPlayInFlying) packet;
-        try {
-            this.hasPos = fieldHasPos.getBoolean(p);
-            this.hasLook = fieldHasLook.getBoolean(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        if (hasPos) {
-            this.x = p.a(0.0D);
-            this.y = p.b(0.0D);
-            this.z = p.c(0.0D);
-        } else {
-            try {
-                this.x = fieldX.getDouble(p);
-                this.y = fieldY.getDouble(p);
-                this.z = fieldZ.getDouble(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-
-        if (hasLook) {
-            this.yaw = p.a(0.0F);
-            this.pitch = p.b(0.0F);
-        } else {
-            try {
-                this.yaw = fieldYaw.getFloat(p);
-                this.pitch = fieldPitch.getFloat(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-        this.f = p.a();
-    }
-
-    public static class WrappedPacketPlayInPosition_1_10 extends WrappedPacketPlayInFlying_1_10 {
-
-        public WrappedPacketPlayInPosition_1_10(Object packet) {
-            super(packet);
-            this.hasPos = true;
-        }
-    }
-
-    public static class WrappedPacketPlayInPosition_Look_1_10 extends WrappedPacketPlayInFlying_1_10 {
-
-        public WrappedPacketPlayInPosition_Look_1_10(Object packet) {
-            super(packet);
-            this.hasLook = true;
-        }
-    }
-
-
-    private static Field fieldHasPos;
-    private static Field fieldHasLook;
-    private static Field fieldX;
-    private static Field fieldY;
-    private static Field fieldZ;
-    private static Field fieldYaw;
-    private static Field fieldPitch;
-
-    static {
-        try {
-            fieldHasPos = PacketPlayInFlying.class.getDeclaredField("hasPos");
-            fieldHasPos.setAccessible(true);
-            fieldHasLook = PacketPlayInFlying.class.getDeclaredField("hasLook");
-            fieldHasLook.setAccessible(true);
-            fieldX = PacketPlayInFlying.class.getDeclaredField("x");
-            fieldX.setAccessible(true);
-            fieldY = PacketPlayInFlying.class.getDeclaredField("y");
-            fieldY.setAccessible(true);
-            fieldZ = PacketPlayInFlying.class.getDeclaredField("z");
-            fieldZ.setAccessible(true);
-            fieldYaw = PacketPlayInFlying.class.getDeclaredField("yaw");
-            fieldYaw.setAccessible(true);
-            fieldPitch = PacketPlayInFlying.class.getDeclaredField("pitch");
-            fieldPitch.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-
-
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_10/WrappedPacketPlayInUseEntity_1_10.java

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

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_11/WrappedPacketPlayInAbilities_1_11.java

@@ -1,49 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_11;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_11_R1.PacketPlayInAbilities;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInAbilities_1_11 extends WrappedVersionPacket {
-
-    public boolean a;
-    public boolean b;
-    public boolean c;
-    public boolean d;
-    public float e;
-    public float f;
-
-    public WrappedPacketPlayInAbilities_1_11(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInAbilities p = (PacketPlayInAbilities) packet;
-        this.a = p.a();
-        this.b = p.isFlying();
-        this.c = p.c();
-        this.d = p.d();
-        try {
-            this.e = fieldE.getFloat(p);
-            this.f = fieldF.getFloat(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private static Field fieldE;
-    private static Field fieldF;
-
-    static {
-        try {
-            fieldE = PacketPlayInAbilities.class.getDeclaredField("e");
-            fieldE.setAccessible(true);
-            fieldF = PacketPlayInAbilities.class.getDeclaredField("f");
-            fieldF.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_11/WrappedPacketPlayInBlockDig_1_11.java

@@ -1,22 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_11;
-
-import me.purplex.packetevents.enums.PlayerDigType;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_11_R1.PacketPlayInBlockDig;
-
-public class WrappedPacketPlayInBlockDig_1_11 extends WrappedVersionPacket {
-
-    public PlayerDigType digType;
-
-    public WrappedPacketPlayInBlockDig_1_11(Object packet) {
-       super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInBlockDig p = (PacketPlayInBlockDig)packet;
-        String name = p.c().name();
-        this.digType = PlayerDigType.valueOf(name);
-    }
-
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_11/WrappedPacketPlayInChat_1_11.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_11;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_11_R1.PacketPlayInChat;
-
-public class WrappedPacketPlayInChat_1_11 extends WrappedVersionPacket {
-    public String message;
-    public WrappedPacketPlayInChat_1_11(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInChat p = (PacketPlayInChat)packet;
-        this.message = p.a();
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_11/WrappedPacketPlayInFlying_1_11.java

@@ -1,107 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_11;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_11_R1.PacketPlayInFlying;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInFlying_1_11 extends WrappedVersionPacket {
-
-    public double x;
-    public double y;
-    public double z;
-    public float yaw;
-    public float pitch;
-    public boolean f;
-    public boolean hasPos;
-    public boolean hasLook;
-
-    public WrappedPacketPlayInFlying_1_11(Object packet) {
-        super(packet);
-    }
-
-
-    @Override
-    protected void setup() {
-        PacketPlayInFlying p = (PacketPlayInFlying) packet;
-        try {
-            this.hasPos = fieldHasPos.getBoolean(p);
-            this.hasLook = fieldHasLook.getBoolean(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        if (hasPos) {
-            this.x = p.a(0.0D);
-            this.y = p.b(0.0D);
-            this.z = p.c(0.0D);
-        } else {
-            try {
-                this.x = fieldX.getDouble(p);
-                this.y = fieldY.getDouble(p);
-                this.z = fieldZ.getDouble(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-
-        if (hasLook) {
-            this.yaw = p.a(0.0F);
-            this.pitch = p.b(0.0F);
-        } else {
-            try {
-                this.yaw = fieldYaw.getFloat(p);
-                this.pitch = fieldPitch.getFloat(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-        this.f = p.a();
-    }
-
-    public static class WrappedPacketPlayInPosition_1_11 extends WrappedPacketPlayInFlying_1_11 {
-
-        public WrappedPacketPlayInPosition_1_11(Object packet) {
-            super(packet);
-            this.hasPos = true;
-        }
-    }
-
-    public static class WrappedPacketPlayInPosition_Look_1_11 extends WrappedPacketPlayInFlying_1_11 {
-
-        public WrappedPacketPlayInPosition_Look_1_11(Object packet) {
-            super(packet);
-            this.hasLook = true;
-        }
-    }
-
-
-    private static Field fieldHasPos;
-    private static Field fieldHasLook;
-    private static Field fieldX;
-    private static Field fieldY;
-    private static Field fieldZ;
-    private static Field fieldYaw;
-    private static Field fieldPitch;
-
-    static {
-        try {
-            fieldHasPos = PacketPlayInFlying.class.getDeclaredField("hasPos");
-            fieldHasPos.setAccessible(true);
-            fieldHasLook = PacketPlayInFlying.class.getDeclaredField("hasLook");
-            fieldHasLook.setAccessible(true);
-            fieldX = PacketPlayInFlying.class.getDeclaredField("x");
-            fieldX.setAccessible(true);
-            fieldY = PacketPlayInFlying.class.getDeclaredField("y");
-            fieldY.setAccessible(true);
-            fieldZ = PacketPlayInFlying.class.getDeclaredField("z");
-            fieldZ.setAccessible(true);
-            fieldYaw = PacketPlayInFlying.class.getDeclaredField("yaw");
-            fieldYaw.setAccessible(true);
-            fieldPitch = PacketPlayInFlying.class.getDeclaredField("pitch");
-            fieldPitch.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-}
-

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_11/WrappedPacketPlayInUseEntity_1_11.java

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

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_12/WrappedPacketPlayInAbilities_1_12.java

@@ -1,55 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_12;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_12_R1.PacketPlayInAbilities;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInAbilities_1_12 extends WrappedVersionPacket {
-
-    public boolean a;
-    public boolean b;
-    public boolean c;
-    public boolean d;
-    public float e;
-    public float f;
-
-    public WrappedPacketPlayInAbilities_1_12(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInAbilities p = (PacketPlayInAbilities) packet;
-        this.a = p.a();
-        this.b = p.isFlying();
-        this.c = p.c();
-        this.d = p.d();
-        try {
-            this.e = fieldE.getFloat(p);
-        } catch (IllegalAccessException illegalAccessException) {
-            illegalAccessException.printStackTrace();
-        }
-        try {
-            this.f = fieldF.getFloat(p);
-        } catch (IllegalAccessException illegalAccessException) {
-            illegalAccessException.printStackTrace();
-        }
-    }
-
-    private static Field fieldE;
-    private static Field fieldF;
-
-    static {
-        try {
-            fieldE = PacketPlayInAbilities.class.getDeclaredField("e");
-            fieldE.setAccessible(true);
-            fieldF = PacketPlayInAbilities.class.getDeclaredField("f");
-            fieldF.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-
-
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_12/WrappedPacketPlayInBlockDig_1_12.java

@@ -1,21 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_12;
-
-import me.purplex.packetevents.enums.PlayerDigType;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_12_R1.PacketPlayInBlockDig;
-
-public class WrappedPacketPlayInBlockDig_1_12 extends WrappedVersionPacket {
-
-    public PlayerDigType digType;
-
-    public WrappedPacketPlayInBlockDig_1_12(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInBlockDig p = (PacketPlayInBlockDig) packet;
-        String name = p.c().name();
-        this.digType = PlayerDigType.valueOf(name);
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_12/WrappedPacketPlayInChat_1_12.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_12;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_12_R1.PacketPlayInChat;
-
-public class WrappedPacketPlayInChat_1_12 extends WrappedVersionPacket {
-    public String message;
-    public WrappedPacketPlayInChat_1_12(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInChat p = (PacketPlayInChat)packet;
-        this.message = p.a();
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_12/WrappedPacketPlayInFlying_1_12.java

@@ -1,106 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_12;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_12_R1.PacketPlayInFlying;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInFlying_1_12 extends WrappedVersionPacket {
-    public double x;
-    public double y;
-    public double z;
-    public float yaw;
-    public float pitch;
-    public boolean f;
-    public boolean hasPos;
-    public boolean hasLook;
-
-    public WrappedPacketPlayInFlying_1_12(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInFlying p = (PacketPlayInFlying) packet;
-        try {
-            this.hasPos = fieldHasPos.getBoolean(p);
-            this.hasLook = fieldHasLook.getBoolean(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        if (hasPos) {
-            this.x = p.a(0.0D);
-            this.y = p.b(0.0D);
-            this.z = p.c(0.0D);
-        } else {
-            try {
-                this.x = fieldX.getDouble(p);
-                this.y = fieldY.getDouble(p);
-                this.z = fieldZ.getDouble(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-
-        if (hasLook) {
-            this.yaw = p.a(0.0F);
-            this.pitch = p.b(0.0F);
-        } else {
-            try {
-                this.yaw = fieldYaw.getFloat(p);
-                this.pitch = fieldPitch.getFloat(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-        this.f = p.a();
-    }
-
-    public static class WrappedPacketPlayInPosition_1_12 extends WrappedPacketPlayInFlying_1_12 {
-
-        public WrappedPacketPlayInPosition_1_12(Object packet) {
-            super(packet);
-            this.hasPos = true;
-        }
-    }
-
-    public static class WrappedPacketPlayInPosition_Look_1_12 extends WrappedPacketPlayInFlying_1_12 {
-
-        public WrappedPacketPlayInPosition_Look_1_12(Object packet) {
-            super(packet);
-            this.hasLook = true;
-        }
-    }
-
-
-    private static Field fieldHasPos;
-    private static Field fieldHasLook;
-    private static Field fieldX;
-    private static Field fieldY;
-    private static Field fieldZ;
-    private static Field fieldYaw;
-    private static Field fieldPitch;
-
-    static {
-        try {
-            fieldHasPos = PacketPlayInFlying.class.getDeclaredField("hasPos");
-            fieldHasPos.setAccessible(true);
-            fieldHasLook = PacketPlayInFlying.class.getDeclaredField("hasLook");
-            fieldHasLook.setAccessible(true);
-            fieldX = PacketPlayInFlying.class.getDeclaredField("x");
-            fieldX.setAccessible(true);
-            fieldY = PacketPlayInFlying.class.getDeclaredField("y");
-            fieldY.setAccessible(true);
-            fieldZ = PacketPlayInFlying.class.getDeclaredField("z");
-            fieldZ.setAccessible(true);
-            fieldYaw = PacketPlayInFlying.class.getDeclaredField("yaw");
-            fieldYaw.setAccessible(true);
-            fieldPitch = PacketPlayInFlying.class.getDeclaredField("pitch");
-            fieldPitch.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-
-
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_12/WrappedPacketPlayInUseEntity_1_12.java

@@ -1,48 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_12;
-
-import me.purplex.packetevents.enums.EntityUseAction;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_12_R1.Entity;
-import net.minecraft.server.v1_12_R1.PacketPlayInUseEntity;
-import net.minecraft.server.v1_12_R1.WorldServer;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-
-public class WrappedPacketPlayInUseEntity_1_12 extends WrappedVersionPacket {
-    private org.bukkit.entity.Entity entity;
-    private EntityUseAction action;
-
-    public WrappedPacketPlayInUseEntity_1_12(Object packet) {
-        super(packet);
-    }
-
-    public org.bukkit.entity.Entity getEntity() {
-        return entity;
-    }
-
-    public EntityUseAction getEntityUseAction() {
-        return action;
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInUseEntity p = (net.minecraft.server.v1_12_R1.PacketPlayInUseEntity) packet;
-        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 (p.a(worldServer) != null) {
-                break;
-            }
-        }
-        Entity entity = p.a(worldServer);
-        this.entity = entity.getBukkitEntity();
-
-    }
-
-    private void setupAction() {
-        PacketPlayInUseEntity p = (PacketPlayInUseEntity) packet;
-        String name = p.a().name();
-        this.action = EntityUseAction.valueOf(name);
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_13/WrappedPacketPlayInAbilities_1_13.java

@@ -1,54 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_13;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_13_R1.PacketPlayInAbilities;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInAbilities_1_13 extends WrappedVersionPacket {
-
-    public boolean a;
-    public boolean b;
-    public boolean c;
-    public boolean d;
-    public float e;
-    public float f;
-
-    public WrappedPacketPlayInAbilities_1_13(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInAbilities p = (PacketPlayInAbilities) packet;
-        this.a = p.b();
-        this.b = p.isFlying();
-        this.c = p.d();
-        this.d = p.e();
-        try {
-            this.e = fieldE.getFloat(p);
-        } catch (IllegalAccessException illegalAccessException) {
-            illegalAccessException.printStackTrace();
-        }
-        try {
-            this.f = fieldF.getFloat(p);
-        } catch (IllegalAccessException illegalAccessException) {
-            illegalAccessException.printStackTrace();
-        }
-    }
-
-    private static Field fieldE;
-    private static Field fieldF;
-
-    static {
-        try {
-            fieldE = PacketPlayInAbilities.class.getDeclaredField("e");
-            fieldE.setAccessible(true);
-            fieldF = PacketPlayInAbilities.class.getDeclaredField("f");
-            fieldF.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_13/WrappedPacketPlayInBlockDig_1_13.java

@@ -1,20 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_13;
-
-import me.purplex.packetevents.enums.PlayerDigType;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_13_R1.PacketPlayInBlockDig;
-
-public class WrappedPacketPlayInBlockDig_1_13 extends WrappedVersionPacket {
-    public PlayerDigType digType;
-
-    public WrappedPacketPlayInBlockDig_1_13(Object packet) {
-        super(packet);
-    }
-    @Override
-    protected void setup() {
-        PacketPlayInBlockDig p = (PacketPlayInBlockDig) packet;
-        String name = p.d().name();
-        this.digType = PlayerDigType.valueOf(name);
-    }
-
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_13/WrappedPacketPlayInChat_1_13.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_13;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_13_R1.PacketPlayInChat;
-
-public class WrappedPacketPlayInChat_1_13 extends WrappedVersionPacket {
-    public String message;
-    public WrappedPacketPlayInChat_1_13(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInChat p = (PacketPlayInChat)packet;
-        this.message = p.b();
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_13/WrappedPacketPlayInFlying_1_13.java

@@ -1,107 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_13;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_13_R1.PacketPlayInFlying;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInFlying_1_13 extends WrappedVersionPacket {
-    public double x;
-    public double y;
-    public double z;
-    public float yaw;
-    public float pitch;
-    public boolean f;
-    public boolean hasPos;
-    public boolean hasLook;
-
-    public WrappedPacketPlayInFlying_1_13(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInFlying p = (PacketPlayInFlying) packet;
-        try {
-            this.hasPos = fieldHasPos.getBoolean(p);
-            this.hasLook = fieldHasLook.getBoolean(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        if (hasPos) {
-            this.x = p.a(0.0D);
-            this.y = p.b(0.0D);
-            this.z = p.c(0.0D);
-        } else {
-            try {
-                this.x = fieldX.getDouble(p);
-                this.y = fieldY.getDouble(p);
-                this.z = fieldZ.getDouble(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-
-        if (hasLook) {
-            this.yaw = p.a(0.0F);
-            this.pitch = p.b(0.0F);
-        } else {
-            try {
-                this.yaw = fieldYaw.getFloat(p);
-                this.pitch = fieldPitch.getFloat(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-        this.f = p.a();
-    }
-
-    public static class WrappedPacketPlayInPosition_1_13 extends WrappedPacketPlayInFlying_1_13 {
-
-        public WrappedPacketPlayInPosition_1_13(Object packet) {
-            super(packet);
-            this.hasPos = true;
-        }
-    }
-
-    public static class WrappedPacketPlayInPosition_Look_1_13 extends WrappedPacketPlayInFlying_1_13 {
-
-        public WrappedPacketPlayInPosition_Look_1_13(Object packet) {
-            super(packet);
-            this.hasLook = true;
-        }
-    }
-
-
-    private static Field fieldHasPos;
-    private static Field fieldHasLook;
-    private static Field fieldX;
-    private static Field fieldY;
-    private static Field fieldZ;
-    private static Field fieldYaw;
-    private static Field fieldPitch;
-
-    static {
-        try {
-            fieldHasPos = PacketPlayInFlying.class.getDeclaredField("hasPos");
-            fieldHasPos.setAccessible(true);
-            fieldHasLook = PacketPlayInFlying.class.getDeclaredField("hasLook");
-            fieldHasLook.setAccessible(true);
-            fieldX = PacketPlayInFlying.class.getDeclaredField("x");
-            fieldX.setAccessible(true);
-            fieldY = PacketPlayInFlying.class.getDeclaredField("y");
-            fieldY.setAccessible(true);
-            fieldZ = PacketPlayInFlying.class.getDeclaredField("z");
-            fieldZ.setAccessible(true);
-            fieldYaw = PacketPlayInFlying.class.getDeclaredField("yaw");
-            fieldYaw.setAccessible(true);
-            fieldPitch = PacketPlayInFlying.class.getDeclaredField("pitch");
-            fieldPitch.setAccessible(true);
-
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-
-
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_13/WrappedPacketPlayInUseEntity_1_13.java

@@ -1,53 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_13;
-
-import me.purplex.packetevents.enums.EntityUseAction;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_13_R1.Entity;
-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;
-
-public class WrappedPacketPlayInUseEntity_1_13 extends WrappedVersionPacket {
-    private org.bukkit.entity.Entity entity;
-    private EntityUseAction action;
-
-    public WrappedPacketPlayInUseEntity_1_13(Object packet) {
-       super(packet);
-    }
-    public org.bukkit.entity.Entity getEntity() {
-        return entity;
-    }
-
-    public EntityUseAction getEntityUseAction() {
-        return action;
-    }
-
-    @Override
-    protected void setup() {
-        setupEntity();
-        setupAction();
-    }
-
-    private void setupEntity() {
-        PacketPlayInUseEntity p = (PacketPlayInUseEntity) packet;
-        WorldServer worldServer = null;
-        for (World bukkitWorld : Bukkit.getWorlds()) {
-            CraftWorld craftWorld = (CraftWorld) bukkitWorld;
-            worldServer = craftWorld.getHandle();
-            if (p.a(worldServer) != null) {
-                break;
-            }
-        }
-        Entity entity = p.a(worldServer);
-        this.entity = entity.getBukkitEntity();
-
-    }
-
-    private void setupAction() {
-        PacketPlayInUseEntity p = (PacketPlayInUseEntity) packet;
-        String name = p.b().name();
-        this.action = EntityUseAction.valueOf(name);
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_13_2/WrappedPacketPlayInAbilities_1_13_2.java

@@ -1,53 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_13_2;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_13_R2.PacketPlayInAbilities;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInAbilities_1_13_2 extends WrappedVersionPacket {
-
-    public boolean a;
-    public boolean b;
-    public boolean c;
-    public boolean d;
-    public float e;
-    public float f;
-
-    public WrappedPacketPlayInAbilities_1_13_2(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInAbilities p = (PacketPlayInAbilities) packet;
-        this.a = p.b();
-        this.b = p.isFlying();
-        this.c = p.d();
-        this.d = p.e();
-        try {
-            this.e = fieldE.getFloat(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        try {
-            this.f = fieldF.getFloat(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-    private static Field fieldE;
-    private static Field fieldF;
-
-    static {
-        try {
-            fieldE = PacketPlayInAbilities.class.getDeclaredField("e");
-            fieldE.setAccessible(true);
-            fieldF = PacketPlayInAbilities.class.getDeclaredField("f");
-            fieldF.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_13_2/WrappedPacketPlayInBlockDig_1_13_2.java

@@ -1,21 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_13_2;
-
-import me.purplex.packetevents.enums.PlayerDigType;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_13_R2.PacketPlayInBlockDig;
-
-public class WrappedPacketPlayInBlockDig_1_13_2 extends WrappedVersionPacket {
-    public PlayerDigType digType;
-
-    public WrappedPacketPlayInBlockDig_1_13_2(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInBlockDig p = (PacketPlayInBlockDig) packet;
-        String name = p.d().name();
-        this.digType = PlayerDigType.valueOf(name);
-    }
-
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_13_2/WrappedPacketPlayInChat_1_13_2.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_13_2;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_13_R2.PacketPlayInChat;
-
-public class WrappedPacketPlayInChat_1_13_2 extends WrappedVersionPacket {
-    public String message;
-    public WrappedPacketPlayInChat_1_13_2(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInChat p = (PacketPlayInChat)packet;
-        this.message = p.b();
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_13_2/WrappedPacketPlayInFlying_1_13_2.java

@@ -1,106 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_13_2;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_13_R2.PacketPlayInFlying;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInFlying_1_13_2 extends WrappedVersionPacket {
-    public double x;
-    public double y;
-    public double z;
-    public float yaw;
-    public float pitch;
-    public boolean f;
-    public boolean hasPos;
-    public boolean hasLook;
-
-    public WrappedPacketPlayInFlying_1_13_2(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInFlying p = (PacketPlayInFlying) packet;
-        try {
-            this.hasPos = fieldHasPos.getBoolean(p);
-            this.hasLook = fieldHasLook.getBoolean(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        if (hasPos) {
-            this.x = p.a(0.0D);
-            this.y = p.b(0.0D);
-            this.z = p.c(0.0D);
-        } else {
-            try {
-                this.x = fieldX.getDouble(p);
-                this.y = fieldY.getDouble(p);
-                this.z = fieldZ.getDouble(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-
-        if (hasLook) {
-            this.yaw = p.a(0.0F);
-            this.pitch = p.b(0.0F);
-        } else {
-            try {
-                this.yaw = fieldYaw.getFloat(p);
-                this.pitch = fieldPitch.getFloat(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-        this.f = p.a();
-    }
-
-    public static class WrappedPacketPlayInPosition_1_13_2 extends WrappedPacketPlayInFlying_1_13_2 {
-
-        public WrappedPacketPlayInPosition_1_13_2(Object packet) {
-            super(packet);
-            this.hasPos = true;
-        }
-    }
-
-    public static class WrappedPacketPlayInPosition_Look_1_13_2 extends WrappedPacketPlayInFlying_1_13_2 {
-
-        public WrappedPacketPlayInPosition_Look_1_13_2(Object packet) {
-            super(packet);
-            this.hasLook = true;
-        }
-    }
-
-    private static Field fieldHasPos;
-    private static Field fieldHasLook;
-    private static Field fieldX;
-    private static Field fieldY;
-    private static Field fieldZ;
-    private static Field fieldYaw;
-    private static Field fieldPitch;
-
-    static {
-        try {
-            fieldHasPos = PacketPlayInFlying.class.getDeclaredField("hasPos");
-            fieldHasPos.setAccessible(true);
-            fieldHasLook = PacketPlayInFlying.class.getDeclaredField("hasLook");
-            fieldHasLook.setAccessible(true);
-            fieldY = PacketPlayInFlying.class.getDeclaredField("y");
-            fieldY.setAccessible(true);
-            fieldX = PacketPlayInFlying.class.getDeclaredField("x");
-            fieldX.setAccessible(true);
-            fieldZ = PacketPlayInFlying.class.getDeclaredField("z");
-            fieldZ.setAccessible(true);
-            fieldPitch = PacketPlayInFlying.class.getDeclaredField("pitch");
-            fieldPitch.setAccessible(true);
-            fieldYaw = PacketPlayInFlying.class.getDeclaredField("yaw");
-            fieldYaw.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-
-
-}
-

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_13_2/WrappedPacketPlayInUseEntity_1_13_2.java

@@ -1,54 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_13_2;
-
-import me.purplex.packetevents.enums.EntityUseAction;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_13_R2.Entity;
-import org.bukkit.Bukkit;
-import org.bukkit.World;
-import org.bukkit.craftbukkit.v1_13_R2.CraftWorld;
-import net.minecraft.server.v1_13_R2.PacketPlayInUseEntity;
-import net.minecraft.server.v1_13_R2.WorldServer;
-public class WrappedPacketPlayInUseEntity_1_13_2 extends WrappedVersionPacket {
-
-    private org.bukkit.entity.Entity entity;
-    private EntityUseAction action;
-
-    public WrappedPacketPlayInUseEntity_1_13_2(Object packet) {
-        super(packet);
-    }
-
-    public org.bukkit.entity.Entity getEntity() {
-        return entity;
-    }
-
-    public EntityUseAction getEntityUseAction() {
-        return action;
-    }
-
-    @Override
-    protected void setup() {
-        setupEntity();
-        setupAction();
-    }
-
-    private void setupEntity() {
-        PacketPlayInUseEntity p = (PacketPlayInUseEntity) packet;
-        WorldServer worldServer = null;
-        for (World bukkitWorld : Bukkit.getWorlds()) {
-            CraftWorld craftWorld = (CraftWorld) bukkitWorld;
-            worldServer = craftWorld.getHandle();
-            if (p.a(worldServer) != null) {
-                break;
-            }
-        }
-        Entity entity = p.a(worldServer);
-        this.entity = entity.getBukkitEntity();
-
-    }
-
-    private void setupAction() {
-        PacketPlayInUseEntity p = (PacketPlayInUseEntity) packet;
-        String name = p.b().name();
-        this.action = EntityUseAction.valueOf(name);
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_14/WrappedPacketPlayInAbilities_1_14.java

@@ -1,53 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_14;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_14_R1.PacketPlayInAbilities;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInAbilities_1_14 extends WrappedVersionPacket {
-
-    public boolean a;
-    public boolean b;
-    public boolean c;
-    public boolean d;
-    public float e;
-    public float f;
-
-    public WrappedPacketPlayInAbilities_1_14(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInAbilities p = (PacketPlayInAbilities) packet;
-        this.a = p.b();
-        this.b = p.isFlying();
-        this.c = p.d();
-        this.d = p.e();
-        try {
-            this.e = fieldE.getFloat(p);
-        } catch (IllegalAccessException illegalAccessException) {
-            illegalAccessException.printStackTrace();
-        }
-        try {
-            this.f = fieldF.getFloat(p);
-        } catch (IllegalAccessException illegalAccessException) {
-            illegalAccessException.printStackTrace();
-        }
-    }
-
-    private static Field fieldE;
-    private static Field fieldF;
-
-    static {
-        try {
-            fieldE = PacketPlayInAbilities.class.getDeclaredField("e");
-            fieldE.setAccessible(true);
-            fieldF = PacketPlayInAbilities.class.getDeclaredField("f");
-            fieldF.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_14/WrappedPacketPlayInBlockDig_1_14.java

@@ -1,20 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_14;
-
-import me.purplex.packetevents.enums.PlayerDigType;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_14_R1.PacketPlayInBlockDig;
-
-public class WrappedPacketPlayInBlockDig_1_14 extends WrappedVersionPacket {
-    public PlayerDigType digType;
-
-    public WrappedPacketPlayInBlockDig_1_14(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInBlockDig p = (PacketPlayInBlockDig) packet;
-        String name = p.d().name();
-        this.digType = PlayerDigType.valueOf(name);
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_14/WrappedPacketPlayInChat_1_14.java

@@ -1,17 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_14;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_14_R1.PacketPlayInChat;
-
-public class WrappedPacketPlayInChat_1_14 extends WrappedVersionPacket {
-    public String message;
-    public WrappedPacketPlayInChat_1_14(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInChat p = (PacketPlayInChat)packet;
-        this.message = p.b();
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_14/WrappedPacketPlayInFlying_1_14.java

@@ -1,107 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_14;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_14_R1.PacketPlayInFlying;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInFlying_1_14 extends WrappedVersionPacket {
-    public double x;
-    public double y;
-    public double z;
-    public float yaw;
-    public float pitch;
-    public boolean f;
-    public boolean hasPos;
-    public boolean hasLook;
-
-    public WrappedPacketPlayInFlying_1_14(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInFlying p = (PacketPlayInFlying) packet;
-        try {
-            this.hasPos = fieldHasPos.getBoolean(p);
-            this.hasLook = fieldHasLook.getBoolean(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        if (hasPos) {
-            this.x = p.a(0.0D);
-            this.y = p.b(0.0D);
-            this.z = p.c(0.0D);
-        } else {
-            try {
-                this.x = fieldX.getDouble(p);
-                this.y = fieldY.getDouble(p);
-                this.z = fieldZ.getDouble(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-
-        if (hasLook) {
-            this.yaw = p.a(0.0F);
-            this.pitch = p.b(0.0F);
-        } else {
-            try {
-                this.yaw = fieldYaw.getFloat(p);
-                this.pitch = fieldPitch.getFloat(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-        this.f = p.a();
-    }
-
-    public static class WrappedPacketPlayInPosition_1_14 extends WrappedPacketPlayInFlying_1_14 {
-
-        public WrappedPacketPlayInPosition_1_14(Object packet) {
-            super(packet);
-            this.hasPos = true;
-        }
-    }
-
-    public static class WrappedPacketPlayInPosition_Look_1_14 extends WrappedPacketPlayInFlying_1_14 {
-
-        public WrappedPacketPlayInPosition_Look_1_14(Object packet) {
-            super(packet);
-            this.hasLook = true;
-        }
-    }
-
-
-    private static Field fieldHasPos;
-    private static Field fieldHasLook;
-    private static Field fieldX;
-    private static Field fieldY;
-    private static Field fieldZ;
-    private static Field fieldYaw;
-    private static Field fieldPitch;
-
-    static {
-        try {
-            fieldHasPos = PacketPlayInFlying.class.getDeclaredField("hasPos");
-            fieldHasPos.setAccessible(true);
-            fieldHasLook = PacketPlayInFlying.class.getDeclaredField("hasLook");
-            fieldHasLook.setAccessible(true);
-            fieldX = PacketPlayInFlying.class.getDeclaredField("x");
-            fieldX.setAccessible(true);
-            fieldY = PacketPlayInFlying.class.getDeclaredField("y");
-            fieldY.setAccessible(true);
-            fieldZ = PacketPlayInFlying.class.getDeclaredField("z");
-            fieldZ.setAccessible(true);
-            fieldYaw = PacketPlayInFlying.class.getDeclaredField("yaw");
-            fieldYaw.setAccessible(true);
-            fieldPitch = PacketPlayInFlying.class.getDeclaredField("pitch");
-            fieldPitch.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-
-
-}
-

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_14/WrappedPacketPlayInUseEntity_1_14.java

@@ -1,54 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_14;
-
-import me.purplex.packetevents.enums.EntityUseAction;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_14_R1.Entity;
-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.craftbukkit.v1_14_R1.CraftWorld;
-
-public class WrappedPacketPlayInUseEntity_1_14 extends WrappedVersionPacket {
-    private org.bukkit.entity.Entity entity;
-    private EntityUseAction action;
-
-    public WrappedPacketPlayInUseEntity_1_14(Object packet) {
-       super(packet);
-    }
-
-    public org.bukkit.entity.Entity getEntity() {
-        return entity;
-    }
-
-    public EntityUseAction getEntityUseAction() {
-        return action;
-    }
-
-    @Override
-    protected void setup() {
-        setupEntity();
-        setupAction();
-    }
-
-    private void setupEntity() {
-        PacketPlayInUseEntity p = (PacketPlayInUseEntity) packet;
-        WorldServer worldServer = null;
-        for (World bukkitWorld : Bukkit.getWorlds()) {
-            CraftWorld craftWorld = (CraftWorld) bukkitWorld;
-            worldServer = craftWorld.getHandle();
-            if (p.a(worldServer) != null) {
-                break;
-            }
-        }
-        Entity entity = p.a(worldServer);
-        this.entity = entity.getBukkitEntity();
-
-    }
-
-    private void setupAction() {
-        PacketPlayInUseEntity p = (PacketPlayInUseEntity) packet;
-        String name = p.b().name();
-        this.action = EntityUseAction.valueOf(name);
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_15/WrappedPacketPlayInAbilities_1_15.java

@@ -1,54 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_15;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_15_R1.PacketPlayInAbilities;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInAbilities_1_15 extends WrappedVersionPacket {
-
-    public boolean a;
-    public boolean b;
-    public boolean c;
-    public boolean d;
-    public float e;
-    public float f;
-
-    public WrappedPacketPlayInAbilities_1_15(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInAbilities p = (PacketPlayInAbilities) packet;
-        this.a = p.b();
-        this.b = p.isFlying();
-        this.c = p.d();
-        this.d = p.e();
-        try {
-            this.e = fieldE.getFloat(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        try {
-            this.f = fieldF.getFloat(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-    }
-
-
-    private static Field fieldE;
-    private static Field fieldF;
-
-    static {
-        try {
-            fieldE = PacketPlayInAbilities.class.getDeclaredField("e");
-            fieldE.setAccessible(true);
-            fieldF = PacketPlayInAbilities.class.getDeclaredField("f");
-            fieldF.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_15/WrappedPacketPlayInBlockDig_1_15.java

@@ -1,20 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_15;
-
-import me.purplex.packetevents.enums.PlayerDigType;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_15_R1.PacketPlayInBlockDig;
-
-public class WrappedPacketPlayInBlockDig_1_15 extends WrappedVersionPacket {
-    public PlayerDigType digType;
-
-    public WrappedPacketPlayInBlockDig_1_15(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInBlockDig p = (PacketPlayInBlockDig) packet;
-        String name = p.d().name();
-        this.digType = PlayerDigType.valueOf(name);
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_15/WrappedPacketPlayInChat_1_15.java

@@ -1,18 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_15;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_15_R1.PacketPlayInChat;
-
-public class WrappedPacketPlayInChat_1_15 extends WrappedVersionPacket {
-
-    public String message;
-    public WrappedPacketPlayInChat_1_15(Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        PacketPlayInChat p = (PacketPlayInChat)packet;
-        this.message = p.b();
-    }
-}

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_15/WrappedPacketPlayInFlying_1_15.java

@@ -1,107 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_15;
-
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_15_R1.PacketPlayInFlying;
-
-import java.lang.reflect.Field;
-
-public class WrappedPacketPlayInFlying_1_15 extends WrappedVersionPacket {
-    public double x;
-    public double y;
-    public double z;
-    public float yaw;
-    public float pitch;
-    public boolean f;
-    public boolean hasPos;
-    public boolean hasLook;
-
-    public WrappedPacketPlayInFlying_1_15(Object packet) {
-        super(packet);
-    }
-
-
-    @Override
-    protected void setup() {
-        PacketPlayInFlying p = (PacketPlayInFlying) packet;
-        try {
-            this.hasPos = fieldHasPos.getBoolean(p);
-            this.hasLook = fieldHasLook.getBoolean(p);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        }
-        if (hasPos) {
-            this.x = p.a(0.0D);
-            this.y = p.b(0.0D);
-            this.z = p.c(0.0D);
-        } else {
-            try {
-                this.x = fieldX.getDouble(p);
-                this.y = fieldY.getDouble(p);
-                this.z = fieldZ.getDouble(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-
-        if (hasLook) {
-            this.yaw = p.a(0.0F);
-            this.pitch = p.b(0.0F);
-        } else {
-            try {
-                this.yaw = fieldYaw.getFloat(p);
-                this.pitch = fieldPitch.getFloat(p);
-            } catch (IllegalAccessException e) {
-                e.printStackTrace();
-            }
-        }
-        this.f = p.a();
-    }
-
-    public static class WrappedPacketPlayInPosition_1_15 extends WrappedPacketPlayInFlying_1_15 {
-
-        public WrappedPacketPlayInPosition_1_15(Object packet) {
-            super(packet);
-            this.hasPos = true;
-        }
-    }
-
-    public static class WrappedPacketPlayInPosition_Look_1_15 extends WrappedPacketPlayInFlying_1_15 {
-
-        public WrappedPacketPlayInPosition_Look_1_15(Object packet) {
-            super(packet);
-            this.hasLook = true;
-        }
-    }
-
-    private static Field fieldHasPos;
-    private static Field fieldHasLook;
-    private static Field fieldX;
-    private static Field fieldY;
-    private static Field fieldZ;
-    private static Field fieldYaw;
-    private static Field fieldPitch;
-
-    static {
-        try {
-            fieldHasPos = PacketPlayInFlying.class.getDeclaredField("hasPos");
-            fieldHasPos.setAccessible(true);
-            fieldHasLook = PacketPlayInFlying.class.getDeclaredField("hasLook");
-            fieldHasLook.setAccessible(true);
-            fieldX = PacketPlayInFlying.class.getDeclaredField("x");
-            fieldX.setAccessible(true);
-            fieldY = PacketPlayInFlying.class.getDeclaredField("y");
-            fieldY.setAccessible(true);
-            fieldZ = PacketPlayInFlying.class.getDeclaredField("z");
-            fieldZ.setAccessible(true);
-            fieldYaw = PacketPlayInFlying.class.getDeclaredField("yaw");
-            fieldYaw.setAccessible(true);
-            fieldPitch = PacketPlayInFlying.class.getDeclaredField("pitch");
-            fieldPitch.setAccessible(true);
-        } catch (NoSuchFieldException e) {
-            e.printStackTrace();
-        }
-    }
-
-
-}
-

src/main/java/me/purplex/packetevents/packetwrappers/in/_1_15/WrappedPacketPlayInUseEntity_1_15.java

@@ -1,54 +0,0 @@
-package me.purplex.packetevents.packetwrappers.in._1_15;
-
-import me.purplex.packetevents.enums.EntityUseAction;
-import me.purplex.packetevents.packetwrappers.api.version.WrappedVersionPacket;
-import net.minecraft.server.v1_15_R1.Entity;
-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;
-
-public class WrappedPacketPlayInUseEntity_1_15 extends WrappedVersionPacket {
-    private org.bukkit.entity.Entity entity;
-    private EntityUseAction action;
-
-    public WrappedPacketPlayInUseEntity_1_15(Object packet) {
-        super(packet);
-    }
-
-
-    public org.bukkit.entity.Entity getEntity() {
-        return entity;
-    }
-
-    public EntityUseAction getEntityUseAction() {
-        return action;
-    }
-
-    @Override
-    protected void setup() {
-        setupEntity();
-        setupAction();
-    }
-
-    private void setupEntity() {
-        PacketPlayInUseEntity p = (PacketPlayInUseEntity) packet;
-        WorldServer worldServer = null;
-        for (World bukkitWorld : Bukkit.getWorlds()) {
-            CraftWorld craftWorld = (CraftWorld) bukkitWorld;
-            worldServer = craftWorld.getHandle();
-            if (p.a(worldServer) != null) {
-                break;
-            }
-        }
-        Entity entity = p.a(worldServer);
-        this.entity = entity.getBukkitEntity();
-    }
-
-    private void setupAction() {
-        PacketPlayInUseEntity p = (PacketPlayInUseEntity) packet;
-        String name = p.b().name();
-        this.action = EntityUseAction.valueOf(name);
-    }
-}