updated readme credit to release 1.3.5

Merge remote-tracking branch 'origin/master'
1.3.5 Release STABLE!
2020-06-25 13:35:53 +02:00 · 2020-06-25 13:16:04 +02:00 · 2020-06-25 13:15:34 +02:00 · 2020-06-22 22:43:50 +02:00 · 2020-06-22 22:36:27 +02:00 · 2020-06-22 22:31:14 +02:00
46 changed files with 996 additions and 1688 deletions
@@ -2,13 +2,15 @@

 A lightweight spigot packetlistener & packetsender coded by retrooper.

-## Credit:
+## Credit

-PacketEvents uses a modified version of [TinyProtocol](http://github.com/dmulloy2/ProtocolLib/blob/master/TinyProtocol/src/main/java/com/comphenix/tinyprotocol/TinyProtocol.java) by [@DeprecatedLuke](https://github.com/DeprecatedLuke) to support 1.7.10 & 1.8.
-I modified DeprecatedLuke's version of TinyProtocol and added support for 1.9+ versions.
+PacketEvents uses [TinyProtocol](https://github.com/dmulloy2/ProtocolLib/blob/master/TinyProtocol)'s [Reflection](https://github.com/dmulloy2/ProtocolLib/blob/master/TinyProtocol/src/main/java/com/comphenix/tinyprotocol/Reflection.java) util class.

-PacketEvents also took Atlas' Packet class.(all the packet names)
+[Find it here in our source](https://github.com/retrooper/packetevents/blob/master/src/main/java/io/github/retrooper/packetevents/reflectionutils/Reflection.java)

+PacketEvents forked [Atlas](https://github.com/funkemunky/Atlas)' [Packet](https://github.com/funkemunky/Atlas/blob/master/AtlasParent/Atlas/src/main/java/cc/funkemunky/api/tinyprotocol/api/Packet.java) class.
+
+[Find our forked version](https://github.com/retrooper/packetevents/blob/master/src/main/java/io/github/retrooper/packetevents/packet/PacketType.java)
 ## About

 This packetlistener is **only** supported on spigot servers and has been tested to work on these spigot forks: PaperSpigot, Tuinity
@@ -6,7 +6,7 @@

    <groupId>io.github.retrooper</groupId>
    <artifactId>packetevents</artifactId>
-    <version>1.3.3</version>
+    <version>1.3.5</version>
    <packaging>jar</packaging>
    <name>packetevents</name>
    <properties>
@@ -56,6 +56,10 @@
            <id>funkemunky-releases</id>
            <url>https://nexus.funkemunky.cc/content/repositories/releases/</url>
        </repository>
+        <repository>
+            <id>viaversion-repo</id>
+            <url>https://repo.viaversion.com</url>
+        </repository>
    </repositories>


@@ -180,5 +184,17 @@
            <version>1.14</version>
            <scope>provided</scope>
        </dependency>
+
+        <dependency>
+            <groupId>us.myles</groupId>
+            <artifactId>viaversion</artifactId>
+            <version>3.0.1</version>
+        </dependency>
+
+        <dependency>
+            <groupId>com.github.ProtocolSupport</groupId>
+            <artifactId>ProtocolSupport</artifactId>
+            <version>4fdd683</version>
+        </dependency>
    </dependencies>
 </project>
@@ -5,36 +5,37 @@ import io.github.retrooper.packetevents.annotations.Nullable;
 import io.github.retrooper.packetevents.annotations.PacketHandler;
 import io.github.retrooper.packetevents.enums.ClientVersion;
 import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.event.PacketEvent;
 import io.github.retrooper.packetevents.event.PacketListener;
 import io.github.retrooper.packetevents.event.impl.*;
 import io.github.retrooper.packetevents.event.manager.EventManager;
-import io.github.retrooper.packetevents.handler.TinyProtocolHandler;
+import io.github.retrooper.packetevents.handler.NettyPacketHandler;
 import io.github.retrooper.packetevents.packet.Packet;
+import io.github.retrooper.packetevents.packet.PacketType;
 import io.github.retrooper.packetevents.packetwrappers.Sendable;
-import io.github.retrooper.packetevents.packetwrappers.login.WrappedPacketLoginHandshake;
 import io.github.retrooper.packetevents.utils.NMSUtils;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.event.player.PlayerMoveEvent;
 import org.bukkit.plugin.Plugin;
 import org.bukkit.scheduler.BukkitTask;

 import java.lang.reflect.InvocationTargetException;
 import java.util.HashMap;
+import java.util.UUID;

 public final class PacketEvents implements PacketListener, Listener {

    private static final ServerVersion version = ServerVersion.getVersion();
    private static final EventManager eventManager = new EventManager();
-    private static final HashMap<Object, ClientVersion> clientVersionLookup = new HashMap<Object, ClientVersion>();
    private static boolean hasRegistered;
    private static PacketEvents instance;
    private static int currentTick;
    private static BukkitTask serverTickTask;
-    private static boolean kickOnRestart;
+
+    private static final HashMap<UUID, ClientVersion> clientVersionsMap = new HashMap<UUID, ClientVersion>();

    public static EventManager getEventManager() {
        return eventManager;
@@ -52,14 +53,12 @@ public final class PacketEvents implements PacketListener, Listener {
            getEventManager().registerListener(getInstance());

            Bukkit.getPluginManager().registerEvents(getInstance(), plugin);
-            //Initialize the TinyProtocolHandler
-            TinyProtocolHandler.initTinyProtocol(plugin);

            //Start the server tick task
            final Runnable tickRunnable = new Runnable() {
                @Override
                public void run() {
-                    getEventManager().callEvent(new ServerTickEvent(currentTick++, highlyPreciseMillis()));
+                    getEventManager().callEvent(new ServerTickEvent(currentTick++, PacketEvents.highlyPreciseMillis()));
                }
            };
            serverTickTask = Bukkit.getScheduler().runTaskTimerAsynchronously(plugin, tickRunnable, 0L, 1L);
@@ -72,18 +71,9 @@ public final class PacketEvents implements PacketListener, Listener {
     */
    public static void stop() {
        if (serverTickTask != null) {
-            if (!serverTickTask.isCancelled()) {
-                serverTickTask.cancel();
-            }
+            serverTickTask.cancel();
        }
        getEventManager().unregisterAllListeners();
-        if (shouldKickOnStop()) {
-            for (final Player p : Bukkit.getOnlinePlayers()) {
-                if (p != null) {
-                    p.kickPlayer("Please wait till the server finishes reloading/restarting.");
-                }
-            }
-        }
    }

    /**
@@ -120,7 +110,7 @@ public final class PacketEvents implements PacketListener, Listener {
    /**
     * Get the server's recent TPS values
     * TPS stands for ticks per second.
-     * Learn more about ticks <a href="https://apexminecrafthosting.com/what-is-minecraft-tps/">"https://apexminecrafthosting.com/what-is-minecraft-tps/"</a>
+     * See to learn more about TPS<a href="https://apexminecrafthosting.com/what-is-minecraft-tps/">"https://apexminecrafthosting.com/what-is-minecraft-tps/"</a>
     *
     * @return recentTPS[]
     */
@@ -137,9 +127,9 @@ public final class PacketEvents implements PacketListener, Listener {
    /**
     * Get the server's current TPS
     * TPS stands for ticks per second.
-     * Learn more about ticks <a href="https://apexminecrafthosting.com/what-is-minecraft-tps/">"https://apexminecrafthosting.com/what-is-minecraft-tps/"</a>
+     * See to learn more about TPS <a href="https://apexminecrafthosting.com/what-is-minecraft-tps/">"https://apexminecrafthosting.com/what-is-minecraft-tps/"</a>
     *
-     * @return currentTPS / recentTPS[0]
+     * @return {@link PacketEvents#getRecentServerTPS()[0]}
     */
    public static double getCurrentServerTPS() {
        return getRecentServerTPS()[0];
@@ -162,15 +152,18 @@ public final class PacketEvents implements PacketListener, Listener {
     * Java documentation recommend using nano time if you are measuring elapsed time.
     * In this function nanoTime is divided by 1 million giving us milliseconds.
     * It is also important to mention that using this method doesn't guarantee thread safety.
+     *
     * @return nanoTime / 1 million
     */
    public static long highlyPreciseMillis() {
        return System.nanoTime() / 1000000;
    }

+
    /**
-     * This is deprecated, use {@link #highlyPreciseMillis()} as they do the same thing, this is basically just a method rename.
+     * This is deprecated, use {@link #highlyPreciseMillis()} as they do the same thing, I just renamed the method.
     */
+    @Deprecated
    public static long currentCalculatedMS() {
        return System.nanoTime() / 1000000;
    }
@@ -184,31 +177,14 @@ public final class PacketEvents implements PacketListener, Listener {
     * @param player
     * @return ClientVersion
     */
+
    @Nullable
    public static ClientVersion getClientVersion(@NotNull final Player player) {
-        final Object channel = TinyProtocolHandler.getPlayerChannel(player);
-        return clientVersionLookup.get(channel);
+        return getClientVersion(player.getUniqueId());
    }

-    /**
-     * Get the players' client version
-     * Do not call this method in the PlayerInjectEvent, it is safe to call it in the PostPlayerInjectEvent.
-     * The EntityPlayer object is null at that time, resulting in the version lookup to fail.
-     *
-     * @param channel
-     * @return ClientVersion
-     */
-    @Nullable
-    public static ClientVersion getClientVersion(@NotNull final Object channel) {
-        return clientVersionLookup.get(channel);
-    }
-
-    public static boolean shouldKickOnStop() {
-        return kickOnRestart;
-    }
-
-    public static void setShouldKickOnRestart(final boolean val) {
-        kickOnRestart = val;
+    public static ClientVersion getClientVersion(@NotNull final UUID uuid) {
+        return clientVersionsMap.get(uuid);
    }

    /**
@@ -217,7 +193,12 @@ public final class PacketEvents implements PacketListener, Listener {
     * @param player
     */
    public static void injectPlayer(final Player player) {
-        TinyProtocolHandler.inject(player);
+        final PlayerInjectEvent injectEvent = new PlayerInjectEvent(player);
+        PacketEvents.getEventManager().callEvent(injectEvent);
+        if (!injectEvent.isCancelled()) {
+            PacketEvents.getEventManager().callEvent(new PostPlayerInjectEvent(player));
+            NettyPacketHandler.injectPlayer(player);
+        }
    }

    /**
@@ -226,7 +207,11 @@ public final class PacketEvents implements PacketListener, Listener {
     * @param player
     */
    public static void uninjectPlayer(final Player player) {
-        TinyProtocolHandler.uninject(player);
+        final PlayerUninjectEvent uninjectEvent = new PlayerUninjectEvent(player);
+        PacketEvents.getEventManager().callEvent(uninjectEvent);
+        if(!uninjectEvent.isCancelled()) {
+            NettyPacketHandler.uninjectPlayer(player);
+        }
    }

    /**
@@ -236,7 +221,7 @@ public final class PacketEvents implements PacketListener, Listener {
     * @return hasInjected
     */
    public static boolean hasInjected(final Player player) {
-        return TinyProtocolHandler.hasInjected(player);
+        return NettyPacketHandler.hasInjected(player);
    }

    /**
@@ -249,22 +234,6 @@ public final class PacketEvents implements PacketListener, Listener {
        NMSUtils.sendSendableWrapper(player, sendable);
    }

-    @PacketHandler
-    public void onLogin(final PacketLoginEvent e) {
-        if (e.getPacketName().equals(Packet.Login.HANDSHAKE)) {
-            final WrappedPacketLoginHandshake handshake = new WrappedPacketLoginHandshake(e.getPacket());
-            final ClientVersion clientVersion = ClientVersion.fromProtocolVersion(handshake.getProtocolVersion());
-            clientVersionLookup.put(e.getNettyChannel(), clientVersion);
-        }
-    }
-
-    @PacketHandler
-    public void onPacket(final PacketEvent e) {
-        if (e instanceof PacketReceiveEvent) {
-            // System.out.println("RECEIVED");
-        }
-    }
-
    /**
     * Do not check the client version in or before the PlayerInjectEvent, use the PostPlayerInjectEvent.
     * It is not recommended to do much in the PlayerInjectEvent, as some fields in the Player object are be null.
@@ -274,24 +243,33 @@ public final class PacketEvents implements PacketListener, Listener {
     */
    @PacketHandler
    public void onInject(final PlayerInjectEvent e) {
-        final String username = e.getPlayer().getName();
+        clientVersionsMap.put(e.getPlayer().getUniqueId(), e.getClientVersion());
+    }
+
+    @PacketHandler
+    public void onReceive(final PacketReceiveEvent e) {
    }

    /**
-     * Called after the PlayerJoinEvent ONLY if the player has been injected!
+     * Deprecated, please do not use this anymore
     *
     * @param e
     */
    @PacketHandler
    public void onPostInject(final PostPlayerInjectEvent e) {
-        //It is safe to get his client version in here.
-        final ClientVersion clientVersion = PacketEvents.getClientVersion(e.getPlayer());
+
    }

    @EventHandler
-    public void onJoin(PlayerJoinEvent e) {
-        if (hasInjected(e.getPlayer())) {
-            PacketEvents.getEventManager().callEvent(new PostPlayerInjectEvent(e.getPlayer()));
+    public void onJoin(final PlayerJoinEvent e) {
+        if (!hasInjected(e.getPlayer())) {
+            injectPlayer(e.getPlayer());
+
        }
    }
+
+    @EventHandler
+    public void onMove(final PlayerMoveEvent e) {
+        PacketEvents.getEventManager().callEvent(new BukkitMoveEvent(e));
+    }
 }
@@ -2,11 +2,13 @@ package io.github.retrooper.packetevents.enums;

 public enum ClientVersion {
    LESS_THAN_V_1_7_10, v_1_7_10, v_1_8, v_1_9, v_1_9_1, v_1_9_2, v_1_9_3, v_1_10, v_1_11, v_1_11_1, v_1_12, v_1_12_1, v_1_12_2,
-    v_1_13, v_1_13_1, v_1_13_2, v_1_14, v_1_14_1, v_1_14_2, v_1_14_3, v_1_14_4, v_1_15, v_1_15_1, v_1_15_2, HIGHER_THAN_V_1_15_2, INVALID;
+    v_1_13, v_1_13_1, v_1_13_2, v_1_14, v_1_14_1, v_1_14_2, v_1_14_3, v_1_14_4, v_1_15, v_1_15_1, v_1_15_2, HIGHER_THAN_V_1_15_2, INVALID, ACCESS_FAILURE;

    public static ClientVersion fromProtocolVersion(final int protocolVersion) {
        int remainder = -1;
        switch (protocolVersion) {
+            case -1:
+                return ACCESS_FAILURE;
            case 1:
            case 2:
            case 3:
@@ -10,7 +10,7 @@ import io.github.retrooper.packetevents.enums.ServerVersion;
 */
 public class PacketEvent {
    protected static ServerVersion version = PacketEvents.getServerVersion();
-    protected long timestamp = PacketEvents.currentCalculatedMS();
+    protected long timestamp = PacketEvents.highlyPreciseMillis();

    /**
     * Timestamp of the packet
@@ -0,0 +1,35 @@
+package io.github.retrooper.packetevents.event.impl;
+
+import io.github.retrooper.packetevents.event.PacketEvent;
+import org.bukkit.Location;
+import org.bukkit.entity.Player;
+import org.bukkit.event.player.PlayerMoveEvent;
+
+public final class BukkitMoveEvent extends PacketEvent {
+    private final Player player;
+    private final Location to, from;
+
+    public BukkitMoveEvent(final Player player, final Location to, final Location from) {
+        this.player = player;
+        this.to = to;
+        this.from = from;
+    }
+
+    public BukkitMoveEvent(final PlayerMoveEvent e) {
+        this.player = e.getPlayer();
+        this.to = e.getTo();
+        this.from = e.getFrom();
+    }
+
+    public Player getPlayer() {
+        return player;
+    }
+
+    public Location getFrom() {
+        return from;
+    }
+
+    public Location getTo() {
+        return to;
+    }
+}
@@ -1,27 +0,0 @@
-package io.github.retrooper.packetevents.event.impl;
-
-import io.github.retrooper.packetevents.event.PacketEvent;
-
-public final class PacketLoginEvent extends PacketEvent {
-    private final Object channel;
-    private final String name;
-    private final Object packet;
-
-    public PacketLoginEvent(final Object channel, final String packetName, final Object packet) {
-        this.channel = channel;
-        this.name = packetName;
-        this.packet = packet;
-    }
-
-    public Object getNettyChannel() {
-        return channel;
-    }
-
-    public String getPacketName() {
-        return name;
-    }
-
-    public Object getPacket() {
-        return packet;
-    }
-}
@@ -34,14 +34,19 @@ public final class PacketReceiveEvent extends PacketEvent {
    }

    /**
-     * Get the raw packet object
+     * This is deprecated, please us {@link #getNMSPacket()}
     *
     * @return packet
     */
+    @Deprecated
    public Object getPacket() {
        return this.packet;
    }

+    public Object getNMSPacket() {
+        return this.packet;
+    }
+
    /**
     * Returns if the packet has been cancelled
     *
@@ -26,12 +26,22 @@ public final class PacketSendEvent extends PacketEvent {
        return this.name;
    }

+    /**
+     * This is deprecated, please us {@link #getNMSPacket()}
+     *
+     * @return packet
+     */
+    @Deprecated
+    public Object getPacket() {
+        return this.packet;
+    }
+
    /**
     * Get the raw packet object
     *
-     * @return nmsPacket
+     * @return packet
     */
-    public Object getPacket() {
+    public Object getNMSPacket() {
        return this.packet;
    }

@@ -1,14 +1,18 @@
 package io.github.retrooper.packetevents.event.impl;

+import io.github.retrooper.packetevents.enums.ClientVersion;
 import io.github.retrooper.packetevents.event.PacketEvent;
+import io.github.retrooper.packetevents.utils.VersionLookupUtils;
 import org.bukkit.entity.Player;

 public final class PlayerInjectEvent extends PacketEvent {
    private final Player player;
    private boolean cancelled;
+    private final ClientVersion clientVersion;

    public PlayerInjectEvent(final Player player) {
        this.player = player;
+        this.clientVersion = ClientVersion.fromProtocolVersion(VersionLookupUtils.getProtocolVersion(player));
    }

    public boolean isCancelled() {
@@ -23,6 +27,10 @@ public final class PlayerInjectEvent extends PacketEvent {
        setCancelled(true);
    }

+    public ClientVersion getClientVersion() {
+        return clientVersion;
+    }
+
    public Player getPlayer() {
        return player;
    }
@@ -5,11 +5,24 @@ import org.bukkit.entity.Player;

 public final class PlayerUninjectEvent extends PacketEvent {
    private final Player player;
+    private boolean cancelled;

    public PlayerUninjectEvent(final Player player) {
        this.player = player;
    }

+    public void setCancelled(final boolean val) {
+        this.cancelled = val;
+    }
+
+    public void cancel() {
+        setCancelled(true);
+    }
+
+    public boolean isCancelled() {
+        return this.cancelled;
+    }
+
    public Player getPlayer() {
        return player;
    }
@@ -3,6 +3,10 @@ package io.github.retrooper.packetevents.event.impl;
 import io.github.retrooper.packetevents.event.PacketEvent;
 import org.bukkit.entity.Player;

+/**
+ * Please use {@link PlayerInjectEvent}
+ */
+@Deprecated
 public final class PostPlayerInjectEvent extends PacketEvent {
    private final Player player;

@@ -10,13 +10,12 @@ public class MainExample extends JavaPlugin {
        PacketEvents.start(this);

        PacketEvents.getServerTickTask().cancel();
-
-        //To fix bugs it is recommend to set this to TRUE
-        PacketEvents.setShouldKickOnRestart(true);
    }

    @Override
    public void onDisable() {
-        PacketEvents.stop(); //it kicks when you call the stop() function
+        PacketEvents.stop();
    }
+
+
 }
@@ -0,0 +1,67 @@
+package io.github.retrooper.packetevents.handler;
+
+import io.github.retrooper.packetevents.PacketEvents;
+import io.github.retrooper.packetevents.enums.ServerVersion;
+import io.github.retrooper.packetevents.event.impl.PacketReceiveEvent;
+import io.github.retrooper.packetevents.event.impl.PacketSendEvent;
+import org.bukkit.entity.Player;
+
+import java.util.HashSet;
+import java.util.UUID;
+import java.util.concurrent.Future;
+
+public class NettyPacketHandler {
+    public static final String handlerName = "packet_handler";
+    private static final ServerVersion version = PacketEvents.getServerVersion();
+
+    public static final HashSet<UUID> injectedSet = new HashSet<UUID>();
+
+    public static void injectPlayer(final Player player) {
+        if (!hasInjected(player)) {
+            if (version.isLowerThan(ServerVersion.v_1_8)) {
+                NettyPacketHandler_7.injectPlayer(player);
+            } else {
+                NettyPacketHandler_8.injectPlayer(player);
+            }
+            injectedSet.add(player.getUniqueId());
+        }
+    }
+
+    public static Future<?> uninjectPlayer(final Player player) {
+        if (hasInjected(player)) {
+            injectedSet.remove(player.getUniqueId());
+            if (version.isLowerThan(ServerVersion.v_1_8)) {
+                return NettyPacketHandler_7.uninjectPlayer(player);
+            } else {
+                return NettyPacketHandler_8.uninjectPlayer(player);
+            }
+        }
+        return null;
+    }
+
+    public static boolean hasInjected(final Player player) {
+        return injectedSet.contains(player.getUniqueId());
+    }
+
+    public static Object read(final Player receiver, final Object packet) {
+        final String packetName = packet.getClass().getSimpleName();
+        final PacketSendEvent packetSendEvent = new PacketSendEvent(receiver, packetName, packet);
+        PacketEvents.getEventManager().callEvent(packetSendEvent);
+        if (!packetSendEvent.isCancelled()) {
+            return packet;
+        }
+        return null;
+    }
+
+    public static Object write(final Player sender, final Object packet) {
+        final String packetName = packet.getClass().getSimpleName();
+        final PacketReceiveEvent packetReceiveEvent = new PacketReceiveEvent(sender, packetName, packet);
+        PacketEvents.getEventManager().callEvent(packetReceiveEvent);
+        if (!packetReceiveEvent.isCancelled()) {
+            return packet;
+        }
+        return null;
+    }
+
+
+}
@@ -0,0 +1,44 @@
+package io.github.retrooper.packetevents.handler;
+
+import io.github.retrooper.packetevents.utils.NMSUtils;
+import net.minecraft.util.io.netty.channel.*;
+import org.bukkit.entity.Player;
+
+import java.util.concurrent.Future;
+
+final class NettyPacketHandler_7 {
+
+    public static void injectPlayer(final Player player) {
+        final ChannelDuplexHandler channelDuplexHandler = new ChannelDuplexHandler() {
+            @Override
+            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+                Object packet = NettyPacketHandler.read(player, msg);
+                if(packet == null) {
+                    return;
+                }
+                super.channelRead(ctx, msg);
+            }
+
+            @Override
+            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
+                Object packet = NettyPacketHandler.write(player, msg);
+                if(packet == null) {
+                    return;
+                }
+                super.write(ctx, msg, promise);
+            }
+        };
+        final ChannelPipeline pipeline = ((Channel) NMSUtils.getChannel(player)).pipeline();
+        pipeline.addBefore(NettyPacketHandler.handlerName, player.getName(), channelDuplexHandler);
+    }
+
+    public static Future<?> uninjectPlayer(final Player player) {
+        final Channel channel = (Channel) NMSUtils.getChannel(player);
+        return channel.eventLoop().submit(new Runnable() {
+            @Override
+            public void run() {
+                channel.pipeline().remove(player.getName());
+            }
+        });
+    }
+}
@@ -0,0 +1,43 @@
+package io.github.retrooper.packetevents.handler;
+
+import io.github.retrooper.packetevents.utils.NMSUtils;
+import io.netty.channel.*;
+import org.bukkit.entity.Player;
+
+import java.util.concurrent.Future;
+
+final class NettyPacketHandler_8 {
+    public static void injectPlayer(final Player player) {
+        final ChannelDuplexHandler channelDuplexHandler = new ChannelDuplexHandler() {
+            @Override
+            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
+                Object packet = NettyPacketHandler.read(player, msg);
+                if(packet == null) {
+                    return;
+                }
+                super.channelRead(ctx, msg);
+            }
+
+            @Override
+            public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
+                Object packet = NettyPacketHandler.write(player, msg);
+                if(packet == null) {
+                    return;
+                }
+                super.write(ctx, msg, promise);
+            }
+        };
+        final ChannelPipeline pipeline = ((Channel) NMSUtils.getChannel(player)).pipeline();
+        pipeline.addBefore(NettyPacketHandler.handlerName, player.getName(), channelDuplexHandler);
+    }
+
+    public static Future<?> uninjectPlayer(final Player player) {
+        final Channel channel = (Channel) NMSUtils.getChannel(player);
+        return channel.eventLoop().submit(new Runnable() {
+            @Override
+            public void run() {
+                channel.pipeline().remove(player.getName());
+            }
+        });
+    }
+}
@@ -1,86 +0,0 @@
-package io.github.retrooper.packetevents.handler;
-
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection.FieldAccessor;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-
-public final class TinyProtocolHandler {
-    private static final ServerVersion version = PacketEvents.getServerVersion();
-    private static final FieldAccessor<?> playerConnectionAccessor, networkManagerAccessor, nettyChannelAccessor;
-    private static Object tinyProtocol;
-    private static Class<?> networkManagerClass;
-    private static Class<?> channelClass;
-
-    static {
-        try {
-            networkManagerClass = NMSUtils.getNMSClass("NetworkManager");
-            channelClass = NMSUtils.getNettyClass("channel.Channel");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-
-        playerConnectionAccessor = Reflection.getField(NMSUtils.entityPlayerClass, NMSUtils.playerConnectionClass, 0);
-        networkManagerAccessor = Reflection.getField(NMSUtils.playerConnectionClass, networkManagerClass, 0);
-        nettyChannelAccessor = Reflection.getField(networkManagerClass, channelClass, 0);
-    }
-
-    public static void initTinyProtocol(final Plugin plugin) {
-        if (version.isLowerThan(ServerVersion.v_1_8)) {
-            TinyProtocolHandler_1_7 tiny = new TinyProtocolHandler_1_7(plugin);
-            tiny.initTinyProtocol();
-            tinyProtocol = tiny;
-        } else {
-            TinyProtocolHandler_1_8 tiny = new TinyProtocolHandler_1_8(plugin);
-            tiny.initTinyProtocol();
-            tinyProtocol = tiny;
-        }
-    }
-
-    public static boolean hasInjected(final Player player) {
-        if (version.isLowerThan(ServerVersion.v_1_8)) {
-            TinyProtocolHandler_1_7 tiny = (TinyProtocolHandler_1_7) tinyProtocol;
-            assert tiny.tinyProtocol != null;
-            return tiny.tinyProtocol.hasInjected(player);
-        } else {
-            TinyProtocolHandler_1_8 tiny = (TinyProtocolHandler_1_8) tinyProtocol;
-            assert tiny.tinyProtocol != null;
-            return tiny.tinyProtocol.hasInjected(player);
-        }
-    }
-
-    public static void inject(final Player player) {
-        if (version.isLowerThan(ServerVersion.v_1_8)) {
-            TinyProtocolHandler_1_7 tiny = (TinyProtocolHandler_1_7) tinyProtocol;
-            assert tiny.tinyProtocol != null;
-            tiny.tinyProtocol.injectPlayer(player);
-        } else {
-            TinyProtocolHandler_1_8 tiny = (TinyProtocolHandler_1_8) tinyProtocol;
-            assert tiny.tinyProtocol != null;
-            tiny.tinyProtocol.injectPlayer(player);
-        }
-    }
-
-    public static void uninject(final Player player) {
-        if (version.isLowerThan(ServerVersion.v_1_8)) {
-            TinyProtocolHandler_1_7 tiny = (TinyProtocolHandler_1_7) tinyProtocol;
-            assert tiny.tinyProtocol != null;
-            tiny.tinyProtocol.uninjectPlayer(player);
-        } else {
-            TinyProtocolHandler_1_8 tiny = (TinyProtocolHandler_1_8) tinyProtocol;
-            assert tiny.tinyProtocol != null;
-            tiny.tinyProtocol.uninjectPlayer(player);
-        }
-    }
-
-    public static Object getPlayerChannel(final Player player) {
-        final Object entityPlayer = NMSUtils.getEntityPlayer(player);
-        final Object playerConnection = playerConnectionAccessor.get(entityPlayer);
-        final Object networkManager = networkManagerAccessor.get(playerConnection);
-        return nettyChannelAccessor.get(networkManager);
-    }
-}
@@ -1,58 +0,0 @@
-package io.github.retrooper.packetevents.handler;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.annotations.Nullable;
-import io.github.retrooper.packetevents.event.impl.PacketLoginEvent;
-import io.github.retrooper.packetevents.event.impl.PacketReceiveEvent;
-import io.github.retrooper.packetevents.event.impl.PacketSendEvent;
-import io.github.retrooper.packetevents.packet.Packet;
-import io.github.retrooper.packetevents.tinyprotocol.TinyProtocol7;
-import net.minecraft.util.io.netty.channel.Channel;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-
-public final class TinyProtocolHandler_1_7 {
-    private final Plugin plugin;
-    @Nullable
-    public TinyProtocol7 tinyProtocol;
-
-    public TinyProtocolHandler_1_7(final Plugin plugin) {
-        this.plugin = plugin;
-    }
-
-    public void initTinyProtocol() {
-        tinyProtocol = new TinyProtocol7(getPlugin()) {
-            @Override
-            public Object onPacketOutAsync(Player receiver, Channel channel, Object packet) {
-                final String packetName = packet.getClass().getSimpleName();
-                final PacketSendEvent packetSendEvent = new PacketSendEvent(receiver, packetName, packet);
-                PacketEvents.getEventManager().callEvent(packetSendEvent);
-                if (!packetSendEvent.isCancelled()) {
-                    return packet;
-                }
-                return null;
-            }
-
-            @Override
-            public Object onPacketInAsync(Player sender, Channel channel, Object packet) {
-                final String packetName = packet.getClass().getSimpleName();
-                for (final String loginPacket : Packet.Login.LOGIN_PACKETS) {
-                    if (packetName.equals(loginPacket)) {
-                        PacketEvents.getEventManager().callEvent(new PacketLoginEvent(channel, packetName, packet));
-                        return packet;
-                    }
-                }
-                final PacketReceiveEvent packetReceiveEvent = new PacketReceiveEvent(sender, packetName, packet);
-                PacketEvents.getEventManager().callEvent(packetReceiveEvent);
-                if (!packetReceiveEvent.isCancelled()) {
-                    return packet;
-                }
-                return null;
-            }
-        };
-    }
-
-    public Plugin getPlugin() {
-        return plugin;
-    }
-}
@@ -1,81 +0,0 @@
-package io.github.retrooper.packetevents.handler;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.annotations.Nullable;
-import io.github.retrooper.packetevents.enums.ServerVersion;
-import io.github.retrooper.packetevents.event.impl.PacketLoginEvent;
-import io.github.retrooper.packetevents.event.impl.PacketReceiveEvent;
-import io.github.retrooper.packetevents.event.impl.PacketSendEvent;
-import io.github.retrooper.packetevents.packet.Packet;
-import io.github.retrooper.packetevents.tinyprotocol.TinyProtocol8;
-import io.netty.channel.Channel;
-import org.bukkit.entity.Player;
-import org.bukkit.plugin.Plugin;
-
-public final class TinyProtocolHandler_1_8 {
-    private static final ServerVersion version = PacketEvents.getServerVersion();
-    private final Plugin plugin;
-    @Nullable
-    public TinyProtocol8 tinyProtocol;
-
-
-    public TinyProtocolHandler_1_8(final Plugin plugin) {
-        this.plugin = plugin;
-    }
-
-    public static String getNetworkManagersFieldName() {
-        //1.8
-        if (version.equals(ServerVersion.v_1_8)) {
-            return "g";
-        }
-        //1.8.3->1.12
-        else if (version.isLowerThan(ServerVersion.v_1_13)) {
-            return "h";
-        }
-        //1.13->1.14
-        else if (version.isLowerThan(ServerVersion.v_1_15)) {
-            return "g";
-        }
-        //1.15
-        else {
-            return "listeningChannels";
-        }
-    }
-
-    public void initTinyProtocol() {
-        tinyProtocol = new TinyProtocol8(getPlugin()) {
-            @Override
-            public Object onPacketOutAsync(Player receiver, Channel channel, Object packet) {
-                final String packetName = packet.getClass().getSimpleName();
-                final PacketSendEvent packetSendEvent = new PacketSendEvent(receiver, packetName, packet);
-                PacketEvents.getEventManager().callEvent(packetSendEvent);
-                if (!packetSendEvent.isCancelled()) {
-                    return packet;
-                }
-                return null;
-            }
-
-            @Override
-            public Object onPacketInAsync(Player sender, Channel channel, Object packet) {
-                final String packetName = packet.getClass().getSimpleName();
-                for (final String loginPacket : Packet.Login.LOGIN_PACKETS) {
-                    if (packetName.equals(loginPacket)) {
-                        PacketEvents.getEventManager().callEvent(new PacketLoginEvent(channel, packetName, packet));
-                        return packet;
-                    }
-                }
-                final PacketReceiveEvent packetReceiveEvent = new PacketReceiveEvent(sender, packetName, packet);
-                PacketEvents.getEventManager().callEvent(packetReceiveEvent);
-                if (!packetReceiveEvent.isCancelled()) {
-                    return packet;
-                }
-
-                return null;
-            }
-        };
-    }
-
-    public Plugin getPlugin() {
-        return plugin;
-    }
-}
@@ -3,7 +3,8 @@ package io.github.retrooper.packetevents.packet;
 import io.github.retrooper.packetevents.enums.ServerVersion;
 import io.github.retrooper.packetevents.utils.NMSUtils;

-public abstract class Packet {
+@Deprecated
+public final class Packet {

    private static Class<?> packetPlayInFlying, packetPlayInPosition, packetPlayInPositionLook, packetPlayInLook;

@@ -11,14 +12,14 @@ public abstract class Packet {
        try {
            packetPlayInFlying = NMSUtils.getNMSClass(Client.FLYING);
        } catch (ClassNotFoundException e) {
-            //That is fine, they are on 1.9+ so we just initiate the rest of the variables
-            try {
-                packetPlayInPosition = NMSUtils.getNMSClass(Client.POSITION);
-                packetPlayInPositionLook = NMSUtils.getNMSClass(Client.POSITION_LOOK);
-                packetPlayInLook = NMSUtils.getNMSClass(Client.LOOK);
-            } catch (ClassNotFoundException e2) {
-                e2.printStackTrace();
-            }
+            //That is fine, they are on 1.9+
+        }
+        try {
+            packetPlayInPosition = NMSUtils.getNMSClass(Client.POSITION);
+            packetPlayInPositionLook = NMSUtils.getNMSClass(Client.POSITION_LOOK);
+            packetPlayInLook = NMSUtils.getNMSClass(Client.LOOK);
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
        }
    }

@@ -42,21 +43,19 @@ public abstract class Packet {
    }

    /**
-     * Use isInstanceOfFlyingPacket(nmsPacketObject) instead of this, as the flying packet is the only packet that has subclasses (in 1.8 atleast).
-     * Will be removed in newer versions of PacketEvents!
-     *
-     * @param fatherPacket
-     * @param childPacket
-     * @return isInstanceOf
+     * Is this NMS Packet an instanceof the "PacketPlayInPosition" or "PacketPlayInPositionLook"
+     * @param nmsPacket
+     * @return
     */
-    @Deprecated
-    public static boolean isInstanceOf(String fatherPacket, String childPacket) {
-        if (fatherPacket.equals(Client.FLYING) && childPacket.equals(Client.POSITION) || childPacket.equals(Client.POSITION_LOOK) || childPacket.equals(Client.LOOK)) {
-            return true;
-        }
-        return fatherPacket.equals(childPacket);
+    public static boolean isInstanceOfPositionOrPositionLook(final Object nmsPacket) {
+        return packetPlayInPosition.isInstance(nmsPacket) || packetPlayInPositionLook.isInstance(nmsPacket);
    }

+    public static boolean isInstanceOfLook(final Object nmsPacket) {
+        return packetPlayInLook.isInstance(nmsPacket);
+    }
+
+
    public static class Client {
        private static final String c = "PacketPlayIn";

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

+    public boolean isFlightAllowed() {
+        return allowFly;
+    }
+
+    /**
+     * Use {@link WrappedPacketInAbilities#isFlightAllowed()}
+     * @return
+     */
+    @Deprecated
    public boolean canFly() {
        return allowFly;
    }
@@ -4,7 +4,7 @@ import io.github.retrooper.packetevents.enums.Direction;
 import io.github.retrooper.packetevents.enums.PlayerDigType;
 import io.github.retrooper.packetevents.enums.ServerVersion;
 import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection;
+import io.github.retrooper.packetevents.reflectionutils.Reflection;
 import io.github.retrooper.packetevents.utils.NMSUtils;
 import io.github.retrooper.packetevents.utils.vector.Vector3i;

@@ -9,14 +9,6 @@ import org.bukkit.inventory.ItemStack;


 public final class WrappedPacketInBlockPlace extends WrappedPacket {
-    static {
-        if (version.isHigherThan(ServerVersion.v_1_8_8)) {
-            WrappedPacketInBlockPlace_1_9.initStatic();
-        } else if (version.isLowerThan(ServerVersion.v_1_9) && version.isHigherThan(ServerVersion.v_1_7_10)) {
-            WrappedPacketInBlockPlace_1_8.initStatic();
-        }
-    }
-
    private Vector3i blockPosition;
    private ItemStack itemStack;

@@ -31,14 +23,19 @@ public final class WrappedPacketInBlockPlace extends WrappedPacket {
        ItemStack itemStack = null;
        try {
            if (version.isHigherThan(ServerVersion.v_1_8_8)) {
-                final WrappedPacketInBlockPlace_1_9 updatedBlockPlace = new WrappedPacketInBlockPlace_1_9(getPlayer(), packet);
-                final Block block = updatedBlockPlace.getBlock();
+                final WrappedPacketInBlockPlace_1_9 blockPlace_1_9 = new WrappedPacketInBlockPlace_1_9(getPlayer(), packet);
+                final Block block = blockPlace_1_9.getBlock();
                position = new Vector3i(block.getX(), block.getY(), block.getZ());
                itemStack = new ItemStack(block.getType());
-            } else {
-                final WrappedPacketInBlockPlace_1_8 legacyBlockPlace = new WrappedPacketInBlockPlace_1_8(packet);
-                position = legacyBlockPlace.getBlockPosition();
-                itemStack = legacyBlockPlace.getItemStack();
+            } else if(version.isHigherThan(ServerVersion.v_1_7_10)){
+                final WrappedPacketInBlockPlace_1_8 blockPlace_1_8 = new WrappedPacketInBlockPlace_1_8(packet);
+                position = blockPlace_1_8.getBlockPosition();
+                itemStack = blockPlace_1_8.getItemStack();
+            }
+            else {
+                final WrappedPacketInBlockPlace_1_7_10 blockPlace_1_7_10 = new WrappedPacketInBlockPlace_1_7_10(getPlayer(), packet);
+                position = blockPlace_1_7_10.getBlockPosition();
+                this.itemStack = blockPlace_1_7_10.getItemStack();
            }
        } catch (IllegalArgumentException e) {
            e.printStackTrace();
@@ -59,4 +56,12 @@ public final class WrappedPacketInBlockPlace extends WrappedPacket {
        return itemStack;
    }

+    static {
+        if (version.isHigherThan(ServerVersion.v_1_8_8)) {
+            WrappedPacketInBlockPlace_1_9.initStatic();
+        } else if (version.isHigherThan(ServerVersion.v_1_7_10)) {
+            WrappedPacketInBlockPlace_1_8.initStatic();
+        }
+    }
+
 }
@@ -1,7 +1,7 @@
 package io.github.retrooper.packetevents.packetwrappers.in.blockplace;

 import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection;
+import io.github.retrooper.packetevents.reflectionutils.Reflection;
 import io.github.retrooper.packetevents.utils.NMSUtils;
 import io.github.retrooper.packetevents.utils.vector.Vector3i;
 import org.bukkit.inventory.ItemStack;
@@ -27,7 +27,7 @@ final class WrappedPacketInBlockPlace_1_9 extends WrappedPacket {

    @Override
    protected void setup() {
-        this.block = getPlayer().getTargetBlock(null, 3);
+        this.block = getPlayer().getTargetBlock((HashSet<Material>) null, 3);

    }

@@ -0,0 +1,51 @@
+package io.github.retrooper.packetevents.packetwrappers.in.transaction;
+
+import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
+import io.github.retrooper.packetevents.reflectionutils.Reflection;
+import io.github.retrooper.packetevents.utils.NMSUtils;
+
+public final class WrappedPacketInTransaction extends WrappedPacket {
+    private int windowId;
+    private short actionNumber;
+    private boolean accepted;
+    public WrappedPacketInTransaction(final Object packet) {
+        super(packet);
+    }
+
+    @Override
+    protected void setup() {
+        this.windowId = windowIdAccessor.get(packet);
+        this.actionNumber = actionNumberAccessor.get(packet);
+        this.accepted = acceptedAccessor.get(packet);
+    }
+
+    public int getWindowId() {
+        return windowId;
+    }
+
+    public short getActionNumber() {
+        return actionNumber;
+    }
+
+    public boolean isAccepted() {
+        return accepted;
+    }
+
+    private static Class<?> packetClass;
+
+    private static final Reflection.FieldAccessor<Integer> windowIdAccessor;
+    private static final Reflection.FieldAccessor<Short> actionNumberAccessor;
+    private static final Reflection.FieldAccessor<Boolean> acceptedAccessor;
+
+    static {
+        try {
+            packetClass = NMSUtils.getNMSClass("PacketPlayInTransaction");
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        windowIdAccessor = Reflection.getField(packetClass, int.class, 0);
+        actionNumberAccessor = Reflection.getField(packetClass, short.class, 0);
+        acceptedAccessor= Reflection.getField(packetClass, boolean.class, 0);
+    }
+}
@@ -1,54 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.login;
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection.FieldAccessor;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-
-public final class WrappedPacketLoginHandshake extends WrappedPacket {
-    private static Class<?> loginHandshakeClass;
-    private static final FieldAccessor<?>[] fields = new FieldAccessor[3];
-
-    static {
-        try {
-            loginHandshakeClass = NMSUtils.getNMSClass("PacketHandshakingInSetProtocol");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-
-        fields[0] = Reflection.getField(loginHandshakeClass, int.class, 0);
-        fields[1] = Reflection.getField(loginHandshakeClass, String.class, 0);
-        fields[2] = Reflection.getField(loginHandshakeClass, int.class, 1);
-    }
-
-    private int protocolVersion, port;
-    private String hostname;
-
-    public WrappedPacketLoginHandshake(final Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        final Object protocolVersionObj = fields[0].get(packet);
-        final Object hostNameObj = fields[1].get(packet);
-        final Object portObj = fields[2].get(packet);
-
-        this.protocolVersion = (int) protocolVersionObj;
-        this.hostname = hostNameObj.toString();
-        this.port = (int) portObj;
-    }
-
-    public int getProtocolVersion() {
-        return protocolVersion;
-    }
-
-    public String getHostname() {
-        return hostname;
-    }
-
-    public int getPort() {
-        return port;
-    }
-}
@@ -1,41 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.login;
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-public final class WrappedPacketLoginInEncryptionBegin extends WrappedPacket {
-    private static final Reflection.FieldAccessor<byte[]>[] fields = new Reflection.FieldAccessor[2];
-    private static Class<?> packetClass;
-
-    static {
-        try {
-            packetClass = NMSUtils.getNMSClass("PacketLoginInEncryptionBegin");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-
-        fields[0] = Reflection.getField(packetClass, byte[].class, 0);
-        fields[1] = Reflection.getField(packetClass, byte[].class, 1);
-    }
-
-    private byte[] publicKey, verifyToken;
-
-    public WrappedPacketLoginInEncryptionBegin(final Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        this.publicKey = fields[0].get(packet);
-        this.verifyToken = fields[1].get(packet);
-    }
-
-    public byte[] getPublicKey() {
-        return publicKey;
-    }
-
-    public byte[] getVerifyToken() {
-        return verifyToken;
-    }
-}
@@ -1,57 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.login;
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-import java.security.PublicKey;
-
-
-public final class WrappedPacketLoginOutEncryptionBegin extends WrappedPacket {
-    private static final Reflection.FieldAccessor<?>[] fields = new Reflection.FieldAccessor[3];
-    private static Class<?> packetClass;
-
-    static {
-        try {
-            packetClass = NMSUtils.getNMSClass("PacketLoginOutEncryptionBegin");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-
-        fields[0] = Reflection.getField(packetClass, String.class, 0);
-        fields[1] = Reflection.getField(packetClass, PublicKey.class, 1);
-        fields[2] = Reflection.getField(packetClass, byte[].class, 2);
-    }
-
-    private String encodedString;
-    private PublicKey encodedKey;
-    private byte[] byteArray;
-
-    public WrappedPacketLoginOutEncryptionBegin(final Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        //string - a (encodedstring)
-        //public key - b (encoded)
-        //byte array - c(byte array)
-        this.encodedString = fields[0].get(packet).toString();
-        this.encodedKey = (PublicKey) fields[1].get(packet);
-        this.byteArray = (byte[]) fields[2].get(packet);
-    }
-
-    public String getEncodedString() {
-        return encodedString;
-    }
-
-    public PublicKey getEncodedKey() {
-        return encodedKey;
-    }
-
-    public byte[] getByteArray() {
-        return byteArray;
-    }
-
-
-}
@@ -1,36 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.login;
-
-import io.github.retrooper.packetevents.mojang.GameProfile;
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-public final class WrappedPacketLoginStart extends WrappedPacket {
-    private static final Reflection.FieldAccessor<com.mojang.authlib.GameProfile> gameProfileAccessor;
-    private static Class<?> packetClass;
-
-    static {
-        try {
-            packetClass = NMSUtils.getNMSClass("PacketLoginInStart");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-        gameProfileAccessor = Reflection.getField(packetClass, com.mojang.authlib.GameProfile.class, 0);
-    }
-
-    private GameProfile gameProfile;
-
-    public WrappedPacketLoginStart(final Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        com.mojang.authlib.GameProfile gp = gameProfileAccessor.get(packet);
-        this.gameProfile = new GameProfile(gp.getId(), gp.getName());
-    }
-
-    public GameProfile getGameProfile() {
-        return gameProfile;
-    }
-}
@@ -1,36 +0,0 @@
-package io.github.retrooper.packetevents.packetwrappers.login;
-
-import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection;
-import io.github.retrooper.packetevents.utils.NMSUtils;
-
-public final class WrappedPacketLoginStatusPing extends WrappedPacket {
-    private static final Reflection.FieldAccessor<Long> numberAccessor;
-    private static Class<?> packetClass;
-
-    static {
-        try {
-            packetClass = NMSUtils.getNMSClass("PacketStatusInPing");
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        }
-
-        numberAccessor = Reflection.getField(packetClass, long.class, 0);
-    }
-
-    private long number;
-
-    public WrappedPacketLoginStatusPing(final Object packet) {
-        super(packet);
-    }
-
-    @Override
-    protected void setup() {
-        this.number = numberAccessor.get(packet);
-    }
-
-    public long getNumber() {
-        return number;
-    }
-
-}
@@ -0,0 +1,52 @@
+package io.github.retrooper.packetevents.packetwrappers.out.abilities;
+
+import io.github.retrooper.packetevents.reflectionutils.Reflection;
+import io.github.retrooper.packetevents.utils.NMSUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+public final class PlayerAbilitiesUtils {
+
+    public static Class<?> playerAbilitiesClass;
+
+    public static Constructor<?> playerAbilitiesConstructor;
+
+    private static final Reflection.FieldAccessor<Boolean>[] booleanFieldAccessors = new Reflection.FieldAccessor[4];
+    private static final Reflection.FieldAccessor<Float>[] floatFieldAccessors = new Reflection.FieldAccessor[2];
+
+    public static Object getPlayerAbilities(final boolean isVulnerable, final boolean isFlying, final boolean allowFlight, final boolean canBuildInstantly,
+                                            final float flySpeed, final float walkSpeed) throws IllegalAccessException, InvocationTargetException, InstantiationException {
+        final Object instance = playerAbilitiesConstructor.newInstance();
+        booleanFieldAccessors[0].set(instance, isVulnerable);
+        booleanFieldAccessors[1].set(instance, isFlying);
+        booleanFieldAccessors[2].set(instance, allowFlight);
+        booleanFieldAccessors[3].set(instance, canBuildInstantly);
+
+        floatFieldAccessors[0].set(instance, flySpeed);
+        floatFieldAccessors[1].set(instance, walkSpeed);
+
+        return instance;
+    }
+
+    static {
+        try {
+            playerAbilitiesClass = NMSUtils.getNMSClass("PlayerAbilities");
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+        try {
+            playerAbilitiesConstructor = playerAbilitiesClass.getConstructor();
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+
+        for (byte i = 0; i < booleanFieldAccessors.length; i++) {
+            booleanFieldAccessors[i] = Reflection.getField(playerAbilitiesClass, boolean.class, i);
+        }
+
+        for (byte i = 0; i < floatFieldAccessors.length; i++) {
+            floatFieldAccessors[i] = Reflection.getField(playerAbilitiesClass, float.class, i);
+        }
+    }
+}
@@ -0,0 +1,103 @@
+package io.github.retrooper.packetevents.packetwrappers.out.abilities;
+
+import io.github.retrooper.packetevents.packetwrappers.Sendable;
+import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
+import io.github.retrooper.packetevents.reflectionutils.Reflection;
+import io.github.retrooper.packetevents.utils.NMSUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+public final class WrappedPacketOutAbilities extends WrappedPacket implements Sendable {
+    private boolean vulnerable, flying, allowFlight, instantBuild;
+    private float flySpeed, walkSpeed;
+
+    public WrappedPacketOutAbilities(final Object packet) {
+        super(packet);
+    }
+
+    public WrappedPacketOutAbilities(final boolean isVulnerable, final boolean isFlying, final boolean allowFlight, final boolean canBuildInstantly,
+                                     final float flySpeed, final float walkSpeed) {
+        super(null);
+        this.vulnerable = isVulnerable;
+        this.flying = isFlying;
+        this.allowFlight = allowFlight;
+        this.instantBuild = canBuildInstantly;
+        this.flySpeed = flySpeed;
+        this.walkSpeed = walkSpeed;
+    }
+
+    @Override
+    protected void setup() {
+        this.vulnerable = booleanFieldAccessors[0].get(packet);
+        this.flying = booleanFieldAccessors[1].get(packet);
+        this.allowFlight = booleanFieldAccessors[2].get(packet);
+        this.instantBuild = booleanFieldAccessors[3].get(packet);
+
+        this.flySpeed = floatFieldAccessors[0].get(packet);
+        this.walkSpeed = floatFieldAccessors[1].get(packet);
+    }
+
+    public boolean isVulnerable() {
+        return vulnerable;
+    }
+
+    public boolean isFlying() {
+        return flying;
+    }
+
+    public boolean isFlightAllowed() {
+        return allowFlight;
+    }
+
+    public boolean canInstantlyBuild() {
+        return instantBuild;
+    }
+
+    public float getFlySpeed() {
+        return flySpeed;
+    }
+
+    public float getWalkSpeed() {
+        return walkSpeed;
+    }
+
+    private static Class<?> packetClass;
+
+    private static Constructor<?> packetConstructor;
+
+    private static final Reflection.FieldAccessor<Boolean>[] booleanFieldAccessors = new Reflection.FieldAccessor[4];
+    private static final Reflection.FieldAccessor<Float>[] floatFieldAccessors = new Reflection.FieldAccessor[2];
+
+    static {
+        try {
+            packetClass = NMSUtils.getNMSClass("PacketPlayOutAbilities");
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        try {
+            packetConstructor = packetClass.getConstructor(PlayerAbilitiesUtils.playerAbilitiesClass);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+
+        for (byte i = 0; i < booleanFieldAccessors.length; i++) {
+            booleanFieldAccessors[i] = Reflection.getField(packetClass, boolean.class, i);
+        }
+
+        for (byte i = 0; i < floatFieldAccessors.length; i++) {
+            floatFieldAccessors[i] = Reflection.getField(packetClass, float.class, i);
+        }
+    }
+
+    @Override
+    public Object asNMSPacket() {
+        try {
+            return packetConstructor.newInstance(PlayerAbilitiesUtils.getPlayerAbilities(vulnerable, flying, allowFlight, instantBuild, flySpeed, walkSpeed));
+        } catch (InstantiationException | InvocationTargetException | IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+}
@@ -3,7 +3,7 @@ package io.github.retrooper.packetevents.packetwrappers.out.kickdisconnect;
 import io.github.retrooper.packetevents.packetwrappers.Sendable;
 import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
 import io.github.retrooper.packetevents.packetwrappers.out.chat.WrappedPacketOutChat;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection;
+import io.github.retrooper.packetevents.reflectionutils.Reflection;
 import io.github.retrooper.packetevents.utils.NMSUtils;

 import java.lang.reflect.Constructor;
@@ -0,0 +1,80 @@
+package io.github.retrooper.packetevents.packetwrappers.out.transaction;
+
+import io.github.retrooper.packetevents.packetwrappers.Sendable;
+import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
+import io.github.retrooper.packetevents.reflectionutils.Reflection;
+import io.github.retrooper.packetevents.utils.NMSUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+public class WrappedPacketOutTransaction extends WrappedPacket implements Sendable {
+    private int windowId;
+    private short actionNumber;
+    private boolean accepted;
+    public WrappedPacketOutTransaction(final Object packet) {
+        super(packet);
+    }
+
+    public WrappedPacketOutTransaction(final int windowId, final short actionNumber, final boolean accepted) {
+        super(null);
+        this.windowId = windowId;
+        this.actionNumber = actionNumber;
+        this.accepted = accepted;
+    }
+    @Override
+    protected void setup() {
+        this.windowId = windowIdAccessor.get(packet);
+        this.actionNumber = actionNumberAccessor.get(packet);
+        this.accepted = acceptedAccessor.get(packet);
+    }
+
+    public int getWindowId() {
+        return windowId;
+    }
+
+    public short getActionNumber() {
+        return actionNumber;
+    }
+
+    public boolean isAccepted() {
+        return accepted;
+    }
+
+    @Override
+    public Object asNMSPacket() {
+        try {
+            return packetConstructor.newInstance(windowId, actionNumber, accepted);
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    private static Class<?> packetClass;
+
+    private static Constructor<?> packetConstructor;
+
+    private static final Reflection.FieldAccessor<Integer> windowIdAccessor;
+    private static final Reflection.FieldAccessor<Short> actionNumberAccessor;
+    private static final Reflection.FieldAccessor<Boolean> acceptedAccessor;
+
+    static {
+        try {
+            packetClass = NMSUtils.getNMSClass("PacketPlayOutTransaction");
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        try {
+            packetConstructor = packetClass.getConstructor(int.class, short.class, boolean.class);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+
+        windowIdAccessor = Reflection.getField(packetClass, int.class, 0);
+        actionNumberAccessor = Reflection.getField(packetClass, short.class, 0);
+        acceptedAccessor= Reflection.getField(packetClass, boolean.class, 0);
+    }
+
+}
@@ -0,0 +1,85 @@
+package io.github.retrooper.packetevents.packetwrappers.out.updatehealth;
+
+import io.github.retrooper.packetevents.packetwrappers.Sendable;
+import io.github.retrooper.packetevents.packetwrappers.api.WrappedPacket;
+import io.github.retrooper.packetevents.reflectionutils.Reflection;
+import io.github.retrooper.packetevents.utils.NMSUtils;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+
+public final class WrappedPacketOutUpdateHealth extends WrappedPacket implements Sendable {
+    private float health, foodSaturation;
+    private int food;
+    public WrappedPacketOutUpdateHealth(final Object packet) {
+        super(packet);
+    }
+
+    /**
+     * See https://wiki.vg/Protocol#Update_Health
+     * @param health
+     * @param food
+     * @param foodSaturation
+     */
+    public WrappedPacketOutUpdateHealth(final float health, final int food, final float foodSaturation) {
+        super(null);
+        this.health= health;
+        this.food = food;
+        this.foodSaturation = foodSaturation;
+    }
+
+    @Override
+    protected void setup() {
+        this.health = healthAccessor.get(packet);
+        this.foodSaturation = foodSaturationAccessor.get(packet);
+        this.food = foodAccessor.get(packet);
+    }
+
+    public float getHealth() {
+        return health;
+    }
+
+    public float getFoodSaturation() {
+        return foodSaturation;
+    }
+
+    public int getFood() {
+        return food;
+    }
+
+    @Override
+    public Object asNMSPacket() {
+        try {
+            return packetConstructor.newInstance(health, food, foodSaturation);
+        } catch (InstantiationException | IllegalAccessException | InvocationTargetException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    private static Class<?> packetClass;
+
+    private static Constructor<?> packetConstructor;
+
+    private static final Reflection.FieldAccessor<Float> healthAccessor, foodSaturationAccessor;
+
+    private static final Reflection.FieldAccessor<Integer> foodAccessor;
+
+    static {
+        try {
+            packetClass = NMSUtils.getNMSClass("PacketPlayOutUpdateHealth");
+        } catch (ClassNotFoundException e) {
+            e.printStackTrace();
+        }
+
+        try {
+            packetConstructor = packetClass.getConstructor(float.class, int.class, float.class);
+        } catch (NoSuchMethodException e) {
+            e.printStackTrace();
+        }
+
+        healthAccessor = Reflection.getField(packetClass, float.class, 0);
+        foodSaturationAccessor = Reflection.getField(packetClass, float.class, 1);
+        foodAccessor = Reflection.getField(packetClass, int.class, 0);
+    }
+}
@@ -1,4 +1,4 @@
-package io.github.retrooper.packetevents.tinyprotocol;
+package io.github.retrooper.packetevents.reflectionutils;

 import org.bukkit.Bukkit;

@@ -1,540 +0,0 @@
-/*
- * This file is part of Hawk Anticheat.
- * Copyright (C) 2018 Hawk Development Team
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package io.github.retrooper.packetevents.tinyprotocol;
-
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.event.impl.PacketSendEvent;
-import io.github.retrooper.packetevents.event.impl.PlayerInjectEvent;
-import io.github.retrooper.packetevents.event.impl.PlayerUninjectEvent;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection.FieldAccessor;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection.MethodInvoker;
-import net.minecraft.util.com.google.common.collect.Lists;
-import net.minecraft.util.com.google.common.collect.MapMaker;
-import net.minecraft.util.com.mojang.authlib.GameProfile;
-import net.minecraft.util.io.netty.channel.*;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.server.PluginDisableEvent;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.scheduler.BukkitRunnable;
-
-import java.util.*;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.logging.Level;
-
-
-/**
- * Represents a very tiny alternative to ProtocolLib.
- * <p>
- * It now supports intercepting packets during login and status ping (such as OUT_SERVER_PING)!
- *
- * @author Kristian
- */
-
-//BROKEN: NPEs when player joins while server is starting, and using PlayerJoinEvent instead will cause NPE for protocol version lookup.
-//Protocol version number lookup method from DeprecatedLuke's version of TinyProtocol
-public abstract class TinyProtocol7 {
-    private static final AtomicInteger ID = new AtomicInteger(0);
-
-    // Used in order to lookup a channel
-    private static final MethodInvoker getPlayerHandle = Reflection.getMethod("{obc}.entity.CraftPlayer", "getHandle");
-    private static final FieldAccessor<Object> getConnection = Reflection.getField("{nms}.EntityPlayer", "playerConnection", Object.class);
-    private static final FieldAccessor<Object> getManager = Reflection.getField("{nms}.PlayerConnection", "networkManager", Object.class);
-    private static final FieldAccessor<Channel> getChannel = Reflection.getField("{nms}.NetworkManager", Channel.class, 0);
-
-    // Looking up ServerConnection
-    private static final Class<Object> minecraftServerClass = Reflection.getUntypedClass("{nms}.MinecraftServer");
-    private static final Class<Object> serverConnectionClass = Reflection.getUntypedClass("{nms}.ServerConnection");
-    private static final FieldAccessor<Object> getMinecraftServer = Reflection.getField("{obc}.CraftServer", minecraftServerClass, 0);
-    private static final FieldAccessor<Object> getServerConnection = Reflection.getField(minecraftServerClass, serverConnectionClass, 0);
-    private static final MethodInvoker getNetworkMarkers = Reflection.getTypedMethod(serverConnectionClass, null, List.class, serverConnectionClass);
-
-    // Packets we have to intercept
-    private static final Class<?> PACKET_LOGIN_IN_START = Reflection.getMinecraftClass("PacketLoginInStart");
-    private static final FieldAccessor<GameProfile> getGameProfile = Reflection.getField(PACKET_LOGIN_IN_START, GameProfile.class, 0);
-
-    // Speedup channel/protocol lookup
-    private final Map<String, Channel> channelLookup = new MapMaker().weakValues().makeMap();
-    // Channels that have already been removed
-    private final Set<Channel> uninjectedChannels = Collections.newSetFromMap(new MapMaker().weakKeys().makeMap());
-    protected volatile boolean closed;
-    protected Plugin plugin;
-    private Listener listener;
-    // List of network markers
-    private List<Object> networkManagers;
-    // Injected channel handlers
-    private final List<Channel> serverChannels = Lists.newArrayList();
-    private ChannelInboundHandlerAdapter serverChannelHandler;
-    private ChannelInitializer<Channel> beginInitProtocol;
-    private ChannelInitializer<Channel> endInitProtocol;
-    // Current handler name
-    private final String handlerName;
-
-    /**
-     * Construct a new instance of TinyProtocol, and start intercepting packets for all connected clients and future clients.
-     * <p>
-     * You can construct multiple instances per plugin.
-     *
-     * @param plugin - the plugin.
-     */
-    public TinyProtocol7(final Plugin plugin) {
-        this.plugin = plugin;
-
-        // Compute handler name
-        this.handlerName = getHandlerName();
-
-        // Prepare existing players
-        registerBukkitEvents();
-
-        try {
-            registerChannelHandler();
-            registerPlayers(plugin);
-        } catch (IllegalArgumentException ex) {
-            // Damn you, late bind
-            plugin.getLogger().info("[TinyProtocol] Delaying server channel injection due to late bind.");
-
-            new BukkitRunnable() {
-                @Override
-                public void run() {
-                    registerChannelHandler();
-                    registerPlayers(plugin);
-                    plugin.getLogger().info("[TinyProtocol] Late bind injection successful.");
-                }
-            }.runTask(plugin);
-        }
-    }
-
-    private void createServerChannelHandler() {
-        // Handle connected channels
-        endInitProtocol = new ChannelInitializer<Channel>() {
-
-            @Override
-            protected void initChannel(Channel channel) throws Exception {
-                try {
-                    // This can take a while, so we need to stop the main thread from interfering
-                    synchronized (networkManagers) {
-                        // Stop injecting channels
-                        if (!closed) {
-                            channel.eventLoop().submit(() -> injectChannelInternal(channel));
-                        }
-                    }
-                } catch (Exception e) {
-                    plugin.getLogger().log(Level.SEVERE, "Cannot inject incomming channel " + channel, e);
-                }
-            }
-
-        };
-
-        // This is executed before Minecraft's channel handler
-        beginInitProtocol = new ChannelInitializer<Channel>() {
-
-            @Override
-            protected void initChannel(Channel channel) throws Exception {
-                channel.pipeline().addLast(endInitProtocol);
-            }
-
-        };
-
-        serverChannelHandler = new ChannelInboundHandlerAdapter() {
-
-            @Override
-            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-                Channel channel = (Channel) msg;
-
-                // Prepare to initialize ths channel
-                channel.pipeline().addFirst(beginInitProtocol);
-                ctx.fireChannelRead(msg);
-            }
-
-        };
-    }
-
-    /**
-     * Register bukkit events.
-     */
-    private void registerBukkitEvents() {
-        listener = new Listener() {
-
-            @EventHandler(priority = EventPriority.LOWEST)
-            public final void onPlayerLogin(PlayerLoginEvent e) {
-                if (closed)
-                    return;
-
-                Channel channel = getChannel(e.getPlayer());
-
-                // Don't inject players that have been explicitly uninjected
-                if (!uninjectedChannels.contains(channel)) {
-                    injectPlayer(e.getPlayer());
-                }
-            }
-
-            @EventHandler
-            public final void onPluginDisable(PluginDisableEvent e) {
-                if (e.getPlugin().equals(plugin)) {
-                    close();
-                }
-            }
-
-        };
-
-        plugin.getServer().getPluginManager().registerEvents(listener, plugin);
-    }
-
-    @SuppressWarnings("unchecked")
-    private void registerChannelHandler() {
-        Object mcServer = getMinecraftServer.get(Bukkit.getServer());
-        Object serverConnection = getServerConnection.get(mcServer);
-        boolean looking = true;
-
-        // We need to synchronize against this list
-        networkManagers = (List<Object>) getNetworkMarkers.invoke(null, serverConnection);
-        createServerChannelHandler();
-
-        // Find the correct list, or implicitly throw an exception
-        for (int i = 0; looking; i++) {
-            List<Object> list = Reflection.getField(serverConnection.getClass(), List.class, i).get(serverConnection);
-
-            for (Object item : list) {
-                if (!(item instanceof ChannelFuture))
-                    break;
-
-                // Channel future that contains the server connection
-                Channel serverChannel = ((ChannelFuture) item).channel();
-
-                serverChannels.add(serverChannel);
-                serverChannel.pipeline().addFirst(serverChannelHandler);
-                looking = false;
-            }
-        }
-    }
-
-    private void unregisterChannelHandler() {
-        if (serverChannelHandler == null)
-            return;
-
-        for (Channel serverChannel : serverChannels) {
-            final ChannelPipeline pipeline = serverChannel.pipeline();
-
-            // Remove channel handler
-            serverChannel.eventLoop().execute(new Runnable() {
-
-                @Override
-                public void run() {
-                    try {
-                        pipeline.remove(serverChannelHandler);
-                    } catch (NoSuchElementException e) {
-                        // That's fine
-                    }
-                }
-
-            });
-        }
-    }
-
-    private void registerPlayers(Plugin plugin) {
-        for (Player player : plugin.getServer().getOnlinePlayers()) {
-            injectPlayer(player);
-        }
-    }
-
-    /**
-     * Invoked when the server is starting to send a packet to a player.
-     * <p>
-     * Note that this is not executed on the main thread.
-     *
-     * @param receiver - the receiving player, NULL for early login/status packets.
-     * @param channel  - the channel that received the packet. Never NULL.
-     * @param packet   - the packet being sent.
-     * @return The packet to send instead, or NULL to cancel the transmission.
-     */
-    public Object onPacketOutAsync(Player receiver, Channel channel, Object packet) {
-        final String packetName = packet.getClass().getSimpleName();
-        final PacketSendEvent packetSendEvent = new PacketSendEvent(receiver, packetName, packet);
-        PacketEvents.getEventManager().callEvent(packetSendEvent);
-        if (!packetSendEvent.isCancelled()) {
-            return packet;
-        }
-        return null;
-    }
-
-    /**
-     * Invoked when the server has received a packet from a given player.
-     * <p>
-     * Use {@link Channel#remoteAddress()} to get the remote address of the client.
-     *
-     * @param sender  - the player that sent the packet, NULL for early login/status packets.
-     * @param channel - channel that received the packet. Never NULL.
-     * @param packet  - the packet being received.
-     * @return The packet to recieve instead, or NULL to cancel.
-     */
-    public Object onPacketInAsync(Player sender, Channel channel, Object packet) {
-        return packet;
-    }
-
-    /**
-     * Send a packet to a particular player.
-     * <p>
-     * Note that {@link #onPacketOutAsync(Player, Channel, Object)} will be invoked with this packet.
-     *
-     * @param player - the destination player.
-     * @param packet - the packet to send.
-     */
-    public void sendPacket(Player player, Object packet) {
-        sendPacket(getChannel(player), packet);
-    }
-
-    /**
-     * Send a packet to a particular client.
-     * <p>
-     * Note that {@link #onPacketOutAsync(Player, Channel, Object)} will be invoked with this packet.
-     *
-     * @param channel - client identified by a channel.
-     * @param packet  - the packet to send.
-     */
-    public void sendPacket(Channel channel, Object packet) {
-        channel.pipeline().writeAndFlush(packet);
-    }
-
-    /**
-     * Pretend that a given packet has been received from a player.
-     * <p>
-     * Note that {@link #onPacketInAsync(Player, Channel, Object)} will be invoked with this packet.
-     *
-     * @param player - the player that sent the packet.
-     * @param packet - the packet that will be received by the server.
-     */
-    public void receivePacket(Player player, Object packet) {
-        receivePacket(getChannel(player), packet);
-    }
-
-    /**
-     * Pretend that a given packet has been received from a given client.
-     * <p>
-     * Note that {@link #onPacketInAsync(Player, Channel, Object)} will be invoked with this packet.
-     *
-     * @param channel - client identified by a channel.
-     * @param packet  - the packet that will be received by the server.
-     */
-    public void receivePacket(Channel channel, Object packet) {
-        channel.pipeline().context("encoder").fireChannelRead(packet);
-    }
-
-
-    /**
-     * Changed from "tiny-" to "packetevents"
-     *
-     * @return handlerName
-     */
-    protected String getHandlerName() {
-        return "packetevents-" + plugin.getName() + "-" + ID.incrementAndGet();
-    }
-
-    /**
-     * Add a custom channel handler to the given player's channel pipeline, allowing us to intercept sent and received packets.
-     * <p>
-     * This will automatically be called when a player has logged in.
-     *
-     * @param player - the player to inject.
-     */
-    public void injectPlayer(Player player) {
-        final PlayerInjectEvent playerInjectEvent = new PlayerInjectEvent(player);
-        PacketEvents.getEventManager().callEvent(playerInjectEvent);
-        if (!playerInjectEvent.isCancelled()) {
-            injectChannelInternal(getChannel(player)).player = player;
-        }
-    }
-
-    /**
-     * Add a custom channel handler to the given channel.
-     *
-     * @param channel - the channel to inject.
-     * @return The intercepted channel, or NULL if it has already been injected.
-     */
-    public void injectChannel(Channel channel) {
-        injectChannelInternal(channel);
-    }
-
-    /**
-     * Add a custom channel handler to the given channel.
-     *
-     * @param channel - the channel to inject.
-     * @return The packet interceptor.
-     */
-    private PacketInterceptor injectChannelInternal(Channel channel) {
-        try {
-            PacketInterceptor interceptor = (PacketInterceptor) channel.pipeline().get(handlerName);
-
-            // Inject our packet interceptor
-            if (interceptor == null) {
-                interceptor = new PacketInterceptor();
-                channel.pipeline().addBefore("packet_handler", handlerName, interceptor);
-                uninjectedChannels.remove(channel);
-            }
-
-            return interceptor;
-        } catch (IllegalArgumentException e) {
-            // Try again
-            return (PacketInterceptor) channel.pipeline().get(handlerName);
-        }
-    }
-
-    /**
-     * Retrieve the Netty channel associated with a player. This is cached.
-     *
-     * @param player - the player.
-     * @return The Netty channel.
-     */
-    public Channel getChannel(Player player) {
-        Channel channel = channelLookup.get(player.getName());
-
-        // Lookup channel again
-        if (channel == null) {
-            Object connection = getConnection.get(getPlayerHandle.invoke(player));
-            Object manager = getManager.get(connection);
-
-            channelLookup.put(player.getName(), channel = getChannel.get(manager));
-        }
-
-        return channel;
-    }
-
-    /**
-     * Uninject a specific player.
-     *
-     * @param player - the injected player.
-     */
-    public void uninjectPlayer(Player player) {
-        uninjectChannel(getChannel(player));
-        PacketEvents.getEventManager().callEvent(new PlayerUninjectEvent(player));
-    }
-
-    /**
-     * Uninject a specific channel.
-     * <p>
-     * This will also disable the automatic channel injection that occurs when a player has properly logged in.
-     *
-     * @param channel - the injected channel.
-     */
-    public void uninjectChannel(final Channel channel) {
-        // No need to guard against this if we're closing
-        if (!closed) {
-            uninjectedChannels.add(channel);
-        }
-
-        // See ChannelInjector in ProtocolLib, line 590
-        channel.eventLoop().execute(new Runnable() {
-
-            @Override
-            public void run() {
-                channel.pipeline().remove(handlerName);
-            }
-
-        });
-    }
-
-    /**
-     * Determine if the given player has been injected by TinyProtocol.
-     *
-     * @param player - the player.
-     * @return TRUE if it is, FALSE otherwise.
-     */
-    public boolean hasInjected(Player player) {
-        return hasInjected(getChannel(player));
-    }
-
-    /**
-     * Determine if the given channel has been injected by TinyProtocol.
-     *
-     * @param channel - the channel.
-     * @return TRUE if it is, FALSE otherwise.
-     */
-    public boolean hasInjected(Channel channel) {
-        return channel.pipeline().get(handlerName) != null;
-    }
-
-    /**
-     * Cease listening for packets. This is called automatically when your plugin is disabled.
-     */
-    public final void close() {
-        if (!closed) {
-            closed = true;
-
-            // Remove our handlers
-            for (Player player : plugin.getServer().getOnlinePlayers()) {
-                uninjectPlayer(player);
-            }
-
-            // Clean up Bukkit
-            HandlerList.unregisterAll(listener);
-            unregisterChannelHandler();
-        }
-    }
-
-    /**
-     * Channel handler that is inserted into the player's channel pipeline, allowing us to intercept sent and received packets.
-     *
-     * @author Kristian
-     */
-    private final class PacketInterceptor extends ChannelDuplexHandler {
-        // Updated by the login event
-        public volatile Player player;
-
-        @Override
-        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-            // Intercept channel
-            final Channel channel = ctx.channel();
-            handleLoginStart(channel, msg);
-
-            try {
-                msg = onPacketInAsync(player, channel, msg);
-            } catch (Exception e) {
-                plugin.getLogger().log(Level.SEVERE, "Error in onPacketInAsync().", e);
-            }
-
-            if (msg != null) {
-                super.channelRead(ctx, msg);
-            }
-        }
-
-        @Override
-        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
-            try {
-                msg = onPacketOutAsync(player, ctx.channel(), msg);
-            } catch (Exception e) {
-                plugin.getLogger().log(Level.SEVERE, "Error in onPacketOutAsync().", e);
-            }
-
-            if (msg != null) {
-                super.write(ctx, msg, promise);
-            }
-        }
-
-        private void handleLoginStart(Channel channel, Object packet) {
-            if (PACKET_LOGIN_IN_START.isInstance(packet)) {
-                GameProfile profile = getGameProfile.get(packet);
-                channelLookup.put(profile.getName(), channel);
-            }
-        }
-    }
-}
@@ -1,545 +0,0 @@
-/*
- * This file is part of Hawk Anticheat.
- * Copyright (C) 2018 Hawk Development Team
- *
- * This program is free software: you can redistribute it and/or modify
- * it under the terms of the GNU General Public License as published by
- * the Free Software Foundation, either version 3 of the License, or
- * (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful,
- * but WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
- * GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program.  If not, see <https://www.gnu.org/licenses/>.
- */
-
-package io.github.retrooper.packetevents.tinyprotocol;
-
-import com.google.common.collect.Lists;
-import com.google.common.collect.MapMaker;
-import com.mojang.authlib.GameProfile;
-import io.github.retrooper.packetevents.PacketEvents;
-import io.github.retrooper.packetevents.event.impl.PlayerInjectEvent;
-import io.github.retrooper.packetevents.event.impl.PlayerUninjectEvent;
-import io.github.retrooper.packetevents.handler.TinyProtocolHandler_1_8;
-import io.github.retrooper.packetevents.tinyprotocol.Reflection.FieldAccessor;
-import io.netty.channel.*;
-import org.bukkit.Bukkit;
-import org.bukkit.entity.Player;
-import org.bukkit.event.EventHandler;
-import org.bukkit.event.EventPriority;
-import org.bukkit.event.HandlerList;
-import org.bukkit.event.Listener;
-import org.bukkit.event.player.PlayerLoginEvent;
-import org.bukkit.event.server.PluginDisableEvent;
-import org.bukkit.plugin.Plugin;
-import org.bukkit.scheduler.BukkitRunnable;
-
-import java.lang.reflect.Field;
-import java.util.*;
-import java.util.concurrent.atomic.AtomicInteger;
-import java.util.logging.Level;
-
-/**
- * Represents a very tiny alternative to ProtocolLib.
- * <p>
- * It now supports intercepting packets during login and status ping (such as OUT_SERVER_PING)!
- *
- * @author Kristian
- */
-
-//BROKEN: NPEs when player joins while server is starting, and using PlayerJoinEvent instead will cause NPE for protocol version lookup.
-//Protocol version number lookup method from DeprecatedLuke's version of TinyProtocol
-public abstract class TinyProtocol8 {
-    private static final AtomicInteger ID = new AtomicInteger(0);
-
-    // Used in order to lookup a channel
-    private static final Reflection.MethodInvoker getPlayerHandle = Reflection.getMethod("{obc}.entity.CraftPlayer", "getHandle");
-    private static final FieldAccessor<Object> getConnection = Reflection.getField("{nms}.EntityPlayer", "playerConnection", Object.class);
-    private static final FieldAccessor<Object> getManager = Reflection.getField("{nms}.PlayerConnection", "networkManager", Object.class);
-    private static final FieldAccessor<Channel> getChannel = Reflection.getField("{nms}.NetworkManager", Channel.class, 0);
-
-    // Looking up ServerConnection
-    private static final Class<Object> minecraftServerClass = Reflection.getUntypedClass("{nms}.MinecraftServer");
-    private static final Class<Object> serverConnectionClass = Reflection.getUntypedClass("{nms}.ServerConnection");
-    private static final FieldAccessor<Object> getMinecraftServer = Reflection.getField("{obc}.CraftServer", minecraftServerClass, 0);
-    private static final FieldAccessor<Object> getServerConnection = Reflection.getField(minecraftServerClass, serverConnectionClass, 0);
-
-    // Packets we have to intercept
-    private static final Class<?> PACKET_LOGIN_IN_START = Reflection.getMinecraftClass("PacketLoginInStart");
-    private static final FieldAccessor<GameProfile> getGameProfile = Reflection.getField(PACKET_LOGIN_IN_START, GameProfile.class, 0);
-
-    // Speedup channel/protocol lookup
-    private final Map<String, Channel> channelLookup = new MapMaker().weakValues().makeMap();
-    // Channels that have already been removed
-    private final Set<Channel> uninjectedChannels = Collections.newSetFromMap(new MapMaker().weakKeys().makeMap());
-    // Injected channel handlers
-    private final List<Channel> serverChannels = Lists.newArrayList();
-    protected volatile boolean closed;
-    protected Plugin plugin;
-    private Listener listener;
-    // List of network markers
-    private List<Object> networkManagers;
-    private ChannelInboundHandlerAdapter serverChannelHandler;
-    private ChannelInitializer<Channel> beginInitProtocol;
-    private ChannelInitializer<Channel> endInitProtocol;
-    // Current handler name
-    private final String handlerName;
-
-    /**
-     * Construct a new instance of TinyProtocol, and start intercepting packets for all connected clients and future clients.
-     * <p>
-     * You can construct multiple instances per plugin.
-     *
-     * @param plugin - the plugin.
-     */
-    public TinyProtocol8(final Plugin plugin) {
-        this.plugin = plugin;
-
-        // Compute handler name
-        this.handlerName = getHandlerName();
-
-        // Prepare existing players
-        registerBukkitEvents();
-
-        try {
-            registerChannelHandler();
-            registerPlayers(plugin);
-        } catch (IllegalArgumentException | NoSuchFieldException | IllegalAccessException ex) {
-            // Damn you, late bind
-            plugin.getLogger().info("[TinyProtocol] Delaying server channel injection due to late bind.");
-
-            new BukkitRunnable() {
-                @Override
-                public void run() {
-                    try {
-                        registerChannelHandler();
-                    } catch (NoSuchFieldException | IllegalAccessException e) {
-                        e.printStackTrace();
-                    }
-                    registerPlayers(plugin);
-                    plugin.getLogger().info("[TinyProtocol] Late bind injection successful.");
-                }
-            }.runTask(plugin);
-        }
-    }
-
-    private void createServerChannelHandler() {
-        // Handle connected channels
-        endInitProtocol = new ChannelInitializer<Channel>() {
-
-            @Override
-            protected void initChannel(Channel channel) throws Exception {
-                try {
-                    // This can take a while, so we need to stop the main thread from interfering
-                    synchronized (networkManagers) {
-                        // Stop injecting channels
-                        if (!closed) {
-                            channel.eventLoop().submit(() -> injectChannelInternal(channel));
-                        }
-                    }
-                } catch (Exception e) {
-                    plugin.getLogger().log(Level.SEVERE, "Cannot inject incomming channel " + channel, e);
-                }
-            }
-
-        };
-
-        // This is executed before Minecraft's channel handler
-        beginInitProtocol = new ChannelInitializer<Channel>() {
-
-            @Override
-            protected void initChannel(Channel channel) throws Exception {
-                channel.pipeline().addLast(endInitProtocol);
-            }
-
-        };
-
-        serverChannelHandler = new ChannelInboundHandlerAdapter() {
-
-            @Override
-            public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-                Channel channel = (Channel) msg;
-
-                // Prepare to initialize ths channel
-                channel.pipeline().addFirst(beginInitProtocol);
-                ctx.fireChannelRead(msg);
-            }
-
-        };
-    }
-
-    /**
-     * Register bukkit events.
-     */
-    private void registerBukkitEvents() {
-        listener = new Listener() {
-
-            @EventHandler(priority = EventPriority.LOWEST)
-            public final void onPlayerLogin(PlayerLoginEvent e) {
-                if (closed)
-                    return;
-
-                Channel channel = getChannel(e.getPlayer());
-
-                // Don't inject players that have been explicitly uninjected
-                if (!uninjectedChannels.contains(channel)) {
-                    injectPlayer(e.getPlayer());
-                }
-            }
-
-            @EventHandler
-            public final void onPluginDisable(PluginDisableEvent e) {
-                if (e.getPlugin().equals(plugin)) {
-                    close();
-                }
-            }
-
-        };
-
-        plugin.getServer().getPluginManager().registerEvents(listener, plugin);
-    }
-
-    /**
-     * Function modified by Retrooper
-     *
-     * @throws NoSuchFieldException
-     * @throws IllegalAccessException
-     */
-    @SuppressWarnings("unchecked")
-    private void registerChannelHandler() throws NoSuchFieldException, IllegalAccessException {
-        Object mcServer = getMinecraftServer.get(Bukkit.getServer());
-        Object serverConnection = getServerConnection.get(mcServer);
-        boolean looking = true;
-
-        /*
-         * I am doing this so we can support 1.8->1.15.2, the previous method TinyProtocol used wasn't supported on some versions
-         * like 1.15.2
-         */
-        final Field networkManagersField = serverConnection.getClass().getDeclaredField(TinyProtocolHandler_1_8.getNetworkManagersFieldName());
-        networkManagersField.setAccessible(true);
-        networkManagers = (List<Object>) networkManagersField.get(serverConnection);
-        createServerChannelHandler();
-
-        // Find the correct list, or implicitly throw an exception
-        for (int i = 0; looking; i++) {
-            List<Object> list = Reflection.getField(serverConnection.getClass(), List.class, i).get(serverConnection);
-            for (Object item : list) {
-                if (!(item instanceof ChannelFuture))
-                    break;
-
-                // Channel future that contains the server connection
-                Channel serverChannel = ((ChannelFuture) item).channel();
-
-                serverChannels.add(serverChannel);
-                serverChannel.pipeline().addFirst(serverChannelHandler);
-                looking = false;
-            }
-        }
-    }
-
-    private void unregisterChannelHandler() {
-        if (serverChannelHandler == null)
-            return;
-
-        for (Channel serverChannel : serverChannels) {
-            final ChannelPipeline pipeline = serverChannel.pipeline();
-
-            // Remove channel handler
-            serverChannel.eventLoop().execute(new Runnable() {
-
-                @Override
-                public void run() {
-                    try {
-                        pipeline.remove(serverChannelHandler);
-                    } catch (NoSuchElementException e) {
-                        // That's fine
-                    }
-                }
-            });
-        }
-    }
-
-    private void registerPlayers(Plugin plugin) {
-        for (Player player : plugin.getServer().getOnlinePlayers()) {
-            injectPlayer(player);
-        }
-    }
-
-    /**
-     * Invoked when the server is starting to send a packet to a player.
-     * <p>
-     * Note that this is not executed on the main thread.
-     *
-     * @param receiver - the receiving player, NULL for early login/status packets.
-     * @param channel  - the channel that received the packet. Never NULL.
-     * @param packet   - the packet being sent.
-     * @return The packet to send instead, or NULL to cancel the transmission.
-     */
-    public Object onPacketOutAsync(Player receiver, Channel channel, Object packet) {
-        return packet;
-    }
-
-    /**
-     * Invoked when the server has received a packet from a given player.
-     * <p>
-     * Use {@link Channel#remoteAddress()} to get the remote address of the client.
-     *
-     * @param sender  - the player that sent the packet, NULL for early login/status packets.
-     * @param channel - channel that received the packet. Never NULL.
-     * @param packet  - the packet being received.
-     * @return The packet to recieve instead, or NULL to cancel.
-     */
-    public Object onPacketInAsync(Player sender, Channel channel, Object packet) {
-        return packet;
-    }
-
-    /**
-     * Send a packet to a particular player.
-     * <p>
-     * Note that {@link #onPacketOutAsync(Player, Channel, Object)} will be invoked with this packet.
-     *
-     * @param player - the destination player.
-     * @param packet - the packet to send.
-     */
-    public void sendPacket(Player player, Object packet) {
-        sendPacket(getChannel(player), packet);
-    }
-
-    /**
-     * Send a packet to a particular client.
-     * <p>
-     * Note that {@link #onPacketOutAsync(Player, Channel, Object)} will be invoked with this packet.
-     *
-     * @param channel - client identified by a channel.
-     * @param packet  - the packet to send.
-     */
-    public void sendPacket(Channel channel, Object packet) {
-        channel.pipeline().writeAndFlush(packet);
-    }
-
-    /**
-     * Pretend that a given packet has been received from a player.
-     * <p>
-     * Note that {@link #onPacketInAsync(Player, Channel, Object)} will be invoked with this packet.
-     *
-     * @param player - the player that sent the packet.
-     * @param packet - the packet that will be received by the server.
-     */
-    public void receivePacket(Player player, Object packet) {
-        receivePacket(getChannel(player), packet);
-    }
-
-    /**
-     * Pretend that a given packet has been received from a given client.
-     * <p>
-     * Note that {@link #onPacketInAsync(Player, Channel, Object)} will be invoked with this packet.
-     *
-     * @param channel - client identified by a channel.
-     * @param packet  - the packet that will be received by the server.
-     */
-    public void receivePacket(Channel channel, Object packet) {
-        channel.pipeline().context("encoder").fireChannelRead(packet);
-    }
-
-
-    /**
-     * Changed from "tiny-" to "packetevents"
-     *
-     * @return handlerName
-     */
-    protected String getHandlerName() {
-        return "packetevents-" + plugin.getName() + "-" + ID.incrementAndGet();
-    }
-
-    /**
-     * Add a custom channel handler to the given player's channel pipeline, allowing us to intercept sent and received packets.
-     * <p>
-     * This will automatically be called when a player has logged in.
-     *
-     * @param player - the player to inject.
-     */
-    public void injectPlayer(Player player) {
-        final PlayerInjectEvent playerInjectEvent = new PlayerInjectEvent(player);
-        PacketEvents.getEventManager().callEvent(playerInjectEvent);
-        if (!playerInjectEvent.isCancelled()) {
-            injectChannelInternal(getChannel(player)).player = player;
-        }
-    }
-
-    /**
-     * Add a custom channel handler to the given channel.
-     *
-     * @param channel - the channel to inject.
-     * @return The intercepted channel, or NULL if it has already been injected.
-     */
-    public void injectChannel(Channel channel) {
-        injectChannelInternal(channel);
-    }
-
-    /**
-     * Add a custom channel handler to the given channel.
-     *
-     * @param channel - the channel to inject.
-     * @return The packet interceptor.
-     */
-    private PacketInterceptor injectChannelInternal(Channel channel) {
-        try {
-            PacketInterceptor interceptor = (PacketInterceptor) channel.pipeline().get(handlerName);
-
-            // Inject our packet interceptor
-            if (interceptor == null) {
-                interceptor = new PacketInterceptor();
-                channel.pipeline().addBefore("packet_handler", handlerName, interceptor);
-                uninjectedChannels.remove(channel);
-            }
-
-            return interceptor;
-        } catch (IllegalArgumentException e) {
-            // Try again
-            return (PacketInterceptor) channel.pipeline().get(handlerName);
-        }
-    }
-
-    /**
-     * Retrieve the Netty channel associated with a player. This is cached.
-     *
-     * @param player - the player.
-     * @return The Netty channel.
-     */
-    public Channel getChannel(Player player) {
-        Channel channel = channelLookup.get(player.getName());
-
-        // Lookup channel again
-        if (channel == null) {
-            Object connection = getConnection.get(getPlayerHandle.invoke(player));
-            Object manager = getManager.get(connection);
-
-            channelLookup.put(player.getName(), channel = getChannel.get(manager));
-        }
-
-        return channel;
-    }
-
-    /**
-     * Uninject a specific player.
-     *
-     * @param player - the injected player.
-     */
-    public void uninjectPlayer(Player player) {
-        uninjectChannel(getChannel(player));
-        PacketEvents.getEventManager().callEvent(new PlayerUninjectEvent(player));
-    }
-
-    /**
-     * Uninject a specific channel.
-     * <p>
-     * This will also disable the automatic channel injection that occurs when a player has properly logged in.
-     *
-     * @param channel - the injected channel.
-     */
-    public void uninjectChannel(final Channel channel) {
-        // No need to guard against this if we're closing
-        if (!closed) {
-            uninjectedChannels.add(channel);
-        }
-
-        // See ChannelInjector in ProtocolLib, line 590
-        channel.eventLoop().execute(new Runnable() {
-
-            @Override
-            public void run() {
-                channel.pipeline().remove(handlerName);
-            }
-
-        });
-    }
-
-    /**
-     * Determine if the given player has been injected by TinyProtocol.
-     *
-     * @param player - the player.
-     * @return TRUE if it is, FALSE otherwise.
-     */
-    public boolean hasInjected(Player player) {
-        return hasInjected(getChannel(player));
-    }
-
-    /**
-     * Determine if the given channel has been injected by TinyProtocol.
-     *
-     * @param channel - the channel.
-     * @return TRUE if it is, FALSE otherwise.
-     */
-    public boolean hasInjected(Channel channel) {
-        return channel.pipeline().get(handlerName) != null;
-    }
-
-    /**
-     * Cease listening for packets. This is called automatically when your plugin is disabled.
-     */
-    public final void close() {
-        if (!closed) {
-            closed = true;
-
-            // Remove our handlers
-            for (Player player : plugin.getServer().getOnlinePlayers()) {
-                uninjectPlayer(player);
-            }
-
-            // Clean up Bukkit
-            HandlerList.unregisterAll(listener);
-            unregisterChannelHandler();
-        }
-    }
-
-    /**
-     * Channel handler that is inserted into the player's channel pipeline, allowing us to intercept sent and received packets.
-     *
-     * @author Kristian
-     */
-    private final class PacketInterceptor extends ChannelDuplexHandler {
-        // Updated by the login event
-        public volatile Player player;
-
-        @Override
-        public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-            // Intercept channel
-            final Channel channel = ctx.channel();
-            handleLoginStart(channel, msg);
-
-            try {
-                msg = onPacketInAsync(player, channel, msg);
-            } catch (Exception e) {
-                plugin.getLogger().log(Level.SEVERE, "Error in onPacketInAsync().", e);
-            }
-
-            if (msg != null) {
-                super.channelRead(ctx, msg);
-            }
-        }
-
-        @Override
-        public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise promise) throws Exception {
-            try {
-                msg = onPacketOutAsync(player, ctx.channel(), msg);
-            } catch (Exception e) {
-                plugin.getLogger().log(Level.SEVERE, "Error in onPacketOutAsync().", e);
-            }
-
-            if (msg != null) {
-                super.write(ctx, msg, promise);
-            }
-        }
-
-        private void handleLoginStart(Channel channel, Object packet) {
-            if (PACKET_LOGIN_IN_START.isInstance(packet)) {
-                GameProfile profile = getGameProfile.get(packet);
-                channelLookup.put(profile.getName(), channel);
-            }
-        }
-    }
-}
@@ -3,6 +3,7 @@ package io.github.retrooper.packetevents.utils;
 import io.github.retrooper.packetevents.annotations.Nullable;
 import io.github.retrooper.packetevents.enums.ServerVersion;
 import io.github.retrooper.packetevents.packetwrappers.Sendable;
+import io.github.retrooper.packetevents.reflectionutils.Reflection;
 import io.github.retrooper.packetevents.utils.nms_entityfinder.EntityFinderUtils;
 import org.bukkit.World;
 import org.bukkit.entity.Entity;
@@ -22,14 +23,18 @@ public final class NMSUtils {
    private static final String obcDir = ServerVersion.getOBCDirectory();

    public static Class<?> minecraftServerClass, craftWorldsClass,
-            packetClass, entityPlayerClass, playerConnectionClass, craftPlayerClass, serverConnectionClass, craftEntityClass, craftItemStack, nmsItemStackClass;
+            packetClass, entityPlayerClass, playerConnectionClass,
+            craftPlayerClass, serverConnectionClass, craftEntityClass,
+    craftItemStack, nmsItemStackClass, networkManagerClass, nettyChannelClass;

    private static Method getServerMethod, getCraftWorldHandleMethod, getServerConnection, getCraftPlayerHandle, getCraftEntityHandle, sendPacketMethod, asBukkitCopy;

    private static Field recentTPSField, entityPlayerPingField, playerConnectionField;
+    public static final Reflection.FieldAccessor<?> networkManagerFieldAccesssor, channelFieldAccessor;

    static {
        try {
+            nettyChannelClass = getNettyClass("channel.Channel");
            minecraftServerClass = getNMSClass("MinecraftServer");
            craftWorldsClass = getOBCClass("CraftWorld");
            craftPlayerClass = getOBCClass("entity.CraftPlayer");
@@ -40,6 +45,7 @@ public final class NMSUtils {
            craftEntityClass = getOBCClass("entity.CraftEntity");
            craftItemStack = getOBCClass("inventory.CraftItemStack");
            nmsItemStackClass = getNMSClass("ItemStack");
+            networkManagerClass = getNMSClass("NetworkManager");
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
@@ -66,7 +72,8 @@ public final class NMSUtils {
            e.printStackTrace();
        }

-
+        networkManagerFieldAccesssor = Reflection.getField(playerConnectionClass, networkManagerClass, 0);
+        channelFieldAccessor = Reflection.getField(networkManagerClass, nettyChannelClass, 0);
    }

    public static Object getMinecraftServerInstance() throws InvocationTargetException, IllegalAccessException {
@@ -124,16 +131,32 @@ public final class NMSUtils {
    }

    public static Object getEntityPlayer(final Player player) {
-        final Object craftPlayer = getCraftPlayer(player);
        Object entityPlayer = null;
        try {
-            return getCraftPlayerHandle.invoke(craftPlayer);
+            return getCraftPlayerHandle.invoke(getCraftPlayer(player));
        } catch (IllegalAccessException | InvocationTargetException e) {
            e.printStackTrace();
        }
        return null;
    }

+    public static Object getPlayerConnection(final Player player) {
+        try {
+            return playerConnectionField.get( getEntityPlayer(player));
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        }
+        return null;
+    }
+
+    public static Object getNetworkManager(final Player player) {
+        return networkManagerFieldAccesssor.get(getPlayerConnection(player));
+    }
+
+    public static Object getChannel(final Player player) {
+        return channelFieldAccessor.get(getNetworkManager(player));
+    }
+
    public static int getPlayerPing(final Player player) {
        Object entityPlayer = getEntityPlayer(player);
        try {
@@ -0,0 +1,10 @@
+package io.github.retrooper.packetevents.utils;
+
+import org.bukkit.entity.Player;
+import protocolsupport.api.ProtocolSupportAPI;
+
+class ProtocolSupportAPIAccessor {
+    public static int getProtocolVersion(final Player player) {
+        return ProtocolSupportAPI.getProtocolVersion(player).getId();
+    }
+}
@@ -0,0 +1,15 @@
+package io.github.retrooper.packetevents.utils;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+import protocolsupport.api.ProtocolSupportAPI;
+
+public class ProtocolSupportUtils {
+    public static boolean isProtocolSupportAvailable() {
+        return Bukkit.getPluginManager().getPlugin("ProtocolSupport") != null;
+    }
+
+    public static int getProtocolVersion(final Player player) {
+        return ProtocolSupportAPI.getProtocolVersion(player).getId();
+    }
+}
@@ -0,0 +1,14 @@
+package io.github.retrooper.packetevents.utils;
+
+import org.bukkit.entity.Player;
+
+public class VersionLookupUtils {
+    public static int getProtocolVersion(final Player player) {
+        if (ViaUtils.isViaAPIAvaialable()) {
+            return ViaUtils.getProtocolVersion(player);
+        } else if (ProtocolSupportUtils.isProtocolSupportAvailable()) {
+            return ProtocolSupportUtils.getProtocolVersion(player);
+        }
+        return -1;
+    }
+}
@@ -0,0 +1,16 @@
+package io.github.retrooper.packetevents.utils;
+
+import org.bukkit.entity.Player;
+import us.myles.ViaVersion.api.Via;
+
+import java.util.UUID;
+
+class ViaAPIAccessor {
+    public static int getProtocolVersion(final Player player) {
+        return getProtocolVersion(player.getUniqueId());
+    }
+
+    public static int getProtocolVersion(final UUID uuid) {
+        return Via.getAPI().getPlayerVersion(uuid);
+    }
+}
@@ -0,0 +1,15 @@
+package io.github.retrooper.packetevents.utils;
+
+import org.bukkit.Bukkit;
+import org.bukkit.entity.Player;
+
+
+public class ViaUtils {
+    public static int getProtocolVersion(final Player player) {
+        return ViaAPIAccessor.getProtocolVersion(player);
+    }
+
+    public static boolean isViaAPIAvaialable() {
+        return Bukkit.getPluginManager().getPlugin("ViaVersion") != null;
+    }
+}
Author	SHA1	Message	Date
retrooper	c0c03a0629	updated readme credit to release 1.3.5	2020-06-25 13:35:53 +02:00
purplexdev	18f3f135c8	Merge remote-tracking branch 'origin/master'	2020-06-25 13:16:04 +02:00
purplexdev	0304d0ac5a	1.3.5 Release STABLE! * TinyProtocol removed * API Size way smaller * PlayerUninjectEvent is now called * Version lookup methods re-added, but version lookup is only possible with ProtocolSupport or ViaVersion plugin avaialable on the server. If you try looking up version and none of the listed plugins could be found, you will result with ClientVersion.ACCESS_FAILURE * WrappedPacketOutAbilities sendable wrapper added * PostPlayerInjectEvent has been deprecated, please use PlayerInjectEvent * PlayerUninjectEvent now cancellable * PlayerInjectEvent or PlayerUninjectEvent cancelling, will cancel the action. * pom.xml version updated to 1.3.5 * Packet class has been deprecated, please use PacketType instead! * Packet.isInstanceOfFlyingPacket(nmsPacket) -> PacketType.Util.isInstanceOfFlyingPacket(nmsPacket), and more instanceof functions are added in the PacketType.Util class too! * PacketReceiveEvent#getPacket() is deprecated, please use PacketReceiveEvent#getNMSPacket() * PacketSendEvent#getPacket() is deprecated, please use PacketSendEvent#getNMSPacket() * PacketEvents.setShouldKickOnRestart(boolean) removed	2020-06-25 13:15:34 +02:00
retrooper	643fa1ad18	updated credits to fit latest commit	2020-06-22 22:43:50 +02:00
retrooper	5c65874749	remove plugin.yml	2020-06-22 22:36:27 +02:00
purplexdev	5a4db46427	1.3.4.1 UNTESTED! Completely removed TinyProtocol, please test it, I will be able to fix any bugs tomorrow!	2020-06-22 22:31:14 +02:00
purplexdev	305d376128	1.3.4 RELEASE, This is probably one of my most important releases, this is the last release using TinyProtocol! Changelog: * Clientbound Abilities wrapper added and is sendable to clients * Clientbound Health update wrapper added and is also sendable to clients Info: TinyProtocol helped us listen to some login and handshake packets! But it also came with a lot of bugs and problems to deal with, even today there are still some bugs and many people using this API have complained about it. I will now stop using TinyProtocol. WHAT WILL THIS MEAN? There will be lots of pro's and con's. Pros: * No more issues with reloading * Smaller file size Cons: * Version lookup will now only be possible with dependencies like ViaVersion. * Soft depend on via version as mentioned above. Soft depend meaning that if you want to lookup versions, ViaVersion api is required to be provided. * All login wrappers and the login event will be removed! It is very important that PacketEvents is stable and people shouldn't be constantly running into issues! I am releasing this version with TinyProtocol for the users that will miss and still want TinyProtocol.	2020-06-22 21:07:34 +02:00
purplexdev	4308936c1a	* Bukkit move event added * In and Out going transaction packet wrapper added (request of Hades developer)	2020-06-22 19:27:12 +02:00
purplexdev	87b0ac9295	* Updated the default value of PacketEvent#timestamp to the non deprecated method PacketEvents#highlyPreciseMillis()	2020-06-21 17:18:32 +02:00
purplexdev	3dee3b2a0e	Bug fixes! * Blockplace_1_9 wrapper error fixed * Blockplace 1_7 wrapper is now being used * PacketEvents#currentCalculatedMS() now deprecated, please use PacketEvents#highlyPreciseMillis() or System#currentTimeMillis() depending on what you need, please read the documentation of PacketEvents#highlyPreciseMillis().	2020-06-21 16:48:41 +02:00
purplexdev	c2f0e30511	Updated pom.xml version to 1.3.3.1	2020-06-18 16:19:12 +02:00