Bump versions

Implement new chunk transformer

README.md

@@ -1,4 +1,4 @@
-# ViaVersion 0.5.7 
+# ViaVersion 0.6.4
 [![Build Status](https://travis-ci.org/MylesIsCool/ViaVersion.svg?branch=master)](https://travis-ci.org/MylesIsCool/ViaVersion)
 **Allows the connection of 1.9 clients to 1.8**
 
@@ -40,6 +40,8 @@ Contributors:
 
 **fillefilip8**
 
+**lenis0012**
+
 
 
 Releases / Dev Builds:
@@ -55,6 +57,9 @@ You can find unofficial dev builds here:
 
 **fillefilip8's Build Server:** http://build.fillecraft.com:8080/job/ViaVersion
 
+**sgdc3's Build Server:** http://ci.xephi.fr/job/ViaVersion/
+**sgdc3's Maven:** http://ci.xephi.fr/plugin/repository/everything/
+
 License:
 --------
 

pom.xml

@@ -6,7 +6,7 @@
 
     <groupId>us.myles</groupId>
     <artifactId>viaversion</artifactId>
-    <version>0.5.8-SNAPSHOT</version>
+    <version>0.6.5-SNAPSHOT</version>
     <packaging>jar</packaging>
 
     <name>ViaVersion</name>

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

@@ -47,18 +47,21 @@ public class NetUtil {
         // 2 = Get block light.
         // 3 = Get sky light.
         Chunk[] chunks = new Chunk[16];
-
+        int chunkCount = 0;
         for (int pass = 0; pass < 4; pass++) {
+            if(pass == 1){
+                if(chunkCount == 0) return null;
+            }
             for (int ind = 0; ind < 16; ind++) {
                 if ((bitmask & 1 << ind) != 0) {
                     if (pass == 0) {
+                        chunkCount++;
                         // Block length + Blocklight length
                         expected += (4096 * 2) + 2048;
                     }
 
                     if (pass == 1) {
                         chunks[ind] = new Chunk(sky || hasSkyLight);
-
                         buf.position(pos / 2);
                         int buffPos = buf.position();
                         // convert short array to new one

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

@@ -1,112 +1,73 @@
 package us.myles.ViaVersion;
 
 import io.netty.buffer.ByteBuf;
-import io.netty.channel.*;
+import io.netty.channel.ChannelHandler;
 import io.netty.channel.socket.SocketChannel;
+import lombok.Getter;
+import lombok.Setter;
 import org.bukkit.Bukkit;
 import org.bukkit.entity.Player;
+import us.myles.ViaVersion.chunks.ChunkManager;
 import us.myles.ViaVersion.packets.State;
 
-import java.util.UUID;
-
+@Getter
+@Setter
 public class ConnectionInfo {
+    private static final long IDLE_PACKET_DELAY = 50L; // Update every 50ms (20tps)
+    private static final long IDLE_PACKET_LIMIT = 20; // Max 20 ticks behind
+
     private final SocketChannel channel;
+    private final ChunkManager chunkManager;
     private Object lastPacket;
     private java.util.UUID UUID;
     private State state = State.HANDSHAKE;
     private String openWindow;
     private int protocol = 0;
     private int compression = 0;
+    private int entityID;
     private boolean active = true;
     private String username;
+    private long nextIdlePacket = 0L;
 
     public ConnectionInfo(SocketChannel socketChannel) {
         this.channel = socketChannel;
-    }
-
-    public int getProtocol() {
-        return protocol;
-    }
-
-    public void setProtocol(int protocol) {
-        this.protocol = protocol;
-    }
-
-    public State getState() {
-        return state;
-    }
-
-    public void setState(State state) {
-        this.state = state;
-    }
-
-    public int getCompression() {
-        return compression;
-    }
-
-    public void setCompression(int compression) {
-        this.compression = compression;
-    }
-
-    public Object getLastPacket() {
-        return lastPacket;
-    }
-
-    public void setLastPacket(Object lastPacket) {
-        this.lastPacket = lastPacket;
-    }
-
-    public java.util.UUID getUUID() {
-        return UUID;
-    }
-
-    public void setUUID(UUID UUID) {
-        this.UUID = UUID;
+        this.chunkManager = new ChunkManager(this);
     }
 
     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;
+        this.nextIdlePacket = System.currentTimeMillis() + IDLE_PACKET_DELAY; // Update every 50 ticks
+    }
+
+    public void sendRawPacket(final ByteBuf packet, boolean currentThread) {
+        final ChannelHandler handler = channel.pipeline().get("encoder");
+        if (currentThread) {
+            channel.pipeline().context(handler).writeAndFlush(packet);
+        } else {
+            channel.eventLoop().submit(new Runnable() {
+                @Override
+                public void run() {
+                    channel.pipeline().context(handler).writeAndFlush(packet);
+                }
+            });
+        }
     }
 
     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);
-            }
-        });
-    }
-
-    public String getOpenWindow() {
-        return openWindow;
-    }
-
-    public void setOpenWindow(String openWindow) {
-        this.openWindow = openWindow;
+        sendRawPacket(packet, false);
     }
 
     public void closeWindow() {
         this.openWindow = null;
     }
 
-    public String getUsername() {
-        return username;
-    }
-
-    public void setUsername(String username) {
-        this.username = username;
+    public void incrementIdlePacket() {
+        // Notify of next update
+        // Allow a maximum lag spike of 1 second (20 ticks/updates)
+        this.nextIdlePacket = Math.max(nextIdlePacket + IDLE_PACKET_DELAY, System.currentTimeMillis() - IDLE_PACKET_DELAY * IDLE_PACKET_LIMIT);
     }
 }

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

@@ -0,0 +1,42 @@
+package us.myles.ViaVersion;
+
+import org.bukkit.scheduler.BukkitRunnable;
+import us.myles.ViaVersion.api.ViaVersion;
+import us.myles.ViaVersion.util.ReflectionUtil;
+
+import java.util.Map;
+import java.util.UUID;
+
+public class ViaIdleThread extends BukkitRunnable {
+    private final Map<UUID, ConnectionInfo> portedPlayers;
+    private final Class<?> idlePacketClass;
+
+    public ViaIdleThread(Map<UUID, ConnectionInfo> portedPlayers) {
+        this.portedPlayers = portedPlayers;
+        try {
+            this.idlePacketClass = ReflectionUtil.nms("PacketPlayInFlying");
+        } catch(ClassNotFoundException e) {
+            throw new RuntimeException("Couldn't find player idle packet, help!", e);
+        }
+    }
+
+    @Override
+    public void run() {
+        for(ConnectionInfo info : portedPlayers.values()) {
+            long nextIdleUpdate = info.getNextIdlePacket();
+            if(nextIdleUpdate <= System.currentTimeMillis()) {
+                try {
+                    Object packet = idlePacketClass.newInstance();
+                    info.getChannel().pipeline().fireChannelRead(packet);
+                } catch(InstantiationException | IllegalAccessException e) {
+                    System.out.println("Failed to create idle packet.");
+                    if(ViaVersion.getInstance().isDebug()) {
+                        e.printStackTrace();
+                    }
+                } finally {
+                    info.incrementIdlePacket();
+                }
+            }
+        }
+    }
+}

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

@@ -4,7 +4,6 @@ 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.Player;
@@ -25,9 +24,13 @@ import us.myles.ViaVersion.handlers.ViaVersionInitializer;
 import us.myles.ViaVersion.listeners.CommandBlockListener;
 import us.myles.ViaVersion.update.UpdateListener;
 import us.myles.ViaVersion.update.UpdateUtil;
+import us.myles.ViaVersion.util.Configuration;
+import us.myles.ViaVersion.util.ListWrapper;
 import us.myles.ViaVersion.util.ReflectionUtil;
 
+import java.io.File;
 import java.lang.reflect.Field;
+import java.lang.reflect.Method;
 import java.util.List;
 import java.util.Map;
 import java.util.UUID;
@@ -53,8 +56,9 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
                 }
             }).get(10, TimeUnit.SECONDS);
         } catch (Exception e) {
-            System.out.println("Error fetching hand item ");
-            e.printStackTrace();
+            System.out.println("Error fetching hand item: " + e.getClass().getName());
+            if (ViaVersion.getInstance().isDebug())
+                e.printStackTrace();
             return null;
         }
     }
@@ -62,7 +66,7 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
     @Override
     public void onEnable() {
         ViaVersion.setInstance(this);
-        saveDefaultConfig();
+        generateConfig();
         if (System.getProperty("ViaVersion") != null) {
             getLogger().severe("ViaVersion is already loaded, we don't support reloads. Please reboot if you wish to update.");
             getLogger().severe("Some features may not work.");
@@ -70,13 +74,10 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
         }
 
         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) {
-            getLogger().severe("Unable to inject handlers, are you on 1.8? ");
-            e.printStackTrace();
-        }
+        injectPacketHandler();
+        if (getConfig().getBoolean("simulate-pt", true))
+            new ViaIdleThread(portedPlayers).runTaskTimerAsynchronously(this, 1L, 1L); // Updates player's idle status
+
         if (getConfig().getBoolean("checkforupdates"))
             UpdateUtil.sendUpdateMessage(this);
 
@@ -94,39 +95,98 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
         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);
