public static void ReadKeepAlive(TestClient client, PacketReader reader)
        {
            KeepAlivePacket ka = new KeepAlivePacket();
            ka.Read(reader);

            if (!reader.Failed)
                TestClient.HandlePacketKeepAlive(client, ka);
        }

 public static void ReadCollectItem(TestClient client, PacketReader reader)
 {
     CollectItemPacket ci = new CollectItemPacket();
     ci.Read(reader);
 }

 public static void ReadUpdateWindowProperty(TestClient client, PacketReader reader)
 {
     UpdateWindowPropertyPacket up = new UpdateWindowPropertyPacket();
     up.Read(reader);
 }

 public static void ReadUpdateHealth(TestClient client, PacketReader reader)
 {
     UpdateHealthPacket uh = new UpdateHealthPacket();
     uh.Read(reader);
 }

        public static void ReadSpawnPosition(TestClient client, PacketReader reader)
        {
            SpawnPositionPacket si = new SpawnPositionPacket();
            si.Read(reader);

            if (!reader.Failed)
                TestClient.HandlePacketSpawnPosition(client, si);
        }

 public static void ReadSetSlot(TestClient client, PacketReader reader)
 {
     SetSlotPacket ss = new SetSlotPacket();
     ss.Read(reader);
 }

 public static void ReadPlayerListItem(TestClient client, PacketReader reader)
 {
     PlayerListItemPacket pl = new PlayerListItemPacket();
     pl.Read(reader);
 }

 public static void ReadNewInvalidState(TestClient client, PacketReader reader)
 {
     NewInvalidStatePacket ni = new NewInvalidStatePacket();
     ni.Read(reader);
 }

 public static void ReadEntityLookAndRelativeMove(TestClient client, PacketReader reader)
 {
     EntityLookAndRelativeMovePacket ela = new EntityLookAndRelativeMovePacket();
     ela.Read(reader);
 }

 public static void ReadEntityLook(TestClient client, PacketReader reader)
 {
     EntityLookPacket el = new EntityLookPacket();
     el.Read(reader);
 }

 public static void ReadEntityEquipment(TestClient client, PacketReader reader)
 {
     EntityEquipmentPacket ee = new EntityEquipmentPacket();
     ee.Read(reader);
 }

        public static void ReadEntityAction(TestClient client, PacketReader reader)
        {
            EntityActionPacket ea = new EntityActionPacket();
            ea.Read(reader);

            // TODO: implement this packet
            /*if (!reader.Failed)
                Client.HandlePacketEntityAction(client, ea);*/
        }

 public static void ReadEntity(TestClient client, PacketReader reader)
 {
     CreateEntityPacket ce = new CreateEntityPacket();
     ce.Read(reader);
 }

        public static void ReadDisconnect(TestClient client, PacketReader reader)
        {
            DisconnectPacket dp = new DisconnectPacket();
            dp.Read(reader);

            if (!reader.Failed)
                TestClient.HandlePacketDisconnect(client, dp);
        }

 public static void ReadDestroyEntity(TestClient client, PacketReader reader)
 {
     DestroyEntityPacket de = new DestroyEntityPacket();
     de.Read(reader);
 }

 public static void ReadMultiBlockChange(TestClient client, PacketReader reader)
 {
     MultiBlockChangePacket mbc = new MultiBlockChangePacket();
     mbc.Read(reader);
 }

 public static void ReadNamedEntitySpawn(TestClient client, PacketReader reader)
 {
     NamedEntitySpawnPacket bc = new NamedEntitySpawnPacket();
     bc.Read(reader);
 }

 public static void ReadEntityMetadata(TestClient client, PacketReader reader)
 {
     EntityMetadataPacket em = new EntityMetadataPacket();
     em.Read(reader);
 }

 public static void ReadPickupSpawn(TestClient client, PacketReader reader)
 {
     SpawnItemPacket si = new SpawnItemPacket();
     si.Read(reader);
 }

 public static void ReadEntityRelativeMove(TestClient client, PacketReader reader)
 {
     EntityRelativeMovePacket er = new EntityRelativeMovePacket();
     er.Read(reader);
 }