Bump version to 0.5.2

Fix commandblocks

ISSUE_TEMPLATE.md

@@ -0,0 +1,12 @@
+### What version of ViaVersion are you using? Type /ver viaversion
+
+### What version of Spigot are you using? Type /ver
+
+### What plugins are you using? Type /plugins
+
+### Are you using any additional software like BungeeCord? If so, what software and version? (Please list your plugins as well)
+
+### How does this error happen? login? Using an item? 
+
+### Is there an error in the console? Use pastebin.com. Is there a kick message?
+

README.md

@@ -1,17 +1,9 @@
-# ViaVersion 0.3.6
-**Allows the connection of 1.8 clients to 1.9**
+# ViaVersion 0.5.2
+**Allows the connection of 1.9 clients to 1.8**
 
 This plugin modifies netty to allow connection of 1.9 clients to 1.8,
 
-**Don't use late bind nor ProtocolLib**
-
-**As of this point it doesn't have everything, I need to fix:**
-
-Attempt to make boats nicer when they don't work
-
-Remap spawn eggs
-
-If you have a bug with entities, please report the full stack trace
+###**Don't use late bind*
 
 
 This took hours of work, so if you enjoy this consider looking into contacting me and supporting my projects.
@@ -24,6 +16,10 @@ Sources:
 
 **MCProtocolLib** (used for chunk reading & some of writing.)
 
+**OpenNBT** (used for slot rewriting)
+
+
+
 Contributors:
 --------
 
@@ -33,10 +29,24 @@ Contributors:
 
 **HugoDaBosss**
 
+**SanderGielisse**
+
+**Paulomart**
+
+**gigosaurus**
+
+**fillefilip8**
+
+**Chat: ** https://gitter.im/MylesIsCool/ViaVersion
+
+We use it to collaborate and solve errors, sign in with github.
+
 License:
 --------
 
 You may modify this work, all rights are still owned by myself excluding any files in the spacebase package as they belong to the respected contributors. Please credit the original author (myself) when forking etc. (or if it helped you understand the new protocol or netty!)
 
 
-Thanks!
+Thanks!
+
+

pom.xml

@@ -1,16 +1,33 @@
 <?xml version="1.0" encoding="UTF-8"?>
-<project xmlns="http://maven.apache.org/POM/4.0.0"
-         xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
-         xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
+<project xmlns="http://maven.apache.org/POM/4.0.0" xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
+    xsi:schemaLocation="http://maven.apache.org/POM/4.0.0 http://maven.apache.org/xsd/maven-4.0.0.xsd">
     <modelVersion>4.0.0</modelVersion>
 
     <groupId>us.myles</groupId>
     <artifactId>ViaVersion</artifactId>
-    <version>1.0-SNAPSHOT</version>
+    <version>0.5.2</version>
     <build>
+        <finalName>ViaVersion-${project.version}</finalName>
         <plugins>
             <plugin>
                 <groupId>org.apache.maven.plugins</groupId>
+                <artifactId>maven-shade-plugin</artifactId>
+                <version>1.4</version>
+                <configuration>
+                    <createDependencyReducedPom>false</createDependencyReducedPom>
+                </configuration>
+                <executions>
+                    <execution>
+                        <phase>package</phase>
+                        <goals>
+                            <goal>shade</goal>
+                        </goals>
+                    </execution>
+                </executions>
+            </plugin>
+            <plugin>
+                <groupId>org.apache.maven.plugins</groupId>
+                <version>3.5.1</version>
                 <artifactId>maven-compiler-plugin</artifactId>
                 <configuration>
                     <source>1.7</source>
@@ -18,8 +35,19 @@
                 </configuration>
             </plugin>
         </plugins>
+        <resources>
+            <resource>
+                <directory>src/main/resources</directory>
+                <filtering>true</filtering>
+            </resource>
+        </resources>
     </build>
     <dependencies>
+        <dependency>
+            <groupId>org.spacehq</groupId>
+            <artifactId>opennbt</artifactId>
+            <version>1.0</version>
+        </dependency>
         <dependency>
             <groupId>org.bukkit</groupId>
             <artifactId>bukkit</artifactId>
@@ -50,5 +78,9 @@
             <id>spigot-repo</id>
             <url>https://hub.spigotmc.org/nexus/content/repositories/snapshots/</url>
         </repository>
-   </repositories>
+        <repository>
+            <id>spacehq-repo</id>
+            <url>https://repo.spacehq.org/content/repositories/releases/</url>
+        </repository>
+    </repositories>
 </project>

src/main/java/org/spacehq/mc/protocol/util/NetUtil.java