-        // 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();
-                        try {
-                            ChannelInitializer<SocketChannel> oldInit = ReflectionUtil.get(bootstrapAcceptor, "childHandler", ChannelInitializer.class);
-                            ChannelInitializer newInit = new ViaVersionInitializer(oldInit);
+    public void generateConfig() {
+        File file = new File(getDataFolder(), "config.yml");
+        if (file.exists()) {
+            // Update config options
+            Configuration oldConfig = new Configuration(file);
+            oldConfig.reload(false); // Load current options from config
+            file.delete(); // Delete old config
+            saveDefaultConfig(); // Generate new config
+            Configuration newConfig = new Configuration(file);
+            newConfig.reload(true); // Load default options
+            for (String key : oldConfig.getKeys(false)) {
+                // Set option in new config if exists
+                if (newConfig.contains(key)) {
+                    newConfig.set(key, oldConfig.get(key));
+                }
+            }
+            newConfig.save();
+        } else {
+            saveDefaultConfig();
+        }
+    }
 
-                            ReflectionUtil.set(bootstrapAcceptor, "childHandler", newInit);
-                        } catch (NoSuchFieldException e) {
-                            // field not found
-                            throw new Exception("Unable to find childHandler, blame " + bootstrapAcceptor.getClass().getName());
+    public void injectPacketHandler() {
+        try {
+            Class<?> serverClazz = ReflectionUtil.nms("MinecraftServer");
+            Object server = ReflectionUtil.invokeStatic(serverClazz, "getServer");
+            Object connection = null;
+            for (Method m : serverClazz.getDeclaredMethods()) {
+                if (m.getReturnType() != null) {
+                    if (m.getReturnType().getSimpleName().equals("ServerConnection")) {
+                        if (m.getParameterTypes().length == 0) {
+                            connection = m.invoke(server);
                         }
-                        injected = true;
-                    } else {
-                        break; // not the right list.
                     }
                 }
             }
+            if (connection == null) {
+                getLogger().warning("We failed to find the ServerConnection? :( What server are you running?");
+                return;
+            }
+            if (connection != null) {
+                for (Field field : connection.getClass().getDeclaredFields()) {
+                    field.setAccessible(true);
+                    final Object value = field.get(connection);
+                    if (value instanceof List) {
+                        // Inject the list
+                        List wrapper = new ListWrapper((List) value) {
+                            @Override
+                            public synchronized void handleAdd(Object o) {
+                                synchronized (this) {
+                                    if (o instanceof ChannelFuture) {
+                                        inject((ChannelFuture) o);
+                                    }
+                                }
+                            }
+                        };
+                        field.set(connection, wrapper);
+                        // Iterate through current list
+                        synchronized (wrapper) {
+                            for (Object o : (List) value) {
+                                if (o instanceof ChannelFuture) {
+                                    inject((ChannelFuture) o);
+                                } else {
+                                    break; // not the right list.
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            System.setProperty("ViaVersion", getDescription().getVersion());
+        } catch (Exception e) {
+            getLogger().severe("Unable to inject handlers, are you on 1.8? ");
+            e.printStackTrace();
         }
-        if (!injected) {
-            throw new Exception("Could not find server to inject (Please ensure late-bind in your spigot.yml is false)");
+    }
+
+    private void inject(ChannelFuture future) {
+        try {
+            ChannelHandler bootstrapAcceptor = future.channel().pipeline().first();
+            try {
+                ChannelInitializer<SocketChannel> oldInit = ReflectionUtil.get(bootstrapAcceptor, "childHandler", ChannelInitializer.class);
+                ChannelInitializer newInit = new ViaVersionInitializer(oldInit);
+
+                ReflectionUtil.set(bootstrapAcceptor, "childHandler", newInit);
+            } catch (NoSuchFieldException e) {
+                // field not found
+                throw new Exception("Unable to find childHandler, blame " + bootstrapAcceptor.getClass().getName());
+            }
+        } catch (Exception e) {
+            getLogger().severe("Have you got late-bind enabled with something else? (ProtocolLib?)");
+            e.printStackTrace();
         }
     }
 
@@ -175,15 +235,34 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
         this.debug = value;
     }
 
-    @Override
-    public boolean isSyncedChunks() {
-        return getConfig().getBoolean("sync-chunks", true);
-    }
-
     public boolean isPreventCollision() {
         return getConfig().getBoolean("prevent-collision", true);
     }
 
+    public boolean isSuppressMetadataErrors() {
+        return getConfig().getBoolean("suppress-metadata-errors", false);
+    }
+
+    public boolean isShieldBlocking() {
+        return getConfig().getBoolean("shield-blocking", true);
+    }
+
+    public boolean isHologramPatch() {
+        return getConfig().getBoolean("hologram-patch", false);
+    }
+
+    public boolean isBossbarPatch() {
+        return getConfig().getBoolean("bossbar-patch", true);
+    }
+
+    public boolean isBossbarAntiflicker() {
+        return getConfig().getBoolean("bossbar-anti-flicker", false);
+    }
+
+    public double getHologramYOffset() {
+        return getConfig().getDouble("hologram-y", -1D);
+    }
+
     public boolean isAutoTeam() {
         // Collision has to be enabled first
         if (!isPreventCollision()) return false;
@@ -211,8 +290,9 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaVersionAPI {
                 f.get(10, TimeUnit.SECONDS);
             }
         } catch (Exception e) {
-            System.out.println("Failed to run task.");
-            e.printStackTrace();
+            System.out.println("Failed to run task: " + e.getClass().getName());
+            if (ViaVersion.getInstance().isDebug())
+                e.printStackTrace();
         }
     }
 }

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

@@ -77,11 +77,4 @@ public interface ViaVersionAPI {
      * @return true if debug is enabled
      */
     boolean isDebug();
-
-    /**
-     * Obtains if syncing chunks is on
-     *
-     * @return true if it is
-     */
-    boolean isSyncedChunks();
 }

src/main/java/us/myles/ViaVersion/api/boss/BossBar.java

@@ -13,6 +13,13 @@ public interface BossBar {
      */
     void setTitle(String title);
 
+    /**
+     * Get the current title
+     *
+     * @return the title
+     */
+    String getTitle();
+
     /**
      * Change the health
      *
@@ -21,11 +28,11 @@ public interface BossBar {
     void setHealth(float health);
 
     /**
-     * Get the bossbar color
+     * Get the health
      *
-     * @return
+     * @return float between 0F - 1F
      */
-    BossColor getColor();
+    float getHealth();
 
     /**
      * Yay colors!
@@ -34,6 +41,13 @@ public interface BossBar {
      */
     void setColor(BossColor color);
 
+    /**
+     * Get the bossbar color
+     *
+     * @return
+     */
+    BossColor getColor();
+
     /**
      * Change the bosbar style
      *
@@ -41,6 +55,13 @@ public interface BossBar {
      */
     void setStyle(BossStyle style);
 
+    /**
+     * Get the bosbar style
+     *
+     * @return BossStyle
+     */
+    BossStyle getStyle();
+
     /**
      * Show the bossbar to a player.
      *

src/main/java/us/myles/ViaVersion/chunks/Chunk.java

@@ -0,0 +1,32 @@
+package us.myles.ViaVersion.chunks;
+
+import lombok.AccessLevel;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+
+@RequiredArgsConstructor(access = AccessLevel.PROTECTED)
+@Getter
+public class Chunk {
+    private final int x;
+    private final int z;
+    private final boolean groundUp;
+    private final int primaryBitmask;
+    private final ChunkSection[] sections;
+    private final byte[] biomeData;
+    private boolean unloadPacket = false;
+
+    /**
+     * Chunk unload.
+     *
+     * @param x coord
+     * @param z coord
+     */
+    protected Chunk(int x, int z) {
+        this(x, z, true, 0, new ChunkSection[16], null);
+        this.unloadPacket = true;
+    }
+
+    public boolean hasBiomeData() {
+        return biomeData != null && groundUp;
+    }
+}

src/main/java/us/myles/ViaVersion/chunks/ChunkManager.java

@@ -0,0 +1,224 @@
+package us.myles.ViaVersion.chunks;
+
+import com.google.common.collect.Lists;
+import com.google.common.collect.Sets;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.bukkit.Bukkit;
+import us.myles.ViaVersion.ConnectionInfo;
+import us.myles.ViaVersion.util.PacketUtil;
+import us.myles.ViaVersion.util.ReflectionUtil;
+import us.myles.ViaVersion.util.ReflectionUtil.ClassReflection;
+
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.nio.ShortBuffer;
+import java.util.BitSet;
+import java.util.List;
+import java.util.Set;
+import java.util.logging.Level;
+
+public class ChunkManager {
+    /**
+     * Amount of sections in a chunk.
+     */
+    private static final int SECTION_COUNT = 16;
+    /**
+     * size of each chunk section (16x16x16).
+     */
+    private static final int SECTION_SIZE = 16;
+    /**
+     * Length of biome data.
+     */
+    private static final int BIOME_DATA_LENGTH = 256;
+
+    private final ConnectionInfo info;
+    private final Set<Long> loadedChunks = Sets.newConcurrentHashSet();
+    private final Set<Long> bulkChunks = Sets.newConcurrentHashSet();
+
+    // Reflection
+    private static ClassReflection mapChunkBulkRef;
+    private static ClassReflection mapChunkRef;
+
+    static {
+        try {
+            mapChunkBulkRef = new ClassReflection(ReflectionUtil.nms("PacketPlayOutMapChunkBulk"));
+            mapChunkRef = new ClassReflection(ReflectionUtil.nms("PacketPlayOutMapChunk"));
+        } catch(Exception e) {
+            Bukkit.getLogger().log(Level.WARNING, "Failed to initialise chunk reflection", e);
+        }
+    }
+
+    public ChunkManager(ConnectionInfo info) {
+        this.info = info;
+    }
+
+    /**
+     * Transform a map chunk bulk in to separate map chunk packets.
+     * These packets are registered  so that they will never be seen as unload packets.
+     *
+     * @param packet to transform
+     * @return List of chunk data packets
+     */
+    public List<Object> transformMapChunkBulk(Object packet) {
+        List<Object> list = Lists.newArrayList();
+        try {
+            int[] xcoords = mapChunkBulkRef.getFieldValue("a", packet, int[].class);
+            int[] zcoords = mapChunkBulkRef.getFieldValue("b", packet, int[].class);
+            Object[] chunkMaps = mapChunkBulkRef.getFieldValue("c", packet, Object[].class);
+            for(int i = 0; i < chunkMaps.length; i++) {
+                int x = xcoords[i];
+                int z = zcoords[i];
+                Object chunkMap = chunkMaps[i];
+                Object chunkPacket = mapChunkRef.newInstance();
+                mapChunkRef.setFieldValue("a", chunkPacket, x);
+                mapChunkRef.setFieldValue("b", chunkPacket, z);
+                mapChunkRef.setFieldValue("c", chunkPacket, chunkMap);
+                mapChunkRef.setFieldValue("d", chunkPacket, true); // Chunk bulk chunks are always ground-up
+                bulkChunks.add(toLong(x, z)); // Store for later
+                list.add(chunkPacket);
+            }
+        } catch(Exception e) {
+            Bukkit.getLogger().log(Level.WARNING, "Failed to transform chunk bulk", e);
+        }
+        return list;
+    }
+
+    /**
+     * Read chunk from 1.8 chunk data.
+     *
+     * @param input data
+     * @return Chunk
+     */
+    public Chunk readChunk(ByteBuf input) {
+        // Primary data
+        int chunkX = input.readInt();
+        int chunkZ = input.readInt();
+        long chunkHash = toLong(chunkX, chunkZ);
+        boolean groundUp = input.readByte() != 0;
+        int bitmask = input.readUnsignedShort();
+        int dataLength = PacketUtil.readVarInt(input);
+
+        // Data to be read
+        BitSet usedSections = new BitSet(16);
+        ChunkSection[] sections = new ChunkSection[16];
+        byte[] biomeData = null;
+
+        // Calculate section count from bitmask
+        for(int i = 0; i < 16; i++) {
+            if((bitmask & (1 << i)) != 0) {
+                usedSections.set(i);
+            }
+        }
+        int sectionCount = usedSections.cardinality(); // the amount of sections set
+
+        // If the chunk is from a chunk bulk, it is never an unload packet
+        // Other wise, if it has no data, it is :)
+        boolean isBulkPacket = bulkChunks.remove(chunkHash);
+        if(sectionCount == 0 && groundUp && !isBulkPacket && loadedChunks.contains(chunkHash)) {
+            // This is a chunk unload packet
+            loadedChunks.remove(chunkHash);
+            return new Chunk(chunkX, chunkZ);
+        }
+
+        int startIndex = input.readerIndex();
+        loadedChunks.add(chunkHash); // mark chunk as loaded
+
+        // Read blocks
+        for(int i = 0; i < SECTION_COUNT; i++) {
+            if(!usedSections.get(i)) continue; // Section not set
+            ChunkSection section = new ChunkSection();
+            sections[i] = section;
+
+            // Read block data and convert to short buffer
+            byte[] blockData = new byte[ChunkSection.SIZE * 2];
+            input.readBytes(blockData);
+            ShortBuffer blockBuf = ByteBuffer.wrap(blockData).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer();
+
+            for(int j = 0; j < ChunkSection.SIZE; j++) {
+                int mask = blockBuf.get();
+                int type = mask >> 4;
+                int data = mask & 0xF;
+                section.setBlock(j, type, data);
+            }
+        }
+
+        // Read block light
+        for(int i = 0; i < SECTION_COUNT; i++) {
+            if(!usedSections.get(i)) continue; // Section not set, has no light
+            byte[] blockLightArray = new byte[ChunkSection.LIGHT_LENGTH];
+            input.readBytes(blockLightArray);
+            sections[i].setBlockLight(blockLightArray);
+        }
+
+        // Read sky light
+        int bytesLeft = dataLength - (input.readerIndex() - startIndex);
+        if(bytesLeft >= ChunkSection.LIGHT_LENGTH) {
+            for(int i = 0; i < SECTION_COUNT; i++) {
+                if(!usedSections.get(i)) continue; // Section not set, has no light
+                byte[] skyLightArray = new byte[ChunkSection.LIGHT_LENGTH];
+                input.readBytes(skyLightArray);
+                sections[i].setSkyLight(skyLightArray);
+                bytesLeft -= ChunkSection.LIGHT_LENGTH;
+            }
+        }
+
+        // Read biome data
+        if(bytesLeft >= BIOME_DATA_LENGTH) {
+            biomeData = new byte[BIOME_DATA_LENGTH];
+            input.readBytes(biomeData);
+            bytesLeft -= BIOME_DATA_LENGTH;
+        }
+
+        // Check remaining bytes
+        if(bytesLeft > 0) {
+            Bukkit.getLogger().log(Level.WARNING, bytesLeft + " Bytes left after reading chunk! (" + groundUp + ")");
+        }
+
+        // Return chunk
+        return new Chunk(chunkX, chunkZ, groundUp, bitmask, sections, biomeData);
+    }
+
+    /**
+     * Write chunk over 1.9 protocol.
+     *
+     * @param chunk chunk
+     * @param output output
+     */
+    public void writeChunk(Chunk chunk, ByteBuf output) {
+        if(chunk.isUnloadPacket()) {
+            output.clear();
+            PacketUtil.writeVarInt(0x1D, output);
+        }
+
+        // Write primary info
+        output.writeInt(chunk.getX());
+        output.writeInt(chunk.getZ());
+        if(chunk.isUnloadPacket()) return;
+        output.writeByte(chunk.isGroundUp() ? 0x01 : 0x00);
+        PacketUtil.writeVarInt(chunk.getPrimaryBitmask(), output);
+
+        ByteBuf buf = Unpooled.buffer();
+        for(int i = 0; i < SECTION_COUNT; i++) {
+            ChunkSection section = chunk.getSections()[i];
+            if(section == null) continue; // Section not set
+            section.writeBlocks(buf);
+            section.writeBlockLight(buf);
+            if(!section.hasSkyLight()) continue; // No sky light, we're done here.
+            section.writeSkyLight(buf);
+        }
+        buf.readerIndex(0);
+        PacketUtil.writeVarInt(buf.readableBytes() + (chunk.hasBiomeData() ? 256 : 0), output);
+        output.writeBytes(buf);
+        buf.release(); // release buffer
+
+        // Write biome data
+        if(chunk.hasBiomeData()) {
+            output.writeBytes(chunk.getBiomeData());
+        }
+    }
+
+    private static long toLong(int msw, int lsw)  {
+        return ((long) msw << 32) + lsw - -2147483648L;
+    }
+}

src/main/java/us/myles/ViaVersion/chunks/ChunkSection.java

@@ -0,0 +1,143 @@
+package us.myles.ViaVersion.chunks;
+
+import com.google.common.collect.Lists;
+import io.netty.buffer.ByteBuf;
+import io.netty.buffer.Unpooled;
+import org.bukkit.Material;
+import us.myles.ViaVersion.util.PacketUtil;
+
+import java.util.List;
+
+public class ChunkSection {
+    /**
+     * Size (dimensions) of blocks in a chunk section.
+     */
+    public static final int SIZE = 16 * 16 * 16; // width * depth * height
+    /**
+     * Length of the sky and block light nibble arrays.
+     */
+    public static final int LIGHT_LENGTH = 16 * 16 * 16 / 2; // size * size * size / 2 (nibble bit count)
+    /**
+     * Length of the block data array.
+     */
+//    public static final int BLOCK_LENGTH = 16 * 16 * 16 * 2; // size * size * size * 2 (char bit count)
+
+    private final List<Integer> palette = Lists.newArrayList();
+    private final int[] blocks;
+    private final NibbleArray blockLight;
+    private NibbleArray skyLight;
+
+    public ChunkSection() {
+        this.blocks = new int[SIZE];
+        this.blockLight = new NibbleArray(SIZE);
+        palette.add(0); // AIR
+    }
+
+    public void setBlock(int x, int y, int z, int type, int data) {
+        setBlock(index(x, y, z), type, data);
+    }
+
+    public void setBlock(int idx, int type, int data) {
+        int hash = type << 4 | (data & 0xF);
+        int index = palette.indexOf(hash);
+        if(index == -1) {
+            index = palette.size();
+            palette.add(hash);
+        }
+
+        blocks[idx] = index;
+    }
+
+    public void setBlockLight(byte[] data) {
+        blockLight.setHandle(data);
+    }
+
+    public void setSkyLight(byte[] data) {
+        if(data.length != LIGHT_LENGTH) throw new IllegalArgumentException("Data length != " + LIGHT_LENGTH);
+        this.skyLight = new NibbleArray(data);
+    }
+
+    private int index(int x, int y, int z) {
+        return z << 8 | y << 4 | x;
+    }
+
+    public void writeBlocks(ByteBuf output) {
+        // Write bits per block
+        int bitsPerBlock = 4;
+        while(palette.size() > 1 << bitsPerBlock) {
+            bitsPerBlock += 1;
+        }
+        long maxEntryValue = (1L << bitsPerBlock) - 1;
+        output.writeByte(bitsPerBlock);
+
+        // Write pallet (or not)
+        PacketUtil.writeVarInt(palette.size(), output);
+        for(int mappedId : palette) {
+            PacketUtil.writeVarInt(mappedId, output);
+        }
+
+        int length = (int) Math.ceil(SIZE * bitsPerBlock / 64.0);
+        PacketUtil.writeVarInt(length, output);
+        long[] data = new long[length];
+        for(int index = 0; index < blocks.length; index++) {
+            int value = blocks[index];
+            int bitIndex = index * bitsPerBlock;
+            int startIndex = bitIndex / 64;
+            int endIndex = ((index + 1) * bitsPerBlock - 1) / 64;
+            int startBitSubIndex = bitIndex % 64;
+            data[startIndex] = data[startIndex] & ~(maxEntryValue << startBitSubIndex) | ((long) value & maxEntryValue) << startBitSubIndex;
+            if(startIndex != endIndex) {
+                int endBitSubIndex = 64 - startBitSubIndex;
+                data[endIndex] = data[endIndex] >>> endBitSubIndex << endBitSubIndex | ((long) value & maxEntryValue) >> endBitSubIndex;
+            }
+        }
+        PacketUtil.writeLongs(data, output);
+    }
+
+    public void writeBlockLight(ByteBuf output) {
+        output.writeBytes(blockLight.getHandle());
+    }
+
+    public void writeSkyLight(ByteBuf output) {
+        output.writeBytes(skyLight.getHandle());
+    }
+
+    public boolean hasSkyLight() {
+        return skyLight != null;
+    }
+
+    /**
+     * Get expected size of this chunk section.
+     *
+     * @return Amount of bytes sent by this section
+     */
+    public int getExpectedSize() {
+        int bitsPerBlock = palette.size() > 255 ? 16 : 8;
+        int bytes = 1; // bits per block
+        bytes += paletteBytes(); // palette
+        bytes += countBytes(bitsPerBlock == 16 ? SIZE * 2 : SIZE); // block data length
+        bytes += (palette.size() > 255 ? 2 : 1) * SIZE; // block data
+        bytes += LIGHT_LENGTH; // block light
+        bytes += hasSkyLight() ? LIGHT_LENGTH : 0; // sky light
+        return bytes;
+    }
+
+    private int paletteBytes() {
+        // Count bytes used by pallet
+        int bytes = countBytes(palette.size());
+        for(int mappedId : palette) {
+            bytes += countBytes(mappedId);
+        }
+        return bytes;
+    }
+
+    private int countBytes(int value) {
+        // Count amount of bytes that would be sent if the value were sent as a VarInt
+        ByteBuf buf = Unpooled.buffer();
+        PacketUtil.writeVarInt(value, buf);
+        buf.readerIndex(0);
+        int bitCount = buf.readableBytes();
+        buf.release();
+        return bitCount;
+    }
+}

src/main/java/us/myles/ViaVersion/chunks/NibbleArray.java

@@ -0,0 +1,74 @@
+package us.myles.ViaVersion.chunks;
+
+import java.util.Arrays;
+
+public class NibbleArray {
+    private final byte[] handle;
+
+    public NibbleArray(int length) {
+        if(length == 0 || length % 2 != 0) {
+            throw new IllegalArgumentException("Length of nibble array must be a positive number dividable by 2!");
+        }
+
+        this.handle = new byte[length / 2];
+    }
+
+    public NibbleArray(byte[] handle) {
+        if(handle.length == 0 || handle.length % 2 != 0) {
+            throw new IllegalArgumentException("Length of nibble array must be a positive number dividable by 2!");
+        }
+
+        this.handle = handle;
+    }
+
+    public byte get(int x, int y, int z) {
+        return get(y << 8 | z << 4 | x);
+    }
+
+    public byte get(int index) {
+        byte value = handle[index / 2];
+        if(index % 2 == 0) {
+            return (byte) (value & 0xF);
+        } else {
+            return (byte) ((value >> 4) & 0xF);
+        }
+    }
+
+    public void set(int x, int y, int z, int value) {
+        set(y << 8 | z << 4 | x, value);
+    }
+
+    public void set(int index, int value) {
+        index /= 2;
+        if(index % 2 == 0) {
+            handle[index] = (byte) (handle[index] & 0xF0 | value & 0xF);
+        } else {
+            handle[index] = (byte) (handle[index] & 0xF | (value & 0xF) << 4);
+        }
+    }
+
+    public int size() {
+        return handle.length * 2;
+    }
+
+    public int actualSize() {
+        return handle.length;
+    }
+
+    public void fill(byte value) {
+        value &= 0xF; // Max nibble size (= 16)
+        Arrays.fill(handle, (byte) ((value << 4) | value));
+    }
+
+    public void setHandle(byte[] handle) {
+        if(handle.length != this.handle.length) {
+            throw new IllegalArgumentException("Length of handle must equal to size of nibble array!");
+        }
+
+        System.arraycopy(handle, 0, this.handle, 0, handle.length);
+    }
+
+    public byte[] getHandle() {
+        return handle;
+    }
+}

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

@@ -20,16 +20,11 @@ public class ViaVersionCommand implements CommandExecutor {
 
     private final ViaVersionPlugin 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."));
-                sender.sendMessage(color("&2/viaversion autoteam &7- &6Toggle automatically teaming to prevent colliding."));
-                sender.sendMessage(color("&2/viaversion dontbugme &7- &6Toggle checking for updates."));
+                sendHelp(sender);
             } else if (args.length == 1) {
                 if (args[0].equalsIgnoreCase("list")) {
                     List<String> portedPlayers = new ArrayList<>();
@@ -44,24 +39,22 @@ public class ViaVersionCommand implements CommandExecutor {
 
                     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")) {
+                } else if (args[0].equalsIgnoreCase("debug")) {
                     plugin.setDebug(!plugin.isDebug());
                     sender.sendMessage(color("&6Debug mode is now " + (plugin.isDebug() ? "&aenabled" : "&cdisabled")));
-                }
-                if (args[0].equalsIgnoreCase("dontbugme")) {
+                } else if (args[0].equalsIgnoreCase("dontbugme")) {
                     boolean newValue = !plugin.getConfig().getBoolean("checkforupdates", true);
                     plugin.getConfig().set("checkforupdates", newValue);
                     plugin.saveConfig();
                     sender.sendMessage(color("&6We will " + (newValue ? "&anotify you about updates." : "&cnot tell you about updates.")));
-                }
-                if (args[0].equalsIgnoreCase("autoteam")) {
+                } else if (args[0].equalsIgnoreCase("autoteam")) {
                     boolean newValue = !plugin.getConfig().getBoolean("auto-team", true);
                     plugin.getConfig().set("auto-team", newValue);
                     plugin.saveConfig();
                     sender.sendMessage(color("&6We will " + (newValue ? "&aautomatically team players" : "&cno longer auto team players")));
                     sender.sendMessage(color("&6All players will need to re-login for the change to take place."));
-
+                } else {
+                    sendHelp(sender);
                 }
             }
 
@@ -69,6 +62,15 @@ public class ViaVersionCommand implements CommandExecutor {
         return false;
     }
 
+    public void sendHelp(CommandSender sender){
+        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."));
+        sender.sendMessage(color("&2/viaversion debug &7- &6Toggle debug mode"));
+        sender.sendMessage(color("&2/viaversion autoteam &7- &6Toggle automatically teaming to prevent colliding."));
+        sender.sendMessage(color("&2/viaversion dontbugme &7- &6Toggle checking for updates."));
+    }
+
     public String color(String string) {
         return string.replace("&", "§");
     }

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

@@ -0,0 +1,36 @@
+package us.myles.ViaVersion.handlers;
+
+import io.netty.buffer.ByteBuf;
+import io.netty.channel.ChannelHandlerContext;
+import io.netty.handler.codec.MessageToMessageEncoder;
+import us.myles.ViaVersion.ConnectionInfo;
+import us.myles.ViaVersion.util.ReflectionUtil;
+
+import java.lang.reflect.Constructor;
+import java.lang.reflect.InvocationTargetException;
+import java.util.List;
+
+public class ViaChunkHandler extends MessageToMessageEncoder {
+    private final ConnectionInfo info;
+
+    public ViaChunkHandler(ConnectionInfo info) {
+        this.info = info;
+    }
+
+    @Override
+    protected void encode(ChannelHandlerContext ctx, Object o, List list) throws Exception {
+        // Split chunk bulk packet up in to single chunk packets before it reached the encoder.
+        // This will prevent issues with several plugins and other protocol handlers due to the chunk being sent twice.
+        // It also sends the chunk in the right order possible resolving some issues with added chunk/block/entity data.
+        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()) {
+                list.addAll(info.getChunkManager().transformMapChunkBulk(o));
+                return;
+            }
+        }
+
+        list.add(o);
+    }
+}

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

@@ -34,7 +34,7 @@ public class ViaDecodeHandler extends ByteToMessageDecoder {
                     incomingTransformer.transform(id, bytebuf, newPacket);
                     bytebuf.clear();
                     bytebuf = newPacket;
-                } catch (CancelException e) {
+                } catch (Exception e) {
                     bytebuf.clear();
                     throw e;
                 }

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

@@ -28,38 +28,6 @@ public class ViaEncodeHandler extends MessageToByteEncoder {
     protected void encode(final ChannelHandlerContext ctx, Object o, final 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()) {
-                final int[] locX = ReflectionUtil.get(o, "a", int[].class);
-                final int[] locZ = ReflectionUtil.get(o, "b", int[].class);
-
-                final Object world = ReflectionUtil.get(o, "world", ReflectionUtil.nms("World"));
-                Class<?> mapChunk = ReflectionUtil.nms("PacketPlayOutMapChunk");
-                final Constructor constructor = mapChunk.getDeclaredConstructor(ReflectionUtil.nms("Chunk"), boolean.class, int.class);
-                Runnable chunks = new Runnable() {
-
-                    @Override
-                    public void run() {
-
-                        for (int i = 0; i < locX.length; i++) {
-                            int x = locX[i];
-                            int z = locZ[i];
-                            // world invoke function
-                            try {
-                                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);
-                            } catch (InstantiationException | InvocationTargetException | ClassNotFoundException | IllegalAccessException | NoSuchMethodException e) {
-                                e.printStackTrace();
-                            }
-                        }
-                    }
-                };
-                chunks.run();
-                bytebuf.clear();
-                throw new CancelException();
-            }
             // call minecraft encoder
             PacketUtil.callEncode(this.minecraftEncoder, ctx, o, bytebuf);
         }
@@ -73,7 +41,7 @@ public class ViaEncodeHandler extends MessageToByteEncoder {
             bytebuf.clear();
             try {
                 outgoingTransformer.transform(id, oldPacket, bytebuf);
-            } catch (CancelException e) {
+            } catch (Exception e) {
                 bytebuf.clear();
                 throw e;
             } finally {

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

@@ -32,8 +32,10 @@ public class ViaVersionInitializer extends ChannelInitializer<SocketChannel> {
         // Add our transformers
         ViaEncodeHandler encoder = new ViaEncodeHandler(info, (MessageToByteEncoder) socketChannel.pipeline().get("encoder"));
         ViaDecodeHandler decoder = new ViaDecodeHandler(info, (ByteToMessageDecoder) socketChannel.pipeline().get("decoder"));
+        ViaChunkHandler chunkHandler = new ViaChunkHandler(info);
 
         socketChannel.pipeline().replace("encoder", "encoder", encoder);
         socketChannel.pipeline().replace("decoder", "decoder", decoder);
+        socketChannel.pipeline().addAfter("packet_handler", "viaversion_chunk_handler", chunkHandler);
     }
 }

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

@@ -33,6 +33,7 @@ public enum MetaIndex {
     PLAYER_HUMAN_BYTE(HumanEntity.class, 16, Type.Byte, NewType.Discontinued), // unused on 1.8
     PLAYER_ADDITIONAL_HEARTS(HumanEntity.class, 17, Type.Float, 10, NewType.Float),
     PLAYER_SCORE(HumanEntity.class, 18, Type.Int, 11, NewType.VarInt),
+    PLAYER_HAND(HumanEntity.class, -1, Type.NonExistent, 5, NewType.Byte), // new in 1.9
     // horse
     HORSE_INFO(Horse.class, 16, Type.Int, 12, NewType.Byte),
     HORSE_TYPE(Horse.class, 19, Type.Byte, 13, NewType.VarInt),
@@ -90,6 +91,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_PROPERTIES(Wither.class, 10, Type.Byte, NewType.Byte),
+    WITHER_UNKNOWN(Wither.class, 11, Type.Byte, NewType.Discontinued),
     // wither skull
     WITHERSKULL_INVULN(WitherSkull.class, 10, Type.Byte, 5, NewType.Boolean),
     // guardian
@@ -122,7 +125,13 @@ public enum MetaIndex {
     ITEMFRAME_ITEM(ItemFrame.class, 8, Type.Slot, 5, NewType.Slot),
     ITEMFRAME_ROTATION(ItemFrame.class, 9, Type.Byte, 6, NewType.VarInt),
     // ender crystal
-    ENDERCRYSTAL_HEALTH(EnderCrystal.class, 8, Type.Int, NewType.Discontinued),;
+    ENDERCRYSTAL_HEALTH(EnderCrystal.class, 8, Type.Int, NewType.Discontinued),
+    // Ender dragon boss bar issues
+    ENDERDRAGON_UNKNOWN(EnderDragon.class, 5, Type.Byte, NewType.Discontinued),
+    ENDERDRAGON_NAME(EnderDragon.class, 10, Type.String, NewType.Discontinued),
+    // Normal Ender dragon
+    ENDERDRAGON_FLAG(EnderDragon.class, 15, Type.Byte, NewType.Discontinued),
+    ENDERDRAGON_PHASE(EnderDragon.class, 11, Type.Byte, NewType.VarInt);
 
     private Class<?> clazz;
     private int newIndex;

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

@@ -6,6 +6,8 @@ import lombok.Setter;
 import org.bukkit.entity.EntityType;
 import org.bukkit.util.EulerAngle;
 import org.bukkit.util.Vector;
+import us.myles.ViaVersion.ViaVersionPlugin;
+import us.myles.ViaVersion.api.ViaVersion;
 import us.myles.ViaVersion.slot.ItemSlotRewriter;
 import us.myles.ViaVersion.slot.ItemSlotRewriter.ItemStack;
 import us.myles.ViaVersion.transformers.OutgoingTransformer;
@@ -38,6 +40,16 @@ public class MetadataRewriter {
                             if (metaIndex.getOldType() == Type.Int) {
                                 output.writeByte(((Integer) value).byteValue());
                             }
+                            // After writing the last one
+                            if (metaIndex == MetaIndex.ENTITY_STATUS && type == EntityType.PLAYER) {
+                                output.writeByte(MetaIndex.PLAYER_HAND.getNewIndex());
+                                output.writeByte(MetaIndex.PLAYER_HAND.getNewType().getTypeID());
+                                if ((((Byte) value) & 0x10) == 0x10) { // Player eating/aiming/drinking
+                                    output.writeByte(1); // Using main hand
+                                } else {
+                                    output.writeByte(0); // Not using any hand to stop animation
+                                }
+                            }
                             break;
                         case OptUUID:
                             String owner = (String) value;
@@ -117,16 +129,18 @@ public class MetadataRewriter {
                     }
                 }
             } catch (Exception e) {
-                System.out.println("INCLUDE THIS IN YOUR ERROR LOG!");
-                if (type != null)
-                    System.out.println("An error occurred with entity meta data for " + type + " OldID: " + entry.oldID);
-                else
-                    System.out.println("An error occurred with entity meta data for UNKOWN_ENTITY 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());
+                if (!((ViaVersionPlugin) ViaVersion.getInstance()).isSuppressMetadataErrors()) {
+                    System.out.println("INCLUDE THIS IN YOUR ERROR LOG!");
+                    if (type != null)
+                        System.out.println("An error occurred with entity meta data for " + type + " OldID: " + entry.oldID);
+                    else
+                        System.out.println("An error occurred with entity meta data for UNKNOWN_ENTITY 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();
                 }
-                e.printStackTrace();
             }
         }
         output.writeByte(255);
@@ -193,7 +207,7 @@ public class MetadataRewriter {
         private MetaIndex index;
         private Object value;
 
-        private Entry(MetaIndex index, Object value, int id) {
+        public 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

@@ -13,7 +13,8 @@ public enum Type {
     String(4),
     Slot(5),
     Position(6),
-    Rotation(7);
+    Rotation(7),
+    NonExistent(-1);
     private final int typeID;
 
     public static Type byId(int id) {

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

@@ -1,200 +1,203 @@
-package us.myles.ViaVersion.packets;
-
-public enum PacketType {
-    /* Handshake serverbound */
-    HANDSHAKE(State.HANDSHAKE, Direction.INCOMING, 0x00),
-    /* Login serverbound */
-    LOGIN_START(State.LOGIN, Direction.INCOMING, 0x00),
-    LOGIN_ENCRYPTION_RESPONSE(State.LOGIN, Direction.INCOMING, 0x01),
-    /* Login clientbound */
-    LOGIN_DISCONNECT(State.LOGIN, Direction.OUTGOING, 0x00),
-    LOGIN_ENCRYPTION_REQUEST(State.LOGIN, Direction.OUTGOING, 0x01),
-    LOGIN_SUCCESS(State.LOGIN, Direction.OUTGOING, 0x02),
-    LOGIN_SETCOMPRESSION(State.LOGIN, Direction.OUTGOING, 0x03),
-    /* Status serverbound */
-    STATUS_REQUEST(State.STATUS, Direction.INCOMING, 0x00),
-    STATUS_PING(State.STATUS, Direction.INCOMING, 0x01),
-    /* Status clientbound */
-    STATUS_RESPONSE(State.STATUS, Direction.OUTGOING, 0x00),
-    STATUS_PONG(State.STATUS, Direction.OUTGOING, 0x01),
-    /* Play serverbound */
-    PLAY_TP_CONFIRM(State.PLAY, Direction.INCOMING, -1, 0x00),
-    PLAY_TAB_COMPLETE_REQUEST(State.PLAY, Direction.INCOMING, 0x14, 0x01),
-    PLAY_CHAT_MESSAGE_CLIENT(State.PLAY, Direction.INCOMING, 0x01, 0x02),
-    PLAY_CLIENT_STATUS(State.PLAY, Direction.INCOMING, 0x16, 0x03),
-    PLAY_CLIENT_SETTINGS(State.PLAY, Direction.INCOMING, 0x15, 0x04),
-    PLAY_CONFIRM_TRANS(State.PLAY, Direction.INCOMING, 0x0F, 0x05),
-    PLAY_ENCHANT_ITEM(State.PLAY, Direction.INCOMING, 0x11, 0x06),
-    PLAY_CLICK_WINDOW(State.PLAY, Direction.INCOMING, 0x0E, 0x07),
-    PLAY_CLOSE_WINDOW_REQUEST(State.PLAY, Direction.INCOMING, 0x0D, 0x08),
-    PLAY_PLUGIN_MESSAGE_REQUEST(State.PLAY, Direction.INCOMING, 0x17, 0x09),
-    PLAY_USE_ENTITY(State.PLAY, Direction.INCOMING, 0x02, 0x0A),
-    PLAY_KEEP_ALIVE_REQUEST(State.PLAY, Direction.INCOMING, 0x00, 0x0B),
-    PLAY_PLAYER_POSITION_REQUEST(State.PLAY, Direction.INCOMING, 0x04, 0x0C),
-    PLAY_PLAYER_POSITION_LOOK_REQUEST(State.PLAY, Direction.INCOMING, 0x06, 0x0D),
-    PLAY_PLAYER_LOOK_REQUEST(State.PLAY, Direction.INCOMING, 0x05, 0x0E),
-    PLAY_PLAYER(State.PLAY, Direction.INCOMING, 0x03, 0x0F),
-    PLAY_VEHICLE_MOVE_REQUEST(State.PLAY, Direction.INCOMING, -1, 0x10),
-    PLAY_STEER_BOAT(State.PLAY, Direction.INCOMING, -1, 0x11),
-    PLAY_PLAYER_ABILITIES_REQUEST(State.PLAY, Direction.INCOMING, 0x13, 0x12),
-    PLAY_PLAYER_DIGGING(State.PLAY, Direction.INCOMING, 0x07, 0x13),
-    PLAY_ENTITY_ACTION(State.PLAY, Direction.INCOMING, 0x0B, 0x14),
-    PLAY_STEER_VEHICLE(State.PLAY, Direction.INCOMING, 0x0C, 0x15),
-    PLAY_RESOURCE_PACK_STATUS(State.PLAY, Direction.INCOMING, 0x19, 0x16),
-    PLAY_HELD_ITEM_CHANGE_REQUEST(State.PLAY, Direction.INCOMING, 0x09, 0x17),
-    PLAY_CREATIVE_INVENTORY_ACTION(State.PLAY, Direction.INCOMING, 0x10, 0x18),
-    PLAY_UPDATE_SIGN_REQUEST(State.PLAY, Direction.INCOMING, 0x12, 0x19),
-    PLAY_ANIMATION_REQUEST(State.PLAY, Direction.INCOMING, 0x0A, 0x1A),
-    PLAY_SPECTATE(State.PLAY, Direction.INCOMING, 0x18, 0x1B),
-    PLAY_PLAYER_BLOCK_PLACEMENT(State.PLAY, Direction.INCOMING, 0x08, 0x1C),
-    PLAY_USE_ITEM(State.PLAY, Direction.INCOMING, -1, 0x1D),
-    /* Play clientbound */
-    PLAY_SPAWN_OBJECT(State.PLAY, Direction.OUTGOING, 0x0E, 0x00),
-    PLAY_SPAWN_XP_ORB(State.PLAY, Direction.OUTGOING, 0x11, 0x01),
-    PLAY_SPAWN_GLOBAL_ENTITY(State.PLAY, Direction.OUTGOING, 0x2C, 0x02),
-    PLAY_SPAWN_MOB(State.PLAY, Direction.OUTGOING, 0x0F, 0x03),
-    PLAY_SPAWN_PAINTING(State.PLAY, Direction.OUTGOING, 0x10, 0x04),
-    PLAY_SPAWN_PLAYER(State.PLAY, Direction.OUTGOING, 0x0C, 0x05),
-    PLAY_ANIMATION(State.PLAY, Direction.OUTGOING, 0x0B, 0x06),
-    PLAY_STATS(State.PLAY, Direction.OUTGOING, 0x37, 0x07),
-    PLAY_BLOCK_BREAK_ANIMATION(State.PLAY, Direction.OUTGOING, 0x25, 0x08),
-    PLAY_UPDATE_BLOCK_ENTITY(State.PLAY, Direction.OUTGOING, 0x35, 0x09),
-    PLAY_BLOCK_ACTION(State.PLAY, Direction.OUTGOING, 0x24, 0x0A),
-    PLAY_BLOCK_CHANGE(State.PLAY, Direction.OUTGOING, 0x23, 0x0B),
-    PLAY_BOSS_BAR(State.PLAY, Direction.OUTGOING, -1, 0x0C),
-    PLAY_SERVER_DIFFICULTY(State.PLAY, Direction.OUTGOING, 0x41, 0x0D),
-    PLAY_TAB_COMPLETE(State.PLAY, Direction.OUTGOING, 0x3A, 0x0E),
-    PLAY_CHAT_MESSAGE(State.PLAY, Direction.OUTGOING, 0x02, 0x0F),
-    PLAY_MULTI_BLOCK_CHANGE(State.PLAY, Direction.OUTGOING, 0x22, 0x10),
-    PLAY_CONFIRM_TRANSACTION(State.PLAY, Direction.OUTGOING, 0x32, 0x11),
-    PLAY_CLOSE_WINDOW(State.PLAY, Direction.OUTGOING, 0x2E, 0x12),
-    PLAY_OPEN_WINDOW(State.PLAY, Direction.OUTGOING, 0x2D, 0x13),
-    PLAY_WINDOW_ITEMS(State.PLAY, Direction.OUTGOING, 0x30, 0x14),
-    PLAY_WINDOW_PROPERTY(State.PLAY, Direction.OUTGOING, 0x31, 0x15),
-    PLAY_SET_SLOT(State.PLAY, Direction.OUTGOING, 0x2F, 0x16),
-    PLAY_SET_COOLDOWN(State.PLAY, Direction.OUTGOING, -1, 0x17),
-    PLAY_PLUGIN_MESSAGE(State.PLAY, Direction.OUTGOING, 0x3F, 0x18),
-    PLAY_NAMED_SOUND_EFFECT(State.PLAY, Direction.OUTGOING, 0x29, 0x19),
-    PLAY_DISCONNECT(State.PLAY, Direction.OUTGOING, 0x40, 0x1A),
-    PLAY_ENTITY_STATUS(State.PLAY, Direction.OUTGOING, 0x1A, 0x1B),
-    PLAY_EXPLOSION(State.PLAY, Direction.OUTGOING, 0x27, 0x1C),
-    PLAY_UNLOAD_CHUNK(State.PLAY, Direction.OUTGOING, -1, 0x1D),
-    PLAY_CHANGE_GAME_STATE(State.PLAY, Direction.OUTGOING, 0x2B, 0x1E),
-    PLAY_KEEP_ALIVE(State.PLAY, Direction.OUTGOING, 0x00, 0x1F),
-    PLAY_CHUNK_DATA(State.PLAY, Direction.OUTGOING, 0x21, 0x20),
-    PLAY_EFFECT(State.PLAY, Direction.OUTGOING, 0x28, 0x21),
-    PLAY_PARTICLE(State.PLAY, Direction.OUTGOING, 0x2A, 0x22),
-    PLAY_JOIN_GAME(State.PLAY, Direction.OUTGOING, 0x01, 0x23),
-    PLAY_MAP(State.PLAY, Direction.OUTGOING, 0x34, 0x24),
-    PLAY_ENTITY_RELATIVE_MOVE(State.PLAY, Direction.OUTGOING, 0x15, 0x25),
-    PLAY_ENTITY_LOOK_MOVE(State.PLAY, Direction.OUTGOING, 0x17, 0x26),
-    PLAY_ENTITY_LOOK(State.PLAY, Direction.OUTGOING, 0x16, 0x27),
-    PLAY_ENTITY(State.PLAY, Direction.OUTGOING, 0x14, 0x28),
-    PLAY_VEHICLE_MOVE(State.PLAY, Direction.OUTGOING, -1, 0x29),
-    PLAY_OPEN_SIGN_EDITOR(State.PLAY, Direction.OUTGOING, 0x36, 0x2A),
-    PLAY_PLAYER_ABILITIES(State.PLAY, Direction.OUTGOING, 0x39, 0x2B),
-    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, 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),
-    PLAY_RESPAWN(State.PLAY, Direction.OUTGOING, 0x07, 0x33),
-    PLAY_ENTITY_HEAD_LOOK(State.PLAY, Direction.OUTGOING, 0x19, 0x34),
-    PLAY_WORLD_BORDER(State.PLAY, Direction.OUTGOING, 0x44, 0x35),
-    PLAY_CAMERA(State.PLAY, Direction.OUTGOING, 0x43, 0x36),
-    PLAY_HELD_ITEM_CHANGE(State.PLAY, Direction.OUTGOING, 0x09, 0x37),
-    PLAY_DISPLAY_SCOREBOARD(State.PLAY, Direction.OUTGOING, 0x3D, 0x38),
-    PLAY_ENTITY_METADATA(State.PLAY, Direction.OUTGOING, 0x1C, 0x39),
-    PLAY_ATTACH_ENTITY(State.PLAY, Direction.OUTGOING, 0x1B, 0x3A),
-    PLAY_ENTITY_VELOCITY(State.PLAY, Direction.OUTGOING, 0x12, 0x3B),
-    PLAY_ENTITY_EQUIPMENT(State.PLAY, Direction.OUTGOING, 0x04, 0x3C),
-    PLAY_SET_XP(State.PLAY, Direction.OUTGOING, 0x1F, 0x3D),
-    PLAY_UPDATE_HEALTH(State.PLAY, Direction.OUTGOING, 0x06, 0x3E),
-    PLAY_SCOREBOARD_OBJ(State.PLAY, Direction.OUTGOING, 0x3B, 0x3F),
-    PLAY_SET_PASSENGERS(State.PLAY, Direction.OUTGOING, -1, 0x40),
-    PLAY_TEAM(State.PLAY, Direction.OUTGOING, 0x3E, 0x41),
-    PLAY_UPDATE_SCORE(State.PLAY, Direction.OUTGOING, 0x3C, 0x42),
-    PLAY_SPAWN_POSITION(State.PLAY, Direction.OUTGOING, 0x05, 0x43),
-    PLAY_TIME_UPDATE(State.PLAY, Direction.OUTGOING, 0x03, 0x44),
-    PLAY_TITLE(State.PLAY, Direction.OUTGOING, 0x45, 0x45),
-    PLAY_UPDATE_SIGN(State.PLAY, Direction.OUTGOING, 0x33, 0x46),
-    PLAY_SOUND_EFFECT(State.PLAY, Direction.OUTGOING, -1, 0x47),
-    PLAY_PLAYER_LIST_HEADER_FOOTER(State.PLAY, Direction.OUTGOING, 0x47, 0x48),
-    PLAY_COLLECT_ITEM(State.PLAY, Direction.OUTGOING, 0x0D, 0x49),
-    PLAY_ENTITY_TELEPORT(State.PLAY, Direction.OUTGOING, 0x18, 0x4A),
-    PLAY_ENTITY_PROPERTIES(State.PLAY, Direction.OUTGOING, 0x20, 0x4B),
-    PLAY_ENTITY_EFFECT(State.PLAY, Direction.OUTGOING, 0x1D, 0x4C),
-
-    PLAY_MAP_CHUNK_BULK(State.PLAY, Direction.OUTGOING, 0x26, -1),
-    PLAY_SET_COMPRESSION(State.PLAY, Direction.OUTGOING, 0x46, -1),
-    PLAY_UPDATE_ENTITY_NBT(State.PLAY, Direction.OUTGOING, 0x49, -1),;
-
-    private State state;
-    private Direction direction;
-    private int packetID;
-    private int newPacketID = -1;
-
-    PacketType(State state, Direction direction, int packetID) {
-        this.state = state;
-        this.direction = direction;
-        this.packetID = packetID;
-        this.newPacketID = packetID;
-    }
-
-    PacketType(State state, Direction direction, int packetID, int newPacketID) {
-        this.state = state;
-        this.direction = direction;
-        this.packetID = packetID;
-        this.newPacketID = newPacketID;
-    }
-
-    public State getState() {
-        return state;
-    }
-
-    public Direction getDirection() {
-        return direction;
-    }
-
-    public int getPacketID() {
-        return packetID;
-    }
-
-    public int getNewPacketID() {
-        return newPacketID;
-    }
-
-    public static PacketType findNewPacket(State state, Direction direction, int id) {
-    	if(id == -1)
-    		return null;
-        for (PacketType pt : values()) {
-            if (pt.getNewPacketID() == id
-                    && pt.getState() == state
-                    && pt.getDirection() == direction)
-                return pt;
-        }
-        return null;
-    }
-
-    public static PacketType findOldPacket(State state, Direction direction, int id) {
-    	if(id == -1)
-    		return null;
-        for (PacketType pt : values()) {
-            if (pt.getPacketID() == id
-                    && pt.getState() == state
-                    && pt.getDirection() == direction)
-                return pt;
-        }
-        return null;
-    }
-
-    public static PacketType getIncomingPacket(State state, int id) {
-        return findNewPacket(state, Direction.INCOMING, id);
-    }
-
-    public static PacketType getOutgoingPacket(State state, int id) {
-        return findOldPacket(state, Direction.OUTGOING, id);
-    }
-}
+package us.myles.ViaVersion.packets;
+
+import java.util.HashMap;
+
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.Table;
+
+public enum PacketType {
+    /* Handshake serverbound */
+    HANDSHAKE(State.HANDSHAKE, Direction.INCOMING, 0x00),
+    /* Login serverbound */
+    LOGIN_START(State.LOGIN, Direction.INCOMING, 0x00),
+    LOGIN_ENCRYPTION_RESPONSE(State.LOGIN, Direction.INCOMING, 0x01),
+    /* Login clientbound */
+    LOGIN_DISCONNECT(State.LOGIN, Direction.OUTGOING, 0x00),
+    LOGIN_ENCRYPTION_REQUEST(State.LOGIN, Direction.OUTGOING, 0x01),
+    LOGIN_SUCCESS(State.LOGIN, Direction.OUTGOING, 0x02),
+    LOGIN_SETCOMPRESSION(State.LOGIN, Direction.OUTGOING, 0x03),
+    /* Status serverbound */
+    STATUS_REQUEST(State.STATUS, Direction.INCOMING, 0x00),
+    STATUS_PING(State.STATUS, Direction.INCOMING, 0x01),
+    /* Status clientbound */
+    STATUS_RESPONSE(State.STATUS, Direction.OUTGOING, 0x00),
+    STATUS_PONG(State.STATUS, Direction.OUTGOING, 0x01),
+    /* Play serverbound */
+    PLAY_TP_CONFIRM(State.PLAY, Direction.INCOMING, -1, 0x00),
+    PLAY_TAB_COMPLETE_REQUEST(State.PLAY, Direction.INCOMING, 0x14, 0x01),
+    PLAY_CHAT_MESSAGE_CLIENT(State.PLAY, Direction.INCOMING, 0x01, 0x02),
+    PLAY_CLIENT_STATUS(State.PLAY, Direction.INCOMING, 0x16, 0x03),
+    PLAY_CLIENT_SETTINGS(State.PLAY, Direction.INCOMING, 0x15, 0x04),
+    PLAY_CONFIRM_TRANS(State.PLAY, Direction.INCOMING, 0x0F, 0x05),
+    PLAY_ENCHANT_ITEM(State.PLAY, Direction.INCOMING, 0x11, 0x06),
+    PLAY_CLICK_WINDOW(State.PLAY, Direction.INCOMING, 0x0E, 0x07),
+    PLAY_CLOSE_WINDOW_REQUEST(State.PLAY, Direction.INCOMING, 0x0D, 0x08),
+    PLAY_PLUGIN_MESSAGE_REQUEST(State.PLAY, Direction.INCOMING, 0x17, 0x09),
+    PLAY_USE_ENTITY(State.PLAY, Direction.INCOMING, 0x02, 0x0A),
+    PLAY_KEEP_ALIVE_REQUEST(State.PLAY, Direction.INCOMING, 0x00, 0x0B),
+    PLAY_PLAYER_POSITION_REQUEST(State.PLAY, Direction.INCOMING, 0x04, 0x0C),
+    PLAY_PLAYER_POSITION_LOOK_REQUEST(State.PLAY, Direction.INCOMING, 0x06, 0x0D),
+    PLAY_PLAYER_LOOK_REQUEST(State.PLAY, Direction.INCOMING, 0x05, 0x0E),
+    PLAY_PLAYER(State.PLAY, Direction.INCOMING, 0x03, 0x0F),
+    PLAY_VEHICLE_MOVE_REQUEST(State.PLAY, Direction.INCOMING, -1, 0x10),
+    PLAY_STEER_BOAT(State.PLAY, Direction.INCOMING, -1, 0x11),
+    PLAY_PLAYER_ABILITIES_REQUEST(State.PLAY, Direction.INCOMING, 0x13, 0x12),
+    PLAY_PLAYER_DIGGING(State.PLAY, Direction.INCOMING, 0x07, 0x13),
+    PLAY_ENTITY_ACTION(State.PLAY, Direction.INCOMING, 0x0B, 0x14),
+    PLAY_STEER_VEHICLE(State.PLAY, Direction.INCOMING, 0x0C, 0x15),
+    PLAY_RESOURCE_PACK_STATUS(State.PLAY, Direction.INCOMING, 0x19, 0x16),
+    PLAY_HELD_ITEM_CHANGE_REQUEST(State.PLAY, Direction.INCOMING, 0x09, 0x17),
+    PLAY_CREATIVE_INVENTORY_ACTION(State.PLAY, Direction.INCOMING, 0x10, 0x18),
+    PLAY_UPDATE_SIGN_REQUEST(State.PLAY, Direction.INCOMING, 0x12, 0x19),
+    PLAY_ANIMATION_REQUEST(State.PLAY, Direction.INCOMING, 0x0A, 0x1A),
+    PLAY_SPECTATE(State.PLAY, Direction.INCOMING, 0x18, 0x1B),
+    PLAY_PLAYER_BLOCK_PLACEMENT(State.PLAY, Direction.INCOMING, 0x08, 0x1C),
+    PLAY_USE_ITEM(State.PLAY, Direction.INCOMING, -1, 0x1D),
+    /* Play clientbound */
+    PLAY_SPAWN_OBJECT(State.PLAY, Direction.OUTGOING, 0x0E, 0x00),
+    PLAY_SPAWN_XP_ORB(State.PLAY, Direction.OUTGOING, 0x11, 0x01),
+    PLAY_SPAWN_GLOBAL_ENTITY(State.PLAY, Direction.OUTGOING, 0x2C, 0x02),
+    PLAY_SPAWN_MOB(State.PLAY, Direction.OUTGOING, 0x0F, 0x03),
+    PLAY_SPAWN_PAINTING(State.PLAY, Direction.OUTGOING, 0x10, 0x04),
+    PLAY_SPAWN_PLAYER(State.PLAY, Direction.OUTGOING, 0x0C, 0x05),
+    PLAY_ANIMATION(State.PLAY, Direction.OUTGOING, 0x0B, 0x06),
+    PLAY_STATS(State.PLAY, Direction.OUTGOING, 0x37, 0x07),
+    PLAY_BLOCK_BREAK_ANIMATION(State.PLAY, Direction.OUTGOING, 0x25, 0x08),
+    PLAY_UPDATE_BLOCK_ENTITY(State.PLAY, Direction.OUTGOING, 0x35, 0x09),
+    PLAY_BLOCK_ACTION(State.PLAY, Direction.OUTGOING, 0x24, 0x0A),
+    PLAY_BLOCK_CHANGE(State.PLAY, Direction.OUTGOING, 0x23, 0x0B),
+    PLAY_BOSS_BAR(State.PLAY, Direction.OUTGOING, -1, 0x0C),
+    PLAY_SERVER_DIFFICULTY(State.PLAY, Direction.OUTGOING, 0x41, 0x0D),
+    PLAY_TAB_COMPLETE(State.PLAY, Direction.OUTGOING, 0x3A, 0x0E),
+    PLAY_CHAT_MESSAGE(State.PLAY, Direction.OUTGOING, 0x02, 0x0F),
+    PLAY_MULTI_BLOCK_CHANGE(State.PLAY, Direction.OUTGOING, 0x22, 0x10),
+    PLAY_CONFIRM_TRANSACTION(State.PLAY, Direction.OUTGOING, 0x32, 0x11),
+    PLAY_CLOSE_WINDOW(State.PLAY, Direction.OUTGOING, 0x2E, 0x12),
+    PLAY_OPEN_WINDOW(State.PLAY, Direction.OUTGOING, 0x2D, 0x13),
+    PLAY_WINDOW_ITEMS(State.PLAY, Direction.OUTGOING, 0x30, 0x14),
+    PLAY_WINDOW_PROPERTY(State.PLAY, Direction.OUTGOING, 0x31, 0x15),
+    PLAY_SET_SLOT(State.PLAY, Direction.OUTGOING, 0x2F, 0x16),
+    PLAY_SET_COOLDOWN(State.PLAY, Direction.OUTGOING, -1, 0x17),
+    PLAY_PLUGIN_MESSAGE(State.PLAY, Direction.OUTGOING, 0x3F, 0x18),
+    PLAY_NAMED_SOUND_EFFECT(State.PLAY, Direction.OUTGOING, 0x29, 0x19),
+    PLAY_DISCONNECT(State.PLAY, Direction.OUTGOING, 0x40, 0x1A),
+    PLAY_ENTITY_STATUS(State.PLAY, Direction.OUTGOING, 0x1A, 0x1B),
+    PLAY_EXPLOSION(State.PLAY, Direction.OUTGOING, 0x27, 0x1C),
+    PLAY_UNLOAD_CHUNK(State.PLAY, Direction.OUTGOING, -1, 0x1D),
+    PLAY_CHANGE_GAME_STATE(State.PLAY, Direction.OUTGOING, 0x2B, 0x1E),
+    PLAY_KEEP_ALIVE(State.PLAY, Direction.OUTGOING, 0x00, 0x1F),
+    PLAY_CHUNK_DATA(State.PLAY, Direction.OUTGOING, 0x21, 0x20),
+    PLAY_EFFECT(State.PLAY, Direction.OUTGOING, 0x28, 0x21),
+    PLAY_PARTICLE(State.PLAY, Direction.OUTGOING, 0x2A, 0x22),
+    PLAY_JOIN_GAME(State.PLAY, Direction.OUTGOING, 0x01, 0x23),
+    PLAY_MAP(State.PLAY, Direction.OUTGOING, 0x34, 0x24),
+    PLAY_ENTITY_RELATIVE_MOVE(State.PLAY, Direction.OUTGOING, 0x15, 0x25),
+    PLAY_ENTITY_LOOK_MOVE(State.PLAY, Direction.OUTGOING, 0x17, 0x26),
+    PLAY_ENTITY_LOOK(State.PLAY, Direction.OUTGOING, 0x16, 0x27),
+    PLAY_ENTITY(State.PLAY, Direction.OUTGOING, 0x14, 0x28),
+    PLAY_VEHICLE_MOVE(State.PLAY, Direction.OUTGOING, -1, 0x29),
+    PLAY_OPEN_SIGN_EDITOR(State.PLAY, Direction.OUTGOING, 0x36, 0x2A),
+    PLAY_PLAYER_ABILITIES(State.PLAY, Direction.OUTGOING, 0x39, 0x2B),
+    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, 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),
+    PLAY_RESPAWN(State.PLAY, Direction.OUTGOING, 0x07, 0x33),
+    PLAY_ENTITY_HEAD_LOOK(State.PLAY, Direction.OUTGOING, 0x19, 0x34),
+    PLAY_WORLD_BORDER(State.PLAY, Direction.OUTGOING, 0x44, 0x35),
+    PLAY_CAMERA(State.PLAY, Direction.OUTGOING, 0x43, 0x36),
+    PLAY_HELD_ITEM_CHANGE(State.PLAY, Direction.OUTGOING, 0x09, 0x37),
+    PLAY_DISPLAY_SCOREBOARD(State.PLAY, Direction.OUTGOING, 0x3D, 0x38),
+    PLAY_ENTITY_METADATA(State.PLAY, Direction.OUTGOING, 0x1C, 0x39),
+    PLAY_ATTACH_ENTITY(State.PLAY, Direction.OUTGOING, 0x1B, 0x3A),
+    PLAY_ENTITY_VELOCITY(State.PLAY, Direction.OUTGOING, 0x12, 0x3B),
+    PLAY_ENTITY_EQUIPMENT(State.PLAY, Direction.OUTGOING, 0x04, 0x3C),
+    PLAY_SET_XP(State.PLAY, Direction.OUTGOING, 0x1F, 0x3D),
+    PLAY_UPDATE_HEALTH(State.PLAY, Direction.OUTGOING, 0x06, 0x3E),
+    PLAY_SCOREBOARD_OBJ(State.PLAY, Direction.OUTGOING, 0x3B, 0x3F),
+    PLAY_SET_PASSENGERS(State.PLAY, Direction.OUTGOING, -1, 0x40),
+    PLAY_TEAM(State.PLAY, Direction.OUTGOING, 0x3E, 0x41),
+    PLAY_UPDATE_SCORE(State.PLAY, Direction.OUTGOING, 0x3C, 0x42),
+    PLAY_SPAWN_POSITION(State.PLAY, Direction.OUTGOING, 0x05, 0x43),
+    PLAY_TIME_UPDATE(State.PLAY, Direction.OUTGOING, 0x03, 0x44),
+    PLAY_TITLE(State.PLAY, Direction.OUTGOING, 0x45, 0x45),
+    PLAY_UPDATE_SIGN(State.PLAY, Direction.OUTGOING, 0x33, 0x46),
+    PLAY_SOUND_EFFECT(State.PLAY, Direction.OUTGOING, -1, 0x47),
+    PLAY_PLAYER_LIST_HEADER_FOOTER(State.PLAY, Direction.OUTGOING, 0x47, 0x48),
+    PLAY_COLLECT_ITEM(State.PLAY, Direction.OUTGOING, 0x0D, 0x49),
+    PLAY_ENTITY_TELEPORT(State.PLAY, Direction.OUTGOING, 0x18, 0x4A),
+    PLAY_ENTITY_PROPERTIES(State.PLAY, Direction.OUTGOING, 0x20, 0x4B),
+    PLAY_ENTITY_EFFECT(State.PLAY, Direction.OUTGOING, 0x1D, 0x4C),
+
+    PLAY_MAP_CHUNK_BULK(State.PLAY, Direction.OUTGOING, 0x26, -1),
+    PLAY_SET_COMPRESSION(State.PLAY, Direction.OUTGOING, 0x46, -1),
+    PLAY_UPDATE_ENTITY_NBT(State.PLAY, Direction.OUTGOING, 0x49, -1),;
+
+    private State state;
+    private Direction direction;
+    private int packetID;
+    private int newPacketID = -1;
+
+    PacketType(State state, Direction direction, int packetID) {
+        this.state = state;
+        this.direction = direction;
+        this.packetID = packetID;
+        this.newPacketID = packetID;
+    }
+
+    PacketType(State state, Direction direction, int packetID, int newPacketID) {
+        this.state = state;
+        this.direction = direction;
+        this.packetID = packetID;
+        this.newPacketID = newPacketID;
+    }
+
+    public State getState() {
+        return state;
+    }
+
+    public Direction getDirection() {
+        return direction;
+    }
+
+    public int getPacketID() {
+        return packetID;
+    }
+
+    public int getNewPacketID() {
+        return newPacketID;
+    }
+
+    public static PacketType findNewPacket(State state, Direction direction, int id) {
+    	return newids.get(toShort((short) id, (short)direction.ordinal(), (short) state.ordinal()));
+    }
+
+    public static PacketType findOldPacket(State state, Direction direction, int id) {
+    	return oldids.get(toShort((short) id, (short)direction.ordinal(), (short) state.ordinal()));
+    }
+
+    public static PacketType getIncomingPacket(State state, int id) {
+        return findNewPacket(state, Direction.INCOMING, id);
+    }
+
+    public static PacketType getOutgoingPacket(State state, int id) {
+        return findOldPacket(state, Direction.OUTGOING, id);
+    }
+	
+	private static short toShort(short id, short direction, short state) {
+		return (short) ((id & 0x00FF) | (direction<<8) & 0x0F00 | (state << 12) & 0xF000);
+	}
+
+    private static HashMap<Short, PacketType> oldids = new HashMap<Short, PacketType>();
+    private static HashMap<Short, PacketType> newids = new HashMap<Short, PacketType>();
+    static {
+    	for(PacketType pt : PacketType.values()) {
+    		oldids.put(toShort((short) pt.getPacketID(), (short)pt.getDirection().ordinal(), (short)pt.getState().ordinal()), pt);
+    		newids.put(toShort((short) pt.getNewPacketID(), (short)pt.getDirection().ordinal(), (short)pt.getState().ordinal()), pt);
+    	}
+    }
+    
+}

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

@@ -16,7 +16,9 @@ import us.myles.ViaVersion.util.PacketUtil;
 import java.io.IOException;
 
 public class IncomingTransformer {
+    private final ViaVersionPlugin plugin = (ViaVersionPlugin) ViaVersion.getInstance();
     private final ConnectionInfo info;
+    private boolean startedBlocking = false;
 
     public IncomingTransformer(ConnectionInfo info) {
         this.info = info;
@@ -33,7 +35,7 @@ public class IncomingTransformer {
         if (packet.getPacketID() != -1) {
             packetID = packet.getPacketID();
         }
-        if (ViaVersion.getInstance().isDebug()) {
+        if (plugin.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());
             }
@@ -41,6 +43,11 @@ public class IncomingTransformer {
         if (packet == PacketType.PLAY_TP_CONFIRM || packet == PacketType.PLAY_VEHICLE_MOVE_REQUEST) { //TODO handle client-sided horse riding
             throw new CancelException();
         }
+        // Handle movement increment
+        // Update idle status (player, position, look, positionandlook)
+        if(packet == PacketType.PLAY_PLAYER || packet == PacketType.PLAY_PLAYER_POSITION_REQUEST || packet == PacketType.PLAY_PLAYER_LOOK_REQUEST || packet == PacketType.PLAY_PLAYER_POSITION_LOOK_REQUEST) {
+            info.incrementIdlePacket();
+        }
         PacketUtil.writeVarInt(packetID, output);
         if (packet == PacketType.HANDSHAKE) {
             int protVer = PacketUtil.readVarInt(input);
@@ -87,14 +94,30 @@ public class IncomingTransformer {
         }
         if (packet == PacketType.PLAY_PLAYER_DIGGING) {
             int status = input.readByte() & 0xFF; // unsign
+            if (status == 5 && startedBlocking) {
+                // stopped blocking
+                startedBlocking = false;
+                sendSecondHandItem(null);
+            }
             if (status == 6) { // item swap
                 throw new CancelException();
             }
             output.writeByte(status);
             // write remaining bytes
-            output.writeBytes(input);
+            Long position = input.readLong();
+            output.writeLong(position);
+
+            int face = input.readUnsignedByte();
+            output.writeByte(face);
             return;
         }
+        if (packet == PacketType.PLAY_HELD_ITEM_CHANGE_REQUEST) {
+            if (startedBlocking) {
+                // stopped blocking
+                startedBlocking = false;
+                sendSecondHandItem(null);
+            }
+        }
         if (packet == PacketType.PLAY_CLICK_WINDOW) {
             // if placed in new slot, reject :)
             int windowID = input.readUnsignedByte();
@@ -250,7 +273,7 @@ public class IncomingTransformer {
             output.writeByte(face);
             PacketUtil.readVarInt(input);
 
-            ItemStack inHand = ViaVersionPlugin.getHandItem(info);
+            ItemStack inHand = plugin.getHandItem(info);
             try {
                 ItemSlotRewriter.ItemStack item = ItemSlotRewriter.ItemStack.fromBukkit(inHand);
                 ItemSlotRewriter.fixIdsFrom1_9To1_8(item);
@@ -258,23 +281,39 @@ public class IncomingTransformer {
             } catch (Exception e) {
                 e.printStackTrace();
             }
-
-            short curX = input.readUnsignedByte();
-            output.writeByte(curX);
-            short curY = input.readUnsignedByte();
-            output.writeByte(curY);
-            short curZ = input.readUnsignedByte();
-            output.writeByte(curZ);
-            return;
+	        short curX = input.readUnsignedByte();
+	        output.writeByte(curX);
+	        short curY = input.readUnsignedByte();
+	        output.writeByte(curY);
+	        short curZ = input.readUnsignedByte();
+	        output.writeByte(curZ);
+	        return;
         }
         if (packet == PacketType.PLAY_USE_ITEM) {
+            int hand = PacketUtil.readVarInt(input);
             output.clear();
             PacketUtil.writeVarInt(PacketType.PLAY_PLAYER_BLOCK_PLACEMENT.getPacketID(), output);
             // Simulate using item :)
             output.writeLong(-1L);
             output.writeByte(255);
             // write item in hand
-            ItemStack inHand = ViaVersionPlugin.getHandItem(info);
+            ItemStack inHand = plugin.getHandItem(info);
+            if (inHand != null && plugin.isShieldBlocking()) {
+                if (inHand.getType().name().endsWith("SWORD")) {
+                    // blocking?
+                    if (hand == 0) {
+                        if (!startedBlocking) {
+                            startedBlocking = true;
+                            ItemSlotRewriter.ItemStack shield = new ItemSlotRewriter.ItemStack();
+                            shield.id = 442;
+                            shield.amount = 1;
+                            shield.data = 0;
+                            sendSecondHandItem(shield);
+                        }
+                        throw new CancelException();
+                    }
+                }
+            }
             try {
                 ItemSlotRewriter.ItemStack item = ItemSlotRewriter.ItemStack.fromBukkit(inHand);
                 ItemSlotRewriter.fixIdsFrom1_9To1_8(item);
@@ -283,9 +322,9 @@ public class IncomingTransformer {
                 e.printStackTrace();
             }
 
-            output.writeByte(-1);
-            output.writeByte(-1);
-            output.writeByte(-1);
+            output.writeByte(0); //Is zero in 1.8, not -1
+            output.writeByte(0);
+            output.writeByte(0);
             return;
         }
         if (packet == PacketType.PLAY_CREATIVE_INVENTORY_ACTION) {
@@ -296,4 +335,18 @@ public class IncomingTransformer {
         }
         output.writeBytes(input);
     }
+
+    private void sendSecondHandItem(ItemSlotRewriter.ItemStack o) {
+        ByteBuf buf = info.getChannel().alloc().buffer();
+        PacketUtil.writeVarInt(PacketType.PLAY_ENTITY_EQUIPMENT.getNewPacketID(), buf);
+        PacketUtil.writeVarInt(info.getEntityID(), buf);
+        PacketUtil.writeVarInt(1, buf); // slot
+        // write shield
+        try {
+            ItemSlotRewriter.writeItemStack(o, buf);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        info.sendRawPacket(buf);
+    }
 }

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

@@ -1,15 +1,13 @@
 package us.myles.ViaVersion.transformers;
 
 import io.netty.buffer.ByteBuf;
-import io.netty.buffer.ByteBufInputStream;
-import io.netty.buffer.ByteBufOutputStream;
+import org.bukkit.Material;
 import org.bukkit.entity.EntityType;
 import org.json.simple.JSONObject;
 import org.json.simple.parser.JSONParser;
 import org.json.simple.parser.ParseException;
 import org.spacehq.mc.protocol.data.game.chunk.Column;
 import org.spacehq.mc.protocol.util.NetUtil;
-import org.spacehq.opennbt.NBTIO;
 import org.spacehq.opennbt.tag.builtin.ByteTag;
 import org.spacehq.opennbt.tag.builtin.CompoundTag;
 import org.spacehq.opennbt.tag.builtin.StringTag;
@@ -17,7 +15,14 @@ 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.api.boss.BossBar;
+import us.myles.ViaVersion.api.boss.BossColor;
+import us.myles.ViaVersion.api.boss.BossStyle;
+import us.myles.ViaVersion.chunks.Chunk;
+import us.myles.ViaVersion.chunks.ChunkManager;
+import us.myles.ViaVersion.metadata.MetaIndex;
 import us.myles.ViaVersion.metadata.MetadataRewriter;
+import us.myles.ViaVersion.metadata.MetadataRewriter.Entry;
 import us.myles.ViaVersion.packets.PacketType;
 import us.myles.ViaVersion.packets.State;
 import us.myles.ViaVersion.slot.ItemSlotRewriter;
@@ -26,8 +31,6 @@ import us.myles.ViaVersion.util.EntityUtil;
 import us.myles.ViaVersion.util.PacketUtil;
 import us.myles.ViaVersion.util.ReflectionUtil;
 
-import java.io.DataInputStream;
-import java.io.DataOutputStream;
 import java.io.IOException;
 import java.util.*;
 
@@ -42,7 +45,11 @@ public class OutgoingTransformer {
     private final Map<Integer, UUID> uuidMap = new HashMap<>();
     private final Map<Integer, EntityType> clientEntityTypes = new HashMap<>();
     private final Map<Integer, Integer> vehicleMap = new HashMap<>();
+    private final Set<Integer> validBlocking = new HashSet<>();
+    private final Set<Integer> knownHolograms = new HashSet<>();
+    private final Map<Integer, BossBar> bossBarMap = new HashMap<>();
     private boolean autoTeam = false;
+    private boolean teamExists = false;
 
     public OutgoingTransformer(ConnectionInfo info) {
         this.info = info;
@@ -106,8 +113,10 @@ public class OutgoingTransformer {
         }
         if (packet == PacketType.PLAY_EFFECT) {
             int effectid = input.readInt();
-            if (effectid >= 1000 && effectid < 2000) //Sound effect
+            if (effectid >= 1000 && effectid < 2000 && effectid != 1005) //Sound effect
                 throw new CancelException();
+            if (effectid == 1005) //Fix jukebox
+                effectid = 1010;
             output.writeInt(effectid);
         }
         if (packet == PacketType.PLAY_ATTACH_ENTITY) {
@@ -217,13 +226,15 @@ public class OutgoingTransformer {
             return;
         }
         if (packet == PacketType.PLAY_ENTITY_TELEPORT) {
-            // Port this so that it relative moves :P
             int id = PacketUtil.readVarInt(input);
             PacketUtil.writeVarInt(id, output);
 
             int x = input.readInt();
             output.writeDouble(x / 32D);
             int y = input.readInt();
+            if (plugin.isHologramPatch() & knownHolograms.contains(id)) {
+                y = (int) ((y) + (plugin.getHologramYOffset() * 32D));
+            }
             output.writeDouble(y / 32D);
             int z = input.readInt();
             output.writeDouble(z / 32D);
@@ -244,6 +255,9 @@ public class OutgoingTransformer {
             int x = input.readByte();
             output.writeShort(x * 128);
             int y = input.readByte();
+            if (plugin.isHologramPatch() & knownHolograms.contains(id)) {
+                y = (int) ((y) + plugin.getHologramYOffset());
+            }
             output.writeShort(y * 128);
             int z = input.readByte();
             output.writeShort(z * 128);
@@ -264,12 +278,16 @@ public class OutgoingTransformer {
             short x = (short) (input.readByte());
             output.writeShort(x * 128);
             short y = (short) (input.readByte());
+            if (plugin.isHologramPatch() & knownHolograms.contains(id)) {
+                y = (short) (y - 1);
+            }
             output.writeShort(y * 128);
             short z = (short) (input.readByte());
             output.writeShort(z * 128);
 
             boolean onGround = input.readBoolean();
             output.writeBoolean(onGround);
+
             return;
 
         }
@@ -320,7 +338,24 @@ public class OutgoingTransformer {
                 slot += 1; // add 1 so it's now 2-5
             }
             PacketUtil.writeVarInt(slot, output);
-
+            if (slot == 0) {
+                // Read aheat for sword
+                input.markReaderIndex();
+                short itemID = input.readShort();
+                if (itemID != -1) {
+                    Material m = Material.getMaterial(itemID);
+                    if (m != null) {
+                        if (m.name().endsWith("SWORD")) {
+                            validBlocking.add(id);
+                        } else {
+                            validBlocking.remove(id);
+                        }
+                    }
+                } else {
+                    validBlocking.remove(id);
+                }
+                input.resetReaderIndex();
+            }
             ItemSlotRewriter.rewrite1_8To1_9(input, output);
             return;
         }
@@ -356,7 +391,14 @@ public class OutgoingTransformer {
             int[] toDestroy = PacketUtil.readVarInts(count, input);
             for (int entityID : toDestroy) {
                 clientEntityTypes.remove(entityID);
+                knownHolograms.remove(entityID);
                 PacketUtil.writeVarInt(entityID, output);
+
+                // Remvoe boss bar
+                BossBar bar = bossBarMap.remove(entityID);
+                if (bar != null) {
+                    bar.hide();
+                }
             }
             return;
         }
@@ -566,8 +608,26 @@ public class OutgoingTransformer {
         if (packet == PacketType.PLAY_JOIN_GAME) {
             int id = input.readInt();
             clientEntityTypes.put(id, EntityType.PLAYER);
+            info.setEntityID(id);
             output.writeInt(id);
-            output.writeBytes(input);
+
+            int gamemode = input.readUnsignedByte();
+            output.writeByte(gamemode);
+            int dimension = input.readByte();
+            output.writeByte(dimension);
+            int difficulty = input.readUnsignedByte();
+            if (info.getProtocol() >= 108) {
+                // 1.8.1 Pre 2
+                output.writeInt(difficulty);
+            } else {
+                output.writeByte(difficulty);
+            }
+            int maxPlayers = input.readUnsignedByte();
+            output.writeByte(maxPlayers);
+            String level = PacketUtil.readString(input);
+            PacketUtil.writeString(level, output);
+            boolean reducedDebug = input.readBoolean();
+            output.writeBoolean(reducedDebug);
             return;
         }
         if (packet == PacketType.PLAY_SERVER_DIFFICULTY) {
@@ -683,12 +743,12 @@ public class OutgoingTransformer {
                         CompoundTag spawn = new CompoundTag("SpawnData");
                         spawn.put(new StringTag("id", entity));
                         tag.put(spawn);
-                        PacketUtil.writeNBT(output,tag);
+                        PacketUtil.writeNBT(output, tag);
                     } else if (tag != null) { // EntityID does not exist
                         CompoundTag spawn = new CompoundTag("SpawnData");
                         spawn.put(new StringTag("id", "AreaEffectCloud")); //Make spawners show up as empty when no EntityId is given.
                         tag.put(spawn);
-                        PacketUtil.writeNBT(output,spawn);
+                        PacketUtil.writeNBT(output, spawn);
                     } else { //There doesn't exist any NBT tag
                         input.readerIndex(index);
                         output.writeBytes(input, input.readableBytes());
@@ -718,51 +778,15 @@ public class OutgoingTransformer {
             return;
         }
         if (packet == PacketType.PLAY_CHUNK_DATA) {
-            // We need to catch unloading chunk packets as defined by wiki.vg
-            // To unload chunks, send this packet with Ground-Up Continuous=true and no 16^3 chunks (eg. Primary Bit Mask=0)
-            int chunkX = input.readInt();
-            int chunkZ = input.readInt();
-            output.writeInt(chunkX);
-            output.writeInt(chunkZ);
-
-
-            boolean groundUp = input.readBoolean();
-            output.writeBoolean(groundUp);
-
-            int bitMask = input.readUnsignedShort();
-            int size = PacketUtil.readVarInt(input);
-            byte[] data = new byte[size];
-            input.readBytes(data);
-//            if (bitMask == 0 && groundUp) {
-//                // if 256
-//                output.clear();
-//                PacketUtil.writeVarInt(PacketType.PLAY_UNLOAD_CHUNK.getNewPacketID(), output);
-//                output.writeInt(chunkX);
-//                output.writeInt(chunkZ);
-//                System.out.println("Sending unload chunk " + chunkX + " " + chunkZ + " - " + size + " bulk: " + bulk);
-//                return;
-//            }
-            boolean sk = false;
-            if (info.getLastPacket().getClass().getName().endsWith("PacketPlayOutMapChunkBulk")) {
-                try {
-                    sk = ReflectionUtil.get(info.getLastPacket(), "d", boolean.class);
-                } catch (NoSuchFieldException e) {
-                    e.printStackTrace();
-                } catch (IllegalAccessException e) {
-                    e.printStackTrace();
-                }
-            }
-            Column read = NetUtil.readOldChunkData(chunkX, chunkZ, groundUp, bitMask, data, true, sk);
-            // Write chunk section array :((
-            ByteBuf temp = output.alloc().buffer();
-            try {
-                int bitmask = NetUtil.writeNewColumn(temp, read, groundUp, sk);
-                PacketUtil.writeVarInt(bitmask, output);
-                PacketUtil.writeVarInt(temp.readableBytes(), output);
-                output.writeBytes(temp);
-            } catch (IOException e) {
-                e.printStackTrace();
+            // Read chunk
+            ChunkManager chunkManager = info.getChunkManager();
+            Chunk chunk = chunkManager.readChunk(input);
+            if(chunk == null) {
+                throw new CancelException();
             }
+
+            // Write chunk
+            chunkManager.writeChunk(chunk, output);
             return;
         }
         output.writeBytes(input);
@@ -774,19 +798,23 @@ public class OutgoingTransformer {
         PacketUtil.writeString("viaversion", buf); // Use viaversion as name
         if (b) {
             // add
-            buf.writeByte(0); // make team
-            PacketUtil.writeString("viaversion", buf);
-            PacketUtil.writeString("", buf); // prefix
-            PacketUtil.writeString("", buf); // suffix
-            buf.writeByte(0); // friendly fire
-            PacketUtil.writeString("", buf); // nametags
-            PacketUtil.writeString("never", buf); // collision rule :)
-            buf.writeByte(0); // color
+            if (!teamExists) {
+                buf.writeByte(0); // make team
+                PacketUtil.writeString("viaversion", buf);
+                PacketUtil.writeString("", buf); // prefix
+                PacketUtil.writeString("", buf); // suffix
+                buf.writeByte(0); // friendly fire
+                PacketUtil.writeString("", buf); // nametags
+                PacketUtil.writeString("never", buf); // collision rule :)
+                buf.writeByte(0); // color
+            } else
+                buf.writeByte(3);
             PacketUtil.writeVarInt(1, buf); // player count
             PacketUtil.writeString(info.getUsername(), buf); // us
         } else {
             buf.writeByte(1); // remove team
         }
+        teamExists = b;
         info.sendRawPacket(buf);
     }
 
@@ -798,9 +826,113 @@ public class OutgoingTransformer {
             return;
         }
         List<MetadataRewriter.Entry> list = MetadataRewriter.readMetadata1_8(type, input);
+        for (MetadataRewriter.Entry entry : list) {
+            handleMetadata(entityID, entry, type);
+        }
+        // Fix: wither (crash fix)
+        if (type == EntityType.WITHER) {
+            // Remove custom value if already exist
+            Iterator<Entry> it = list.iterator();
+            while (it.hasNext()) {
+                Entry e = it.next();
+                if (e.getOldID() == 10) {
+                    it.remove();
+                }
+            }
+
+            list.add(new Entry(MetaIndex.WITHER_PROPERTIES, (byte) 0, 10));
+        }
+        // Fix: Dragon (crash fix)
+        if (type == EntityType.ENDER_DRAGON) {
+            // Remove custom value if already exist
+            Iterator<Entry> it = list.iterator();
+            while (it.hasNext()) {
+                Entry e = it.next();
+                if (e.getOldID() == 11) {
+                    it.remove();
+                }
+            }
+
+            list.add(new Entry(MetaIndex.ENDERDRAGON_PHASE, (byte) 0, 11));
+        }
         MetadataRewriter.writeMetadata1_9(type, list, output);
     }
 
+    private void handleMetadata(int entityID, MetadataRewriter.Entry entry, EntityType type) {
+        // This handles old IDs
+        if (type == EntityType.PLAYER) {
+            if (entry.getOldID() == 0) {
+                // Byte
+                byte data = (byte) entry.getValue();
+                if (entityID != info.getEntityID() && plugin.isShieldBlocking()) {
+                    if ((data & 0x10) == 0x10) {
+                        if (validBlocking.contains(entityID)) {
+                            ItemSlotRewriter.ItemStack shield = new ItemSlotRewriter.ItemStack();
+                            shield.id = 442;
+                            shield.amount = 1;
+                            shield.data = 0;
+                            sendSecondHandItem(entityID, shield);
+                        }
+                    } else {
+                        sendSecondHandItem(entityID, null);
+                    }
+                }
+            }
+        }
+        if (type == EntityType.ARMOR_STAND && plugin.isHologramPatch()) {
+            if (entry.getOldID() == 0) {
+                byte data = (byte) entry.getValue();
+                if ((data & 0x20) == 0x20) {
+                    if (!knownHolograms.contains(entityID)) {
+                        knownHolograms.add(entityID);
+                        // Send movement
+                        ByteBuf buf = info.getChannel().alloc().buffer();
+                        PacketUtil.writeVarInt(PacketType.PLAY_ENTITY_RELATIVE_MOVE.getNewPacketID(), buf);
+                        PacketUtil.writeVarInt(entityID, buf);
+                        buf.writeShort(0);
+                        buf.writeShort((short) (128D * (plugin.getHologramYOffset() * 32D)));
+                        buf.writeShort(0);
+                        buf.writeBoolean(true);
+                        info.sendRawPacket(buf, false);
+                    }
+                }
+            }
+        }
+
+        // Boss bar
+        if (plugin.isBossbarPatch()) {
+            if (type == EntityType.ENDER_DRAGON || type == EntityType.WITHER) {
+                if (entry.getOldID() == 2) {
+                    BossBar bar = bossBarMap.get(entityID);
+                    String title = (String) entry.getValue();
+                    title = title.isEmpty() ? (type == EntityType.ENDER_DRAGON ? "Ender Dragon" : "Wither") : title;
+                    if (bar == null) {
+                        bar = ViaVersion.getInstance().createBossBar(title, BossColor.PINK, BossStyle.SOLID);
+                        bossBarMap.put(entityID, bar);
+                        bar.addPlayer(info.getPlayer());
+                        bar.show();
+                    } else {
+                        bar.setTitle(title);
+                    }
+                } else if (entry.getOldID() == 6 && !plugin.isBossbarAntiflicker()) { // If anti flicker is enabled, don't update health
+                    BossBar bar = bossBarMap.get(entityID);
+                    // Make health range between 0 and 1
+                    float maxHealth = type == EntityType.ENDER_DRAGON ? 200.0f : 300.0f;
+                    float health = Math.max(0.0f, Math.min(((float) entry.getValue()) / maxHealth, 1.0f));
+                    if (bar == null) {
+                        String title = type == EntityType.ENDER_DRAGON ? "Ender Dragon" : "Wither";
+                        bar = ViaVersion.getInstance().createBossBar(title, health, BossColor.PINK, BossStyle.SOLID);
+                        bossBarMap.put(entityID, bar);
+                        bar.addPlayer(info.getPlayer());
+                        bar.show();
+                    } else {
+                        bar.setHealth(health);
+                    }
+                }
+            }
+        }
+    }
+
 
     private UUID getUUID(int id) {
         if (uuidMap.containsKey(id)) {
@@ -812,4 +944,18 @@ public class OutgoingTransformer {
         }
     }
 
+    private void sendSecondHandItem(int entityID, ItemSlotRewriter.ItemStack o) {
+
+        ByteBuf buf = info.getChannel().alloc().buffer();
+        PacketUtil.writeVarInt(PacketType.PLAY_ENTITY_EQUIPMENT.getNewPacketID(), buf);
+        PacketUtil.writeVarInt(entityID, buf);
+        PacketUtil.writeVarInt(1, buf); // slot
+        // write shield
+        try {
+            ItemSlotRewriter.writeItemStack(o, buf);
+        } catch (IOException e) {
+            e.printStackTrace();
+        }
+        info.sendRawPacket(buf, true);
+    }
 }

src/main/java/us/myles/ViaVersion/update/UpdateUtil.java

@@ -98,7 +98,7 @@ public class UpdateUtil {
             URL url = new URL(URL + PLUGIN + "?" + System.currentTimeMillis());
             HttpURLConnection connection = (HttpURLConnection) url.openConnection();
             connection.setUseCaches(true);
-            connection.addRequestProperty("User-Agent", "Mozilla/4.76");
+            connection.addRequestProperty("User-Agent", "ViaVersion " + ViaVersion.getInstance().getVersion());
             connection.setDoOutput(true);
             BufferedReader br = new BufferedReader(new InputStreamReader(connection.getInputStream()));
             String input;

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

@@ -0,0 +1,246 @@
+package us.myles.ViaVersion.util;
+
+import com.google.common.base.Joiner;
+import com.google.common.collect.Lists;
+import com.google.common.collect.Maps;
+import org.bukkit.Bukkit;
+import org.bukkit.configuration.InvalidConfigurationException;
+import org.bukkit.configuration.file.YamlConfiguration;
+
+import java.io.File;
+import java.io.FileWriter;
+import java.io.IOException;
+import java.util.Arrays;
+import java.util.List;
+import java.util.Map;
+import java.util.logging.Level;
+import java.util.regex.Pattern;
+
+public class Configuration extends YamlConfiguration {
+    private List<String> mainHeader = Lists.newArrayList();
+    private final Map<String, List<String>> headers = Maps.newConcurrentMap();
+    private final File file;
+    private boolean loadHeaders;
+
+    public Configuration(File file) {
+        this.file = file;
+    }
+
+    /**
+     * Set the main header displayed at top of config.
+     *
+     * @param header header
+     */
+    public void mainHeader(String... header) {
+        mainHeader = Arrays.asList(header);
+    }
+
+    /**
+     * Get main header displayed at top of config.
+     *
+     * @return header
+     */
+    public List<String> mainHeader() {
+        return mainHeader;
+    }
+
+    /**
+     * Set option header.
+     *
+     * @param key of option (or section)
+     * @param header of option (or section)
+     */
+    public void header(String key, String... header) {
+//        String value = Joiner.on('\n').join(header);
+        headers.put(key, Arrays.asList(header));
+    }
+
+    /**
+     * Get header of option
+     *
+     * @param key of option (or section)
+     * @return Header
+     */
+    public List<String> header(String key) {
+        return headers.get(key);
+    }
+
+    public <T> T get(String key, Class<T> type) {
+        return type.cast(get(key));
+    }
+
+    /**
+     * Reload config from file.
+     */
+    public void reload() {
+        reload(headers.isEmpty());
+    }
+
+    /**
+     * Reload config from file.
+     *
+     * @param loadHeaders Whether or not to load headers.
+     */
+    public void reload(boolean loadHeaders) {
+        this.loadHeaders = loadHeaders;
+        try {
+            load(file);
+        } catch(Exception e) {
+            Bukkit.getLogger().log(Level.WARNING, "failed to reload file", e);
+        }
+    }
+
+    @Override
+    public void loadFromString(String contents) throws InvalidConfigurationException {
+        if(!loadHeaders) {
+            super.loadFromString(contents);
+            return;
+        }
+
+        StringBuilder memoryData = new StringBuilder();
+
+        // Parse headers
+        final int indentLength = options().indent();
+        final String pathSeparator = Character.toString(options().pathSeparator());
+        int currentIndents = 0;
+        String key = "";
+        List<String> headers = Lists.newArrayList();
+        for(String line : contents.split("\n")) {
+            if(line.isEmpty()) continue; // Skip empty lines
+            int indent = getSuccessiveCharCount(line, ' ');
+            String subline = indent > 0 ? line.substring(indent) : line;
+            if(subline.startsWith("#")) {
+                if(subline.startsWith("#>")) {
+                    String txt = subline.startsWith("#> ") ? subline.substring(3) : subline.substring(2);
+                    mainHeader.add(txt);
+                    continue; // Main header, handled by bukkit
+                }
+
+                // Add header to list
+                String txt = subline.startsWith("# ") ? subline.substring(2) : subline.substring(1);
+                headers.add(txt);
+                continue;
+            }
+
+            int indents = indent / indentLength;
+            if(indents <= currentIndents) {
+                // Remove last section of key
+                String[] array = key.split(Pattern.quote(pathSeparator));
+                int backspace = currentIndents - indents + 1;
+                key = join(array, options().pathSeparator(), 0, array.length - backspace);
+            }
+
+            // Add new section to key
+            String separator = key.length() > 0 ? pathSeparator : "";
+            String lineKey = line.contains(":") ? line.split(Pattern.quote(":"))[0] : line;
+            key += separator + lineKey.substring(indent);
+
+            currentIndents = indents;
+
+            memoryData.append(line).append('\n');
+            if(!headers.isEmpty()) {
+                this.headers.put(key, headers);
+                headers = Lists.newArrayList();
+            }
+        }
+
+        // Parse remaining text
+        super.loadFromString(memoryData.toString());
+
+        // Clear bukkit header
+        options().header(null);
+    }
+
+    /**
+     * Save config to file
+     */
+    public void save() {
+        if(headers.isEmpty() && mainHeader.isEmpty()) {
+            try {
+                super.save(file);
+            } catch(IOException e) {
+                Bukkit.getLogger().log(Level.WARNING, "Failed to save file", e);
+            }
+            return;
+        }
+
+        // Custom save
+        final int indentLength = options().indent();
+        final String pathSeparator = Character.toString(options().pathSeparator());
+        String content = saveToString();
+        StringBuilder fileData = new StringBuilder(buildHeader());
+        int currentIndents = 0;
+        String key = "";
+        for(String h : mainHeader) {
+            // Append main header to top of file
+            fileData.append("#> ").append(h).append('\n');
+        }
+
+        for(String line : content.split("\n")) {
+            if(line.isEmpty()) continue; // Skip empty lines
+            int indent = getSuccessiveCharCount(line, ' ');
+            int indents = indent / indentLength;
+            String indentText = indent > 0 ? line.substring(0, indent) : "";
+            if(indents <= currentIndents) {
+                // Remove last section of key
+                String[] array = key.split(Pattern.quote(pathSeparator));
+                int backspace = currentIndents - indents + 1;
+                key = join(array, options().pathSeparator(), 0, array.length - backspace);
+            }
+
+            // Add new section to key
+            String separator = key.length() > 0 ? pathSeparator : "";
+            String lineKey = line.contains(":") ? line.split(Pattern.quote(":"))[0] : line;
+            key += separator + lineKey.substring(indent);
+
+            currentIndents = indents;
+
+            List<String> header = headers.get(key);
+            String headerText = header != null ? addHeaderTags(header, indentText) : "";
+            fileData.append(headerText).append(line).append('\n');
+        }
+
+        // Write data to file
+        FileWriter writer = null;
+        try {
+            writer = new FileWriter(file);
+            writer.write(fileData.toString());
+            writer.flush();
+        } catch(IOException e) {
+            Bukkit.getLogger().log(Level.WARNING, "Failed to save file", e);
+        } finally {
+            if(writer != null) {
+                try {
+                    writer.close();
+                } catch(IOException e) {
+                }
+            }
+        }
+    }
+
+    private String addHeaderTags(List<String> header, String indent) {
+        StringBuilder builder = new StringBuilder();
+        for(String line : header) {
+            builder.append(indent).append("# ").append(line).append('\n');
+        }
+        return builder.toString();
+    }
+
+    private String join(String[] array, char joinChar, int start, int length) {
+        String[] copy = new String[length - start];
+        System.arraycopy(array, start, copy, 0, length - start);
+        return Joiner.on(joinChar).join(copy);
+    }
+
+    private int getSuccessiveCharCount(String text, char key) {
+        int count = 0;
+        for(int i = 0; i < text.length(); i++) {
+            if(text.charAt(i) == key) {
+                count += 1;
+            } else {
+                break;
+            }
+        }
+        return count;
+    }
+}

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

@@ -0,0 +1,138 @@
+package us.myles.ViaVersion.util;
+
+import java.util.Collection;
+import java.util.Iterator;
+import java.util.List;
+import java.util.ListIterator;
+
+public abstract class ListWrapper implements List {
+    private final List list;
+
+    public ListWrapper(List inputList) {
+        this.list = inputList;
+    }
+
+    public abstract void handleAdd(Object o);
+
+    @Override
+    public synchronized int size() {
+        return this.list.size();
+    }
+
+    @Override
+    public synchronized boolean isEmpty() {
+        return this.list.isEmpty();
+    }
+
+    @Override
+    public synchronized boolean contains(Object o) {
+        return this.list.contains(o);
+    }
+
+    @Override
+    public synchronized Iterator iterator() {
+        return this.list.iterator();
+    }
+
+    @Override
+    public synchronized Object[] toArray() {
+        return this.list.toArray();
+    }
+
+    @Override
+    public synchronized boolean add(Object o) {
+        handleAdd(o);
+        return this.list.add(o);
+    }
+
+    @Override
+    public synchronized boolean remove(Object o) {
+        return this.list.remove(o);
+    }
+
+    @Override
+    public synchronized boolean addAll(Collection c) {
+        for (Object o : c) {
+            handleAdd(o);
+        }
+        return this.list.addAll(c);
+    }
+
+    @Override
+    public synchronized boolean addAll(int index, Collection c) {
+        for (Object o : c) {
+            handleAdd(o);
+        }
+        return this.list.addAll(index, c);
+    }
+
+    @Override
+    public synchronized void clear() {
+        this.list.clear();
+    }
+
+    @Override
+    public synchronized Object get(int index) {
+        return this.list.get(index);
+    }
+
+    @Override
+    public synchronized Object set(int index, Object element) {
+        return this.list.set(index, element);
+    }
+
+    @Override
+    public synchronized void add(int index, Object element) {
+        this.list.add(index, element);
+    }
+
+    @Override
+    public synchronized Object remove(int index) {
+        return this.list.remove(index);
+    }
+
+    @Override
+    public synchronized int indexOf(Object o) {
+        return this.list.indexOf(o);
+    }
+
+    @Override
+    public synchronized int lastIndexOf(Object o) {
+        return this.list.lastIndexOf(o);
+    }
+
+    @Override
+    public synchronized ListIterator listIterator() {
+        return this.list.listIterator();
+    }
+
+    @Override
+    public synchronized ListIterator listIterator(int index) {
+        return this.list.listIterator(index);
+    }
+
+    @Override
+    public synchronized List subList(int fromIndex, int toIndex) {
+        return this.list.subList(fromIndex, toIndex);
+    }
+
+    @Override
+    public synchronized boolean retainAll(Collection c) {
+        return this.list.retainAll(c);
+    }
+
+    @Override
+    public synchronized boolean removeAll(Collection c) {
+        return this.list.removeAll(c);
+    }
+
+    @Override
+    public synchronized boolean containsAll(Collection c) {
+        return this.list.containsAll(c);
+    }
+
+    @Override
+    public synchronized Object[] toArray(Object[] a) {
+        return this.list.toArray(a);
+    }
+}

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

@@ -42,6 +42,9 @@ public class PacketUtil {
     }
 
     public static CompoundTag readNBT(ByteBuf input) throws IOException {
+        // Default client is limited to 2097152 bytes. (2.09mb)
+        Preconditions.checkArgument(input.readableBytes() <= 2097152, "Cannot read NBT (got %s bytes)", input.readableBytes());
+
         int readerIndex = input.readerIndex();
         byte b = input.readByte();
         if (b == 0) {

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

@@ -1,10 +1,14 @@
 package us.myles.ViaVersion.util;
 
+import com.google.common.collect.Maps;
 import org.bukkit.Bukkit;
 
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
+import java.util.Collection;
+import java.util.Collections;
+import java.util.Map;
 
 public class ReflectionUtil {
     private static String BASE = Bukkit.getServer().getClass().getPackage().getName();
@@ -50,4 +54,74 @@ public class ReflectionUtil {
         field.setAccessible(true);
         field.set(o, value);
     }
+
+    public static final class ClassReflection {
+        private final Class<?> handle;
+        private final Map<String, Field> fields = Maps.newConcurrentMap();
+        private final Map<String, Method> methods = Maps.newConcurrentMap();
+
+        public ClassReflection(Class<?> handle) {
+            this(handle, true);
+        }
+
+        public ClassReflection(Class<?> handle, boolean recursive) {
+            this.handle = handle;
+            scanFields(handle, recursive);
+            scanMethods(handle, recursive);
+        }
+
+        private void scanFields(Class<?> host, boolean recursive) {
+            if(host.getSuperclass() != null && recursive) {
+                scanFields(host.getSuperclass(), true);
+            }
+
+            for(Field field : host.getDeclaredFields()) {
+                field.setAccessible(true);
+                fields.put(field.getName(), field);
+            }
+        }
+
+        private void scanMethods(Class<?> host, boolean recursive) {
+            if(host.getSuperclass() != null && recursive) {
+                scanMethods(host.getSuperclass(), true);
+            }
+
+            for(Method method : host.getDeclaredMethods()) {
+                method.setAccessible(true);
+                methods.put(method.getName(), method);
+            }
+        }
+
+        public Object newInstance() throws IllegalAccessException, InstantiationException {
+            return handle.newInstance();
+        }
+
+        public Field getField(String name) {
+            return fields.get(name);
+        }
+
+        public void setFieldValue(String fieldName, Object instance, Object value) throws IllegalAccessException {
+            getField(fieldName).set(instance, value);
+        }
+
+        public <T> T getFieldValue(String fieldName, Object instance, Class<T> type) throws IllegalAccessException {
+            return type.cast(getField(fieldName).get(instance));
+        }
+
+        public <T> T invokeMethod(Class<T> type, String methodName, Object instance, Object... args) throws InvocationTargetException, IllegalAccessException {
+            return type.cast(getMethod(methodName).invoke(instance, args));
+        }
+
+        public Method getMethod(String name) {
+            return methods.get(name);
+        }
+
+        public Collection<Field> getFields() {
+            return Collections.unmodifiableCollection(fields.values());
+        }
+
+        public Collection<Method> getMethods() {
+            return Collections.unmodifiableCollection(methods.values());
+        }
+    }
 }

src/main/resources/config.yml

@@ -1,10 +1,22 @@
 # Should ViaVersion check for updates?
 checkforupdates: true
-# Should we send any bulk chunks, in sync (may be slower but fixes timings)
-# Currently broken due to sign updates, possibly will return
-sync-chunks: true
 # No collide options, these allow you to configure how collision works.
 # Do you want us to prevent collision?
 prevent-collision: true
 # If the above is true, should we automatically team players until you do?
 auto-team: true
+# When enabled if certain metadata can't be read we won't tell you about it
+suppress-metadata-errors: false
+# When enabled 1.9 will be able to block by using shields
+shield-blocking: true
+# Should we enable our hologram patch?
+# If they're in the wrong place enable this
+hologram-patch: false
+# This is the offset, should work as default when enabled.
+hologram-y: -1
+# Enable player tick simulation, this fixes eating, drinking, nether portals.
+simulate-pt: true
+# Should we patch boss bars so they work? (Default: true, disable if you're having issues)
+bossbar-patch: true
+# If your boss bar flickers on 1.9, set this to 'true'. It will keep all boss bars on 100% (not recommended)
+bossbar-anti-flicker: false