@@ -39,7 +39,7 @@ public class NetUtil {
 
     public static Column readOldChunkData(int x, int z, boolean isFullChunk, int bitmask, byte[] input, boolean checkForSky, boolean hasSkyLight) {
         int pos = 0;
-        int expected = 0;
+        int expected = isFullChunk ? 256 : 0;
         boolean sky = false;
         ShortBuffer buf = ByteBuffer.wrap(input).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer();
         // 0 = Calculate expected length and determine if the packet has skylight.
@@ -85,7 +85,7 @@ public class NetUtil {
                     }
 
                     if(pass == 3) {
-                        if(chunks[ind].getSkyLight() != null) {
+                        if(sky) {
                             NibbleArray3d skylight = chunks[ind].getSkyLight();
                             System.arraycopy(input, pos, skylight.getData(), 0, skylight.getData().length);
                             pos += skylight.getData().length;

src/main/java/us/myles/ViaVersion/ConnectionInfo.java

@@ -1,5 +1,8 @@
 package us.myles.ViaVersion;
 
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandler;
+import io.netty.channel.socket.SocketChannel;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
 import us.myles.ViaVersion.packets.State;
@@ -7,11 +10,17 @@ import us.myles.ViaVersion.packets.State;
 import java.util.UUID;
 
 public class ConnectionInfo {
-    private int protocol = 0;
-    private State state = State.HANDSHAKE;
-    private int compression = 0;
+    private final SocketChannel channel;
     private Object lastPacket;
     private java.util.UUID UUID;
+    private State state = State.HANDSHAKE;
+    private int protocol = 0;
+    private int compression = 0;
+    private boolean active = true;
+
+    public ConnectionInfo(SocketChannel socketChannel) {
+        this.channel = socketChannel;
+    }
 
     public int getProtocol() {
         return protocol;
@@ -56,4 +65,26 @@ public class ConnectionInfo {
     public Player getPlayer() {
         return UUID == null ? null : Bukkit.getPlayer(UUID);
     }
+
+    public SocketChannel getChannel() {
+        return channel;
+    }
+
+    public boolean isActive() {
+        return active;
+    }
+
+    public void setActive(boolean active) {
+        this.active = active;
+    }
+
+    public void sendRawPacket(final ByteBuf packet) {
+        final ChannelHandler handler = channel.pipeline().get("encoder");
+        channel.eventLoop().submit(new Runnable() {
+            @Override
+            public void run() {
+                channel.pipeline().context(handler).writeAndFlush(packet);
+            }
+        });
+    }
 }

src/main/java/us/myles/ViaVersion/ViaVersionPlugin.java

@@ -1,27 +1,29 @@
 package us.myles.ViaVersion;
 
+import io.netty.buffer.ByteBuf;
 import io.netty.channel.ChannelFuture;
 import io.netty.channel.ChannelHandler;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.ChannelPipeline;
 import io.netty.channel.socket.SocketChannel;
 import org.bukkit.Bukkit;
-import org.bukkit.entity.Entity;
 import org.bukkit.entity.Player;
 import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.player.PlayerQuitEvent;
 import org.bukkit.inventory.ItemStack;
 import org.bukkit.plugin.java.JavaPlugin;
-
 import us.myles.ViaVersion.api.ViaVersion;
 import us.myles.ViaVersion.api.ViaVersionAPI;
+import us.myles.ViaVersion.armor.ArmorListener;
+import us.myles.ViaVersion.commands.ViaVersionCommand;
 import us.myles.ViaVersion.handlers.ViaVersionInitializer;
+import us.myles.ViaVersion.listeners.CommandBlockListener;
 import us.myles.ViaVersion.util.ReflectionUtil;
 
-import java.util.Collections;
+import java.lang.reflect.Field;
 import java.util.List;
-import java.util.Set;
+import java.util.Map;
 import java.util.UUID;
 import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
@@ -29,81 +31,100 @@ import java.util.concurrent.TimeUnit;
 
 public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
 
-    private final Set<UUID> portedPlayers = Collections.newSetFromMap(new ConcurrentHashMap<UUID, Boolean>());
+    private final Map<UUID, ConnectionInfo> portedPlayers = new ConcurrentHashMap<UUID, ConnectionInfo>();
+    private boolean debug = false;
 
     @Override
     public void onEnable() {
         ViaVersion.setInstance(this);
-        System.out.println("ViaVersion enabled, injecting. (Allows 1.8 to be accessed via 1.9)");
+        if (System.getProperty("ViaVersion") != null) {
+            getLogger().severe("ViaVersion is already loaded, we don't support reloads. Please reboot if you wish to update.");
+            return;
+        }
+
+        getLogger().info("ViaVersion " + getDescription().getVersion() + " is now enabled, injecting. (Allows 1.8 to be accessed via 1.9)");
         try {
             injectPacketHandler();
+            System.setProperty("ViaVersion", getDescription().getVersion());
         } catch (Exception e) {
-            if(Bukkit.getPluginManager().getPlugin("ProtocolLib") != null){
-                System.out.println("This plugin is not compatible with protocol lib.");
-            }
-            System.out.println("Unable to inject handlers, are you on 1.8? ");
+            getLogger().severe("Unable to inject handlers, are you on 1.8? ");
             e.printStackTrace();
         }
+
         Bukkit.getPluginManager().registerEvents(new Listener() {
             @EventHandler
             public void onPlayerQuit(PlayerQuitEvent e) {
-                setPorted(e.getPlayer().getUniqueId(), false);
+                removePortedClient(e.getPlayer().getUniqueId());
             }
         }, this);
+
+        Bukkit.getPluginManager().registerEvents(new ArmorListener(this), this);
+        Bukkit.getPluginManager().registerEvents(new CommandBlockListener(this), this);
+
+        getCommand("viaversion").setExecutor(new ViaVersionCommand(this));
     }
 
     public void injectPacketHandler() throws Exception {
         Class<?> serverClazz = ReflectionUtil.nms("MinecraftServer");
         Object server = ReflectionUtil.invokeStatic(serverClazz, "getServer");
         Object connection = serverClazz.getDeclaredMethod("getServerConnection").invoke(server);
-
-        List<ChannelFuture> futures = ReflectionUtil.get(connection, "g", List.class);
-        if (futures.size() == 0) {
-            throw new Exception("Could not find server to inject (late bind?)");
+        // loop through all fields checking if list
+        boolean injected = false;
+        for (Field field : connection.getClass().getDeclaredFields()) {
+            field.setAccessible(true);
+            Object value = field.get(connection);
+            if (value instanceof List) {
+                for (Object o : (List) value) {
+                    if (o instanceof ChannelFuture) {
+                        ChannelFuture future = (ChannelFuture) o;
+                        ChannelPipeline pipeline = future.channel().pipeline();
+                        ChannelHandler bootstrapAcceptor = pipeline.first();
+                        ChannelInitializer<SocketChannel> oldInit = ReflectionUtil.get(bootstrapAcceptor, "childHandler", ChannelInitializer.class);
+                        ChannelInitializer newInit = new ViaVersionInitializer(oldInit);
+                        ReflectionUtil.set(bootstrapAcceptor, "childHandler", newInit);
+                        injected = true;
+                    } else {
+                        break; // not the right list.
+                    }
+                }
+            }
         }
-
-        for (ChannelFuture future : futures) {
-            ChannelPipeline pipeline = future.channel().pipeline();
-            ChannelHandler bootstrapAcceptor = pipeline.first();
-            ChannelInitializer<SocketChannel> oldInit = ReflectionUtil.get(bootstrapAcceptor, "childHandler", ChannelInitializer.class);
-            ChannelInitializer newInit = new ViaVersionInitializer(oldInit);
-            ReflectionUtil.set(bootstrapAcceptor, "childHandler", newInit);
+        if (!injected) {
+            throw new Exception("Could not find server to inject (Please ensure late-bind in your spigot.yml is false)");
         }
     }
 
     @Override
     public boolean isPorted(Player player) {
-        return portedPlayers.contains(player.getUniqueId());
+        return portedPlayers.containsKey(player.getUniqueId());
     }
 
-    public void setPorted(UUID id, boolean value) {
-        if (value) {
-            portedPlayers.add(id);
-        } else {
-            portedPlayers.remove(id);
-        }
+    @Override
+    public String getVersion() {
+        return getDescription().getVersion();
     }
 
-    public static Entity getEntity(final UUID player, final int id) {
-        try {
-            return Bukkit.getScheduler().callSyncMethod(getPlugin(ViaVersionPlugin.class), new Callable<Entity>() {
-                @Override
-                public Entity call() throws Exception {
-                    Player p = Bukkit.getPlayer(player);
-                    if (p == null) return null;
-                    for (Entity e : p.getWorld().getEntities()) {
-                        if (e.getEntityId() == id) {
-                            return e;
-                        }
-                    }
-                    return null;
-                }
-            }).get(10, TimeUnit.SECONDS);
-        } catch (Exception e) {
-            System.out.println("Error fetching entity ");
-            e.printStackTrace();
-            return null;
-        }
+    public void sendRawPacket(Player player, ByteBuf packet) throws IllegalArgumentException {
+        if (!isPorted(player)) throw new IllegalArgumentException("This player is not on 1.9");
+        ConnectionInfo ci = portedPlayers.get(player.getUniqueId());
+        ci.sendRawPacket(packet);
+    }
+
+    @Override
+    public boolean isDebug() {
+        return this.debug;
+    }
+
+    public void setDebug(boolean value) {
+        this.debug = value;
+    }
+
+    public void addPortedClient(ConnectionInfo info) {
+        portedPlayers.put(info.getUUID(), info);
+    }
+
+    public void removePortedClient(UUID clientID) {
+        portedPlayers.remove(clientID);
     }
 
     public static ItemStack getHandItem(final ConnectionInfo info) {

src/main/java/us/myles/ViaVersion/api/ViaVersionAPI.java

@@ -1,8 +1,33 @@
 package us.myles.ViaVersion.api;
 
+import io.netty.buffer.ByteBuf;
 import org.bukkit.entity.Player;
 
 public interface ViaVersionAPI {
-
+    /**
+     * Is player using 1.9?
+     * @param player
+     * @return True if the client is on 1.9
+     */
     boolean isPorted(Player player);
+
+    /**
+     * Get the version of the plugin
+     * @return Plugin version
+     */
+    String getVersion();
+
+    /**
+     * Send a raw packet to the player (Use new IDs)
+     * @param player The player to send packet
+     * @param packet The packet, you need a VarInt ID then the packet contents.
+     * @throws IllegalArgumentException If not on 1.9 throws IllegalArg
+     */
+    void sendRawPacket(Player player, ByteBuf packet) throws IllegalArgumentException;
+
+    /**
+     * Obtain if global debug is enabled
+     * @return true if debug is enabled
+     */
+    boolean isDebug();
 }

src/main/java/us/myles/ViaVersion/armor/ArmorListener.java

@@ -0,0 +1,106 @@
+package us.myles.ViaVersion.armor;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.bukkit.Bukkit;
+import org.bukkit.entity.HumanEntity;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.inventory.InventoryClickEvent;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.bukkit.inventory.CraftingInventory;
+import us.myles.ViaVersion.ViaVersionPlugin;
+import us.myles.ViaVersion.api.ViaVersion;
+import us.myles.ViaVersion.packets.PacketType;
+
+import java.util.UUID;
+
+import static us.myles.ViaVersion.util.PacketUtil.*;
+
+public class ArmorListener implements Listener {
+
+    private final ViaVersionPlugin plugin;
+
+    private static UUID armorAttribute = UUID.fromString("2AD3F246-FEE1-4E67-B886-69FD380BB150");
+
+    public ArmorListener(ViaVersionPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onInventoryClick(InventoryClickEvent e) {
+        HumanEntity human = e.getWhoClicked();
+        if (human instanceof Player && e.getInventory() instanceof CraftingInventory) {
+            final Player player = (Player) human;
+            if (ViaVersion.getInstance().isPorted(player)) {
+                if (e.getCurrentItem() != null) {
+                    if (ArmorType.isArmor(e.getCurrentItem().getType())) {
+                        sendDelayedArmorUpdate(player);
+                        return;
+                    }
+                }
+                if (e.getRawSlot() >= 5 && e.getRawSlot() <= 8) {
+                    sendDelayedArmorUpdate(player);
+                    return;
+                }
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onInteract(PlayerInteractEvent e) {
+        if (e.getItem() != null) {
+            if (e.getAction() == Action.RIGHT_CLICK_AIR || e.getAction() == Action.RIGHT_CLICK_BLOCK) {
+                if (ArmorType.isArmor(e.getMaterial())) {
+                    final Player player = e.getPlayer();
+                    // Due to odd bugs it's 3 ticks later
+                    Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
+                        @Override
+                        public void run() {
+                            if (ViaVersion.getInstance().isPorted(player)) {
+                                sendArmorUpdate(player);
+                            }
+                        }
+                    }, 3L);
+                }
+            }
+        }
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR, ignoreCancelled = true)
+    public void onJoin(PlayerJoinEvent e) {
+        sendDelayedArmorUpdate(e.getPlayer());
+    }
+
+    public void sendDelayedArmorUpdate(final Player player) {
+        Bukkit.getScheduler().scheduleSyncDelayedTask(plugin, new Runnable() {
+            @Override
+            public void run() {
+                if (ViaVersion.getInstance().isPorted(player)) {
+                    sendArmorUpdate(player);
+                }
+            }
+        });
+    }
+
+    public static void sendArmorUpdate(Player player) {
+        int armor = ArmorType.calculateArmorPoints(player.getInventory().getArmorContents());
+
+        ByteBuf buf = Unpooled.buffer();
+        writeVarInt(PacketType.PLAY_ENTITY_PROPERTIES.getNewPacketID(), buf);
+        writeVarInt(player.getEntityId(), buf);
+        buf.writeInt(1); // only 1 property
+        writeString("generic.armor", buf);
+        buf.writeDouble(0); //default 0 armor
+        writeVarInt(1, buf); // 1 modifier
+        writeUUID(armorAttribute, buf); // armor modifier uuid
+        buf.writeDouble((double) armor); // the modifier value
+        buf.writeByte(0); // the modifier operation, 0 is add number
+
+        ViaVersion.getInstance().sendRawPacket(player, buf);
+    }
+}

src/main/java/us/myles/ViaVersion/armor/ArmorType.java

@@ -0,0 +1,91 @@
+package us.myles.ViaVersion.armor;
+
+import org.bukkit.Material;
+import org.bukkit.inventory.ItemStack;
+
+public enum ArmorType {
+
+    LEATHER_HELMET(1, 298, Material.LEATHER_HELMET),
+    LEATHER_CHESTPLATE(3, 299, Material.LEATHER_CHESTPLATE),
+    LEATHER_LEGGINGS(2, 300, Material.LEATHER_LEGGINGS),
+    LEATHER_BOOTS(1, 301, Material.LEATHER_BOOTS),
+    CHAINMAIL_HELMET(2, 302, Material.CHAINMAIL_HELMET),
+    CHAINMAIL_CHESTPLATE(5, 303, Material.CHAINMAIL_CHESTPLATE),
+    CHAINMAIL_LEGGINGS(4, 304, Material.CHAINMAIL_LEGGINGS),
+    CHAINMAIL_BOOTS(1, 305, Material.CHAINMAIL_BOOTS),
+    IRON_HELMET(2, 306, Material.IRON_HELMET),
+    IRON_CHESTPLATE(6, 307, Material.IRON_CHESTPLATE),
+    IRON_LEGGINGS(5, 308, Material.IRON_LEGGINGS),
+    IRON_BOOTS(2, 309, Material.IRON_BOOTS),
+    DIAMOND_HELMET(3, 310, Material.DIAMOND_HELMET),
+    DIAMOND_CHESTPLATE(8, 311, Material.DIAMOND_CHESTPLATE),
+    DIAMOND_LEGGINGS(6, 312, Material.DIAMOND_LEGGINGS),
+    DIAMOND_BOOTS(3, 313, Material.DIAMOND_BOOTS),
+    GOLD_HELMET(2, 314, Material.GOLD_HELMET),
+    GOLD_CHESTPLATE(5, 315, Material.GOLD_CHESTPLATE),
+    GOLD_LEGGINGS(3, 316, Material.GOLD_LEGGINGS),
+    GOLD_BOOTS(1, 317, Material.GOLD_BOOTS),
+    NONE(0, 0, Material.AIR);
+
+    private int armorpoints;
+    private int id;
+    private Material type;
+
+    ArmorType(int armor, int id, Material type) {
+        this.armorpoints = armor;
+        this.id = id;
+        this.type = type;
+    }
+
+    public int getArmorPoints() {
+        return this.armorpoints;
+    }
+
+    public int getId() {
+        return this.id;
+    }
+
+    public Material getType() {
+        return this.type;
+    }
+
+    public static ArmorType findByType(Material type) {
+        for(ArmorType a : ArmorType.values())
+            if(a.getType() == type)
+                return a;
+        return ArmorType.NONE;
+    }
+
+    public static int calculateArmorPoints(ItemStack[] armor) {
+        int total = 0;
+        for(int i = 0; i < armor.length; i++) {
+            if(armor[i] != null)
+                total += findByType(armor[i].getType()).getArmorPoints();
+        }
+        return total;
+    }
+
+    public static ArmorType findById(int id) {
+        for(ArmorType a : ArmorType.values())
+            if(a.getId() == id)
+                return a;
+        return ArmorType.NONE;
+    }
+
+    public static boolean isArmor(Material material){
+        for(ArmorType a : ArmorType.values())
+            if(a.getType() == material)
+                return true;
+        return false;
+    }
+
+    public static int calculateArmorPoints(int[] armor) {
+        int total = 0;
+        for(int i = 0; i < armor.length; i++) {
+            if(armor[i] != -1)
+                total += findById(armor[i]).getArmorPoints();
+        }
+        return total;
+    }
+
+}

src/main/java/us/myles/ViaVersion/commands/ViaVersionCommand.java

@@ -0,0 +1,59 @@
+package us.myles.ViaVersion.commands;
+
+import org.bukkit.Bukkit;
+import org.bukkit.command.Command;
+import org.bukkit.command.CommandExecutor;
+import org.bukkit.command.CommandSender;
+import org.bukkit.entity.Player;
+import us.myles.ViaVersion.ViaVersionPlugin;
+import us.myles.ViaVersion.api.ViaVersion;
+
+import java.util.ArrayList;
+import java.util.List;
+
+/**
+ * Created by fillefilip8 on 2016-03-03.
+ */
+public class ViaVersionCommand implements CommandExecutor {
+    private final ViaVersionPlugin plugin;
+
+    public ViaVersionCommand(ViaVersionPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public boolean onCommand(CommandSender sender, Command cmd, String label, String[] args) {
+        if (sender.hasPermission("viaversion.admin")) {
+            if (args.length == 0) {
+                sender.sendMessage(color("&aViaVersion &c" + ViaVersion.getInstance().getVersion()));
+                sender.sendMessage(color("&6Commands:"));
+                sender.sendMessage(color("&2/viaversion list &7- &6Shows lists of all 1.9 clients and 1.8 clients."));
+            } else if (args.length == 1) {
+                if (args[0].equalsIgnoreCase("list")) {
+                    List<String> portedPlayers = new ArrayList<String>();
+                    List<String> normalPlayers = new ArrayList<String>();
+                    for (Player p : Bukkit.getOnlinePlayers()) {
+                        if (ViaVersion.getInstance().isPorted(p)) {
+                            portedPlayers.add(p.getName());
+                        } else {
+                            normalPlayers.add(p.getName());
+                        }
+                    }
+
+                    sender.sendMessage(color("&8[&61.9&8]: &b" + portedPlayers.toString()));
+                    sender.sendMessage(color("&8[&61.8&8]: &b" + normalPlayers.toString()));
+                }
+                if (args[0].equalsIgnoreCase("debug")) {
+                    plugin.setDebug(!plugin.isDebug());
+                    sender.sendMessage(color("&6Debug mode is now " + (plugin.isDebug() ? "&aenabled" : "&cdisabled")));
+                }
+            }
+
+        }
+        return false;
+    }
+
+    public String color(String string) {
+        return string.replace("&", "§");
+    }
+}

src/main/java/us/myles/ViaVersion/handlers/ViaDecodeHandler.java

@@ -0,0 +1,51 @@
+package us.myles.ViaVersion.handlers;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import us.myles.ViaVersion.CancelException;
+import us.myles.ViaVersion.ConnectionInfo;
+import us.myles.ViaVersion.transformers.IncomingTransformer;
+import us.myles.ViaVersion.util.PacketUtil;
+
+import java.util.List;
+
+public class ViaDecodeHandler extends ByteToMessageDecoder {
+    private final IncomingTransformer incomingTransformer;
+    private final ByteToMessageDecoder minecraftDecoder;
+    private final ConnectionInfo info;
+
+    public ViaDecodeHandler(ConnectionInfo info, ByteToMessageDecoder minecraftDecoder) {
+        this.info = info;
+        this.minecraftDecoder = minecraftDecoder;
+        this.incomingTransformer = new IncomingTransformer(info);
+    }
+
+    @Override
+    protected void decode(ChannelHandlerContext ctx, ByteBuf bytebuf, List<Object> list) throws Exception {
+        // use transformers
+        if (bytebuf.readableBytes() > 0) {
+            if (info.isActive()) {
+                int id = PacketUtil.readVarInt(bytebuf);
+                // Transform
+                ByteBuf newPacket = ctx.alloc().buffer();
+                try {
+                    incomingTransformer.transform(id, bytebuf, newPacket);
+                    bytebuf.readBytes(bytebuf.readableBytes());
+                    bytebuf = newPacket;
+                } catch (CancelException e) {
+                    bytebuf.readBytes(bytebuf.readableBytes());
+                    throw e;
+                }
+            }
+            // call minecraft decoder
+            list.addAll(PacketUtil.callDecode(this.minecraftDecoder, ctx, bytebuf));
+        }
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        if (PacketUtil.containsCause(cause, CancelException.class)) return;
+        super.exceptionCaught(ctx, cause);
+    }
+}

src/main/java/us/myles/ViaVersion/handlers/ViaEncodeHandler.java

@@ -0,0 +1,77 @@
+package us.myles.ViaVersion.handlers;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToByteEncoder;
+import us.myles.ViaVersion.CancelException;
+import us.myles.ViaVersion.ConnectionInfo;
+import us.myles.ViaVersion.transformers.OutgoingTransformer;
+import us.myles.ViaVersion.util.PacketUtil;
+import us.myles.ViaVersion.util.ReflectionUtil;
+
+import java.lang.reflect.Constructor;
+
+public class ViaEncodeHandler extends MessageToByteEncoder {
+    private final ConnectionInfo info;
+    private final MessageToByteEncoder minecraftEncoder;
+    private final OutgoingTransformer outgoingTransformer;
+
+    public ViaEncodeHandler(ConnectionInfo info, MessageToByteEncoder minecraftEncoder) {
+        this.info = info;
+        this.minecraftEncoder = minecraftEncoder;
+        this.outgoingTransformer = new OutgoingTransformer(info);
+    }
+
+
+    @Override
+    protected void encode(ChannelHandlerContext ctx, Object o, ByteBuf bytebuf) throws Exception {
+        // handle the packet type
+        if (!(o instanceof ByteBuf)) {
+            info.setLastPacket(o);
+            /* This transformer is more for fixing issues which we find hard at packet level :) */
+            if (o.getClass().getName().endsWith("PacketPlayOutMapChunkBulk") && info.isActive()) {
+                int[] locX = ReflectionUtil.get(o, "a", int[].class);
+                int[] locZ = ReflectionUtil.get(o, "b", int[].class);
+
+                Object world = ReflectionUtil.get(o, "world", ReflectionUtil.nms("World"));
+                Class<?> mapChunk = ReflectionUtil.nms("PacketPlayOutMapChunk");
+                Constructor constructor = mapChunk.getDeclaredConstructor(ReflectionUtil.nms("Chunk"), boolean.class, int.class);
+                for (int i = 0; i < locX.length; i++) {
+                    int x = locX[i];
+                    int z = locZ[i];
+                    // world invoke function
+                    Object chunk = ReflectionUtil.nms("World").getDeclaredMethod("getChunkAt", int.class, int.class).invoke(world, x, z);
+                    Object packet = constructor.newInstance(chunk, true, 65535);
+                    ctx.pipeline().writeAndFlush(packet);
+                }
+                bytebuf.readBytes(bytebuf.readableBytes());
+                throw new CancelException();
+            }
+            // call minecraft encoder
+            PacketUtil.callEncode(this.minecraftEncoder, ctx, o, bytebuf);
+        }
+        if (bytebuf.readableBytes() == 0) {
+            throw new CancelException();
+        }
+        if (info.isActive()) {
+            int id = PacketUtil.readVarInt(bytebuf);
+            // Transform
+            ByteBuf oldPacket = bytebuf.copy();
+            bytebuf.clear();
+            try {
+                outgoingTransformer.transform(id, oldPacket, bytebuf);
+            } catch (CancelException e) {
+                bytebuf.readBytes(bytebuf.readableBytes());
+                throw e;
+            } finally {
+                oldPacket.release();
+            }
+        }
+    }
+
+    @Override
+    public void exceptionCaught(ChannelHandlerContext ctx, Throwable cause) throws Exception {
+        if (PacketUtil.containsCause(cause, CancelException.class)) return;
+        super.exceptionCaught(ctx, cause);
+    }
+}

src/main/java/us/myles/ViaVersion/handlers/ViaInboundHandler.java

@@ -1,53 +0,0 @@
-package us.myles.ViaVersion.handlers;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.Channel;
-import io.netty.channel.ChannelHandler;
-import io.netty.channel.ChannelHandlerContext;
-import io.netty.channel.ChannelInboundHandlerAdapter;
-import us.myles.ViaVersion.CancelException;
-import us.myles.ViaVersion.ConnectionInfo;
-import us.myles.ViaVersion.util.PacketUtil;
-import us.myles.ViaVersion.transformers.IncomingTransformer;
-
-@ChannelHandler.Sharable
-public class ViaInboundHandler extends ChannelInboundHandlerAdapter {
-    private final IncomingTransformer incomingTransformer;
-    private final ViaVersionInitializer init;
-
-    public ViaInboundHandler(Channel c, ConnectionInfo info, ViaVersionInitializer init) {
-        this.init = init;
-        this.incomingTransformer = new IncomingTransformer(c, info, init);
-    }
-
-    @Override
-    public void channelRead(ChannelHandlerContext ctx, Object msg) throws Exception {
-        boolean compression = ctx.pipeline().get("compress") != null;
-
-        if (msg instanceof ByteBuf) {
-            ByteBuf bytebuf = (ByteBuf) msg;
-            if (compression) {
-                // decompress :)
-                bytebuf = PacketUtil.decompress(ctx, bytebuf);
-            }
-            int id = PacketUtil.readVarInt(bytebuf);
-            // Transform
-            ByteBuf newPacket = ctx.alloc().buffer();
-            try {
-                incomingTransformer.transform(id, bytebuf, newPacket);
-            } catch (CancelException e) {
-                return;
-            } finally {
-                bytebuf.release();
-            }
-            if (compression) {
-                // recompress :)
-                newPacket = PacketUtil.compress(ctx, newPacket);
-            }
-            msg = newPacket;
-        }
-        super.channelRead(ctx, msg);
-    }
-
-
-}

src/main/java/us/myles/ViaVersion/handlers/ViaOutboundHandler.java

@@ -1,53 +0,0 @@
-package us.myles.ViaVersion.handlers;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.*;
-import us.myles.ViaVersion.CancelException;
-import us.myles.ViaVersion.ConnectionInfo;
-import us.myles.ViaVersion.util.PacketUtil;
-import us.myles.ViaVersion.transformers.OutgoingTransformer;
-
-@ChannelHandler.Sharable
-public class ViaOutboundHandler extends ChannelOutboundHandlerAdapter {
-    private final OutgoingTransformer outgoingTransformer;
-    private final ViaVersionInitializer init;
-
-    public ViaOutboundHandler(Channel c, ConnectionInfo info, ViaVersionInitializer init) {
-        this.init = init;
-        this.outgoingTransformer = new OutgoingTransformer(c, info, init);
-    }
-
-    @Override
-    public void write(ChannelHandlerContext ctx, Object msg, ChannelPromise channelPromise) throws Exception {
-        try {
-            if (channelPromise.isDone()) return; // don't break any <3s
-            boolean compression = ctx.pipeline().get("compress") != null;
-            if (msg instanceof ByteBuf) {
-                ByteBuf bytebuf = (ByteBuf) msg;
-                if (compression) {
-                    // decompress :)
-                    bytebuf = PacketUtil.decompress(ctx, bytebuf);
-                }
-                int id = PacketUtil.readVarInt(bytebuf);
-                // Transform
-                ByteBuf newPacket = ctx.alloc().buffer();
-                try {
-                    outgoingTransformer.transform(id, bytebuf, newPacket);
-                } catch (CancelException e) {
-                    return;
-                } finally {
-                    bytebuf.release();
-                }
-                if (compression) {
-                    // recompress :)
-                    newPacket = PacketUtil.compress(ctx, newPacket);
-                }
-                msg = newPacket;
-            }
-            super.write(ctx, msg, channelPromise);
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-    }
-
-}

src/main/java/us/myles/ViaVersion/handlers/ViaOutboundPacketHandler.java

@@ -1,43 +0,0 @@
-package us.myles.ViaVersion.handlers;
-
-import io.netty.buffer.ByteBuf;
-import io.netty.channel.*;
-import us.myles.ViaVersion.ConnectionInfo;
-import us.myles.ViaVersion.util.ReflectionUtil;
-
-import java.lang.reflect.Constructor;
-
-@ChannelHandler.Sharable
-public class ViaOutboundPacketHandler extends ChannelOutboundHandlerAdapter {
-    private final ConnectionInfo info;
-
-    public ViaOutboundPacketHandler(Channel c, ConnectionInfo info) {
-        this.info = info;
-    }
-
-    @Override
-    public void write(ChannelHandlerContext channelHandlerContext, Object o, ChannelPromise channelPromise) throws Exception {
-        if (!(o instanceof ByteBuf)) {
-            info.setLastPacket(o);
-            /* This transformer is more for fixing issues which we find hard at byte level :) */
-            if (o.getClass().getName().endsWith("PacketPlayOutMapChunkBulk")) {
-                int[] locX = ReflectionUtil.get(o, "a", int[].class);
-                int[] locZ = ReflectionUtil.get(o, "b", int[].class);
-
-                Object world = ReflectionUtil.get(o, "world", ReflectionUtil.nms("World"));
-                Class<?> mapChunk = ReflectionUtil.nms("PacketPlayOutMapChunk");
-                Constructor constructor = mapChunk.getDeclaredConstructor(ReflectionUtil.nms("Chunk"), boolean.class, int.class);
-                for (int i = 0; i < locX.length; i++) {
-                    int x = locX[i];
-                    int z = locZ[i];
-                    // world invoke function
-                    Object chunk = ReflectionUtil.nms("World").getDeclaredMethod("getChunkAt", int.class, int.class).invoke(world, x, z);
-                    Object packet = constructor.newInstance(chunk, true, 65535);
-                    channelHandlerContext.write(packet);
-                }
-                return;
-            }
-        }
-        super.write(channelHandlerContext, o, channelPromise);
-    }
-}

src/main/java/us/myles/ViaVersion/handlers/ViaVersionInitializer.java

@@ -3,6 +3,8 @@ package us.myles.ViaVersion.handlers;
 import io.netty.channel.Channel;
 import io.netty.channel.ChannelInitializer;
 import io.netty.channel.socket.SocketChannel;
+import io.netty.handler.codec.ByteToMessageDecoder;
+import io.netty.handler.codec.MessageToByteEncoder;
 import us.myles.ViaVersion.ConnectionInfo;
 
 import java.lang.reflect.Method;
@@ -10,11 +12,6 @@ import java.lang.reflect.Method;
 public class ViaVersionInitializer extends ChannelInitializer<SocketChannel> {
     private final ChannelInitializer<SocketChannel> oldInit;
     private Method method;
-    private ConnectionInfo info;
-    private ViaInboundHandler inbound;
-    private ViaOutboundHandler outbound;
-    private SocketChannel socketChannel;
-    private ViaOutboundPacketHandler outbound2;
 
     public ViaVersionInitializer(ChannelInitializer<SocketChannel> oldInit) {
         this.oldInit = oldInit;
@@ -28,24 +25,14 @@ public class ViaVersionInitializer extends ChannelInitializer<SocketChannel> {
 
     @Override
     protected void initChannel(SocketChannel socketChannel) throws Exception {
-        info = new ConnectionInfo();
+        ConnectionInfo info = new ConnectionInfo(socketChannel);
         // Add originals
         this.method.invoke(this.oldInit, socketChannel);
         // Add our transformers
-        this.socketChannel = socketChannel;
-        this.inbound = new ViaInboundHandler(socketChannel, info, this);
-        this.outbound = new ViaOutboundHandler(socketChannel, info, this);
-        this.outbound2 = new ViaOutboundPacketHandler(socketChannel, info);
-        socketChannel.pipeline().addBefore("decoder", "via_incoming", this.inbound);
-        socketChannel.pipeline().addBefore("packet_handler", "via_outgoing2", this.outbound2);
-        socketChannel.pipeline().addBefore("encoder", "via_outgoing", this.outbound);
+        ViaEncodeHandler encoder = new ViaEncodeHandler(info, (MessageToByteEncoder) socketChannel.pipeline().get("encoder"));
+        ViaDecodeHandler decoder = new ViaDecodeHandler(info, (ByteToMessageDecoder) socketChannel.pipeline().get("decoder"));
 
+        socketChannel.pipeline().replace("encoder", "encoder", encoder);
+        socketChannel.pipeline().replace("decoder", "decoder", decoder);
     }
-
-    public void remove(){
-        socketChannel.pipeline().remove("via_incoming");
-        socketChannel.pipeline().remove("via_outgoing");
-        socketChannel.pipeline().remove("via_outgoing2");
-    }
-
 }

src/main/java/us/myles/ViaVersion/listeners/CommandBlockListener.java

@@ -0,0 +1,63 @@
+package us.myles.ViaVersion.listeners;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.bukkit.block.Block;
+import org.bukkit.block.CommandBlock;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.block.Action;
+import org.bukkit.event.player.PlayerInteractEvent;
+import org.bukkit.event.player.PlayerJoinEvent;
+import us.myles.ViaVersion.ViaVersionPlugin;
+import us.myles.ViaVersion.packets.PacketType;
+import us.myles.ViaVersion.util.PacketUtil;
+import us.myles.ViaVersion.util.ReflectionUtil;
+
+import java.lang.reflect.InvocationTargetException;
+import java.lang.reflect.Method;
+
+public class CommandBlockListener implements Listener {
+    private final ViaVersionPlugin plugin;
+
+    public CommandBlockListener(ViaVersionPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @EventHandler(ignoreCancelled = true, priority = EventPriority.MONITOR)
+    public void onJoin(final PlayerJoinEvent e) {
+        if (e.getPlayer().isOp() && plugin.isPorted(e.getPlayer())) {
+            ByteBuf buf = Unpooled.buffer();
+            PacketUtil.writeVarInt(PacketType.PLAY_ENTITY_STATUS.getNewPacketID(), buf);
+            buf.writeInt(e.getPlayer().getEntityId());
+            buf.writeByte(26);
+            plugin.sendRawPacket(e.getPlayer(), buf);
+        }
+    }
+
+    @EventHandler(ignoreCancelled = true)
+    public void onInteract(PlayerInteractEvent e) {
+        if (e.getAction() == Action.RIGHT_CLICK_BLOCK && plugin.isPorted(e.getPlayer()) && e.getPlayer().isOp()) {
+            try {
+                sendCommandBlockPacket(e.getClickedBlock(), e.getPlayer());
+            } catch (NoSuchFieldException | IllegalAccessException | InvocationTargetException | NoSuchMethodException | ClassNotFoundException e1) {
+                e1.printStackTrace();
+            }
+        }
+    }
+
+    private void sendCommandBlockPacket(Block b, Player player) throws NoSuchFieldException, IllegalAccessException, NoSuchMethodException, InvocationTargetException, ClassNotFoundException {
+        if (!(b.getState() instanceof CommandBlock))
+            return;
+        CommandBlock cmd = (CommandBlock) b.getState();
+
+        Object tileEntityCommand = ReflectionUtil.get(cmd, "commandBlock", ReflectionUtil.nms("TileEntityCommand"));
+        Object updatePacket = ReflectionUtil.invoke(tileEntityCommand, "getUpdatePacket");
+        Object nmsPlayer = ReflectionUtil.invoke(player, "getHandle");
+        Object playerConnection = ReflectionUtil.get(nmsPlayer, "playerConnection", ReflectionUtil.nms("PlayerConnection"));
+        Method sendPacket = playerConnection.getClass().getMethod("sendPacket", ReflectionUtil.nms("Packet"));
+        sendPacket.invoke(playerConnection, updatePacket); //Let the transformer do the work
+    }
+}

src/main/java/us/myles/ViaVersion/metadata/MetaIndex.java

@@ -1,6 +1,7 @@
 package us.myles.ViaVersion.metadata;
 
 import org.bukkit.entity.*;
+import org.bukkit.entity.minecart.CommandMinecart;
 
 public enum MetaIndex {
 
@@ -27,10 +28,10 @@ public enum MetaIndex {
     STAND_LL_POS(ArmorStand.class, 15, Type.Rotation, NewType.Vector3F),
     STAND_RL_POS(ArmorStand.class, 16, Type.Rotation, NewType.Vector3F),
     // human, discountined?
-    PLAYER_SKIN_FLAGS(HumanEntity.class, 10, Type.Byte, NewType.Discontinued), // unsigned on 1.8
+    PLAYER_SKIN_FLAGS(HumanEntity.class, 10, Type.Byte, 12, NewType.Byte), // unsigned on 1.8
     PLAYER_HUMAN_BYTE(HumanEntity.class, 16, Type.Byte, NewType.Discontinued), // unused on 1.8
-    PLAYER_ADDITIONAL_HEARTS(HumanEntity.class, 17, Type.Float, NewType.Discontinued),
-    PLAYER_SCORE(HumanEntity.class, 18, Type.Int, NewType.Discontinued),
+    PLAYER_ADDITIONAL_HEARTS(HumanEntity.class, 17, Type.Float, 10, NewType.Float),
+    PLAYER_SCORE(HumanEntity.class, 18, Type.Int, 11, NewType.VarInt),
     // horse
     HORSE_INFO(Horse.class, 16, Type.Int, 12, NewType.Byte),
     HORSE_TYPE(Horse.class, 19, Type.Byte, 13, NewType.VarInt),
@@ -88,6 +89,8 @@ public enum MetaIndex {
     WITHER_TARGET2(Wither.class, 18, Type.Int, 12, NewType.VarInt),
     WITHER_TARGET3(Wither.class, 19, Type.Int, 13, NewType.VarInt),
     WITHER_INVULN_TIME(Wither.class, 20, Type.Int, 14, NewType.VarInt),
+    // wither skull
+    WITHERSKULL_INVULN(WitherSkull.class, 10, Type.Byte, 5, NewType.Boolean),
     // guardian
     GUARDIAN_INFO(Guardian.class, 16, Type.Int, 11, NewType.Byte),
     GUARDIAN_TARGET(Guardian.class, 17, Type.Int, 12, NewType.VarInt),
@@ -103,6 +106,9 @@ public enum MetaIndex {
     MINECART_BLOCK(Minecart.class, 20, Type.Int, 8, NewType.VarInt),
     MINECART_BLOCK_Y(Minecart.class, 21, Type.Int, 9, NewType.VarInt),
     MINECART_SHOWBLOCK(Minecart.class, 22, Type.Byte, 10, NewType.Boolean),
+    // Command minecart (they are still broken)
+    MINECART_COMMANDBLOCK_COMMAND(CommandMinecart.class,23,Type.String,11,NewType.String),
+    MINECART_COMMANDBLOCK_OUTPUT(CommandMinecart.class,24,Type.String,12,NewType.Chat),
     // furnace cart
     FURNACECART_ISPOWERED(org.bukkit.entity.minecart.PoweredMinecart.class, 16, Type.Byte, 11, NewType.Boolean),
     // item drop

src/main/java/us/myles/ViaVersion/metadata/MetadataRewriter.java

@@ -0,0 +1,197 @@
+package us.myles.ViaVersion.metadata;
+
+import java.util.ArrayList;
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
+
+import org.bukkit.entity.EntityType;
+import org.bukkit.util.EulerAngle;
+import org.bukkit.util.Vector;
+
+import io.netty.buffer.ByteBuf;
+
+import us.myles.ViaVersion.slot.ItemSlotRewriter;
+import us.myles.ViaVersion.slot.ItemSlotRewriter.ItemStack;
+import us.myles.ViaVersion.util.PacketUtil;
+
+public class MetadataRewriter {
+
+    public static void writeMetadata1_9(EntityType type, List<Entry> list, ByteBuf output) {
+        short id = -1;
+        int data = -1;
+        Iterator<Entry> iterator = list.iterator();
+        while (iterator.hasNext()) {
+            Entry entry = iterator.next(); //
+            MetaIndex metaIndex = entry.index;
+            try {
+                if (metaIndex.getNewType() != NewType.Discontinued) {
+                    if (metaIndex.getNewType() != NewType.BlockID || id != -1 && data == -1 || id == -1 && data != -1) { // block ID is only written if we have both parts
+                        output.writeByte(metaIndex.getNewIndex());
+                        output.writeByte(metaIndex.getNewType().getTypeID());
+                    }
+                    Object value = entry.value;
+                    switch (metaIndex.getNewType()) {
+                        case Byte:
+                            // convert from int, byte
+                            if (metaIndex.getOldType() == Type.Byte) {
+                                output.writeByte(((Byte) value).byteValue());
+                            }
+                            if (metaIndex.getOldType() == Type.Int) {
+                                output.writeByte(((Integer) value).byteValue());
+                            }
+                            break;
+                        case OptUUID:
+                            String owner = (String) value;
+                            UUID toWrite = null;
+                            if (owner.length() != 0) {
+                                try {
+                                    toWrite = UUID.fromString(owner);
+                                } catch (Exception ignored) {
+                                }
+                            }
+                            output.writeBoolean(toWrite != null);
+                            if (toWrite != null)
+                                PacketUtil.writeUUID((UUID) toWrite, output);
+                            break;
+                        case BlockID:
+                            // if we have both sources :))
+                            if (metaIndex.getOldType() == Type.Byte) {
+                                data = ((Byte) value).byteValue();
+                            }
+                            if (metaIndex.getOldType() == Type.Short) {
+                                id = ((Short) value).shortValue();
+                            }
+                            if (id != -1 && data != -1) {
+                                int combined = id << 4 | data;
+                                data = -1;
+                                id = -1;
+                                PacketUtil.writeVarInt(combined, output);
+                            }
+                            break;
+                        case VarInt:
+                            // convert from int, short, byte
+                            if (metaIndex.getOldType() == Type.Byte) {
+                                PacketUtil.writeVarInt(((Byte) value).intValue(), output);
+                            }
+                            if (metaIndex.getOldType() == Type.Short) {
+                                PacketUtil.writeVarInt(((Short) value).intValue(), output);
+                            }
+                            if (metaIndex.getOldType() == Type.Int) {
+                                PacketUtil.writeVarInt(((Integer) value).intValue(), output);
+                            }
+                            break;
+                        case Float:
+                            output.writeFloat(((Float) value).floatValue());
+                            break;
+                        case String:
+                            PacketUtil.writeString((String) value, output);
+                            break;
+                        case Boolean:
+                            if(metaIndex == MetaIndex.AGEABLE_AGE)
+                                output.writeBoolean(((Byte) value).byteValue() < 0);
+                            else
+                                output.writeBoolean(((Byte) value).byteValue() != 0);
+                            break;
+                        case Slot:
+                            ItemStack item = (ItemStack) value;
+                            ItemSlotRewriter.fixIdsFrom1_8To1_9(item);
+                            ItemSlotRewriter.writeItemStack(item, output);
+                            break;
+                        case Position:
+                            Vector vector = (Vector) value;
+                            output.writeInt((int) vector.getX());
+                            output.writeInt((int) vector.getY());
+                            output.writeInt((int) vector.getZ());
+                            break;
+                        case Vector3F:
+                            EulerAngle angle = (EulerAngle) value;
+                            output.writeFloat((float) angle.getX());
+                            output.writeFloat((float) angle.getY());
+                            output.writeFloat((float) angle.getZ());
+                            break;
+                        default:
+                            System.out.println("[Out] Unhandled MetaDataType: " + metaIndex.getNewType());
+                            break;
+                    }
+                }
+            } catch (Exception e) {
+                if (type != null) {
+                    System.out.println("An error occurred with entity meta data for " + type + " OldID: " + entry.oldID);
+                    if (metaIndex != null) {
+                        System.out.println("Old ID: " + metaIndex.getIndex() + " New ID: " + metaIndex.getNewIndex());
+                        System.out.println("Old Type: " + metaIndex.getOldType() + " New Type: " + metaIndex.getNewType());
+                    }
+                }
+                e.printStackTrace();
+            }
+        }
+        output.writeByte(255);
+    }
+
+    public static List<Entry> readMetadata1_8(EntityType entityType, ByteBuf buf) {
+        List<Entry> entries = new ArrayList<>();
+        byte item;
+        while ((item = buf.readByte()) != 127) {
+            Type type = Type.byId((item & 0xE0) >> 5);
+            int id = item & 0x1F;
+            MetaIndex index = MetaIndex.getIndex(entityType, id);
+            switch (type) {
+                case Byte:
+                    entries.add(new Entry(index, buf.readByte(), id));
+                    break;
+                case Short:
+                    entries.add(new Entry(index, buf.readShort(), id));
+                    break;
+                case Int:
+                    entries.add(new Entry(index, buf.readInt(), id));
+                    break;
+                case Float:
+                    entries.add(new Entry(index, buf.readFloat(), id));
+                    break;
+                case String:
+                    entries.add(new Entry(index, PacketUtil.readString(buf), id));
+                    break;
+                case Slot: {
+                    try {
+                        entries.add(new Entry(index, ItemSlotRewriter.readItemStack(buf), id));
+                    } catch (Exception e) {
+                        e.printStackTrace();
+                    }
+                }
+                    break;
+                case Position: {
+                    int x = buf.readInt();
+                    int y = buf.readInt();
+                    int z = buf.readInt();
+                    entries.add(new Entry(index, new Vector(x, y, z), id));
+                    break;
+                }
+                case Rotation: {
+                    float x = buf.readFloat();
+                    float y = buf.readFloat();
+                    float z = buf.readFloat();
+                    entries.add(new Entry(index, new EulerAngle(x, y, z), id));
+                    break;
+                }
+                default:
+                    System.out.println("[Out] Unhandled MetaDataType: " + type);
+                    break;
+            }
+        }
+        return entries;
+    }
+
+    public static class Entry {
+
+        private final int oldID;
+        private MetaIndex index;
+        private Object value;
+
+        private Entry(MetaIndex index, Object value, int id) {
+            this.index = index;
+            this.value = value;
+            this.oldID = id;
+        }
+    }
+}

src/main/java/us/myles/ViaVersion/metadata/Type.java

@@ -18,4 +18,8 @@ public enum Type {
     public int getTypeID() {
         return typeID;
     }
+
+    public static Type byId(int id) {
+        return values()[id];
+    }
 }

src/main/java/us/myles/ViaVersion/packets/PacketType.java

@@ -96,7 +96,7 @@ public enum PacketType {
     PLAY_COMBAT_EVENT(State.PLAY, Direction.OUTGOING, 0x42, 0x2C),
     PLAY_PLAYER_LIST_ITEM(State.PLAY, Direction.OUTGOING, 0x38, 0x2D),
     PLAY_PLAYER_POSITION_LOOK(State.PLAY, Direction.OUTGOING, 0x08, 0x2E),
-    PLAY_USE_BED(State.PLAY, Direction.OUTGOING, 0x2F, 0x2F),
+    PLAY_USE_BED(State.PLAY, Direction.OUTGOING, 0x0A, 0x2F),
     PLAY_DESTROY_ENTITIES(State.PLAY, Direction.OUTGOING, 0x13, 0x30),
     PLAY_REMOVE_ENTITY_EFFECT(State.PLAY, Direction.OUTGOING, 0x1E, 0x31),
     PLAY_RESOURCE_PACK_SEND(State.PLAY, Direction.OUTGOING, 0x48, 0x32),
@@ -170,7 +170,7 @@ public enum PacketType {
     	if(id == -1)
     		return null;
         for (PacketType pt : values()) {
-            if (pt.getNewPacketID() == id && id != -1
+            if (pt.getNewPacketID() == id
                     && pt.getState() == state
                     && pt.getDirection() == direction)
                 return pt;
@@ -182,7 +182,7 @@ public enum PacketType {
     	if(id == -1)
     		return null;
         for (PacketType pt : values()) {
-            if (pt.getPacketID() == id && id != -1
+            if (pt.getPacketID() == id
                     && pt.getState() == state
                     && pt.getDirection() == direction)
                 return pt;

src/main/java/us/myles/ViaVersion/slot/ItemSlotRewriter.java

@@ -0,0 +1,322 @@
+package us.myles.ViaVersion.slot;
+
+import io.netty.buffer.ByteBuf;
+import org.bukkit.Material;
+import org.spacehq.opennbt.tag.builtin.CompoundTag;
+import org.spacehq.opennbt.tag.builtin.ListTag;
+import org.spacehq.opennbt.tag.builtin.StringTag;
+import org.spacehq.opennbt.tag.builtin.Tag;
+import us.myles.ViaVersion.CancelException;
+import us.myles.ViaVersion.transformers.OutgoingTransformer;
+import us.myles.ViaVersion.util.PacketUtil;
+
+import java.io.IOException;
+import java.util.Collections;
+import java.util.HashMap;
+import java.util.Map;
+
+public class ItemSlotRewriter {
+
+    public static void rewrite1_9To1_8(ByteBuf input, ByteBuf output) throws CancelException {
+        try {
+            ItemStack item = readItemStack(input);
+            fixIdsFrom1_9To1_8(item);
+            writeItemStack(item, output);
+        } catch (Exception e) {
+            System.out.println("Error while rewriting an item slot.");
+            e.printStackTrace();
+            throw new CancelException();
+        }
+    }
+
+    public static void rewrite1_8To1_9(ByteBuf input, ByteBuf output) throws CancelException {
+        try {
+            ItemStack item = readItemStack(input);
+            fixIdsFrom1_8To1_9(item);
+            writeItemStack(item, output);
+        } catch (Exception e) {
+            System.out.println("Error while rewriting an item slot.");
+            e.printStackTrace();
+            throw new CancelException();
+        }
+    }
+
+    public static void fixIdsFrom1_9To1_8(ItemStack item) {
+        if (item != null) {
+            if (item.id == Material.MONSTER_EGG.getId() && item.data == 0) {
+                CompoundTag tag = item.tag;
+                int data = 0;
+                if (tag != null && tag.get("EntityTag") instanceof CompoundTag) {
+                    CompoundTag entityTag = tag.get("EntityTag");
+                    if (entityTag.get("id") instanceof StringTag) {
+                        StringTag id = entityTag.get("id");
+                        if (ENTTIY_NAME_TO_ID.containsKey(id.getValue()))
+                            data = ENTTIY_NAME_TO_ID.get(id.getValue());
+                    }
+                }
+                item.tag = null;
+                item.data = (short) data;
+            }
+            if (item.id == Material.POTION.getId()) {
+                CompoundTag tag = item.tag;
+                int data = 0;
+                if (tag != null && tag.get("Potion") instanceof StringTag) {
+                    StringTag potion = tag.get("Potion");
+                    String potionName = potion.getValue().replace("minecraft:", "");
+                    if (POTION_NAME_TO_ID.containsKey(potionName)) {
+                        data = POTION_NAME_TO_ID.get(potionName);
+                    }
+                }
+                item.tag = null;
+                item.data = (short) data;
+            }
+            if (item.id == 438) {
+                CompoundTag tag = item.tag;
+                int data = 0;
+                item.id = (short) Material.POTION.getId();
+                if (tag != null && tag.get("Potion") instanceof StringTag) {
+                    StringTag potion = tag.get("Potion");
+                    String potionName = potion.getValue().replace("minecraft:", "");
+                    if (POTION_NAME_TO_ID.containsKey(potionName)) {
+                        data = POTION_NAME_TO_ID.get(potionName) + 8192;
+                    }
+                }
+                item.tag = null;
+                item.data = (short) data;
+            }
+        }
+    }
+
+    public static void fixIdsFrom1_8To1_9(ItemStack item) {
+        if (item != null) {
+            if (item.id == Material.MONSTER_EGG.getId() && item.data != 0) {
+                CompoundTag tag = item.tag;
+                if (tag == null) {
+                    tag = new CompoundTag("tag");
+                }
+                CompoundTag entityTag = new CompoundTag("EntityTag");
+                if (ENTTIY_ID_TO_NAME.containsKey(Integer.valueOf(item.data))) {
+                    StringTag id = new StringTag("id", ENTTIY_ID_TO_NAME.get(Integer.valueOf(item.data)));
+                    entityTag.put(id);
+                    tag.put(entityTag);
+                }
+                item.tag = tag;
+                item.data = 0;
+            }
+            if (item.id == Material.POTION.getId()) {
+                CompoundTag tag = item.tag;
+                if (tag == null) {
+                    tag = new CompoundTag("tag");
+                }
+                if (item.data >= 16384) {
+                    item.id = 438; // splash id
+                    item.data = (short) (item.data - 8192);
+                }
+                if (POTION_ID_TO_NAME.containsKey(Integer.valueOf(item.data))) {
+                    String name = POTION_ID_TO_NAME.get(Integer.valueOf(item.data));
+                    StringTag potion = new StringTag("Potion", "minecraft:" + name);
+                    tag.put(potion);
+                }
+                item.tag = tag;
+                item.data = 0;
+            }
+            if (item.id == Material.WRITTEN_BOOK.getId()) {
+                CompoundTag tag = item.tag;
+                if (tag == null) {
+                    tag = new CompoundTag("tag");
+                }
+                ListTag pages = tag.get("pages");
+                if (pages == null) {
+                    pages = new ListTag("pages", Collections.<Tag>singletonList(new StringTag(OutgoingTransformer.fixJson(""))));
+                    tag.put(pages);
+                    item.tag = tag;
+                    return;
+                }
+
+                for (int i = 0; i < pages.size(); i++) {
+                    if (!(pages.get(i) instanceof StringTag))
+                        continue;
+                    StringTag page = pages.get(i);
+                    page.setValue(OutgoingTransformer.fixJson(page.getValue()));
+                }
+                item.tag = tag;
+            }
+        }
+    }
+
+    public static ItemStack readItemStack(ByteBuf input) throws IOException {
+        short id = input.readShort();
+        if (id < 0) {
+
+            return null;
+        } else {
+            ItemStack item = new ItemStack();
+            item.id = id;
+            item.amount = input.readByte();
+            item.data = input.readShort();
+            item.tag = PacketUtil.readNBT(input);
+            return item;
+        }
+    }
+
+    public static void writeItemStack(ItemStack item, ByteBuf output) throws IOException {
+        if (item == null) {
+            output.writeShort(-1);
+        } else {
+            output.writeShort(item.id);
+            output.writeByte(item.amount);
+            output.writeShort(item.data);
+            PacketUtil.writeNBT(output, item.tag);
+        }
+    }
+
+    public static class ItemStack {
+
+        public short id;
+        public byte amount;
+        public short data;
+        public CompoundTag tag;
+
+        public static ItemStack fromBukkit(org.bukkit.inventory.ItemStack stack) {
+            ItemStack item = new ItemStack();
+            item.id = (short) stack.getTypeId();
+            item.amount = (byte) stack.getAmount();
+            item.data = stack.getData().getData();
+            // TODO: nbt
+            return item;
+        }
+    }
+
+    private static Map<String, Integer> ENTTIY_NAME_TO_ID = new HashMap<>();
+    private static Map<Integer, String> ENTTIY_ID_TO_NAME = new HashMap<>();
+
+    private static Map<String, Integer> POTION_NAME_TO_ID = new HashMap<>();
+    private static Map<Integer, String> POTION_ID_TO_NAME = new HashMap<>();
+
+    static {
+        /* Entities */
+        registerEntity(1, "Item");
+        registerEntity(2, "XPOrb");
+        registerEntity(7, "ThrownEgg");
+        registerEntity(8, "LeashKnot");
+        registerEntity(9, "Painting");
+        registerEntity(10, "Arrow");
+        registerEntity(11, "Snowball");
+        registerEntity(12, "Fireball");
+        registerEntity(13, "SmallFireball");
+        registerEntity(14, "ThrownEnderpearl");
+        registerEntity(15, "EyeOfEnderSignal");
+        registerEntity(16, "ThrownPotion");
+        registerEntity(17, "ThrownExpBottle");
+        registerEntity(18, "ItemFrame");
+        registerEntity(19, "WitherSkull");
+        registerEntity(20, "PrimedTnt");
+        registerEntity(21, "FallingSand");
+        registerEntity(22, "FireworksRocketEntity");
+        registerEntity(30, "ArmorStand");
+        registerEntity(40, "MinecartCommandBlock");
+        registerEntity(41, "Boat");
+        registerEntity(42, "MinecartRideable");
+        registerEntity(43, "MinecartChest");
+        registerEntity(44, "MinecartFurnace");
+        registerEntity(45, "MinecartTNT");
+        registerEntity(46, "MinecartHopper");
+        registerEntity(47, "MinecartSpawner");
+        registerEntity(48, "Mob");
+        registerEntity(49, "Monster");
+        registerEntity(50, "Creeper");
+        registerEntity(51, "Skeleton");
+        registerEntity(52, "Spider");
+        registerEntity(53, "Giant");
+        registerEntity(54, "Zombie");
+        registerEntity(55, "Slime");
+        registerEntity(56, "Ghast");
+        registerEntity(57, "PigZombie");
+        registerEntity(58, "Enderman");
+        registerEntity(59, "CaveSpider");
+        registerEntity(60, "Silverfish");
+        registerEntity(61, "Blaze");
+        registerEntity(62, "LavaSlime");
+        registerEntity(63, "EnderDragon");
+        registerEntity(64, "WitherBoss");
+        registerEntity(65, "Bat");
+        registerEntity(66, "Witch");
+        registerEntity(67, "Endermite");
+        registerEntity(68, "Guardian");
+        registerEntity(90, "Pig");
+        registerEntity(91, "Sheep");
+        registerEntity(92, "Cow");
+        registerEntity(93, "Chicken");
+        registerEntity(94, "Squid");
+        registerEntity(95, "Wolf");
+        registerEntity(96, "MushroomCow");
+        registerEntity(97, "SnowMan");
+        registerEntity(98, "Ozelot");
+        registerEntity(99, "VillagerGolem");
+        registerEntity(100, "EntityHorse");
+        registerEntity(101, "Rabbit");
+        registerEntity(120, "Villager");
+        registerEntity(200, "EnderCrystal");
+
+        /* Potions */
+        registerPotion(0, "water");
+        registerPotion(64, "mundane");
+        registerPotion(32, "thick");
+        registerPotion(16, "awkward");
+
+        registerPotion(8198, "night_vision");
+        registerPotion(8262, "long_night_vision");
+
+        registerPotion(8206, "invisibility");
+        registerPotion(8270, "long_invisibility");
+
+        registerPotion(8203, "leaping");
+        registerPotion(8267, "long_leaping");
+        registerPotion(8235, "strong_leaping");
+
+        registerPotion(8195, "fire_resistance");
+        registerPotion(8259, "long_fire_resistance");
+
+        registerPotion(8194, "swiftness");
+        registerPotion(8258, "long_swiftness");
+        registerPotion(8226, "strong_swiftness");
+
+        registerPotion(8202, "slowness");
+        registerPotion(8266, "long_slowness");
+
+        registerPotion(8205, "water_breathing");
+        registerPotion(8269, "long_water_breathing");
+
+        registerPotion(8197, "healing");
+        registerPotion(8229, "strong_healing");
+
+        registerPotion(8204, "harming");
+        registerPotion(8236, "strong_harming");
+
+        registerPotion(8196, "poison");
+        registerPotion(8260, "long_poison");
+        registerPotion(8228, "strong_poison");
+
+        registerPotion(8193, "regeneration");
+        registerPotion(8257, "long_regeneration");
+        registerPotion(8225, "strong_regeneration");
+
+        registerPotion(8201, "strength");
+        registerPotion(8265, "long_strength");
+        registerPotion(8233, "strong_strength");
+
+        registerPotion(8200, "weakness");
+        registerPotion(8264, "long_weakness");
+
+    }
+
+    private static void registerEntity(Integer id, String name) {
+        ENTTIY_ID_TO_NAME.put(id, name);
+        ENTTIY_NAME_TO_ID.put(name, id);
+    }
+
+    private static void registerPotion(Integer id, String name) {
+        POTION_ID_TO_NAME.put(id, name);
+        POTION_NAME_TO_ID.put(name, id);
+    }
+}

src/main/java/us/myles/ViaVersion/sounds/SoundEffect.java

@@ -198,7 +198,7 @@ public enum SoundEffect {
     MOB_ENDERMEN_SCREAM("mob.endermen.scream", "entity.endermen.scream", SoundCategory.HOSTILE),
     MOB_CAT_HITT("mob.cat.hitt", "entity.cat.hurt", SoundCategory.NEUTRAL),
     MOB_MAGMACUBE_SMALL("mob.magmacube.small", "entity.small_magmacube.squish", SoundCategory.HOSTILE),
-    FIRE_IGNITE("fire.ignite", "item.flintandsteel.use", SoundCategory.BLOCK),
+    FIRE_IGNITE("fire.ignite", "item.flintandsteel.use", SoundCategory.BLOCK, true),
     MOB_ENDERDRAGON_HIT("mob.enderdragon.hit", "entity.enderdragon.hurt", SoundCategory.HOSTILE),
     MOB_ZOMBIE_HURT("mob.zombie.hurt", "entity.zombie_villager.hurt", SoundCategory.HOSTILE),
     RANDOM_EXPLODE("random.explode", "block.end_gateway.spawn", SoundCategory.BLOCK),
@@ -252,11 +252,20 @@ public enum SoundEffect {
     private String name;
     private String newname;
     private SoundCategory cat;
+    private boolean breaksound;
 
     SoundEffect(String name, String newname, SoundCategory cat) {
         this.cat = cat;
         this.newname = newname;
         this.name = name;
+        this.breaksound = name.startsWith("dig.");
+    }
+    
+    SoundEffect(String name, String newname, SoundCategory cat, boolean shouldIgnore) {
+        this.cat = cat;
+        this.newname = newname;
+        this.name = name;
+        this.breaksound = name.startsWith("dig.") || shouldIgnore;
     }
 
     public static SoundEffect getByName(String name) {
@@ -279,5 +288,9 @@ public enum SoundEffect {
     public SoundCategory getCategory() {
         return cat;
     }
+    
+    public boolean isBreakPlaceSound() {
+    	return breaksound;
+    }
 
 }

src/main/java/us/myles/ViaVersion/transformers/IncomingTransformer.java

@@ -1,27 +1,28 @@
 package us.myles.ViaVersion.transformers;
 
 import io.netty.buffer.ByteBuf;
-import io.netty.channel.Channel;
+import io.netty.buffer.Unpooled;
+import org.bukkit.Material;
 import org.bukkit.inventory.ItemStack;
-import us.myles.ViaVersion.*;
-import us.myles.ViaVersion.handlers.ViaVersionInitializer;
+import us.myles.ViaVersion.CancelException;
+import us.myles.ViaVersion.ConnectionInfo;
+import us.myles.ViaVersion.ViaVersionPlugin;
+import us.myles.ViaVersion.api.ViaVersion;
 import us.myles.ViaVersion.packets.PacketType;
 import us.myles.ViaVersion.packets.State;
+import us.myles.ViaVersion.slot.ItemSlotRewriter;
 import us.myles.ViaVersion.util.PacketUtil;
 import us.myles.ViaVersion.util.ReflectionUtil;
 
+import java.io.IOException;
+import java.lang.reflect.Constructor;
 import java.lang.reflect.InvocationTargetException;
-import java.lang.reflect.Method;
 
 public class IncomingTransformer {
-    private final Channel channel;
     private final ConnectionInfo info;
-    private final ViaVersionInitializer init;
 
-    public IncomingTransformer(Channel channel, ConnectionInfo info, ViaVersionInitializer init) {
-        this.channel = channel;
+    public IncomingTransformer(ConnectionInfo info) {
         this.info = info;
-        this.init = init;
     }
 
     public void transform(int packetID, ByteBuf input, ByteBuf output) throws CancelException {
@@ -35,9 +36,11 @@ public class IncomingTransformer {
         if (packet.getPacketID() != -1) {
             packetID = packet.getPacketID();
         }
-//        if (packet != PacketType.PLAY_PLAYER_POSITION_LOOK_REQUEST && packet != PacketType.PLAY_KEEP_ALIVE_REQUEST && packet != PacketType.PLAY_PLAYER_POSITION_REQUEST && packet != PacketType.PLAY_PLAYER_LOOK_REQUEST) {
-//            System.out.println("Packet Type: " + packet + " New ID: " + packetID + " Original: " + original);
-//        }
+        if (ViaVersion.getInstance().isDebug()) {
+            if (packet != PacketType.PLAY_PLAYER_POSITION_LOOK_REQUEST && packet != PacketType.PLAY_KEEP_ALIVE_REQUEST && packet != PacketType.PLAY_PLAYER_POSITION_REQUEST && packet != PacketType.PLAY_PLAYER_LOOK_REQUEST) {
+                System.out.println("Direction " + packet.getDirection().name() + " Packet Type: " + packet + " New ID: " + packetID + " Original: " + original + " Size: " + input.readableBytes());
+            }
+        }
         if (packet == PacketType.PLAY_TP_CONFIRM || packet == PacketType.PLAY_VEHICLE_MOVE_REQUEST) { //TODO handle client-sided horse riding
             throw new CancelException();
         }
@@ -48,8 +51,8 @@ public class IncomingTransformer {
             PacketUtil.writeVarInt(protVer <= 102 ? protVer : 47, output); // pretend to be older
 
             if (protVer <= 102) {
-                // Not 1.9 remove pipes
-                this.init.remove();
+                // not 1.9, remove pipes
+                info.setActive(false);
             }
             String serverAddress = PacketUtil.readString(input);
             PacketUtil.writeString(serverAddress, output);
@@ -86,16 +89,13 @@ public class IncomingTransformer {
             return;
         }
         if (packet == PacketType.PLAY_PLAYER_DIGGING) {
-            byte status = input.readByte();
+            int status = input.readByte() & 0xFF; // unsign
             if (status == 6) { // item swap
                 throw new CancelException();
             }
             output.writeByte(status);
-            // read position
-            Long pos = input.readLong();
-            output.writeLong(pos);
-            short face = input.readUnsignedByte();
-            output.writeByte(face);
+            // write remaining bytes
+            output.writeBytes(input);
             return;
         }
         if (packet == PacketType.PLAY_CLICK_WINDOW) {
@@ -106,11 +106,14 @@ public class IncomingTransformer {
             byte button = input.readByte();
             short action = input.readShort();
             byte mode = input.readByte();
+            // if the action is on an elytra armour slot
             if (slot == 45 && windowID == 0) {
                 try {
                     Class<?> setSlot = ReflectionUtil.nms("PacketPlayOutSetSlot");
-                    Object setSlotPacket = setSlot.getConstructors()[1].newInstance(windowID, slot, null);
-                    channel.writeAndFlush(setSlotPacket); // slot is empty
+                    Constructor setSlotConstruct = setSlot.getDeclaredConstructor(int.class, int.class, ReflectionUtil.nms("ItemStack"));
+                    // properly construct
+                    Object setSlotPacket = setSlotConstruct.newInstance(windowID, slot, null);
+                    info.getChannel().pipeline().writeAndFlush(setSlotPacket); // slot is empty
                     slot = -999; // we're evil, they'll throw item on the ground
                 } catch (ClassNotFoundException e) {
                     e.printStackTrace();
@@ -120,6 +123,8 @@ public class IncomingTransformer {
                     e.printStackTrace();
                 } catch (InvocationTargetException e) {
                     e.printStackTrace();
+                } catch (NoSuchMethodException e) {
+                    e.printStackTrace();
                 }
 
             }
@@ -128,7 +133,7 @@ public class IncomingTransformer {
             output.writeByte(button);
             output.writeShort(action);
             output.writeByte(mode);
-            output.writeBytes(input);
+            ItemSlotRewriter.rewrite1_9To1_8(input, output);
             return;
         }
         if (packet == PacketType.PLAY_CLIENT_SETTINGS) {
@@ -173,6 +178,44 @@ public class IncomingTransformer {
             }
             return;
         }
+        if (packet == PacketType.PLAY_PLUGIN_MESSAGE_REQUEST) {
+            String name = PacketUtil.readString(input);
+            PacketUtil.writeString(name, output);
+            byte[] b = new byte[input.readableBytes()];
+            input.readBytes(b);
+            // patch books
+            if (name.equals("MC|BSign")) {
+                ByteBuf in = Unpooled.wrappedBuffer(b);
+                try {
+                    ItemSlotRewriter.ItemStack stack = ItemSlotRewriter.readItemStack(in);
+                    stack.id = (short) Material.WRITTEN_BOOK.getId();
+                    // write
+                    ItemSlotRewriter.writeItemStack(stack, output);
+                } catch (IOException e) {
+                    e.printStackTrace();
+                }
+                return;
+            } else if (name.equals("MC|AutoCmd")) {
+                ByteBuf in = Unpooled.wrappedBuffer(b);
+                int x = in.readInt();
+                int y = in.readInt();
+                int z = in.readInt();
+                String command = PacketUtil.readString(in);
+                boolean flag = in.readBoolean();
+
+                output.clear();
+                PacketUtil.writeVarInt(PacketType.PLAY_PLUGIN_MESSAGE_REQUEST.getPacketID(), output);
+                PacketUtil.writeString("MC|AdvCdm", output);
+                output.writeByte(0);
+                output.writeInt(x);
+                output.writeInt(y);
+                output.writeInt(z);
+                PacketUtil.writeString(command, output);
+                output.writeBoolean(flag);
+                return;
+            }
+            output.writeBytes(b);
+        }
         if (packet == PacketType.PLAY_PLAYER_BLOCK_PLACEMENT) {
             Long position = input.readLong();
             output.writeLong(position);
@@ -181,22 +224,14 @@ public class IncomingTransformer {
             int hand = PacketUtil.readVarInt(input);
 
             ItemStack inHand = ViaVersionPlugin.getHandItem(info);
-            Object item = null;
             try {
-                Method m = ReflectionUtil.obc("inventory.CraftItemStack").getDeclaredMethod("asNMSCopy", ItemStack.class);
-                item = m.invoke(null, inHand);
-            } catch (NoSuchMethodException e) {
-                e.printStackTrace();
-            } catch (ClassNotFoundException e) {
-                e.printStackTrace();
-            } catch (InvocationTargetException e) {
-                e.printStackTrace();
-            } catch (IllegalAccessException e) {
+                ItemSlotRewriter.ItemStack item = ItemSlotRewriter.ItemStack.fromBukkit(inHand);
+                ItemSlotRewriter.fixIdsFrom1_9To1_8(item);
+                ItemSlotRewriter.writeItemStack(item, output);
+            } catch (Exception e) {
                 e.printStackTrace();
             }
 
-            PacketUtil.writeItem(item, output);
-
             short curX = input.readUnsignedByte();
             output.writeByte(curX);
             short curY = input.readUnsignedByte();
@@ -210,15 +245,28 @@ public class IncomingTransformer {
             PacketUtil.writeVarInt(PacketType.PLAY_PLAYER_BLOCK_PLACEMENT.getPacketID(), output);
             // Simulate using item :)
             output.writeLong(-1L);
-            output.writeByte(-1);
+            output.writeByte(255);
             // write item in hand
-            output.writeShort(-1);
+            ItemStack inHand = ViaVersionPlugin.getHandItem(info);
+            try {
+                ItemSlotRewriter.ItemStack item = ItemSlotRewriter.ItemStack.fromBukkit(inHand);
+                ItemSlotRewriter.fixIdsFrom1_9To1_8(item);
+                ItemSlotRewriter.writeItemStack(item, output);
+            } catch (Exception e) {
+                e.printStackTrace();
+            }
 
             output.writeByte(-1);
             output.writeByte(-1);
             output.writeByte(-1);
             return;
         }
+        if (packet == PacketType.PLAY_CREATIVE_INVENTORY_ACTION) {
+            short slot = input.readShort();
+            output.writeShort(slot);
+
+            ItemSlotRewriter.rewrite1_9To1_8(input, output);
+        }
         output.writeBytes(input);
     }
 }

src/main/java/us/myles/ViaVersion/util/PacketUtil.java

@@ -3,6 +3,8 @@ package us.myles.ViaVersion.util;
 import com.google.common.base.Charsets;
 import com.google.common.base.Preconditions;
 import io.netty.buffer.ByteBuf;
+import io.netty.buffer.ByteBufInputStream;
+import io.netty.buffer.ByteBufOutputStream;
 import io.netty.channel.ChannelHandlerContext;
 import io.netty.handler.codec.ByteToMessageDecoder;
 import io.netty.handler.codec.MessageToByteEncoder;
@@ -11,6 +13,9 @@ import us.myles.ViaVersion.chunks.PacketChunk;
 import us.myles.ViaVersion.chunks.PacketChunkData;
 
 import java.io.ByteArrayOutputStream;
+import java.io.DataInputStream;
+import java.io.DataOutputStream;
+import java.io.IOException;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
 import java.nio.ByteBuffer;
@@ -21,6 +26,9 @@ import java.util.BitSet;
 import java.util.List;
 import java.util.UUID;
 
+import org.spacehq.opennbt.NBTIO;
+import org.spacehq.opennbt.tag.builtin.CompoundTag;
+
 public class PacketUtil {
     private static Method DECODE_METHOD;
     private static Method ENCODE_METHOD;
@@ -42,29 +50,57 @@ public class PacketUtil {
         }
     }
 
-    public static ByteBuf decompress(ChannelHandlerContext ctx, ByteBuf msg) {
-        ByteToMessageDecoder x = (ByteToMessageDecoder) ctx.pipeline().get("decompress");
+    public static CompoundTag readNBT(ByteBuf input) throws IOException {
+        int readerIndex = input.readerIndex();
+        byte b = input.readByte();
+        if (b == 0) {
+            return null;
+        } else {
+            input.readerIndex(readerIndex);
+            return (CompoundTag) NBTIO.readTag(new DataInputStream(new ByteBufInputStream(input)));
+        }
+    }
+
+    public static void writeNBT(ByteBuf output, CompoundTag tag) throws IOException {
+        if (tag == null) {
+            output.writeByte(0);
+        } else {
+            NBTIO.writeTag(new DataOutputStream(new ByteBufOutputStream(output)), tag);
+        }
+    }
+
+    public static List<Object> callDecode(ByteToMessageDecoder decoder, ChannelHandlerContext ctx, Object input) {
         List<Object> output = new ArrayList<Object>();
         try {
-            PacketUtil.DECODE_METHOD.invoke(x, ctx, msg, output);
+            PacketUtil.DECODE_METHOD.invoke(decoder, ctx, input, output);
         } catch (IllegalAccessException e) {
             e.printStackTrace();
         } catch (InvocationTargetException e) {
             e.printStackTrace();
         }
+        return output;
+    }
+
+    public static void callEncode(MessageToByteEncoder encoder, ChannelHandlerContext ctx, Object msg, ByteBuf output) {
+        try {
+            PacketUtil.ENCODE_METHOD.invoke(encoder, ctx, msg, output);
+        } catch (IllegalAccessException e) {
+            e.printStackTrace();
+        } catch (InvocationTargetException e) {
+            e.printStackTrace();
+        }
+    }
+
+    public static ByteBuf decompress(ChannelHandlerContext ctx, ByteBuf msg) {
+        ByteToMessageDecoder x = (ByteToMessageDecoder) ctx.pipeline().get("decompress");
+        List<Object> output = callDecode(x, ctx, msg);
         return output.size() == 0 ? null : (ByteBuf) output.get(0);
     }
 
     public static ByteBuf compress(ChannelHandlerContext ctx, ByteBuf msg) {
         MessageToByteEncoder x = (MessageToByteEncoder) ctx.pipeline().get("compress");
         ByteBuf output = ctx.alloc().buffer();
-        try {
-            PacketUtil.ENCODE_METHOD.invoke(x, ctx, msg, output);
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        } catch (InvocationTargetException e) {
-            e.printStackTrace();
-        }
+        callEncode(x, ctx, msg, output);
         return output;
     }
 
@@ -185,9 +221,9 @@ public class PacketUtil {
     }
 
     public static void writeVarIntArray(List<Integer> integers, ByteBuf output) {
-        writeVarInt(integers.size(),output);
-        for (Integer i  : integers){
-            writeVarInt(i,output);
+        writeVarInt(integers.size(), output);
+        for (Integer i : integers) {
+            writeVarInt(i, output);
         }
     }
 
@@ -345,25 +381,6 @@ public class PacketUtil {
         return output;
     }
 
-    public static void writeItem(Object value, ByteBuf output) {
-        try {
-            Class<?> serializer = ReflectionUtil.nms("PacketDataSerializer");
-            Object init = serializer.getDeclaredConstructor(ByteBuf.class).newInstance(output);
-            Method toCall = init.getClass().getDeclaredMethod("a", ReflectionUtil.nms("ItemStack"));
-            toCall.invoke(init, value);
-        } catch (ClassNotFoundException e) {
-            e.printStackTrace();
-        } catch (NoSuchMethodException e) {
-            e.printStackTrace();
-        } catch (InstantiationException e) {
-            e.printStackTrace();
-        } catch (IllegalAccessException e) {
-            e.printStackTrace();
-        } catch (InvocationTargetException e) {
-            e.printStackTrace();
-        }
-    }
-
     public static long[] readBlockPosition(ByteBuf buf) {
         long val = buf.readLong();
         long x = (val >> 38); // signed
@@ -385,4 +402,12 @@ public class PacketUtil {
 
         return data;
     }
+
+    public static boolean containsCause(Throwable t, Class<? extends Throwable> c) {
+        while (t != null) {
+            t = t.getCause();
+            if (c.isAssignableFrom(t.getClass())) return true;
+        }
+        return false;
+    }
 }

src/main/java/us/myles/ViaVersion/util/ReflectionUtil.java

@@ -27,6 +27,18 @@ public class ReflectionUtil {
         return m.invoke(o);
     }
 
+    public static <T> T getStatic(Class<?> clazz, String f, Class<T> t) throws NoSuchFieldException, IllegalAccessException {
+        Field field = clazz.getDeclaredField(f);
+        field.setAccessible(true);
+        return (T) field.get(null);
+    }
+
+    public static <T> T get(Object instance, Class<?> clazz, String f, Class<T> t) throws NoSuchFieldException, IllegalAccessException {
+        Field field = clazz.getDeclaredField(f);
+        field.setAccessible(true);
+        return (T) field.get(instance);
+    }
+
     public static <T> T get(Object o, String f, Class<T> t) throws NoSuchFieldException, IllegalAccessException {
         Field field = o.getClass().getDeclaredField(f);
         field.setAccessible(true);

src/main/resources/plugin.yml

@@ -1,4 +1,11 @@
 name: ViaVersion
 main: us.myles.ViaVersion.ViaVersionPlugin
 author: _MylesC
-version: 0.3.6
+version: ${project.version}
+load: startup
+loadbefore: [ProtocolLib, ProxyPipe]
+commands:
+  viaversion:
+    description: Shows ViaVersion Version and more.
+    permission: viaversion.admin
+    aliases: [viaver]