4.4.2 Release

Fixes #3093

.github/ISSUE_TEMPLATE/feature_request.yml

@@ -1,5 +1,6 @@
 name: Feature Request
 description: Suggest a feature to be added
+labels: [Feature Request]
 
 body:
   - type: textarea
@@ -34,4 +35,4 @@ body:
       description: |
         Does the feature apply to any specific version or environment?
     validations:
-      required: false
+      required: false

README.md

@@ -8,7 +8,7 @@
 
 Supported Versions:
 
-![Table (https://i.imgur.com/uDM9HR8.png)](https://i.imgur.com/RRa5KnK.png)
+![Table (https://i.imgur.com/aSjHvQk.png)](https://i.imgur.com/aSjHvQk.png)
 
 On Paper you may also use ProtocolSupport, but ensure you have the right build for your server version.
 

api-legacy/src/main/java/us/myles/ViaVersion/api/protocol/ProtocolVersion.java

@@ -83,6 +83,8 @@ public class ProtocolVersion {
     public static final ProtocolVersion v1_17_1 = register(756, "1.17.1");
     public static final ProtocolVersion v1_18 = register(757, "1.18/1.18.1", new VersionRange("1.18", 0, 1));
     public static final ProtocolVersion v1_18_2 = register(758, "1.18.2");
+    public static final ProtocolVersion v1_19 = register(759, "1.19");
+    public static final ProtocolVersion v1_19_1 = register(760, "1.19.1");
     public static final ProtocolVersion unknown = register(-1, "UNKNOWN");
 
     public static ProtocolVersion register(int version, String name) {

api/src/main/java/com/viaversion/viaversion/api/Via.java

@@ -25,6 +25,7 @@ package com.viaversion.viaversion.api;
 import com.google.common.base.Preconditions;
 import com.viaversion.viaversion.api.configuration.ViaVersionConfig;
 import com.viaversion.viaversion.api.platform.ViaPlatform;
+import com.viaversion.viaversion.api.platform.ViaServerProxyPlatform;
 
 public final class Via {
     private static ViaManager manager;
@@ -63,6 +64,11 @@ public final class Via {
         return manager().getPlatform();
     }
 
+    public static ViaServerProxyPlatform<?> proxyPlatform() {
+        Preconditions.checkArgument(manager().getPlatform() instanceof ViaServerProxyPlatform, "Platform is not proxying Minecraft servers!");
+        return (ViaServerProxyPlatform<?>) manager().getPlatform();
+    }
+
     /**
      * Register the ViaManager associated with the platform.
      *

api/src/main/java/com/viaversion/viaversion/api/ViaAPI.java

@@ -64,7 +64,7 @@ public interface ViaAPI<T> {
      * @return API version incremented with meaningful API changes
      */
     default int apiVersion() {
-        return 10;
+        return 15;
     }
 
     /**

api/src/main/java/com/viaversion/viaversion/api/configuration/ViaVersionConfig.java

@@ -28,6 +28,7 @@ import com.viaversion.viaversion.api.connection.UserConnection;
 import com.viaversion.viaversion.api.minecraft.WorldIdentifiers;
 import com.viaversion.viaversion.api.protocol.version.BlockedProtocolVersions;
 import it.unimi.dsi.fastutil.ints.IntSet;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 public interface ViaVersionConfig {
 
@@ -455,4 +456,6 @@ public interface ViaVersionConfig {
     WorldIdentifiers get1_16WorldNamesMap();
 
     boolean cache1_17Light();
+
+    @Nullable String chatTypeFormat(String translationKey);
 }

api/src/main/java/com/viaversion/viaversion/api/connection/StorableObject.java

@@ -29,4 +29,13 @@ package com.viaversion.viaversion.api.connection;
  * @see UserConnection#put(StorableObject)
  */
 public interface StorableObject {
+
+    /**
+     * Returns whether the object should be uncached on a server switch.
+     *
+     * @return whether the object should be uncached on a server switch
+     */
+    default boolean clearOnServerSwitch() {
+        return true;
+    }
 }

api/src/main/java/com/viaversion/viaversion/api/connection/UserConnection.java

@@ -58,6 +58,15 @@ public interface UserConnection {
      */
     boolean has(Class<? extends StorableObject> objectClass);
 
+    /**
+     * Removes and returns an object from the storage.
+     *
+     * @param objectClass class of the object to get
+     * @param <T>         type of the class you want to get
+     * @return removed storable object if present
+     */
+    @Nullable <T extends StorableObject> T remove(Class<T> objectClass);
+
     /**
      * Put an object into the stored objects based on class.
      *
@@ -83,6 +92,7 @@ public interface UserConnection {
 
     /**
      * Adds an entity tracker to the user connection.
+     * Does not override existing entity trackers.
      *
      * @param protocolClass protocol class
      * @param tracker       entity tracker
@@ -91,9 +101,18 @@ public interface UserConnection {
 
     /**
      * Clear stored objects and entity trackers.
-     * Used for Bungee when switching servers.
      */
-    void clearStoredObjects();
+    default void clearStoredObjects() {
+        clearStoredObjects(false);
+    }
+
+    /**
+     * Clear stored objects and entity trackers.
+     * If cleared for a proxy server switch, some stored objects and tracker data will be retained.
+     *
+     * @param isServerSwitch whether the clear is due to a server switch
+     */
+    void clearStoredObjects(boolean isServerSwitch);
 
     /**
      * Sends a raw packet to the connection on the current thread.

api/src/main/java/com/viaversion/viaversion/api/data/FullMappings.java

@@ -0,0 +1,73 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.data;
+
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+/**
+ * Mappings containing the full string identifier mappings.
+ */
+public interface FullMappings {
+
+    Mappings mappings();
+
+    /**
+     * Returns the unmapped integer id for the given identifier, or -1 if not found.
+     *
+     * @param identifier unmapped string identifier
+     * @return unmapped int id, or -1 if not found
+     */
+    int id(String identifier);
+
+    /**
+     * Returns the mapped integer id for the given mapped identifier, or -1 if not found.
+     *
+     * @param mappedIdentifier mapped string identifier
+     * @return mapped int id, or -1 if not found
+     */
+    int mappedId(String mappedIdentifier);
+
+    /**
+     * Returns the unmapped string identifier for the given mapped id.
+     *
+     * @param id unmapped id
+     * @return unmapped string identifier
+     */
+    String identifier(int id);
+
+    /**
+     * Returns the mapped string identifier for the given mapped id.
+     *
+     * @param mappedId mapped id
+     * @return mapped string identifier
+     */
+    String mappedIdentifier(int mappedId);
+
+    /**
+     * Returns the mapped string identifier for the given unmapped identifier.
+     *
+     * @param identifier unmapped identifier
+     * @return mapped string identifier, or null if not found
+     */
+    @Nullable String mappedIdentifier(String identifier);
+}

api/src/main/java/com/viaversion/viaversion/api/data/FullMappingsBase.java

@@ -0,0 +1,89 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.data;
+
+import com.google.gson.JsonArray;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+public class FullMappingsBase implements FullMappings {
+    private final Object2IntMap<String> stringToId;
+    private final Object2IntMap<String> mappedStringToId;
+    private final String[] idToString;
+    private final String[] mappedIdToString;
+    private final Mappings mappings;
+
+    public FullMappingsBase(final JsonArray oldMappings, final JsonArray newMappings, final Mappings mappings) {
+        this.mappings = mappings;
+        stringToId = MappingDataLoader.arrayToMap(oldMappings);
+        mappedStringToId = MappingDataLoader.arrayToMap(newMappings);
+        stringToId.defaultReturnValue(-1);
+        mappedStringToId.defaultReturnValue(-1);
+
+        idToString = new String[oldMappings.size()];
+        for (int i = 0; i < oldMappings.size(); i++) {
+            idToString[i] = oldMappings.get(i).getAsString();
+        }
+
+        mappedIdToString = new String[newMappings.size()];
+        for (int i = 0; i < newMappings.size(); i++) {
+            mappedIdToString[i] = newMappings.get(i).getAsString();
+        }
+    }
+
+    @Override
+    public Mappings mappings() {
+        return mappings;
+    }
+
+    @Override
+    public int id(final String identifier) {
+        return stringToId.getInt(identifier);
+    }
+
+    @Override
+    public int mappedId(final String mappedIdentifier) {
+        return mappedStringToId.getInt(mappedIdentifier);
+    }
+
+    @Override
+    public String identifier(final int id) {
+        return idToString[id];
+    }
+
+    @Override
+    public String mappedIdentifier(final int mappedId) {
+        return mappedIdToString[mappedId];
+    }
+
+    @Override
+    public @Nullable String mappedIdentifier(final String identifier) {
+        final int id = id(identifier);
+        if (id == -1) {
+            return null;
+        }
+
+        final int mappedId = mappings.getNewId(id);
+        return mappedId != -1 ? mappedIdentifier(mappedId) : null;
+    }
+}

api/src/main/java/com/viaversion/viaversion/api/data/Int2IntMapMappings.java

@@ -0,0 +1,66 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.data;
+
+import it.unimi.dsi.fastutil.ints.Int2IntMap;
+import it.unimi.dsi.fastutil.ints.Int2IntOpenHashMap;
+
+public class Int2IntMapMappings implements Mappings {
+    private final Int2IntMap mappings;
+    private final int mappedIds;
+
+    protected Int2IntMapMappings(final Int2IntMap mappings, final int mappedIds) {
+        this.mappings = mappings;
+        this.mappedIds = mappedIds;
+        mappings.defaultReturnValue(-1);
+    }
+
+    public static Int2IntMapMappings of(final Int2IntMap mappings, final int mappedIds) {
+        return new Int2IntMapMappings(mappings, mappedIds);
+    }
+
+    public static Int2IntMapMappings of() {
+
+        return new Int2IntMapMappings(new Int2IntOpenHashMap(), -1);
+    }
+
+    @Override
+    public int getNewId(final int id) {
+        return mappings.get(id);
+    }
+
+    @Override
+    public void setNewId(final int id, final int newId) {
+        mappings.put(id, newId);
+    }
+
+    @Override
+    public int size() {
+        return mappings.size();
+    }
+
+    @Override
+    public int mappedSize() {
+        return mappedIds;
+    }
+}

api/src/main/java/com/viaversion/viaversion/api/data/MappingData.java

@@ -102,4 +102,12 @@ public interface MappingData {
     @Nullable Mappings getSoundMappings();
 
     @Nullable Mappings getStatisticsMappings();
+
+    @Nullable Mappings getEnchantmentMappings();
+
+    @Nullable FullMappings getEntityMappings();
+
+    @Nullable FullMappings getArgumentTypeMappings();
+
+    @Nullable Mappings getPaintingMappings();
 }

api/src/main/java/com/viaversion/viaversion/api/data/MappingDataBase.java

@@ -44,12 +44,16 @@ public class MappingDataBase implements MappingData {
     protected final String newVersion;
     protected final boolean hasDiffFile;
     protected Int2IntBiMap itemMappings;
+    protected FullMappings argumentTypeMappings;
+    protected FullMappings entityMappings;
     protected ParticleMappings particleMappings;
     protected Mappings blockMappings;
     protected Mappings blockStateMappings;
     protected Mappings blockEntityMappings;
     protected Mappings soundMappings;
     protected Mappings statisticsMappings;
+    protected Mappings enchantmentMappings;
+    protected Mappings paintingMappings;
     protected Map<RegistryType, List<TagData>> tags;
     protected boolean loadItems = true;
 
@@ -75,6 +79,11 @@ public class MappingDataBase implements MappingData {
         blockEntityMappings = loadFromArray(oldMappings, newMappings, diffmapping, "blockentities");
         soundMappings = loadFromArray(oldMappings, newMappings, diffmapping, "sounds");
         statisticsMappings = loadFromArray(oldMappings, newMappings, diffmapping, "statistics");
+        enchantmentMappings = loadFromArray(oldMappings, newMappings, diffmapping, "enchantments");
+        paintingMappings = loadFromArray(oldMappings, newMappings, diffmapping, "paintings");
+
+        entityMappings = loadFullMappings(oldMappings, newMappings, diffmapping, "entities");
+        argumentTypeMappings = loadFullMappings(oldMappings, newMappings, diffmapping, "argumenttypes");
 
         Mappings particles = loadFromArray(oldMappings, newMappings, diffmapping, "particles");
         if (particles != null) {
@@ -102,6 +111,11 @@ public class MappingDataBase implements MappingData {
         loadExtras(oldMappings, newMappings, diffmapping);
     }
 
+    protected FullMappings loadFullMappings(JsonObject oldMappings, JsonObject newMappings, @Nullable JsonObject diffMappings, String key) {
+        Mappings mappings = loadFromArray(oldMappings, newMappings, diffMappings, key);
+        return mappings != null ? new FullMappingsBase(oldMappings.getAsJsonArray(key), newMappings.getAsJsonArray(key), mappings) : null;
+    }
+
     private void loadTags(RegistryType type, JsonObject object, Object2IntMap<String> typeMapping) {
         JsonObject tags = object.getAsJsonObject(type.resourceLocation());
         List<TagData> tagsList = new ArrayList<>(tags.size());
@@ -148,7 +162,7 @@ public class MappingDataBase implements MappingData {
 
     @Override
     public int getNewParticleId(int id) {
-        return checkValidity(id, particleMappings.getMappings().getNewId(id), "particles");
+        return checkValidity(id, particleMappings.mappings().getNewId(id), "particles");
     }
 
     @Override
@@ -191,6 +205,26 @@ public class MappingDataBase implements MappingData {
         return statisticsMappings;
     }
 
+    @Override
+    public @Nullable Mappings getEnchantmentMappings() {
+        return enchantmentMappings;
+    }
+
+    @Override
+    public @Nullable FullMappings getEntityMappings() {
+        return entityMappings;
+    }
+
+    @Override
+    public @Nullable FullMappings getArgumentTypeMappings() {
+        return argumentTypeMappings;
+    }
+
+    @Override
+    public @Nullable Mappings getPaintingMappings() {
+        return paintingMappings;
+    }
+
     protected @Nullable Mappings loadFromArray(JsonObject oldMappings, JsonObject newMappings, @Nullable JsonObject diffMappings, String key) {
         if (!oldMappings.has(key) || !newMappings.has(key)) return null;
 

api/src/main/java/com/viaversion/viaversion/api/data/MappingDataLoader.java

@@ -164,7 +164,7 @@ public class MappingDataLoader {
         mapIdentifiers(output, oldIdentifiers, newIdentifiers, diffIdentifiers, true);
     }
 
-    private static int mapIdentifierEntry(Map.Entry<String, JsonElement> entry, Object2IntMap newIdentifierMap, @Nullable JsonObject diffIdentifiers, boolean warnOnMissing) {
+    private static int mapIdentifierEntry(Map.Entry<String, JsonElement> entry, Object2IntMap<String> newIdentifierMap, @Nullable JsonObject diffIdentifiers, boolean warnOnMissing) {
         int value = newIdentifierMap.getInt(entry.getValue().getAsString());
         if (value == -1) {
             // Search in diff mappings

api/src/main/java/com/viaversion/viaversion/api/data/Mappings.java

@@ -38,6 +38,28 @@ public interface Mappings {
      */
     int getNewId(int id);
 
+    /**
+     * Returns the mapped id from the given id, or the given default if unmapped/invalid.
+     *
+     * @param id  unmapped id
+     * @param def fallback return value
+     * @return mapped id, or -1 if invalid/out of bounds
+     */
+    default int getNewIdOrDefault(int id, int def) {
+        final int mappedId = getNewId(id);
+        return mappedId != -1 ? mappedId : def;
+    }
+
+    /**
+     * Returns whether the id has a mapping.
+     *
+     * @param id unmapped id
+     * @return whether the id has a mapped id
+     */
+    default boolean contains(int id) {
+        return getNewId(id) != -1;
+    }
+
     /**
      * Manually maps a specific id.
      *

api/src/main/java/com/viaversion/viaversion/api/data/ParticleMappings.java

@@ -25,51 +25,19 @@ package com.viaversion.viaversion.api.data;
 import com.google.gson.JsonArray;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.ints.IntList;
-import it.unimi.dsi.fastutil.objects.Object2IntMap;
 
-public class ParticleMappings {
-    private final Object2IntMap<String> stringToId;
-    private final Object2IntMap<String> mappedStringToId;
-    private final Mappings mappings;
+public class ParticleMappings extends FullMappingsBase {
     private final IntList itemParticleIds = new IntArrayList(2);
     private final IntList blockParticleIds = new IntArrayList(4);
 
     public ParticleMappings(JsonArray oldMappings, JsonArray newMappings, Mappings mappings) {
-        this.mappings = mappings;
-        stringToId = MappingDataLoader.arrayToMap(oldMappings);
-        mappedStringToId = MappingDataLoader.arrayToMap(newMappings);
-        stringToId.defaultReturnValue(-1);
-        mappedStringToId.defaultReturnValue(-1);
+        super(oldMappings, newMappings, mappings);
         addBlockParticle("block");
         addBlockParticle("falling_dust");
         addBlockParticle("block_marker");
         addItemParticle("item");
     }
 
-    /**
-     * Returns the unmapped integer id for the given identifier, or -1 if not found.
-     *
-     * @param identifier unmapped string identifier
-     * @return unmapped int id, or -1 if not found
-     */
-    public int id(String identifier) {
-        return stringToId.getInt(identifier);
-    }
-
-    /**
-     * Returns the mapped integer id for the given mapped identifier, or -1 if not found.
-     *
-     * @param mappedIdentifier mapped string identifier
-     * @return mapped int id, or -1 if not found
-     */
-    public int mappedId(String mappedIdentifier) {
-        return mappedStringToId.getInt(mappedIdentifier);
-    }
-
-    public Mappings getMappings() {
-        return mappings;
-    }
-
     public boolean addItemParticle(final String identifier) {
         final int id = id(identifier);
         return id != -1 && itemParticleIds.add(id);

api/src/main/java/com/viaversion/viaversion/api/data/entity/DimensionData.java

@@ -0,0 +1,30 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.data.entity;
+
+public interface DimensionData {
+
+    int minY();
+
+    int height();
+}

api/src/main/java/com/viaversion/viaversion/api/data/entity/EntityTracker.java

@@ -26,6 +26,8 @@ import com.viaversion.viaversion.api.connection.UserConnection;
 import com.viaversion.viaversion.api.minecraft.entities.EntityType;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
+import java.util.Map;
+
 public interface EntityTracker {
 
     /**
@@ -151,4 +153,18 @@ public interface EntityTracker {
     int biomesSent();
 
     void setBiomesSent(int biomesSent);
+
+    EntityType playerType();
+
+    @Nullable DimensionData dimensionData(String dimension);
+
+    void setDimensions(Map<String, DimensionData> dimensions);
+
+    /**
+     * Adds the client player entity to the tracker.
+     * If the client entity has not been set yet, this will return false.
+     *
+     * @return whether the client has been tracked
+     */
+    boolean trackClientEntity();
 }

api/src/main/java/com/viaversion/viaversion/api/data/entity/StoredEntityData.java

@@ -51,6 +51,15 @@ public interface StoredEntityData {
      */
     @Nullable <T> T get(Class<T> objectClass);
 
+    /**
+     * Removes and returns an object from the storage if present.
+     *
+     * @param objectClass class of the object to remove
+     * @param <T>         object type
+     * @return removed object if present
+     */
+    @Nullable <T> T remove(Class<T> objectClass);
+
     /**
      * Stores an object based on its class.
      *

api/src/main/java/com/viaversion/viaversion/api/debug/DebugHandler.java

@@ -22,8 +22,12 @@
  */
 package com.viaversion.viaversion.api.debug;
 
+import com.google.common.annotations.Beta;
+import com.viaversion.viaversion.api.protocol.packet.Direction;
+import com.viaversion.viaversion.api.protocol.packet.PacketType;
 import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
 
+@Beta
 public interface DebugHandler {
 
     /**
@@ -47,6 +51,14 @@ public interface DebugHandler {
      */
     void addPacketTypeNameToLog(String packetTypeName);
 
+    /**
+     * Adds a packet id to the list of packet types to log.
+     * Packets will be checked on each protocol transformer, so this is best used on single protocol pipes.
+     *
+     * @param packetType packet type
+     */
+    void addPacketTypeToLog(PacketType packetType);
+
     /**
      * Removes a packet type name from the list of packet types to log.
      *
@@ -78,8 +90,16 @@ public interface DebugHandler {
      * Returns whether the given packet should be logged.
      * If no specific packet type has been added, all packet types will be logged.
      *
-     * @param wrapper packet wrapper
+     * @param wrapper   packet wrapper
+     * @param direction packet direction
      * @return whether the packet should be logged
      */
-    boolean shouldLog(PacketWrapper wrapper);
+    boolean shouldLog(PacketWrapper wrapper, Direction direction);
+
+    default void enableAndLogIds(final PacketType... packetTypes) {
+        setEnabled(true);
+        for (final PacketType packetType : packetTypes) {
+            addPacketTypeToLog(packetType);
+        }
+    }
 }

api/src/main/java/com/viaversion/viaversion/api/minecraft/GlobalPosition.java

@@ -0,0 +1,66 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.minecraft;
+
+public final class GlobalPosition extends Position {
+    private final String dimension;
+
+    public GlobalPosition(final String dimension, final int x, final int y, final int z) {
+        super(x, y, z);
+        this.dimension = dimension;
+    }
+
+    public String dimension() {
+        return dimension;
+    }
+
+    @Override
+    public boolean equals(final Object o) {
+        if (this == o) return true;
+        if (o == null || getClass() != o.getClass()) return false;
+        final GlobalPosition position = (GlobalPosition) o;
+        if (x != position.x) return false;
+        if (y != position.y) return false;
+        if (z != position.z) return false;
+        return dimension.equals(position.dimension);
+    }
+
+    @Override
+    public int hashCode() {
+        int result = dimension.hashCode();
+        result = 31 * result + x;
+        result = 31 * result + y;
+        result = 31 * result + z;
+        return result;
+    }
+
+    @Override
+    public String toString() {
+        return "GlobalPosition{" +
+                "dimension='" + dimension + '\'' +
+                ", x=" + x +
+                ", y=" + y +
+                ", z=" + z +
+                '}';
+    }
+}

api/src/main/java/com/viaversion/viaversion/api/minecraft/PlayerMessageSignature.java

@@ -20,28 +20,24 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-package com.viaversion.viaversion.api.type.types.minecraft;
+package com.viaversion.viaversion.api.minecraft;
 
-import com.viaversion.viaversion.api.minecraft.Position;
-import com.viaversion.viaversion.api.type.Type;
-import io.netty.buffer.ByteBuf;
+import java.util.UUID;
 
-public class OptPositionType extends Type<Position> {
-    public OptPositionType() {
-        super(Position.class);
+public final class PlayerMessageSignature {
+    private final UUID uuid;
+    private final byte[] signatureBytes;
+
+    public PlayerMessageSignature(final UUID uuid, final byte[] signatureBytes) {
+        this.uuid = uuid;
+        this.signatureBytes = signatureBytes;
     }
 
-    @Override
-    public Position read(ByteBuf buffer) throws Exception {
-        boolean present = buffer.readBoolean();
-        if (!present) return null;
-        return Type.POSITION.read(buffer);
+    public UUID uuid() {
+        return uuid;
     }
 
-    @Override
-    public void write(ByteBuf buffer, Position object) throws Exception {
-        buffer.writeBoolean(object != null);
-        if (object != null)
-            Type.POSITION.write(buffer, object);
+    public byte[] signatureBytes() {
+        return signatureBytes;
     }
 }

api/src/main/java/com/viaversion/viaversion/api/minecraft/Position.java

@@ -23,9 +23,9 @@
 package com.viaversion.viaversion.api.minecraft;
 
 public class Position {
-    private final int x;
-    private final int y;
-    private final int z;
+    protected final int x;
+    protected final int y;
+    protected final int z;
 
     public Position(int x, int y, int z) {
         this.x = x;
@@ -59,6 +59,10 @@ public class Position {
         return z;
     }
 
+    public GlobalPosition withDimension(String dimension) {
+        return new GlobalPosition(dimension, x, y, z);
+    }
+
     @Deprecated/*(forRemoval=true)*/
     public int getX() {
         return x;

api/src/main/java/com/viaversion/viaversion/api/minecraft/Position3d.java

@@ -0,0 +1,47 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.minecraft;
+
+public class Position3d {
+    private final double x;
+    private final double y;
+    private final double z;
+
+    public Position3d(final double x, final double y, final double z) {
+        this.x = x;
+        this.y = y;
+        this.z = z;
+    }
+
+    public double x() {
+        return x;
+    }
+
+    public double y() {
+        return y;
+    }
+
+    public double z() {
+        return z;
+    }
+}

api/src/main/java/com/viaversion/viaversion/api/minecraft/ProfileKey.java

@@ -0,0 +1,47 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.minecraft;
+
+public final class ProfileKey {
+    private final long expiresAt;
+    private final byte[] publicKey;
+    private final byte[] keySignature;
+
+    public ProfileKey(final long expiresAt, final byte[] publicKey, final byte[] keySignature) {
+        this.expiresAt = expiresAt;
+        this.publicKey = publicKey;
+        this.keySignature = keySignature;
+    }
+
+    public long expiresAt() {
+        return expiresAt;
+    }
+
+    public byte[] publicKey() {
+        return publicKey;
+    }
+
+    public byte[] keySignature() {
+        return keySignature;
+    }
+}

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/Entity1_10Types.java

@@ -170,6 +170,16 @@ public class Entity1_10Types {
         public EntityType getParent() {
             return parent;
         }
+
+        @Override
+        public String identifier() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean isAbstractType() {
+            return id != -1;
+        }
     }
 
     public enum ObjectType implements com.viaversion.viaversion.api.minecraft.entities.ObjectType {

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/Entity1_11Types.java

@@ -187,6 +187,16 @@ public class Entity1_11Types {
             return parent;
         }
 
+        @Override
+        public String identifier() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean isAbstractType() {
+            return id != -1;
+        }
+
         static {
             for (EntityType type : EntityType.values()) {
                 TYPES.put(type.id, type);

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/Entity1_12Types.java

@@ -191,6 +191,16 @@ public class Entity1_12Types {
             return parent;
         }
 
+        @Override
+        public String identifier() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean isAbstractType() {
+            return id != -1;
+        }
+
         static {
             for (EntityType type : EntityType.values()) {
                 TYPES.put(type.id, type);

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/Entity1_13Types.java

@@ -240,6 +240,16 @@ public class Entity1_13Types {
             return parent;
         }
 
+        @Override
+        public String identifier() {
+            throw new UnsupportedOperationException();
+        }
+
+        @Override
+        public boolean isAbstractType() {
+            return id != -1;
+        }
+
         static {
             for (EntityType type : EntityType.values()) {
                 TYPES.put(type.id, type);

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/Entity1_14Types.java

@@ -224,6 +224,16 @@ public enum Entity1_14Types implements EntityType {
         return parent;
     }
 
+    @Override
+    public String identifier() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean isAbstractType() {
+        return id != -1;
+    }
+
     static {
         TYPES = EntityTypeUtil.toOrderedArray(values());
     }

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/Entity1_15Types.java

@@ -226,6 +226,16 @@ public enum Entity1_15Types implements EntityType {
         return parent;
     }
 
+    @Override
+    public String identifier() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean isAbstractType() {
+        return id != -1;
+    }
+
     static {
         TYPES = EntityTypeUtil.toOrderedArray(values());
     }

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/Entity1_16Types.java

@@ -231,6 +231,16 @@ public enum Entity1_16Types implements EntityType {
         return parent;
     }
 
+    @Override
+    public String identifier() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean isAbstractType() {
+        return id != -1;
+    }
+
     static {
         TYPES = EntityTypeUtil.toOrderedArray(values());
     }

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/Entity1_16_2Types.java

@@ -235,6 +235,16 @@ public enum Entity1_16_2Types implements EntityType {
         return parent;
     }
 
+    @Override
+    public String identifier() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean isAbstractType() {
+        return id != -1;
+    }
+
     static {
         TYPES = EntityTypeUtil.toOrderedArray(values());
     }

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/Entity1_17Types.java

@@ -240,6 +240,16 @@ public enum Entity1_17Types implements EntityType {
         return parent;
     }
 
+    @Override
+    public String identifier() {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public boolean isAbstractType() {
+        return id != -1;
+    }
+
     static {
         TYPES = EntityTypeUtil.toOrderedArray(values());
     }

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/Entity1_19Types.java

@@ -0,0 +1,274 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.minecraft.entities;
+
+import com.google.common.base.Preconditions;
+import com.viaversion.viaversion.api.protocol.Protocol;
+import com.viaversion.viaversion.util.EntityTypeUtil;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+import java.util.Locale;
+
+public enum Entity1_19Types implements EntityType {
+
+    ENTITY(null, null),
+
+    AREA_EFFECT_CLOUD(ENTITY),
+    END_CRYSTAL(ENTITY),
+    EVOKER_FANGS(ENTITY),
+    EXPERIENCE_ORB(ENTITY),
+    EYE_OF_ENDER(ENTITY),
+    FALLING_BLOCK(ENTITY),
+    FIREWORK_ROCKET(ENTITY),
+    ITEM(ENTITY),
+    LLAMA_SPIT(ENTITY),
+    TNT(ENTITY),
+    SHULKER_BULLET(ENTITY),
+    FISHING_BOBBER(ENTITY),
+
+    LIVINGENTITY(ENTITY, null),
+    ARMOR_STAND(LIVINGENTITY),
+    MARKER(ENTITY),
+    PLAYER(LIVINGENTITY),
+
+    ABSTRACT_INSENTIENT(LIVINGENTITY, null),
+    ENDER_DRAGON(ABSTRACT_INSENTIENT),
+
+    BEE(ABSTRACT_INSENTIENT),
+
+    ABSTRACT_CREATURE(ABSTRACT_INSENTIENT, null),
+
+    ABSTRACT_AGEABLE(ABSTRACT_CREATURE, null),
+    VILLAGER(ABSTRACT_AGEABLE),
+    WANDERING_TRADER(ABSTRACT_AGEABLE),
+
+    // Animals
+    ABSTRACT_ANIMAL(ABSTRACT_AGEABLE, null),
+    AXOLOTL(ABSTRACT_ANIMAL),
+    DOLPHIN(ABSTRACT_INSENTIENT),
+    CHICKEN(ABSTRACT_ANIMAL),
+    COW(ABSTRACT_ANIMAL),
+    MOOSHROOM(COW),
+    PANDA(ABSTRACT_INSENTIENT),
+    PIG(ABSTRACT_ANIMAL),
+    POLAR_BEAR(ABSTRACT_ANIMAL),
+    RABBIT(ABSTRACT_ANIMAL),
+    SHEEP(ABSTRACT_ANIMAL),
+    TURTLE(ABSTRACT_ANIMAL),
+    FOX(ABSTRACT_ANIMAL),
+    FROG(ABSTRACT_ANIMAL),
+    GOAT(ABSTRACT_ANIMAL),
+
+    ABSTRACT_TAMEABLE_ANIMAL(ABSTRACT_ANIMAL, null),
+    CAT(ABSTRACT_TAMEABLE_ANIMAL),
+    OCELOT(ABSTRACT_TAMEABLE_ANIMAL),
+    WOLF(ABSTRACT_TAMEABLE_ANIMAL),
+
+    ABSTRACT_PARROT(ABSTRACT_TAMEABLE_ANIMAL, null),
+    PARROT(ABSTRACT_PARROT),
+
+    // Horses
+    ABSTRACT_HORSE(ABSTRACT_ANIMAL, null),
+    CHESTED_HORSE(ABSTRACT_HORSE, null),
+    DONKEY(CHESTED_HORSE),
+    MULE(CHESTED_HORSE),
+    LLAMA(CHESTED_HORSE),
+    TRADER_LLAMA(CHESTED_HORSE),
+    HORSE(ABSTRACT_HORSE),
+    SKELETON_HORSE(ABSTRACT_HORSE),
+    ZOMBIE_HORSE(ABSTRACT_HORSE),
+
+    // Golem
+    ABSTRACT_GOLEM(ABSTRACT_CREATURE, null),
+    SNOW_GOLEM(ABSTRACT_GOLEM),
+    IRON_GOLEM(ABSTRACT_GOLEM),
+    SHULKER(ABSTRACT_GOLEM),
+
+    // Fish
+    ABSTRACT_FISHES(ABSTRACT_CREATURE, null),
+    COD(ABSTRACT_FISHES),
+    PUFFERFISH(ABSTRACT_FISHES),
+    SALMON(ABSTRACT_FISHES),
+    TROPICAL_FISH(ABSTRACT_FISHES),
+
+    // Monsters
+    ABSTRACT_MONSTER(ABSTRACT_CREATURE, null),
+    BLAZE(ABSTRACT_MONSTER),
+    CREEPER(ABSTRACT_MONSTER),
+    ENDERMITE(ABSTRACT_MONSTER),
+    ENDERMAN(ABSTRACT_MONSTER),
+    GIANT(ABSTRACT_MONSTER),
+    SILVERFISH(ABSTRACT_MONSTER),
+    VEX(ABSTRACT_MONSTER),
+    WITCH(ABSTRACT_MONSTER),
+    WITHER(ABSTRACT_MONSTER),
+    RAVAGER(ABSTRACT_MONSTER),
+
+    ABSTRACT_PIGLIN(ABSTRACT_MONSTER, null),
+
+    PIGLIN(ABSTRACT_PIGLIN),
+    PIGLIN_BRUTE(ABSTRACT_PIGLIN),
+
+    HOGLIN(ABSTRACT_ANIMAL),
+    STRIDER(ABSTRACT_ANIMAL),
+    TADPOLE(ABSTRACT_FISHES),
+    ZOGLIN(ABSTRACT_MONSTER),
+    WARDEN(ABSTRACT_MONSTER),
+
+    // Illagers
+    ABSTRACT_ILLAGER_BASE(ABSTRACT_MONSTER, null),
+    ABSTRACT_EVO_ILLU_ILLAGER(ABSTRACT_ILLAGER_BASE, null),
+    EVOKER(ABSTRACT_EVO_ILLU_ILLAGER),
+    ILLUSIONER(ABSTRACT_EVO_ILLU_ILLAGER),
+    VINDICATOR(ABSTRACT_ILLAGER_BASE),
+    PILLAGER(ABSTRACT_ILLAGER_BASE),
+
+    // Skeletons
+    ABSTRACT_SKELETON(ABSTRACT_MONSTER, null),
+    SKELETON(ABSTRACT_SKELETON),
+    STRAY(ABSTRACT_SKELETON),
+    WITHER_SKELETON(ABSTRACT_SKELETON),
+
+    // Guardians
+    GUARDIAN(ABSTRACT_MONSTER),
+    ELDER_GUARDIAN(GUARDIAN),
+
+    // Spiders
+    SPIDER(ABSTRACT_MONSTER),
+    CAVE_SPIDER(SPIDER),
+
+    // Zombies
+    ZOMBIE(ABSTRACT_MONSTER),
+    DROWNED(ZOMBIE),
+    HUSK(ZOMBIE),
+    ZOMBIFIED_PIGLIN(ZOMBIE),
+    ZOMBIE_VILLAGER(ZOMBIE),
+
+    // Flying entities
+    ABSTRACT_FLYING(ABSTRACT_INSENTIENT, null),
+    GHAST(ABSTRACT_FLYING),
+    PHANTOM(ABSTRACT_FLYING),
+
+    ABSTRACT_AMBIENT(ABSTRACT_INSENTIENT, null),
+    BAT(ABSTRACT_AMBIENT),
+    ALLAY(ABSTRACT_CREATURE),
+
+    ABSTRACT_WATERMOB(ABSTRACT_INSENTIENT, null),
+    SQUID(ABSTRACT_WATERMOB),
+    GLOW_SQUID(SQUID),
+
+    // Slimes
+    SLIME(ABSTRACT_INSENTIENT),
+    MAGMA_CUBE(SLIME),
+
+    // Hangable objects
+    ABSTRACT_HANGING(ENTITY, null),
+    LEASH_KNOT(ABSTRACT_HANGING),
+    ITEM_FRAME(ABSTRACT_HANGING),
+    GLOW_ITEM_FRAME(ITEM_FRAME),
+    PAINTING(ABSTRACT_HANGING),
+
+    ABSTRACT_LIGHTNING(ENTITY, null),
+    LIGHTNING_BOLT(ABSTRACT_LIGHTNING),
+
+    // Arrows
+    ABSTRACT_ARROW(ENTITY, null),
+    ARROW(ABSTRACT_ARROW),
+    SPECTRAL_ARROW(ABSTRACT_ARROW),
+    TRIDENT(ABSTRACT_ARROW),
+
+    // Fireballs
+    ABSTRACT_FIREBALL(ENTITY, null),
+    DRAGON_FIREBALL(ABSTRACT_FIREBALL),
+    FIREBALL(ABSTRACT_FIREBALL),
+    SMALL_FIREBALL(ABSTRACT_FIREBALL),
+    WITHER_SKULL(ABSTRACT_FIREBALL),
+
+    // Projectiles
+    PROJECTILE_ABSTRACT(ENTITY, null),
+    SNOWBALL(PROJECTILE_ABSTRACT),
+    ENDER_PEARL(PROJECTILE_ABSTRACT),
+    EGG(PROJECTILE_ABSTRACT),
+    POTION(PROJECTILE_ABSTRACT),
+    EXPERIENCE_BOTTLE(PROJECTILE_ABSTRACT),
+
+    // Vehicles
+    MINECART_ABSTRACT(ENTITY, null),
+    CHESTED_MINECART_ABSTRACT(MINECART_ABSTRACT, null),
+    CHEST_MINECART(CHESTED_MINECART_ABSTRACT),
+    HOPPER_MINECART(CHESTED_MINECART_ABSTRACT),
+    MINECART(MINECART_ABSTRACT),
+    FURNACE_MINECART(MINECART_ABSTRACT),
+    COMMAND_BLOCK_MINECART(MINECART_ABSTRACT),
+    TNT_MINECART(MINECART_ABSTRACT),
+    SPAWNER_MINECART(MINECART_ABSTRACT),
+    BOAT(ENTITY),
+    CHEST_BOAT(BOAT);
+
+    private static final EntityType[] TYPES = EntityTypeUtil.createSizedArray(values());
+    private final EntityType parent;
+    private final String identifier;
+    private int id = -1;
+
+    Entity1_19Types(final EntityType parent) {
+        this.parent = parent;
+        this.identifier = "minecraft:" + name().toLowerCase(Locale.ROOT);
+    }
+
+    Entity1_19Types(final EntityType parent, @Nullable final String identifier) {
+        this.parent = parent;
+        this.identifier = identifier;
+    }
+
+    @Override
+    public int getId() {
+        if (id == -1) {
+            throw new IllegalStateException("Ids have not been initialized yet (type " + name() + ")");
+        }
+        return id;
+    }
+
+    @Override
+    public String identifier() {
+        Preconditions.checkArgument(identifier != null, "Called identifier method on abstract type");
+        return identifier;
+    }
+
+    @Override
+    public @Nullable EntityType getParent() {
+        return parent;
+    }
+
+    @Override
+    public boolean isAbstractType() {
+        return identifier == null;
+    }
+
+    public static EntityType getTypeFromId(final int typeId) {
+        return EntityTypeUtil.getTypeFromId(TYPES, typeId, ENTITY);
+    }
+
+    public static void initialize(final Protocol<?, ?, ?, ?> protocol) {
+        EntityTypeUtil.initialize(values(), TYPES, protocol, (type, id) -> type.id = id);
+    }
+}

api/src/main/java/com/viaversion/viaversion/api/minecraft/entities/EntityType.java

@@ -30,6 +30,7 @@ public interface EntityType {
      * Returns the entity id.
      *
      * @return entity id
+     * @throws IllegalStateException if ids have not been loaded yet
      */
     int getId();
 
@@ -47,6 +48,22 @@ public interface EntityType {
      */
     String name();
 
+    /**
+     * Returns the entity's Vanilla identifier.
+     *
+     * @return entity identifier
+     * @throws IllegalArgumentException if {@link #isAbstractType()} returns true
+     */
+    String identifier();
+
+    /**
+     * Returns whether the type does not represent an actual entity, e.g. animal or monster.
+     *
+     * @return whether the type does not represent an actual entity
+     */
+    boolean isAbstractType();
+
+    @Deprecated/*(forRemoval = true)*/
     default boolean is(EntityType... types) {
         for (EntityType type : types) {
             if (this == type) {

api/src/main/java/com/viaversion/viaversion/api/minecraft/metadata/types/MetaTypes1_19.java

@@ -0,0 +1,59 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.minecraft.metadata.types;
+
+import com.viaversion.viaversion.api.minecraft.metadata.MetaType;
+import com.viaversion.viaversion.api.type.Type;
+import com.viaversion.viaversion.api.type.types.minecraft.ParticleType;
+
+public final class MetaTypes1_19 extends AbstractMetaTypes {
+
+    public final MetaType byteType = add(0, Type.BYTE);
+    public final MetaType varIntType = add(1, Type.VAR_INT);
+    public final MetaType floatType = add(2, Type.FLOAT);
+    public final MetaType stringType = add(3, Type.STRING);
+    public final MetaType componentType = add(4, Type.COMPONENT);
+    public final MetaType optionalComponentType = add(5, Type.OPTIONAL_COMPONENT);
+    public final MetaType itemType = add(6, Type.FLAT_VAR_INT_ITEM);
+    public final MetaType booleanType = add(7, Type.BOOLEAN);
+    public final MetaType rotationType = add(8, Type.ROTATION);
+    public final MetaType positionType = add(9, Type.POSITION1_14);
+    public final MetaType optionalPositionType = add(10, Type.OPTIONAL_POSITION_1_14);
+    public final MetaType directionType = add(11, Type.VAR_INT);
+    public final MetaType optionalUUIDType = add(12, Type.OPTIONAL_UUID);
+    public final MetaType blockStateType = add(13, Type.VAR_INT);
+    public final MetaType nbtType = add(14, Type.NBT);
+    public final MetaType particleType;
+    public final MetaType villagerDatatType = add(16, Type.VILLAGER_DATA);
+    public final MetaType optionalVarIntType = add(17, Type.OPTIONAL_VAR_INT);
+    public final MetaType poseType = add(18, Type.VAR_INT);
+    public final MetaType catVariantType = add(19, Type.VAR_INT);
+    public final MetaType frogVariantType = add(20, Type.VAR_INT);
+    public final MetaType optionalGlobalPosition = add(21, Type.OPTIONAL_GLOBAL_POSITION);
+    public final MetaType paintingVariantType = add(22, Type.VAR_INT);
+
+    public MetaTypes1_19(final ParticleType particleType) {
+        super(23);
+        this.particleType = add(15, particleType);
+    }
+}

api/src/main/java/com/viaversion/viaversion/api/platform/ProtocolDetectorService.java

@@ -0,0 +1,65 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.platform;
+
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+
+public interface ProtocolDetectorService {
+
+    /**
+     * Returns the protocol version of the proxied server, or -1 if unknown.
+     *
+     * @param serverName name of the proxied server
+     * @return protocol version of the proxied server, or -1 if unknown
+     */
+    int serverProtocolVersion(String serverName);
+
+    /**
+     * Probes all registered proxied servers for their protocol version.
+     * This is executed automatically in the interval set in the ViaVersion config.
+     */
+    void probeAllServers();
+
+    /**
+     * Sets the stored protocol version of a proxied server.
+     *
+     * @param serverName      name of the proxied server
+     * @param protocolVersion protocol version of the server
+     */
+    void setProtocolVersion(String serverName, int protocolVersion);
+
+    /**
+     * Uncaches and returns the previously stored protocol version of the proxied server. Returns -1 if none was stored.
+     *
+     * @param serverName name of the proxied server
+     * @return previously stored protocol version of the proxied server, or -1 if none was present
+     */
+    int uncacheProtocolVersion(String serverName);
+
+    /**
+     * Returns an unmodifiable map of detected protocol versions.
+     *
+     * @return unmodifiable map of detected protocol versions
+     */
+    Object2IntMap<String> detectedProtocolVersions();
+}

api/src/main/java/com/viaversion/viaversion/api/platform/ViaPlatform.java

@@ -218,4 +218,12 @@ public interface ViaPlatform<T> {
     default Collection<UnsupportedSoftware> getUnsupportedSoftwareClasses() {
         return Collections.emptyList();
     }
+
+    /**
+     * Returns whether the platform has a plugin/mod with the given name (even if disabled).
+     *
+     * @param name plugin or identifier
+     * @return whether the platform has a plugin/mod with the given name
+     */
+    boolean hasPlugin(String name);
 }

api/src/main/java/com/viaversion/viaversion/api/platform/ViaServerProxyPlatform.java

@@ -0,0 +1,42 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.platform;
+
+import com.google.common.annotations.Beta;
+
+/**
+ * Represents a platform that proxies a list of Minecraft servers (Velocity, Bungee).
+ * A platform might not be a proxy platform, even if {@link ViaPlatform#isProxy()} is true.
+ *
+ * @param <T> platform player type
+ */
+@Beta
+public interface ViaServerProxyPlatform<T> extends ViaPlatform<T> {
+
+    /**
+     * Returns a service to get protocol versions for proxied servers.
+     *
+     * @return protocol detector service
+     */
+    ProtocolDetectorService protocolDetectorService();
+}

api/src/main/java/com/viaversion/viaversion/api/protocol/AbstractProtocol.java

@@ -351,7 +351,7 @@ public abstract class AbstractProtocol<C1 extends ClientboundPacketType, C2 exte
         throw e;
     }
 
-    private String toNiceHex(int id) {
+    public static String toNiceHex(int id) {
         String hex = Integer.toHexString(id).toUpperCase();
         return (hex.length() == 1 ? "0x0" : "0x") + hex;
     }

api/src/main/java/com/viaversion/viaversion/api/protocol/Protocol.java

@@ -300,9 +300,9 @@ public interface Protocol<C1 extends ClientboundPacketType, C2 extends Clientbou
      * <p>
      * To be overridden if needed.
      *
-     * @param userConnection The user to initialise
+     * @param connection user to initialise
      */
-    default void init(UserConnection userConnection) {
+    default void init(UserConnection connection) {
     }
 
     /**

api/src/main/java/com/viaversion/viaversion/api/protocol/ProtocolManager.java

@@ -177,35 +177,49 @@ public interface ProtocolManager {
                                                                        @Nullable Class<S> serverboundPacketsClass);
 
     /**
-     * Returns whether protocol path calculation expects the path to come closer to the expected version with each entry, true by default.
+     * Sets the max delta the path calculation allows the distance to the target protocol version to increase.
      * <p>
-     * In practice, this means a path will never go to a protocol version that puts it farther from the desired
+     * If set to 0, protocol paths will have to come closer to the target protocol version with every entry,
+     * never going farther away from it (1→5→10 and 1→11→10 are ok, 1→20→10 is not ok).
+     * If set to -1, no distance checks will be applied (1→20→10 is ok).
+     *
+     * @param maxPathDeltaIncrease the max delta the path calculation allows the distance to the target protocol version to increase
+     * @see #onlyCheckLoweringPathEntries()
+     */
+    void setMaxPathDeltaIncrease(int maxPathDeltaIncrease);
+
+    /**
+     * Returns the max delta the path calculation allows the distance to the target protocol version to increase. 0 by default.
+     * <p>
+     * In practice, a value of 0 means a path will never go to a protocol version that puts it farther from the desired
      * server protocol version, even if a path existed.
-     * If this is set to false, *all* possible paths will be checked until a fitting one is found.
+     * If this is set to -1, *all* possible paths will be checked until a fitting one is found.
      * <p>
-     * Negative examples if this returns true:
+     * Negative examples if this returns 0:
      * <ul>
      *     A possible path from 3 to 5 in order of 3→10→5 will be dismissed.
      *     A possible path from 5 to 3 in order of 5→0→3 will be dismissed.
      * </ul>
      * <p>
-     * Negative examples if this returns false:
+     * Negative examples if this returns -1:
      * <ul>
      *     While searching for a path from 3 to 5, 3→2→1 could be checked first before 3→4→5 is found.
      *     While searching for a path from 5 to 3, 5→6→7 could be checked first before 5→4→3 is found.
      * </ul>
      *
-     * @return whether protocol path calculation expects the path to come closer to the expected version with each entry
+     * @return max delta the path calculation allows the distance to the target protocol version to increase
      */
-    boolean onlyCheckLoweringPathEntries();
+    int getMaxPathDeltaIncrease();
 
-    /**
-     * Sets whether protocol path calculation expects the path to come closer to the expected version with each entry.
-     *
-     * @param onlyCheckLoweringPathEntries whether protocol path calculation expects the path to come closer to the expected version with each entry
-     * @see #onlyCheckLoweringPathEntries()
-     */
-    void setOnlyCheckLoweringPathEntries(boolean onlyCheckLoweringPathEntries);
+    @Deprecated/*(forRemoval = true)*/
+    default void setOnlyCheckLoweringPathEntries(final boolean onlyCheckLoweringPathEntries) {
+        setMaxPathDeltaIncrease(onlyCheckLoweringPathEntries ? 0 : -1);
+    }
+
+    @Deprecated/*(forRemoval = true)*/
+    default boolean onlyCheckLoweringPathEntries() {
+        return getMaxPathDeltaIncrease() != -1;
+    }
 
     /**
      * Returns the maximum protocol path size applied to {@link #getProtocolPath(int, int)}.

api/src/main/java/com/viaversion/viaversion/api/protocol/version/ProtocolVersion.java

@@ -80,6 +80,8 @@ public class ProtocolVersion {
     public static final ProtocolVersion v1_17_1 = register(756, "1.17.1");
     public static final ProtocolVersion v1_18 = register(757, "1.18/1.18.1", new VersionRange("1.18", 0, 1));
     public static final ProtocolVersion v1_18_2 = register(758, "1.18.2");
+    public static final ProtocolVersion v1_19 = register(759, "1.19");
+    public static final ProtocolVersion v1_19_1 = register(760, "1.19.1/2", new VersionRange("1.19", 1, 2));
     public static final ProtocolVersion unknown = register(-1, "UNKNOWN");
 
     public static ProtocolVersion register(int version, String name) {

api/src/main/java/com/viaversion/viaversion/api/rewriter/RewriterBase.java

@@ -49,6 +49,9 @@ public abstract class RewriterBase<T extends Protocol> implements Rewriter<T> {
     protected void registerRewrites() {
     }
 
+    public void onMappingDataLoaded() {
+    }
+
     @Override
     public T protocol() {
         return protocol;

api/src/main/java/com/viaversion/viaversion/api/type/ByteBufReader.java

@@ -24,13 +24,15 @@ package com.viaversion.viaversion.api.type;
 
 import io.netty.buffer.ByteBuf;
 
+@FunctionalInterface
 public interface ByteBufReader<T> {
+
     /**
-     * Read a value from a ByteBuf
+     * Reads a value from a ByteBuf.
      *
-     * @param buffer The buffer to read from.
-     * @return The type based on the class type.
-     * @throws Exception Throws exception if it failed reading.
+     * @param buffer buffer to read from
+     * @return type based on the class type
+     * @throws Exception if it failed reading
      */
     T read(ByteBuf buffer) throws Exception;
 }

api/src/main/java/com/viaversion/viaversion/api/type/ByteBufWriter.java

@@ -24,13 +24,15 @@ package com.viaversion.viaversion.api.type;
 
 import io.netty.buffer.ByteBuf;
 
+@FunctionalInterface
 public interface ByteBufWriter<T> {
+
     /**
-     * Write an object to a type to a ByteBuf
+     * Writes an object to a type to a ByteBuf.
      *
-     * @param buffer The buffer to write to
-     * @param object The object to write
-     * @throws Exception Throws if it failed to write
+     * @param buffer buffer to write to
+     * @param value  value to write
+     * @throws Exception if it failed to write
      */
-    void write(ByteBuf buffer, T object) throws Exception;
+    void write(ByteBuf buffer, T value) throws Exception;
 }

api/src/main/java/com/viaversion/viaversion/api/type/OptionalType.java

@@ -20,31 +20,31 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-package com.viaversion.viaversion.api.type.types.minecraft;
+package com.viaversion.viaversion.api.type;
 
-import com.google.gson.JsonElement;
-import com.viaversion.viaversion.api.type.Type;
 import io.netty.buffer.ByteBuf;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
-public class OptionalComponentType extends Type<JsonElement> {
+public abstract class OptionalType<T> extends Type<T> {
+    private final Type<T> type;
 
-    public OptionalComponentType() {
-        super(JsonElement.class);
+    protected OptionalType(final Type<T> type) {
+        super(type.getOutputClass());
+        this.type = type;
     }
 
     @Override
-    public JsonElement read(ByteBuf buffer) throws Exception {
-        boolean present = buffer.readBoolean();
-        return present ? Type.COMPONENT.read(buffer) : null;
+    public @Nullable T read(ByteBuf buffer) throws Exception {
+        return buffer.readBoolean() ? type.read(buffer) : null;
     }
 
     @Override
-    public void write(ByteBuf buffer, JsonElement object) throws Exception {
-        if (object == null) {
+    public void write(final ByteBuf buffer, @Nullable final T value) throws Exception {
+        if (value == null) {
             buffer.writeBoolean(false);
         } else {
             buffer.writeBoolean(true);
-            Type.COMPONENT.write(buffer, object);
+            type.write(buffer, value);
         }
     }
-}
+}

api/src/main/java/com/viaversion/viaversion/api/type/Type.java

@@ -27,7 +27,10 @@ import com.github.steveice10.opennbt.tag.builtin.CompoundTag;
 import com.google.gson.JsonElement;
 import com.viaversion.viaversion.api.minecraft.BlockChangeRecord;
 import com.viaversion.viaversion.api.minecraft.EulerAngle;
+import com.viaversion.viaversion.api.minecraft.GlobalPosition;
+import com.viaversion.viaversion.api.minecraft.PlayerMessageSignature;
 import com.viaversion.viaversion.api.minecraft.Position;
+import com.viaversion.viaversion.api.minecraft.ProfileKey;
 import com.viaversion.viaversion.api.minecraft.Vector;
 import com.viaversion.viaversion.api.minecraft.VillagerData;
 import com.viaversion.viaversion.api.minecraft.item.Item;
@@ -59,16 +62,15 @@ import com.viaversion.viaversion.api.type.types.minecraft.FlatItemArrayType;
 import com.viaversion.viaversion.api.type.types.minecraft.FlatItemType;
 import com.viaversion.viaversion.api.type.types.minecraft.FlatVarIntItemArrayType;
 import com.viaversion.viaversion.api.type.types.minecraft.FlatVarIntItemType;
+import com.viaversion.viaversion.api.type.types.minecraft.GlobalPositionType;
 import com.viaversion.viaversion.api.type.types.minecraft.ItemArrayType;
 import com.viaversion.viaversion.api.type.types.minecraft.ItemType;
 import com.viaversion.viaversion.api.type.types.minecraft.NBTType;
-import com.viaversion.viaversion.api.type.types.minecraft.OptPosition1_14Type;
-import com.viaversion.viaversion.api.type.types.minecraft.OptPositionType;
-import com.viaversion.viaversion.api.type.types.minecraft.OptUUIDType;
-import com.viaversion.viaversion.api.type.types.minecraft.OptionalComponentType;
 import com.viaversion.viaversion.api.type.types.minecraft.OptionalVarIntType;
+import com.viaversion.viaversion.api.type.types.minecraft.PlayerMessageSignatureType;
 import com.viaversion.viaversion.api.type.types.minecraft.Position1_14Type;
 import com.viaversion.viaversion.api.type.types.minecraft.PositionType;
+import com.viaversion.viaversion.api.type.types.minecraft.ProfileKeyType;
 import com.viaversion.viaversion.api.type.types.minecraft.VarLongBlockChangeRecordType;
 import com.viaversion.viaversion.api.type.types.minecraft.VectorType;
 import com.viaversion.viaversion.api.type.types.minecraft.VillagerDataType;
@@ -102,15 +104,17 @@ public abstract class Type<T> implements ByteBufReader<T>, ByteBufWriter<T> {
 
     /* Other Types */
     public static final Type<JsonElement> COMPONENT = new ComponentType();
-    public static final Type<JsonElement> OPTIONAL_COMPONENT = new OptionalComponentType();
+    public static final Type<JsonElement> OPTIONAL_COMPONENT = new ComponentType.OptionalComponentType();
 
     public static final Type<String> STRING = new StringType();
+    public static final Type<String> OPTIONAL_STRING = new StringType.OptionalStringType();
     public static final Type<String[]> STRING_ARRAY = new ArrayType<>(Type.STRING);
 
     public static final Type<UUID> UUID = new UUIDType();
-    public static final Type<UUID> OPTIONAL_UUID = new OptUUIDType();
-    public static final Type<UUID> UUID_INT_ARRAY = new UUIDIntArrayType();
+    public static final Type<UUID> OPTIONAL_UUID = new UUIDType.OptionalUUIDType();
     public static final Type<UUID[]> UUID_ARRAY = new ArrayType<>(Type.UUID);
+    @Deprecated/*(forRemoval = true)*/
+    public static final Type<UUID> UUID_INT_ARRAY = new UUIDIntArrayType();
 
     public static final VarIntType VAR_INT = new VarIntType();
     public static final OptionalVarIntType OPTIONAL_VAR_INT = new OptionalVarIntType();
@@ -146,14 +150,16 @@ public abstract class Type<T> implements ByteBufReader<T>, ByteBufWriter<T> {
 
     /* MC Types */
     public static final Type<Position> POSITION = new PositionType();
+    public static final Type<Position> OPTIONAL_POSITION = new PositionType.OptionalPositionType();
     public static final Type<Position> POSITION1_14 = new Position1_14Type();
+    public static final Type<Position> OPTIONAL_POSITION_1_14 = new Position1_14Type.OptionalPosition1_14Type();
     public static final Type<EulerAngle> ROTATION = new EulerAngleType();
     public static final Type<Vector> VECTOR = new VectorType();
     public static final Type<CompoundTag> NBT = new NBTType();
     public static final Type<CompoundTag[]> NBT_ARRAY = new ArrayType<>(Type.NBT);
 
-    public static final Type<Position> OPTIONAL_POSITION = new OptPositionType();
-    public static final Type<Position> OPTIONAL_POSITION_1_14 = new OptPosition1_14Type();
+    public static final Type<GlobalPosition> GLOBAL_POSITION = new GlobalPositionType();
+    public static final Type<GlobalPosition> OPTIONAL_GLOBAL_POSITION = new GlobalPositionType.OptionalGlobalPositionType();
 
     public static final Type<BlockChangeRecord> BLOCK_CHANGE_RECORD = new BlockChangeRecordType();
     public static final Type<BlockChangeRecord[]> BLOCK_CHANGE_RECORD_ARRAY = new ArrayType<>(Type.BLOCK_CHANGE_RECORD);
@@ -166,6 +172,13 @@ public abstract class Type<T> implements ByteBufReader<T>, ByteBufWriter<T> {
     public static final Type<Item> ITEM = new ItemType();
     public static final Type<Item[]> ITEM_ARRAY = new ItemArrayType();
 
+    public static final Type<ProfileKey> PROFILE_KEY = new ProfileKeyType();
+    public static final Type<ProfileKey> OPTIONAL_PROFILE_KEY = new ProfileKeyType.OptionalProfileKeyType();
+
+    public static final Type<PlayerMessageSignature> PLAYER_MESSAGE_SIGNATURE = new PlayerMessageSignatureType();
+    public static final Type<PlayerMessageSignature> OPTIONAL_PLAYER_MESSAGE_SIGNATURE = new PlayerMessageSignatureType.OptionalPlayerMessageSignatureType();
+    public static final Type<PlayerMessageSignature[]> PLAYER_MESSAGE_SIGNATURE_ARRAY = new ArrayType<>(PLAYER_MESSAGE_SIGNATURE);
+
     /* 1.13 Flat Item (no data) */
     public static final Type<Item> FLAT_ITEM = new FlatItemType();
     public static final Type<Item> FLAT_VAR_INT_ITEM = new FlatVarIntItemType();

api/src/main/java/com/viaversion/viaversion/api/type/types/ComponentType.java

@@ -26,6 +26,7 @@ import com.google.gson.JsonElement;
 import com.google.gson.JsonParser;
 import com.google.gson.JsonSyntaxException;
 import com.viaversion.viaversion.api.Via;
+import com.viaversion.viaversion.api.type.OptionalType;
 import com.viaversion.viaversion.api.type.Type;
 import io.netty.buffer.ByteBuf;
 
@@ -51,4 +52,11 @@ public class ComponentType extends Type<JsonElement> {
     public void write(ByteBuf buffer, JsonElement object) throws Exception {
         STRING_TAG.write(buffer, object.toString());
     }
+
+    public static final class OptionalComponentType extends OptionalType<JsonElement> {
+
+        public OptionalComponentType() {
+            super(Type.COMPONENT);
+        }
+    }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/LongArrayType.java

@@ -36,7 +36,7 @@ public class LongArrayType extends Type<long[]> {
         int length = Type.VAR_INT.readPrimitive(buffer);
         long[] array = new long[length];
         for (int i = 0; i < array.length; i++) {
-            array[i] = Type.LONG.readPrimitive(buffer);
+            array[i] = buffer.readLong();
         }
         return array;
     }
@@ -45,7 +45,7 @@ public class LongArrayType extends Type<long[]> {
     public void write(ByteBuf buffer, long[] object) throws Exception {
         Type.VAR_INT.writePrimitive(buffer, object.length);
         for (long l : object) {
-            Type.LONG.writePrimitive(buffer, l);
+            buffer.writeLong(l);
         }
     }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/StringType.java

@@ -23,6 +23,7 @@
 package com.viaversion.viaversion.api.type.types;
 
 import com.google.common.base.Preconditions;
+import com.viaversion.viaversion.api.type.OptionalType;
 import com.viaversion.viaversion.api.type.Type;
 import io.netty.buffer.ByteBuf;
 
@@ -67,4 +68,11 @@ public class StringType extends Type<String> {
         Type.VAR_INT.writePrimitive(buffer, b.length);
         buffer.writeBytes(b);
     }
+
+    public static final class OptionalStringType extends OptionalType<String> {
+
+        public OptionalStringType() {
+            super(Type.STRING);
+        }
+    }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/UUIDType.java

@@ -22,12 +22,14 @@
  */
 package com.viaversion.viaversion.api.type.types;
 
+import com.viaversion.viaversion.api.type.OptionalType;
 import com.viaversion.viaversion.api.type.Type;
 import io.netty.buffer.ByteBuf;
 
 import java.util.UUID;
 
 public class UUIDType extends Type<UUID> {
+
     public UUIDType() {
         super(UUID.class);
     }
@@ -42,4 +44,11 @@ public class UUIDType extends Type<UUID> {
         buffer.writeLong(object.getMostSignificantBits());
         buffer.writeLong(object.getLeastSignificantBits());
     }
+
+    public static final class OptionalUUIDType extends OptionalType<UUID> {
+
+        public OptionalUUIDType() {
+            super(Type.UUID);
+        }
+    }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/VarIntType.java

@@ -28,40 +28,37 @@ import io.netty.buffer.ByteBuf;
 
 public class VarIntType extends Type<Integer> implements TypeConverter<Integer> {
 
+    private static final int CONTINUE_BIT = 0x80;
+    private static final int VALUE_BITS = 0x7F;
+    private static final int MULTI_BYTE_BITS = ~VALUE_BITS;
+    private static final int MAX_BYTES = 5;
+
     public VarIntType() {
         super("VarInt", Integer.class);
     }
 
     public int readPrimitive(ByteBuf buffer) {
-        int out = 0;
+        int value = 0;
         int bytes = 0;
         byte in;
         do {
             in = buffer.readByte();
-
-            out |= (in & 0x7F) << (bytes++ * 7);
-
-            if (bytes > 5) { // 5 is maxBytes
+            value |= (in & VALUE_BITS) << (bytes++ * 7);
+            if (bytes > MAX_BYTES) {
                 throw new RuntimeException("VarInt too big");
             }
 
-        } while ((in & 0x80) == 0x80);
-        return out;
+        } while ((in & CONTINUE_BIT) == CONTINUE_BIT);
+        return value;
     }
 
-    public void writePrimitive(ByteBuf buffer, int object) {
-        int part;
-        do {
-            part = object & 0x7F;
+    public void writePrimitive(ByteBuf buffer, int value) {
+        while ((value & MULTI_BYTE_BITS) != 0) {
+            buffer.writeByte((value & VALUE_BITS) | CONTINUE_BIT);
+            value >>>= 7;
+        }
 
-            object >>>= 7;
-            if (object != 0) {
-                part |= 0x80;
-            }
-
-            buffer.writeByte(part);
-
-        } while (object != 0);
+        buffer.writeByte(value);
     }
 
     /**

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/FlatItemType.java

@@ -26,6 +26,7 @@ import com.viaversion.viaversion.api.minecraft.item.DataItem;
 import com.viaversion.viaversion.api.minecraft.item.Item;
 import com.viaversion.viaversion.api.type.Type;
 import io.netty.buffer.ByteBuf;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 public class FlatItemType extends BaseItemType {
     public FlatItemType() {
@@ -33,7 +34,7 @@ public class FlatItemType extends BaseItemType {
     }
 
     @Override
-    public Item read(ByteBuf buffer) throws Exception {
+    public @Nullable Item read(ByteBuf buffer) throws Exception {
         short id = buffer.readShort();
         if (id < 0) {
             return null;
@@ -47,7 +48,7 @@ public class FlatItemType extends BaseItemType {
     }
 
     @Override
-    public void write(ByteBuf buffer, Item object) throws Exception {
+    public void write(ByteBuf buffer, @Nullable Item object) throws Exception {
         if (object == null) {
             buffer.writeShort(-1);
         } else {

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/FlatVarIntItemType.java

@@ -25,6 +25,7 @@ package com.viaversion.viaversion.api.type.types.minecraft;
 import com.viaversion.viaversion.api.minecraft.item.DataItem;
 import com.viaversion.viaversion.api.minecraft.item.Item;
 import io.netty.buffer.ByteBuf;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 public class FlatVarIntItemType extends BaseItemType {
     public FlatVarIntItemType() {
@@ -32,7 +33,7 @@ public class FlatVarIntItemType extends BaseItemType {
     }
 
     @Override
-    public Item read(ByteBuf buffer) throws Exception {
+    public @Nullable Item read(ByteBuf buffer) throws Exception {
         boolean present = buffer.readBoolean();
         if (!present) {
             return null;
@@ -46,7 +47,7 @@ public class FlatVarIntItemType extends BaseItemType {
     }
 
     @Override
-    public void write(ByteBuf buffer, Item object) throws Exception {
+    public void write(ByteBuf buffer, @Nullable Item object) throws Exception {
         if (object == null) {
             buffer.writeBoolean(false);
         } else {

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/GlobalPositionType.java

@@ -22,31 +22,33 @@
  */
 package com.viaversion.viaversion.api.type.types.minecraft;
 
+import com.viaversion.viaversion.api.minecraft.GlobalPosition;
+import com.viaversion.viaversion.api.type.OptionalType;
 import com.viaversion.viaversion.api.type.Type;
 import io.netty.buffer.ByteBuf;
 
-import java.util.UUID;
+public class GlobalPositionType extends Type<GlobalPosition> {
 
-public class OptUUIDType extends Type<UUID> {
-    public OptUUIDType() {
-        super(UUID.class);
+    public GlobalPositionType() {
+        super(GlobalPosition.class);
     }
 
     @Override
-    public UUID read(ByteBuf buffer) {
-        boolean present = buffer.readBoolean();
-        if (!present) return null;
-        return new UUID(buffer.readLong(), buffer.readLong());
+    public GlobalPosition read(ByteBuf buffer) throws Exception {
+        final String dimension = Type.STRING.read(buffer);
+        return Type.POSITION1_14.read(buffer).withDimension(dimension);
     }
 
     @Override
-    public void write(ByteBuf buffer, UUID object) {
-        if (object == null) {
-            buffer.writeBoolean(false);
-        } else {
-            buffer.writeBoolean(true);
-            buffer.writeLong(object.getMostSignificantBits());
-            buffer.writeLong(object.getLeastSignificantBits());
+    public void write(ByteBuf buffer, GlobalPosition object) throws Exception {
+        Type.STRING.write(buffer, object.dimension());
+        Type.POSITION1_14.write(buffer, object);
+    }
+
+    public static final class OptionalGlobalPositionType extends OptionalType<GlobalPosition> {
+
+        public OptionalGlobalPositionType() {
+            super(Type.GLOBAL_POSITION);
         }
     }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/ItemType.java

@@ -25,6 +25,7 @@ package com.viaversion.viaversion.api.type.types.minecraft;
 import com.viaversion.viaversion.api.minecraft.item.DataItem;
 import com.viaversion.viaversion.api.minecraft.item.Item;
 import io.netty.buffer.ByteBuf;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 public class ItemType extends BaseItemType {
     public ItemType() {
@@ -32,7 +33,7 @@ public class ItemType extends BaseItemType {
     }
 
     @Override
-    public Item read(ByteBuf buffer) throws Exception {
+    public @Nullable Item read(ByteBuf buffer) throws Exception {
         short id = buffer.readShort();
         if (id < 0) {
             return null;
@@ -47,7 +48,7 @@ public class ItemType extends BaseItemType {
     }
 
     @Override
-    public void write(ByteBuf buffer, Item object) throws Exception {
+    public void write(ByteBuf buffer, @Nullable Item object) throws Exception {
         if (object == null) {
             buffer.writeShort(-1);
         } else {

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/NBTType.java

@@ -24,7 +24,7 @@ package com.viaversion.viaversion.api.type.types.minecraft;
 
 import com.github.steveice10.opennbt.NBTIO;
 import com.github.steveice10.opennbt.tag.builtin.CompoundTag;
-import com.google.common.base.Preconditions;
+import com.github.steveice10.opennbt.tag.limiter.TagLimiter;
 import com.viaversion.viaversion.api.type.Type;
 import io.netty.buffer.ByteBuf;
 import io.netty.buffer.ByteBufInputStream;
@@ -35,21 +35,22 @@ import java.io.DataOutput;
 
 public class NBTType extends Type<CompoundTag> {
 
+    private static final int MAX_NBT_BYTES = 2097152; // 2mb
+    private static final int MAX_NESTING_LEVEL = 512;
+
     public NBTType() {
         super(CompoundTag.class);
     }
 
     @Override
     public CompoundTag read(ByteBuf buffer) throws Exception {
-        Preconditions.checkArgument(buffer.readableBytes() <= 2097152, "Cannot read NBT (got %s bytes)", buffer.readableBytes());
-
         int readerIndex = buffer.readerIndex();
         byte b = buffer.readByte();
         if (b == 0) {
             return null;
         } else {
             buffer.readerIndex(readerIndex);
-            return NBTIO.readTag((DataInput) new ByteBufInputStream(buffer));
+            return NBTIO.readTag((DataInput) new ByteBufInputStream(buffer), TagLimiter.create(MAX_NBT_BYTES, MAX_NESTING_LEVEL));
         }
     }
 

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/OptionalVarIntType.java

@@ -26,20 +26,23 @@ import com.viaversion.viaversion.api.type.Type;
 import io.netty.buffer.ByteBuf;
 
 public class OptionalVarIntType extends Type<Integer> {
+
     public OptionalVarIntType() {
         super(Integer.class);
     }
 
     @Override
-    public Integer read(ByteBuf buffer) throws Exception {
-        int read = Type.VAR_INT.readPrimitive(buffer);
-        if (read == 0) return null;
-        return read - 1;
+    public Integer read(final ByteBuf buffer) throws Exception {
+        final int value = Type.VAR_INT.readPrimitive(buffer);
+        return value == 0 ? null : value - 1;
     }
 
     @Override
-    public void write(ByteBuf buffer, Integer object) throws Exception {
-        if (object == null) Type.VAR_INT.writePrimitive(buffer, 0);
-        else Type.VAR_INT.writePrimitive(buffer, object + 1);
+    public void write(final ByteBuf buffer, final Integer object) throws Exception {
+        if (object == null) {
+            Type.VAR_INT.writePrimitive(buffer, 0);
+        } else {
+            Type.VAR_INT.writePrimitive(buffer, object + 1);
+        }
     }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/ParticleType.java

@@ -117,6 +117,12 @@ public class ParticleType extends Type<Particle> {
             }
             particle.add(Type.VAR_INT, Type.VAR_INT.readPrimitive(buf)); // Arrival in ticks
         };
+        public static final ParticleReader SCULK_CHARGE = (buf, particle) -> {
+            particle.add(Type.FLOAT, Type.FLOAT.readPrimitive(buf)); // Roll
+        };
+        public static final ParticleReader SHRIEK = (buf, particle) -> {
+            particle.add(Type.VAR_INT, Type.VAR_INT.readPrimitive(buf)); // Delay
+        };
     }
 
     public final class ParticleTypeFiller {

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/PlayerMessageSignatureType.java

@@ -0,0 +1,53 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.type.types.minecraft;
+
+import com.viaversion.viaversion.api.minecraft.PlayerMessageSignature;
+import com.viaversion.viaversion.api.type.OptionalType;
+import com.viaversion.viaversion.api.type.Type;
+import io.netty.buffer.ByteBuf;
+
+public class PlayerMessageSignatureType extends Type<PlayerMessageSignature> {
+
+    public PlayerMessageSignatureType() {
+        super(PlayerMessageSignature.class);
+    }
+
+    @Override
+    public PlayerMessageSignature read(final ByteBuf buffer) throws Exception {
+        return new PlayerMessageSignature(Type.UUID.read(buffer), Type.BYTE_ARRAY_PRIMITIVE.read(buffer));
+    }
+
+    @Override
+    public void write(final ByteBuf buffer, final PlayerMessageSignature value) throws Exception {
+        Type.UUID.write(buffer, value.uuid());
+        Type.BYTE_ARRAY_PRIMITIVE.write(buffer, value.signatureBytes());
+    }
+
+    public static final class OptionalPlayerMessageSignatureType extends OptionalType<PlayerMessageSignature> {
+
+        public OptionalPlayerMessageSignatureType() {
+            super(Type.PLAYER_MESSAGE_SIGNATURE);
+        }
+    }
+}

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/Position1_14Type.java

@@ -23,6 +23,7 @@
 package com.viaversion.viaversion.api.type.types.minecraft;
 
 import com.viaversion.viaversion.api.minecraft.Position;
+import com.viaversion.viaversion.api.type.OptionalType;
 import com.viaversion.viaversion.api.type.Type;
 import io.netty.buffer.ByteBuf;
 
@@ -48,4 +49,11 @@ public class Position1_14Type extends Type<Position> {
                 | (object.y() & 0xfff)
                 | ((((long) object.z()) & 0x3ffffff) << 12));
     }
+
+    public static final class OptionalPosition1_14Type extends OptionalType<Position> {
+
+        public OptionalPosition1_14Type() {
+            super(Type.POSITION1_14);
+        }
+    }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/PositionType.java

@@ -23,6 +23,7 @@
 package com.viaversion.viaversion.api.type.types.minecraft;
 
 import com.viaversion.viaversion.api.minecraft.Position;
+import com.viaversion.viaversion.api.type.OptionalType;
 import com.viaversion.viaversion.api.type.Type;
 import io.netty.buffer.ByteBuf;
 
@@ -48,4 +49,11 @@ public class PositionType extends Type<Position> {
                 | ((((long) object.y()) & 0xfff) << 26)
                 | (object.z() & 0x3ffffff));
     }
+
+    public static final class OptionalPositionType extends OptionalType<Position> {
+
+        public OptionalPositionType() {
+            super(Type.POSITION);
+        }
+    }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/minecraft/ProfileKeyType.java

@@ -0,0 +1,54 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * Permission is hereby granted, free of charge, to any person obtaining a copy
+ * of this software and associated documentation files (the "Software"), to deal
+ * in the Software without restriction, including without limitation the rights
+ * to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+ * copies of the Software, and to permit persons to whom the Software is
+ * furnished to do so, subject to the following conditions:
+ *
+ * The above copyright notice and this permission notice shall be included in all
+ * copies or substantial portions of the Software.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+ * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+ * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+ * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+ * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+ * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+ * SOFTWARE.
+ */
+package com.viaversion.viaversion.api.type.types.minecraft;
+
+import com.viaversion.viaversion.api.minecraft.ProfileKey;
+import com.viaversion.viaversion.api.type.OptionalType;
+import com.viaversion.viaversion.api.type.Type;
+import io.netty.buffer.ByteBuf;
+
+public class ProfileKeyType extends Type<ProfileKey> {
+
+    public ProfileKeyType() {
+        super(ProfileKey.class);
+    }
+
+    @Override
+    public ProfileKey read(final ByteBuf buffer) throws Exception {
+        return new ProfileKey(buffer.readLong(), Type.BYTE_ARRAY_PRIMITIVE.read(buffer), Type.BYTE_ARRAY_PRIMITIVE.read(buffer));
+    }
+
+    @Override
+    public void write(final ByteBuf buffer, final ProfileKey object) throws Exception {
+        buffer.writeLong(object.expiresAt());
+        Type.BYTE_ARRAY_PRIMITIVE.write(buffer, object.publicKey());
+        Type.BYTE_ARRAY_PRIMITIVE.write(buffer, object.keySignature());
+    }
+
+    public static final class OptionalProfileKeyType extends OptionalType<ProfileKey> {
+
+        public OptionalProfileKeyType() {
+            super(Type.PROFILE_KEY);
+        }
+    }
+}

api/src/main/java/com/viaversion/viaversion/api/type/types/version/ChunkSectionType1_13.java

@@ -41,8 +41,10 @@ public class ChunkSectionType1_13 extends Type<ChunkSection> {
         int bitsPerBlock = buffer.readUnsignedByte();
         int originalBitsPerBlock = bitsPerBlock;
 
-        if (bitsPerBlock == 0 || bitsPerBlock > 8) {
+        if (bitsPerBlock > 8) {
             bitsPerBlock = GLOBAL_PALETTE;
+        } else if (bitsPerBlock < 4) {
+            bitsPerBlock = 4;
         }
 
         // Read palette
@@ -58,18 +60,13 @@ public class ChunkSectionType1_13 extends Type<ChunkSection> {
         }
 
         // Read blocks
-        long[] blockData = new long[Type.VAR_INT.readPrimitive(buffer)];
+        long[] blockData = Type.LONG_ARRAY_PRIMITIVE.read(buffer);
         if (blockData.length > 0) {
             int expectedLength = (int) Math.ceil(ChunkSection.SIZE * bitsPerBlock / 64.0);
-            if (blockData.length != expectedLength) {
-                throw new IllegalStateException("Block data length (" + blockData.length + ") does not match expected length (" + expectedLength + ")! bitsPerBlock=" + bitsPerBlock + ", originalBitsPerBlock=" + originalBitsPerBlock);
+            if (blockData.length == expectedLength) {
+                CompactArrayUtil.iterateCompactArray(bitsPerBlock, ChunkSection.SIZE, blockData,
+                        bitsPerBlock == GLOBAL_PALETTE ? chunkSection::setFlatBlock : chunkSection::setPaletteIndex);
             }
-
-            for (int i = 0; i < blockData.length; i++) {
-                blockData[i] = buffer.readLong();
-            }
-            CompactArrayUtil.iterateCompactArray(bitsPerBlock, ChunkSection.SIZE, blockData,
-                    bitsPerBlock == GLOBAL_PALETTE ? chunkSection::setFlatBlock : chunkSection::setPaletteIndex);
         }
 
         return chunkSection;
@@ -88,7 +85,7 @@ public class ChunkSectionType1_13 extends Type<ChunkSection> {
 
         buffer.writeByte(bitsPerBlock);
 
-        // Write pallet (or not)
+        // Write palette
         if (bitsPerBlock != GLOBAL_PALETTE) {
             Type.VAR_INT.writePrimitive(buffer, chunkSection.getPaletteSize());
             for (int i = 0; i < chunkSection.getPaletteSize(); i++) {
@@ -98,9 +95,6 @@ public class ChunkSectionType1_13 extends Type<ChunkSection> {
 
         long[] data = CompactArrayUtil.createCompactArray(bitsPerBlock, ChunkSection.SIZE,
                 bitsPerBlock == GLOBAL_PALETTE ? chunkSection::getFlatBlock : chunkSection::getPaletteIndex);
-        Type.VAR_INT.writePrimitive(buffer, data.length);
-        for (long l : data) {
-            buffer.writeLong(l);
-        }
+        Type.LONG_ARRAY_PRIMITIVE.write(buffer, data);
     }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/version/ChunkSectionType1_16.java

@@ -41,8 +41,10 @@ public class ChunkSectionType1_16 extends Type<ChunkSection> {
         int bitsPerBlock = buffer.readUnsignedByte();
         int originalBitsPerBlock = bitsPerBlock;
 
-        if (bitsPerBlock == 0 || bitsPerBlock > 8) {
+        if (bitsPerBlock > 8) {
             bitsPerBlock = GLOBAL_PALETTE;
+        } else if (bitsPerBlock < 4) {
+            bitsPerBlock = 4;
         }
 
         // Read palette
@@ -58,19 +60,14 @@ public class ChunkSectionType1_16 extends Type<ChunkSection> {
         }
 
         // Read blocks
-        long[] blockData = new long[Type.VAR_INT.readPrimitive(buffer)];
+        long[] blockData = Type.LONG_ARRAY_PRIMITIVE.read(buffer);
         if (blockData.length > 0) {
             char valuesPerLong = (char) (64 / bitsPerBlock);
             int expectedLength = (ChunkSection.SIZE + valuesPerLong - 1) / valuesPerLong;
-            if (blockData.length != expectedLength) {
-                throw new IllegalStateException("Block data length (" + blockData.length + ") does not match expected length (" + expectedLength + ")! bitsPerBlock=" + bitsPerBlock + ", originalBitsPerBlock=" + originalBitsPerBlock);
+            if (blockData.length == expectedLength) {
+                CompactArrayUtil.iterateCompactArrayWithPadding(bitsPerBlock, ChunkSection.SIZE, blockData,
+                        bitsPerBlock == GLOBAL_PALETTE ? chunkSection::setFlatBlock : chunkSection::setPaletteIndex);
             }
-
-            for (int i = 0; i < blockData.length; i++) {
-                blockData[i] = buffer.readLong();
-            }
-            CompactArrayUtil.iterateCompactArrayWithPadding(bitsPerBlock, ChunkSection.SIZE, blockData,
-                    bitsPerBlock == GLOBAL_PALETTE ? chunkSection::setFlatBlock : chunkSection::setPaletteIndex);
         }
 
         return chunkSection;
@@ -89,7 +86,7 @@ public class ChunkSectionType1_16 extends Type<ChunkSection> {
 
         buffer.writeByte(bitsPerBlock);
 
-        // Write pallet (or not)
+        // Write palette
         if (bitsPerBlock != GLOBAL_PALETTE) {
             Type.VAR_INT.writePrimitive(buffer, chunkSection.getPaletteSize());
             for (int i = 0; i < chunkSection.getPaletteSize(); i++) {
@@ -99,9 +96,6 @@ public class ChunkSectionType1_16 extends Type<ChunkSection> {
 
         long[] data = CompactArrayUtil.createCompactArrayWithPadding(bitsPerBlock, ChunkSection.SIZE,
                 bitsPerBlock == GLOBAL_PALETTE ? chunkSection::getFlatBlock : chunkSection::getPaletteIndex);
-        Type.VAR_INT.writePrimitive(buffer, data.length);
-        for (long l : data) {
-            buffer.writeLong(l);
-        }
+        Type.LONG_ARRAY_PRIMITIVE.write(buffer, data);
     }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/version/ChunkSectionType1_9.java

@@ -40,10 +40,6 @@ public class ChunkSectionType1_9 extends Type<ChunkSection> {
         // Reaad bits per block
         int bitsPerBlock = buffer.readUnsignedByte();
         int originalBitsPerBlock = bitsPerBlock;
-
-        if (bitsPerBlock == 0) {
-            bitsPerBlock = GLOBAL_PALETTE;
-        }
         if (bitsPerBlock < 4) {
             bitsPerBlock = 4;
         }
@@ -63,19 +59,14 @@ public class ChunkSectionType1_9 extends Type<ChunkSection> {
         }
 
         // Read blocks
-        long[] blockData = new long[Type.VAR_INT.readPrimitive(buffer)];
+        long[] blockData = Type.LONG_ARRAY_PRIMITIVE.read(buffer);
         if (blockData.length > 0) {
             int expectedLength = (int) Math.ceil(ChunkSection.SIZE * bitsPerBlock / 64.0);
-            if (blockData.length != expectedLength) {
-                throw new IllegalStateException("Block data length (" + blockData.length + ") does not match expected length (" + expectedLength + ")! bitsPerBlock=" + bitsPerBlock + ", originalBitsPerBlock=" + originalBitsPerBlock);
+            if (blockData.length == expectedLength) {
+                CompactArrayUtil.iterateCompactArray(bitsPerBlock, ChunkSection.SIZE, blockData,
+                        bitsPerBlock == GLOBAL_PALETTE ? chunkSection::setFlatBlock
+                                : chunkSection::setPaletteIndex);
             }
-
-            for (int i = 0; i < blockData.length; i++) {
-                blockData[i] = buffer.readLong();
-            }
-            CompactArrayUtil.iterateCompactArray(bitsPerBlock, ChunkSection.SIZE, blockData,
-                    bitsPerBlock == GLOBAL_PALETTE ? chunkSection::setFlatBlock
-                            : chunkSection::setPaletteIndex);
         }
 
         return chunkSection;
@@ -92,10 +83,9 @@ public class ChunkSectionType1_9 extends Type<ChunkSection> {
             bitsPerBlock = GLOBAL_PALETTE;
         }
 
-        long maxEntryValue = (1L << bitsPerBlock) - 1;
         buffer.writeByte(bitsPerBlock);
 
-        // Write pallet (or not)
+        // Write palette
         if (bitsPerBlock != GLOBAL_PALETTE) {
             Type.VAR_INT.writePrimitive(buffer, chunkSection.getPaletteSize());
             for (int i = 0; i < chunkSection.getPaletteSize(); i++) {
@@ -107,9 +97,6 @@ public class ChunkSectionType1_9 extends Type<ChunkSection> {
 
         long[] data = CompactArrayUtil.createCompactArray(bitsPerBlock, ChunkSection.SIZE,
                 bitsPerBlock == GLOBAL_PALETTE ? chunkSection::getFlatBlock : chunkSection::getPaletteIndex);
-        Type.VAR_INT.writePrimitive(buffer, data.length);
-        for (long l : data) {
-            buffer.writeLong(l);
-        }
+        Type.LONG_ARRAY_PRIMITIVE.write(buffer, data);
     }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/version/PaletteType1_18.java

@@ -42,23 +42,25 @@ public final class PaletteType1_18 extends Type<DataPalette> {
 
     @Override
     public DataPalette read(final ByteBuf buffer) throws Exception {
-        int bitsPerValue = buffer.readByte();
-        final int originalBitsPerValue = bitsPerValue;
+        final int originalBitsPerValue = buffer.readByte();
+        int bitsPerValue = originalBitsPerValue;
 
-        if (bitsPerValue > type.highestBitsPerValue()) {
-            bitsPerValue = globalPaletteBits;
-        }
-
-        // Read palette
         final DataPaletteImpl palette;
         if (bitsPerValue == 0) {
-            //TODO Create proper singleton palette Object
+            // Single value storage
             palette = new DataPaletteImpl(type.size(), 1);
             palette.addId(Type.VAR_INT.readPrimitive(buffer));
-            Type.VAR_INT.readPrimitive(buffer); // 0 values length
+            Type.LONG_ARRAY_PRIMITIVE.read(buffer); // Just eat it if not empty - thanks, Hypixel
             return palette;
         }
 
+        if (bitsPerValue < 0 || bitsPerValue > type.highestBitsPerValue()) {
+            bitsPerValue = globalPaletteBits;
+        } else if (type == PaletteType.BLOCKS && bitsPerValue < 4) {
+            bitsPerValue = 4; // Linear block palette values are always 4 bits
+        }
+
+        // Read palette
         if (bitsPerValue != globalPaletteBits) {
             final int paletteLength = Type.VAR_INT.readPrimitive(buffer);
             palette = new DataPaletteImpl(type.size(), paletteLength);
@@ -70,38 +72,32 @@ public final class PaletteType1_18 extends Type<DataPalette> {
         }
 
         // Read values
-        final long[] values = new long[Type.VAR_INT.readPrimitive(buffer)];
+        final long[] values = Type.LONG_ARRAY_PRIMITIVE.read(buffer);
         if (values.length > 0) {
-            final char valuesPerLong = (char) (64 / bitsPerValue);
+            final int valuesPerLong = (char) (64 / bitsPerValue);
             final int expectedLength = (type.size() + valuesPerLong - 1) / valuesPerLong;
-            if (values.length != expectedLength) {
-                throw new IllegalStateException("Palette data length (" + values.length + ") does not match expected length (" + expectedLength + ")! bitsPerValue=" + bitsPerValue + ", originalBitsPerValue=" + originalBitsPerValue);
+            if (values.length == expectedLength) { // Thanks, Hypixel
+                CompactArrayUtil.iterateCompactArrayWithPadding(bitsPerValue, type.size(), values,
+                        bitsPerValue == globalPaletteBits ? palette::setIdAt : palette::setPaletteIndexAt);
             }
-
-            for (int i = 0; i < values.length; i++) {
-                values[i] = buffer.readLong();
-            }
-            CompactArrayUtil.iterateCompactArrayWithPadding(bitsPerValue, type.size(), values,
-                    bitsPerValue == globalPaletteBits ? palette::setIdAt : palette::setPaletteIndexAt);
         }
         return palette;
     }
 
     @Override
     public void write(final ByteBuf buffer, final DataPalette palette) throws Exception {
-        if (palette.size() == 1) {
+        final int size = palette.size();
+        if (size == 1) {
             // Single value palette
             buffer.writeByte(0); // 0 bit storage
             Type.VAR_INT.writePrimitive(buffer, palette.idByIndex(0));
             Type.VAR_INT.writePrimitive(buffer, 0); // Empty values length
             return;
-        }/* else if (palette.size() == 0) {
-            Via.getPlatform().getLogger().warning("Palette size is 0!");
-        }*/
+        }
 
         // 1, 2, and 3 bit linear block palettes can't be read by the client
         final int min = type == PaletteType.BLOCKS ? 4 : 1;
-        int bitsPerValue = Math.max(min, MathUtil.ceilLog2(palette.size()));
+        int bitsPerValue = Math.max(min, MathUtil.ceilLog2(size));
         if (bitsPerValue > type.highestBitsPerValue()) {
             bitsPerValue = globalPaletteBits;
         }
@@ -109,17 +105,13 @@ public final class PaletteType1_18 extends Type<DataPalette> {
         buffer.writeByte(bitsPerValue);
 
         if (bitsPerValue != globalPaletteBits) {
-            // Write pallete
-            Type.VAR_INT.writePrimitive(buffer, palette.size());
-            for (int i = 0; i < palette.size(); i++) {
+            // Write palette
+            Type.VAR_INT.writePrimitive(buffer, size);
+            for (int i = 0; i < size; i++) {
                 Type.VAR_INT.writePrimitive(buffer, palette.idByIndex(i));
             }
         }
 
-        final long[] data = CompactArrayUtil.createCompactArrayWithPadding(bitsPerValue, type.size(), bitsPerValue == globalPaletteBits ? palette::idAt : palette::paletteIndexAt);
-        Type.VAR_INT.writePrimitive(buffer, data.length);
-        for (final long l : data) {
-            buffer.writeLong(l);
-        }
+        Type.LONG_ARRAY_PRIMITIVE.write(buffer, CompactArrayUtil.createCompactArrayWithPadding(bitsPerValue, type.size(), bitsPerValue == globalPaletteBits ? palette::idAt : palette::paletteIndexAt));
     }
 }

api/src/main/java/com/viaversion/viaversion/api/type/types/version/Types1_19.java

@@ -20,29 +20,20 @@
  * OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
  * SOFTWARE.
  */
-package com.viaversion.viaversion.api.type.types.minecraft;
+package com.viaversion.viaversion.api.type.types.version;
 
-import com.viaversion.viaversion.api.minecraft.Position;
+import com.viaversion.viaversion.api.minecraft.metadata.Metadata;
+import com.viaversion.viaversion.api.minecraft.metadata.types.MetaTypes1_19;
 import com.viaversion.viaversion.api.type.Type;
-import io.netty.buffer.ByteBuf;
+import com.viaversion.viaversion.api.type.types.minecraft.MetaListType;
+import com.viaversion.viaversion.api.type.types.minecraft.ParticleType;
 
-public class OptPosition1_14Type extends Type<Position> {
-    public OptPosition1_14Type() {
-        super(Position.class);
-    }
+import java.util.List;
 
-    @Override
-    public Position read(ByteBuf buffer) throws Exception {
-        boolean present = buffer.readBoolean();
-        if (!present) return null;
-        return Type.POSITION1_14.read(buffer);
-    }
+public final class Types1_19 {
 
-    @Override
-    public void write(ByteBuf buffer, Position object) throws Exception {
-        buffer.writeBoolean(object != null);
-        if (object != null) {
-            Type.POSITION1_14.write(buffer, object);
-        }
-    }
+    public static final ParticleType PARTICLE = new ParticleType(); // Only safe to use after protocol loading
+    public static final MetaTypes1_19 META_TYPES = new MetaTypes1_19(PARTICLE);
+    public static final Type<Metadata> METADATA = new MetadataType(META_TYPES);
+    public static final Type<List<Metadata>> METADATA_LIST = new MetaListType(METADATA);
 }

api/src/main/java/com/viaversion/viaversion/exception/InformativeException.java

@@ -48,7 +48,7 @@ public class InformativeException extends Exception {
 
     @Override
     public String getMessage() {
-        StringBuilder builder = new StringBuilder("Please post this error to https://github.com/ViaVersion/ViaVersion/issues and follow the issue template\n{");
+        StringBuilder builder = new StringBuilder("Please report this on the Via support Discord or open an issue on the relevant GitHub repository\n");
         boolean first = true;
         for (Map.Entry<String, Object> entry : info.entrySet()) {
             if (!first) {
@@ -57,11 +57,11 @@ public class InformativeException extends Exception {
             builder.append(entry.getKey()).append(": ").append(entry.getValue());
             first = false;
         }
-        return builder.append("}\nActual Error: ").toString();
+        return builder.toString();
     }
 
     @Override
-    public synchronized Throwable fillInStackTrace() {
+    public Throwable fillInStackTrace() {
         // Don't record this stack
         return this;
     }

api/src/main/java/com/viaversion/viaversion/util/EntityTypeUtil.java

@@ -22,14 +22,18 @@
  */
 package com.viaversion.viaversion.util;
 
+import com.google.common.base.Preconditions;
 import com.viaversion.viaversion.api.Via;
 import com.viaversion.viaversion.api.minecraft.entities.EntityType;
+import com.viaversion.viaversion.api.protocol.Protocol;
 
 import java.util.ArrayList;
 import java.util.Comparator;
 import java.util.List;
 
-public class EntityTypeUtil {
+public final class EntityTypeUtil {
+
+    private static final EntityType[] EMPTY_ARRAY = new EntityType[0];
 
     /**
      * Returns an ordered array with each index representing the actual entity id.
@@ -37,16 +41,48 @@ public class EntityTypeUtil {
      * @param values entity types
      * @return ordered array with each index representing the actual entity id
      */
-    public static EntityType[] toOrderedArray(EntityType[] values) {
-        List<EntityType> types = new ArrayList<>();
-        for (EntityType type : values) {
+    public static EntityType[] toOrderedArray(final EntityType[] values) {
+        final List<EntityType> types = new ArrayList<>();
+        for (final EntityType type : values) {
             if (type.getId() != -1) {
                 types.add(type);
             }
         }
 
         types.sort(Comparator.comparingInt(EntityType::getId));
-        return types.toArray(new EntityType[0]);
+        return types.toArray(EMPTY_ARRAY);
+    }
+
+    /**
+     * Sets entity type ids based on the protocol's mapping data and fills the given typesToFill array with the index corresponding to the id.
+     *
+     * @param values      full enum values
+     * @param typesToFill yet unfilled array to be filled with types ordered by id
+     * @param protocol    protocol to get entity types from
+     * @param idSetter    function to set the internal entity id
+     * @param <T>         entity type
+     */
+    public static <T extends EntityType> void initialize(final T[] values, final EntityType[] typesToFill, final Protocol<?, ?, ?, ?> protocol, final EntityIdSetter<T> idSetter) {
+        for (final T type : values) {
+            if (type.isAbstractType()) {
+                continue;
+            }
+
+            final int id = protocol.getMappingData().getEntityMappings().mappedId(type.identifier());
+            Preconditions.checkArgument(id != -1, "Entity type %s has no id", type.identifier());
+            idSetter.setId(type, id);
+            typesToFill[id] = type;
+        }
+    }
+
+    public static EntityType[] createSizedArray(final EntityType[] values) {
+        int count = 0;
+        for (final EntityType type : values) {
+            if (!type.isAbstractType()) {
+                count++;
+            }
+        }
+        return new EntityType[count];
     }
 
     /**
@@ -57,12 +93,18 @@ public class EntityTypeUtil {
      * @param fallback fallback/base entity type
      * @return entity type from id
      */
-    public static EntityType getTypeFromId(EntityType[] values, int typeId, EntityType fallback) {
-        EntityType type;
+    public static EntityType getTypeFromId(final EntityType[] values, final int typeId, final EntityType fallback) {
+        final EntityType type;
         if (typeId < 0 || typeId >= values.length || (type = values[typeId]) == null) {
             Via.getPlatform().getLogger().severe("Could not find " + fallback.getClass().getSimpleName() + " type id " + typeId);
             return fallback;
         }
         return type;
     }
+
+    @FunctionalInterface
+    public interface EntityIdSetter<T extends EntityType> {
+
+        void setId(T entityType, int id);
+    }
 }

bukkit-legacy/src/main/java/com/viaversion/viaversion/bukkit/providers/BukkitBlockConnectionProvider.java

@@ -17,13 +17,13 @@
  */
 package com.viaversion.viaversion.bukkit.providers;
 
+import com.viaversion.viaversion.api.connection.UserConnection;
+import com.viaversion.viaversion.protocols.protocol1_13to1_12_2.blockconnections.providers.BlockConnectionProvider;
 import org.bukkit.Bukkit;
 import org.bukkit.Chunk;
 import org.bukkit.World;
 import org.bukkit.block.Block;
 import org.bukkit.entity.Player;
-import com.viaversion.viaversion.api.connection.UserConnection;
-import com.viaversion.viaversion.protocols.protocol1_13to1_12_2.blockconnections.providers.BlockConnectionProvider;
 
 import java.util.UUID;
 
@@ -48,7 +48,7 @@ public class BukkitBlockConnectionProvider extends BlockConnectionProvider {
     }
 
     public Chunk getChunk(World world, int x, int z) {
-        if (lastChunk != null && lastChunk.getX() == x && lastChunk.getZ() == z) {
+        if (lastChunk != null && lastChunk.getWorld().equals(world) && lastChunk.getX() == x && lastChunk.getZ() == z) {
             return lastChunk;
         }
         return lastChunk = world.getChunkAt(x, z);

bukkit/src/main/java/com/viaversion/viaversion/ViaVersionPlugin.java

@@ -37,7 +37,8 @@ import com.viaversion.viaversion.bukkit.platform.BukkitViaLoader;
 import com.viaversion.viaversion.bukkit.platform.BukkitViaTask;
 import com.viaversion.viaversion.bukkit.util.NMSUtil;
 import com.viaversion.viaversion.dump.PluginInfo;
-import com.viaversion.viaversion.unsupported.UnsupportedSoftwareImpl;
+import com.viaversion.viaversion.unsupported.UnsupportedPlugin;
+import com.viaversion.viaversion.unsupported.UnsupportedServerSoftware;
 import com.viaversion.viaversion.util.GsonUtil;
 import org.bukkit.Bukkit;
 import org.bukkit.ChatColor;
@@ -89,8 +90,8 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaPlatform<Player>
     @Override
     public void onLoad() {
         // Via should load before PL, so we can't check for it in the constructor
-        boolean hasProtocolLib = Bukkit.getPluginManager().getPlugin("ProtocolLib") != null;
-        ((BukkitViaInjector) Via.getManager().getInjector()).setProtocolLib(hasProtocolLib);
+        Plugin protocolLib = Bukkit.getPluginManager().getPlugin("ProtocolLib");
+        ProtocolLibEnableListener.checkCompat(protocolLib);
 
         // Spigot detector
         try {
@@ -285,15 +286,23 @@ public class ViaVersionPlugin extends JavaPlugin implements ViaPlatform<Player>
 
     @Override
     public final Collection<UnsupportedSoftware> getUnsupportedSoftwareClasses() {
-        List<UnsupportedSoftware> list = new ArrayList<>(ViaPlatform.super.getUnsupportedSoftwareClasses());
-        list.add(new UnsupportedSoftwareImpl.Builder().name("Yatopia").reason(UnsupportedSoftwareImpl.Reason.DANGEROUS_SERVER_SOFTWARE)
+        final List<UnsupportedSoftware> list = new ArrayList<>(ViaPlatform.super.getUnsupportedSoftwareClasses());
+        list.add(new UnsupportedServerSoftware.Builder().name("Yatopia").reason(UnsupportedServerSoftware.Reason.DANGEROUS_SERVER_SOFTWARE)
                 .addClassName("org.yatopiamc.yatopia.server.YatopiaConfig")
                 .addClassName("net.yatopia.api.event.PlayerAttackEntityEvent")
                 .addClassName("yatopiamc.org.yatopia.server.YatopiaConfig") // Only the best kind of software relocates its own classes to hide itself :tinfoilhat:
                 .addMethod("org.bukkit.Server", "getLastTickTime").build());
+        list.add(new UnsupportedPlugin.Builder().name("software to mess with message signing").reason(UnsupportedPlugin.Reason.SECURE_CHAT_BYPASS)
+                .addPlugin("NoEncryption").addPlugin("NoReport")
+                .addPlugin("NoChatReports").addPlugin("NoChatReport").build());
         return Collections.unmodifiableList(list);
     }
 
+    @Override
+    public boolean hasPlugin(final String name) {
+        return getServer().getPluginManager().getPlugin(name) != null;
+    }
+
     public boolean isLateBind() {
         return lateBind;
     }

bukkit/src/main/java/com/viaversion/viaversion/bukkit/handlers/BukkitEncodeHandler.java

@@ -100,4 +100,8 @@ public class BukkitEncodeHandler extends MessageToByteEncoder implements ViaCode
             cause.printStackTrace(); // Print if CB doesn't already do it
         }
     }
+
+    public UserConnection getInfo() {
+        return info;
+    }
 }

bukkit/src/main/java/com/viaversion/viaversion/bukkit/listeners/JoinListener.java

@@ -0,0 +1,116 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.viaversion.viaversion.bukkit.listeners;
+
+import com.viaversion.viaversion.api.Via;
+import com.viaversion.viaversion.api.connection.ProtocolInfo;
+import com.viaversion.viaversion.api.connection.UserConnection;
+import com.viaversion.viaversion.bukkit.handlers.BukkitEncodeHandler;
+import com.viaversion.viaversion.bukkit.util.NMSUtil;
+import io.netty.channel.Channel;
+import org.bukkit.entity.Player;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.Listener;
+import org.bukkit.event.player.PlayerJoinEvent;
+import org.jetbrains.annotations.Nullable;
+
+import java.lang.reflect.Field;
+import java.lang.reflect.Method;
+import java.util.logging.Level;
+
+public class JoinListener implements Listener {
+
+    private static final Method GET_HANDLE;
+    private static final Field CONNECTION;
+    private static final Field NETWORK_MANAGER;
+    private static final Field CHANNEL;
+
+    static {
+        Method gh = null;
+        Field conn = null, nm = null, ch = null;
+        try {
+            gh = NMSUtil.obc("entity.CraftPlayer").getDeclaredMethod("getHandle");
+            conn = findField(gh.getReturnType(), "PlayerConnection", "ServerGamePacketListenerImpl");
+            nm = findField(conn.getType(), "NetworkManager", "Connection");
+            ch = findField(nm.getType(), "Channel");
+        } catch (NoSuchMethodException | NoSuchFieldException | ClassNotFoundException e) {
+            Via.getPlatform().getLogger().log(
+                    Level.WARNING,
+                    "Couldn't find reflection methods/fields to access Channel from player.\n" +
+                            "Login race condition fixer will be disabled.\n" +
+                            " Some plugins that use ViaAPI on join event may work incorrectly.", e);
+        }
+        GET_HANDLE = gh;
+        CONNECTION = conn;
+        NETWORK_MANAGER = nm;
+        CHANNEL = ch;
+    }
+
+    // Loosely search a field with any name, as long as it matches a type name.
+    private static Field findField(Class<?> cl, String... types) throws NoSuchFieldException {
+        for (Field field : cl.getDeclaredFields()) {
+            for (String type : types)
+                if (field.getType().getSimpleName().equals(type))
+                    return field;
+        }
+        throw new NoSuchFieldException(types[0]);
+    }
+
+    @EventHandler(priority = EventPriority.LOWEST)
+    public void onJoin(PlayerJoinEvent e) {
+        if (CHANNEL == null) return;
+        Player player = e.getPlayer();
+
+        Channel channel;
+        try {
+          channel = getChannel(player);
+        } catch (Exception ex) {
+            Via.getPlatform().getLogger().log(Level.WARNING, ex,
+                    () -> "Could not find Channel for logging-in player " + player.getUniqueId());
+            return;
+        }
+        // The connection has already closed, that was a quick leave
+        if (!channel.isOpen()) return;
+
+        UserConnection user = getUserConnection(channel);
+        if (user == null) {
+            Via.getPlatform().getLogger().log(Level.WARNING,
+                    "Could not find UserConnection for logging-in player {0}",
+                    player.getUniqueId());
+            return;
+        }
+        ProtocolInfo info = user.getProtocolInfo();
+        info.setUuid(player.getUniqueId());
+        info.setUsername(player.getName());
+        Via.getManager().getConnectionManager().onLoginSuccess(user);
+    }
+
+    private @Nullable UserConnection getUserConnection(Channel channel) {
+        BukkitEncodeHandler encoder = channel.pipeline().get(BukkitEncodeHandler.class);
+        return encoder != null ? encoder.getInfo() : null;
+    }
+
+    private Channel getChannel(Player player) throws Exception {
+        Object entityPlayer = GET_HANDLE.invoke(player);
+        Object pc = CONNECTION.get(entityPlayer);
+        Object nm = NETWORK_MANAGER.get(pc);
+        return (Channel) CHANNEL.get(nm);
+    }
+
+}

bukkit/src/main/java/com/viaversion/viaversion/bukkit/listeners/ProtocolLibEnableListener.java

@@ -23,6 +23,8 @@ import org.bukkit.event.EventHandler;
 import org.bukkit.event.Listener;
 import org.bukkit.event.server.PluginDisableEvent;
 import org.bukkit.event.server.PluginEnableEvent;
+import org.bukkit.plugin.Plugin;
+import org.jetbrains.annotations.Nullable;
 
 public class ProtocolLibEnableListener implements Listener {
 
@@ -30,7 +32,7 @@ public class ProtocolLibEnableListener implements Listener {
     public void onPluginEnable(PluginEnableEvent e) {
         // Will likely never happen, but try to account for hacky plugin loading systems anyways
         if (e.getPlugin().getName().equals("ProtocolLib")) {
-            ((BukkitViaInjector) Via.getManager().getInjector()).setProtocolLib(true);
+            checkCompat(e.getPlugin());
         }
     }
 
@@ -40,4 +42,21 @@ public class ProtocolLibEnableListener implements Listener {
             ((BukkitViaInjector) Via.getManager().getInjector()).setProtocolLib(false);
         }
     }
+
+    public static void checkCompat(@Nullable Plugin protocolLib) {
+        if (protocolLib != null) {
+            String version = protocolLib.getDescription().getVersion();
+            String majorVersion = version.split("\\.", 2)[0];
+            try {
+                // Only need the compat check for version < 5
+                if (Integer.parseInt(majorVersion) < 5) {
+                    ((BukkitViaInjector) Via.getManager().getInjector()).setProtocolLib(true);
+                    return;
+                }
+            } catch (NumberFormatException ignored) {
+                Via.getPlatform().getLogger().warning("ProtocolLib version check failed for version " + version);
+            }
+        }
+        ((BukkitViaInjector) Via.getManager().getInjector()).setProtocolLib(false);
+    }
 }

bukkit/src/main/java/com/viaversion/viaversion/bukkit/listeners/protocol1_19to1_18_2/BlockBreakListener.java

@@ -0,0 +1,70 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.viaversion.viaversion.bukkit.listeners.protocol1_19to1_18_2;
+
+import com.viaversion.viaversion.ViaVersionPlugin;
+import com.viaversion.viaversion.api.Via;
+import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
+import com.viaversion.viaversion.bukkit.listeners.ViaBukkitListener;
+import com.viaversion.viaversion.bukkit.util.NMSUtil;
+import com.viaversion.viaversion.protocols.protocol1_19to1_18_2.Protocol1_19To1_18_2;
+import org.bukkit.block.Block;
+import org.bukkit.block.BlockState;
+import org.bukkit.event.EventHandler;
+import org.bukkit.event.EventPriority;
+import org.bukkit.event.block.BlockBreakEvent;
+
+public final class BlockBreakListener extends ViaBukkitListener {
+
+    private static final Class<?> CRAFT_BLOCK_STATE_CLASS;
+
+    static {
+        try {
+            CRAFT_BLOCK_STATE_CLASS = NMSUtil.obc("block.CraftBlockState");
+        } catch (final ClassNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    public BlockBreakListener(ViaVersionPlugin plugin) {
+        super(plugin, Protocol1_19To1_18_2.class);
+    }
+
+    @EventHandler(priority = EventPriority.MONITOR)
+    public void blockBreak(BlockBreakEvent event) {
+        final Block block = event.getBlock();
+        if (!event.isCancelled() || !isBlockEntity(block.getState())) {
+            return;
+        }
+
+        // We need to resend the block entity data after an ack has been sent out
+        final int serverProtocolVersion = Via.getAPI().getServerVersion().highestSupportedVersion();
+        final long delay = serverProtocolVersion > ProtocolVersion.v1_8.getVersion() && serverProtocolVersion < ProtocolVersion.v1_14.getVersion() ? 2 : 1;
+        getPlugin().getServer().getScheduler().runTaskLater(getPlugin(), () -> {
+            final BlockState state = block.getState();
+            if (isBlockEntity(state)) {
+                state.update(true, false);
+            }
+        }, delay);
+    }
+
+    private boolean isBlockEntity(final BlockState state) {
+        // We love legacy versions
+        return state.getClass() != CRAFT_BLOCK_STATE_CLASS;
+    }
+}

bukkit/src/main/java/com/viaversion/viaversion/bukkit/platform/BukkitViaLoader.java

@@ -24,20 +24,24 @@ import com.viaversion.viaversion.api.minecraft.item.Item;
 import com.viaversion.viaversion.api.platform.ViaPlatformLoader;
 import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
 import com.viaversion.viaversion.bukkit.classgenerator.ClassGenerator;
+import com.viaversion.viaversion.bukkit.listeners.JoinListener;
 import com.viaversion.viaversion.bukkit.listeners.UpdateListener;
 import com.viaversion.viaversion.bukkit.listeners.multiversion.PlayerSneakListener;
 import com.viaversion.viaversion.bukkit.listeners.protocol1_15to1_14_4.EntityToggleGlideListener;
+import com.viaversion.viaversion.bukkit.listeners.protocol1_19to1_18_2.BlockBreakListener;
 import com.viaversion.viaversion.bukkit.listeners.protocol1_9to1_8.ArmorListener;
 import com.viaversion.viaversion.bukkit.listeners.protocol1_9to1_8.BlockListener;
 import com.viaversion.viaversion.bukkit.listeners.protocol1_9to1_8.DeathListener;
 import com.viaversion.viaversion.bukkit.listeners.protocol1_9to1_8.HandItemCache;
 import com.viaversion.viaversion.bukkit.listeners.protocol1_9to1_8.PaperPatch;
+import com.viaversion.viaversion.bukkit.providers.BukkitAckSequenceProvider;
 import com.viaversion.viaversion.bukkit.providers.BukkitBlockConnectionProvider;
 import com.viaversion.viaversion.bukkit.providers.BukkitInventoryQuickMoveProvider;
 import com.viaversion.viaversion.bukkit.providers.BukkitViaMovementTransmitter;
 import com.viaversion.viaversion.protocols.protocol1_12to1_11_1.providers.InventoryQuickMoveProvider;
 import com.viaversion.viaversion.protocols.protocol1_13to1_12_2.blockconnections.ConnectionData;
 import com.viaversion.viaversion.protocols.protocol1_13to1_12_2.blockconnections.providers.BlockConnectionProvider;
+import com.viaversion.viaversion.protocols.protocol1_19to1_18_2.provider.AckSequenceProvider;
 import com.viaversion.viaversion.protocols.protocol1_9to1_8.providers.HandItemProvider;
 import com.viaversion.viaversion.protocols.protocol1_9to1_8.providers.MovementTransmitterProvider;
 import org.bukkit.Bukkit;
@@ -47,7 +51,6 @@ import org.bukkit.event.Listener;
 import org.bukkit.scheduler.BukkitTask;
 
 import java.util.HashSet;
-import java.util.Locale;
 import java.util.Set;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
@@ -78,6 +81,9 @@ public class BukkitViaLoader implements ViaPlatformLoader {
         // Update Listener
         registerListener(new UpdateListener());
 
+        // Login listener
+        registerListener(new JoinListener());
+
         /* Base Protocol */
         final ViaVersionPlugin plugin = (ViaVersionPlugin) Bukkit.getPluginManager().getPlugin("ViaVersion");
 
@@ -174,6 +180,10 @@ public class BukkitViaLoader implements ViaPlatformLoader {
                 ConnectionData.blockConnectionProvider = blockConnectionProvider;
             }
         }
+        if (serverProtocolVersion < ProtocolVersion.v1_19.getVersion()) {
+            Via.getManager().getProviders().use(AckSequenceProvider.class, new BukkitAckSequenceProvider(plugin));
+            storeListener(new BlockBreakListener(plugin)).register();
+        }
     }
 
     @Override

bukkit/src/main/java/com/viaversion/viaversion/bukkit/providers/BukkitAckSequenceProvider.java

@@ -0,0 +1,45 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.viaversion.viaversion.bukkit.providers;
+
+import com.viaversion.viaversion.ViaVersionPlugin;
+import com.viaversion.viaversion.api.connection.UserConnection;
+import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
+import com.viaversion.viaversion.bukkit.tasks.protocol1_19to1_18_2.AckSequenceTask;
+import com.viaversion.viaversion.protocols.protocol1_19to1_18_2.provider.AckSequenceProvider;
+import com.viaversion.viaversion.protocols.protocol1_19to1_18_2.storage.SequenceStorage;
+
+public final class BukkitAckSequenceProvider extends AckSequenceProvider {
+
+    private final ViaVersionPlugin plugin;
+
+    public BukkitAckSequenceProvider(final ViaVersionPlugin plugin) {
+        this.plugin = plugin;
+    }
+
+    @Override
+    public void handleSequence(final UserConnection connection, final int sequence) {
+        final SequenceStorage sequenceStorage = connection.get(SequenceStorage.class);
+        final int previousSequence = sequenceStorage.setSequenceId(sequence);
+        if (previousSequence == -1) {
+            final int serverProtocolVersion = connection.getProtocolInfo().getServerProtocolVersion();
+            final long delay = serverProtocolVersion > ProtocolVersion.v1_8.getVersion() && serverProtocolVersion < ProtocolVersion.v1_14.getVersion() ? 2 : 1;
+            plugin.getServer().getScheduler().scheduleSyncDelayedTask(plugin, new AckSequenceTask(connection, sequenceStorage), delay);
+        }
+    }
+}

bukkit/src/main/java/com/viaversion/viaversion/bukkit/providers/BukkitViaMovementTransmitter.java

@@ -84,14 +84,14 @@ public class BukkitViaMovementTransmitter extends MovementTransmitterProvider {
     public Object getFlyingPacket() {
         if (idlePacket == null)
             throw new NullPointerException("Could not locate flying packet");
-        return idlePacket2;
+        return idlePacket;
     }
 
     @Override
     public Object getGroundPacket() {
         if (idlePacket == null)
             throw new NullPointerException("Could not locate flying packet");
-        return idlePacket;
+        return idlePacket2;
     }
 
     @Override

bukkit/src/main/java/com/viaversion/viaversion/bukkit/tasks/protocol1_19to1_18_2/AckSequenceTask.java

@@ -0,0 +1,48 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.viaversion.viaversion.bukkit.tasks.protocol1_19to1_18_2;
+
+import com.viaversion.viaversion.api.connection.UserConnection;
+import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
+import com.viaversion.viaversion.api.type.Type;
+import com.viaversion.viaversion.protocols.protocol1_19to1_18_2.ClientboundPackets1_19;
+import com.viaversion.viaversion.protocols.protocol1_19to1_18_2.Protocol1_19To1_18_2;
+import com.viaversion.viaversion.protocols.protocol1_19to1_18_2.storage.SequenceStorage;
+
+public final class AckSequenceTask implements Runnable {
+
+    private final UserConnection connection;
+    private final SequenceStorage sequenceStorage;
+
+    public AckSequenceTask(final UserConnection connection, final SequenceStorage sequenceStorage) {
+        this.connection = connection;
+        this.sequenceStorage = sequenceStorage;
+    }
+
+    @Override
+    public void run() {
+        final int sequence = sequenceStorage.setSequenceId(-1);
+        try {
+            final PacketWrapper ackPacket = PacketWrapper.create(ClientboundPackets1_19.BLOCK_CHANGED_ACK, connection);
+            ackPacket.write(Type.VAR_INT, sequence);
+            ackPacket.scheduleSend(Protocol1_19To1_18_2.class);
+        } catch (final Exception e) {
+            e.printStackTrace();
+        }
+    }
+}

bukkit/src/main/resources/plugin.yml

@@ -8,5 +8,6 @@ loadbefore: [ProtocolLib, ProxyPipe, SpigotLib, SkinRestorer]
 softdepend: [ProtocolSupport, PacketListenerApi]
 commands:
   viaversion:
+    permission: viaversion.admin # The permission is also referenced here to filter root suggestions (/via<tab>)
     description: Shows ViaVersion Version and more.
     aliases: [viaver, vvbukkit]

bungee/src/main/java/com/viaversion/viaversion/BungeePlugin.java

@@ -17,6 +17,7 @@
  */
 package com.viaversion.viaversion;
 
+import com.google.common.collect.ImmutableList;
 import com.google.gson.JsonObject;
 import com.viaversion.viaversion.api.Via;
 import com.viaversion.viaversion.api.ViaAPI;
@@ -24,17 +25,19 @@ import com.viaversion.viaversion.api.command.ViaCommandSender;
 import com.viaversion.viaversion.api.configuration.ConfigurationProvider;
 import com.viaversion.viaversion.api.data.MappingDataLoader;
 import com.viaversion.viaversion.api.platform.PlatformTask;
-import com.viaversion.viaversion.api.platform.ViaPlatform;
+import com.viaversion.viaversion.api.platform.UnsupportedSoftware;
+import com.viaversion.viaversion.api.platform.ViaServerProxyPlatform;
 import com.viaversion.viaversion.bungee.commands.BungeeCommand;
 import com.viaversion.viaversion.bungee.commands.BungeeCommandHandler;
 import com.viaversion.viaversion.bungee.commands.BungeeCommandSender;
-import com.viaversion.viaversion.bungee.platform.BungeeViaTask;
 import com.viaversion.viaversion.bungee.platform.BungeeViaAPI;
 import com.viaversion.viaversion.bungee.platform.BungeeViaConfig;
 import com.viaversion.viaversion.bungee.platform.BungeeViaInjector;
 import com.viaversion.viaversion.bungee.platform.BungeeViaLoader;
+import com.viaversion.viaversion.bungee.platform.BungeeViaTask;
 import com.viaversion.viaversion.bungee.service.ProtocolDetectorService;
 import com.viaversion.viaversion.dump.PluginInfo;
+import com.viaversion.viaversion.unsupported.UnsupportedServerSoftware;
 import com.viaversion.viaversion.util.GsonUtil;
 import net.md_5.bungee.api.ProxyServer;
 import net.md_5.bungee.api.connection.ProxiedPlayer;
@@ -49,14 +52,15 @@ import java.util.List;
 import java.util.UUID;
 import java.util.concurrent.TimeUnit;
 
-public class BungeePlugin extends Plugin implements ViaPlatform<ProxiedPlayer>, Listener {
+public class BungeePlugin extends Plugin implements ViaServerProxyPlatform<ProxiedPlayer>, Listener {
+    private final ProtocolDetectorService protocolDetectorService = new ProtocolDetectorService();
     private BungeeViaAPI api;
     private BungeeViaConfig config;
 
     @Override
     public void onLoad() {
         try {
-            ProtocolConstants.class.getField("MINECRAFT_1_18");
+            ProtocolConstants.class.getField("MINECRAFT_1_19_1");
         } catch (NoSuchFieldException e) {
             getLogger().warning("      / \\");
             getLogger().warning("     /   \\");
@@ -197,7 +201,7 @@ public class BungeePlugin extends Plugin implements ViaPlatform<ProxiedPlayer>,
             ));
 
         platformSpecific.add("plugins", GsonUtil.getGson().toJsonTree(plugins));
-        platformSpecific.add("servers", GsonUtil.getGson().toJsonTree(ProtocolDetectorService.getDetectedIds()));
+        platformSpecific.add("servers", GsonUtil.getGson().toJsonTree(protocolDetectorService.detectedProtocolVersions()));
         return platformSpecific;
     }
 
@@ -205,4 +209,25 @@ public class BungeePlugin extends Plugin implements ViaPlatform<ProxiedPlayer>,
     public boolean isOldClientsAllowed() {
         return true;
     }
+
+    @Override
+    public Collection<UnsupportedSoftware> getUnsupportedSoftwareClasses() {
+        final Collection<UnsupportedSoftware> list = new ArrayList<>(ViaServerProxyPlatform.super.getUnsupportedSoftwareClasses());
+        list.add(new UnsupportedServerSoftware.Builder()
+                .name("FlameCord")
+                .addClassName("dev._2lstudios.flamecord.FlameCord")
+                .reason(UnsupportedServerSoftware.Reason.BREAKING_PROXY_SOFTWARE)
+                .build());
+        return ImmutableList.copyOf(list);
+    }
+
+    @Override
+    public boolean hasPlugin(final String name) {
+        return getProxy().getPluginManager().getPlugin(name) != null;
+    }
+
+    @Override
+    public ProtocolDetectorService protocolDetectorService() {
+        return protocolDetectorService;
+    }
 }

bungee/src/main/java/com/viaversion/viaversion/bungee/commands/BungeeCommand.java

@@ -25,7 +25,7 @@ public class BungeeCommand extends Command implements TabExecutor {
     private final BungeeCommandHandler handler;
 
     public BungeeCommand(BungeeCommandHandler handler) {
-        super("viaversion", "", "viaver", "vvbungee"); // The CommandHandler will handle the permission
+        super("viaversion", "viaversion.admin", "viaver", "vvbungee"); // The permission is also referenced here to filter root suggestions (/via<tab>)
         this.handler = handler;
     }
 

bungee/src/main/java/com/viaversion/viaversion/bungee/commands/subs/ProbeSubCmd.java

@@ -21,7 +21,6 @@ import com.viaversion.viaversion.api.Via;
 import com.viaversion.viaversion.api.command.ViaCommandSender;
 import com.viaversion.viaversion.api.command.ViaSubCommand;
 import com.viaversion.viaversion.bungee.platform.BungeeViaConfig;
-import com.viaversion.viaversion.bungee.service.ProtocolDetectorService;
 
 public class ProbeSubCmd extends ViaSubCommand {
     @Override
@@ -38,7 +37,7 @@ public class ProbeSubCmd extends ViaSubCommand {
 
     @Override
     public boolean execute(ViaCommandSender sender, String[] args) {
-        ProtocolDetectorService.getInstance().run();
+        Via.proxyPlatform().protocolDetectorService().probeAllServers();
         sendMessage(sender, "&6Started searching for protocol versions");
         return true;
     }

bungee/src/main/java/com/viaversion/viaversion/bungee/handlers/BungeeServerHandler.java

@@ -29,7 +29,6 @@ import com.viaversion.viaversion.api.protocol.ProtocolPipeline;
 import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
 import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
 import com.viaversion.viaversion.api.type.Type;
-import com.viaversion.viaversion.bungee.service.ProtocolDetectorService;
 import com.viaversion.viaversion.bungee.storage.BungeeStorage;
 import com.viaversion.viaversion.protocols.protocol1_13to1_12_2.packets.InventoryPackets;
 import com.viaversion.viaversion.protocols.protocol1_9to1_8.ClientboundPackets1_9;
@@ -48,9 +47,12 @@ import net.md_5.bungee.protocol.packet.PluginMessage;
 import java.lang.reflect.Field;
 import java.lang.reflect.InvocationTargetException;
 import java.lang.reflect.Method;
-import java.nio.charset.StandardCharsets;
-import java.util.*;
-import java.util.stream.Collectors;
+import java.util.ArrayList;
+import java.util.Collection;
+import java.util.HashSet;
+import java.util.Iterator;
+import java.util.List;
+import java.util.UUID;
 
 public class BungeeServerHandler implements Listener {
     private static Method getHandshake;
@@ -93,7 +95,7 @@ public class BungeeServerHandler implements Listener {
             user.put(new BungeeStorage(e.getPlayer()));
         }
 
-        int protocolId = ProtocolDetectorService.getProtocolId(e.getTarget().getName());
+        int protocolId = Via.proxyPlatform().protocolDetectorService().serverProtocolVersion(e.getTarget().getName());
         List<ProtocolPathEntry> protocols = Via.getManager().getProtocolManager().getProtocolPath(user.getProtocolInfo().getProtocolVersion(), protocolId);
 
         // Check if ViaVersion can support that version
@@ -161,7 +163,7 @@ public class BungeeServerHandler implements Listener {
 
                     storage.setCurrentServer(serverName);
 
-                    int protocolId = ProtocolDetectorService.getProtocolId(serverName);
+                    int protocolId = Via.proxyPlatform().protocolDetectorService().serverProtocolVersion(serverName);
 
                     if (protocolId <= ProtocolVersion.v1_8.getVersion()) { // 1.8 doesn't have BossBar packet
                         if (storage.getBossbar() != null) {
@@ -184,7 +186,7 @@ public class BungeeServerHandler implements Listener {
                     // Refresh the pipes
                     List<ProtocolPathEntry> protocolPath = Via.getManager().getProtocolManager().getProtocolPath(info.getProtocolVersion(), protocolId);
                     ProtocolPipeline pipeline = user.getProtocolInfo().getPipeline();
-                    user.clearStoredObjects();
+                    user.clearStoredObjects(true);
                     pipeline.cleanPipes();
                     if (protocolPath == null) {
                         // TODO Check Bungee Supported Protocols? *shrugs*

bungee/src/main/java/com/viaversion/viaversion/bungee/platform/BungeeViaAPI.java

@@ -18,6 +18,7 @@
 package com.viaversion.viaversion.bungee.platform;
 
 import com.viaversion.viaversion.ViaAPIBase;
+import com.viaversion.viaversion.api.Via;
 import com.viaversion.viaversion.bungee.service.ProtocolDetectorService;
 import io.netty.buffer.ByteBuf;
 import net.md_5.bungee.api.config.ServerInfo;
@@ -41,6 +42,6 @@ public class BungeeViaAPI extends ViaAPIBase<ProxiedPlayer> {
      * @param serverInfo The serverinfo to probe
      */
     public void probeServer(ServerInfo serverInfo) {
-        ProtocolDetectorService.probeServer(serverInfo);
+        ((ProtocolDetectorService) Via.proxyPlatform().protocolDetectorService()).probeServer(serverInfo);
     }
 }

bungee/src/main/java/com/viaversion/viaversion/bungee/platform/BungeeViaLoader.java

@@ -30,7 +30,6 @@ import com.viaversion.viaversion.bungee.providers.BungeeEntityIdProvider;
 import com.viaversion.viaversion.bungee.providers.BungeeMainHandProvider;
 import com.viaversion.viaversion.bungee.providers.BungeeMovementTransmitter;
 import com.viaversion.viaversion.bungee.providers.BungeeVersionProvider;
-import com.viaversion.viaversion.bungee.service.ProtocolDetectorService;
 import com.viaversion.viaversion.protocols.protocol1_9to1_8.providers.BossBarProvider;
 import com.viaversion.viaversion.protocols.protocol1_9to1_8.providers.EntityIdProvider;
 import com.viaversion.viaversion.protocols.protocol1_9to1_8.providers.MainHandProvider;
@@ -44,10 +43,9 @@ import java.util.Set;
 import java.util.concurrent.TimeUnit;
 
 public class BungeeViaLoader implements ViaPlatformLoader {
-    private final BungeePlugin plugin;
-
     private final Set<Listener> listeners = new HashSet<>();
     private final Set<ScheduledTask> tasks = new HashSet<>();
+    private final BungeePlugin plugin;
 
     public BungeeViaLoader(BungeePlugin plugin) {
         this.plugin = plugin;
@@ -82,7 +80,7 @@ public class BungeeViaLoader implements ViaPlatformLoader {
         if (plugin.getConf().getBungeePingInterval() > 0) {
             tasks.add(plugin.getProxy().getScheduler().schedule(
                     plugin,
-                    new ProtocolDetectorService(plugin),
+                    () -> Via.proxyPlatform().protocolDetectorService().probeAllServers(),
                     0, plugin.getConf().getBungeePingInterval(),
                     TimeUnit.SECONDS
             ));

bungee/src/main/java/com/viaversion/viaversion/bungee/service/ProtocolDetectorService.java

@@ -17,93 +17,77 @@
  */
 package com.viaversion.viaversion.bungee.service;
 
-import com.viaversion.viaversion.BungeePlugin;
 import com.viaversion.viaversion.api.Via;
 import com.viaversion.viaversion.bungee.platform.BungeeViaConfig;
 import com.viaversion.viaversion.bungee.providers.BungeeVersionProvider;
-import net.md_5.bungee.api.Callback;
-import net.md_5.bungee.api.ServerPing;
+import com.viaversion.viaversion.platform.AbstractProtocolDetectorService;
+import net.md_5.bungee.api.ProxyServer;
 import net.md_5.bungee.api.config.ServerInfo;
 
-import java.util.HashMap;
+import java.util.Collection;
+import java.util.HashSet;
 import java.util.Map;
-import java.util.concurrent.ConcurrentHashMap;
+import java.util.Set;
 
-public class ProtocolDetectorService implements Runnable {
-    private static final Map<String, Integer> detectedProtocolIds = new ConcurrentHashMap<>();
-    private static ProtocolDetectorService instance;
-    private final BungeePlugin plugin;
+public final class ProtocolDetectorService extends AbstractProtocolDetectorService {
 
-    public ProtocolDetectorService(BungeePlugin plugin) {
-        this.plugin = plugin;
-        instance = this;
-    }
+    public void probeServer(final ServerInfo serverInfo) {
+        final String serverName = serverInfo.getName();
+        serverInfo.ping((serverPing, throwable) -> {
+            // Ensure protocol is positive, some services will return -1
+            if (throwable != null || serverPing == null || serverPing.getVersion() == null || serverPing.getVersion().getProtocol() <= 0) {
+                return;
+            }
 
-    public static Integer getProtocolId(String serverName) {
-        // Step 1. Check Config
-        Map<String, Integer> servers = ((BungeeViaConfig) Via.getConfig()).getBungeeServerProtocols();
-        Integer protocol = servers.get(serverName);
-        if (protocol != null) {
-            return protocol;
-        }
-        // Step 2. Check Detected
-        Integer detectedProtocol = detectedProtocolIds.get(serverName);
-        if (detectedProtocol != null) {
-            return detectedProtocol;
-        }
-        // Step 3. Use Default
-        Integer defaultProtocol = servers.get("default");
-        if (defaultProtocol != null) {
-            return defaultProtocol;
-        }
-        // Step 4: Use bungee lowest supported... *cries*
-        return BungeeVersionProvider.getLowestSupportedVersion();
-    }
+            final int oldProtocolVersion = serverProtocolVersion(serverName);
+            if (oldProtocolVersion == serverPing.getVersion().getProtocol()) {
+                // Same value as previously
+                return;
+            }
 
-    @Override
-    public void run() {
-        for (final Map.Entry<String, ServerInfo> lists : plugin.getProxy().getServers().entrySet()) {
-            probeServer(lists.getValue());
-        }
-    }
+            setProtocolVersion(serverName, serverPing.getVersion().getProtocol());
 
-    public static void probeServer(final ServerInfo serverInfo) {
-        final String key = serverInfo.getName();
-        serverInfo.ping(new Callback<ServerPing>() {
-            @Override
-            public void done(ServerPing serverPing, Throwable throwable) {
-                if (throwable == null && serverPing != null && serverPing.getVersion() != null) {
-                    // Ensure protocol is positive, some services will return -1
-                    if (serverPing.getVersion().getProtocol() > 0) {
-                        detectedProtocolIds.put(key, serverPing.getVersion().getProtocol());
-                        if (((BungeeViaConfig) Via.getConfig()).isBungeePingSave()) {
-                            Map<String, Integer> servers = ((BungeeViaConfig) Via.getConfig()).getBungeeServerProtocols();
-                            Integer protocol = servers.get(key);
-                            if (protocol != null && protocol == serverPing.getVersion().getProtocol()) {
-                                return;
-                            }
-                            // Ensure we're the only ones writing to the config
-                            synchronized (Via.getPlatform().getConfigurationProvider()) {
-                                servers.put(key, serverPing.getVersion().getProtocol());
-                            }
-                            // Save
-                            Via.getPlatform().getConfigurationProvider().saveConfig();
-                        }
-                    }
+            if (((BungeeViaConfig) Via.getConfig()).isBungeePingSave()) {
+                final Map<String, Integer> servers = ((BungeeViaConfig) Via.getConfig()).getBungeeServerProtocols();
+                final Integer protocol = servers.get(serverName);
+                if (protocol != null && protocol == serverPing.getVersion().getProtocol()) {
+                    return;
                 }
+
+                // Ensure we're the only ones writing to the config
+                synchronized (Via.getPlatform().getConfigurationProvider()) {
+                    servers.put(serverName, serverPing.getVersion().getProtocol());
+                }
+                Via.getPlatform().getConfigurationProvider().saveConfig();
             }
         });
     }
 
-    public static Map<String, Integer> getDetectedIds() {
-        return new HashMap<>(detectedProtocolIds);
+    @Override
+    public void probeAllServers() {
+        final Collection<ServerInfo> servers = ProxyServer.getInstance().getServers().values();
+        final Set<String> serverNames = new HashSet<>(servers.size());
+        for (final ServerInfo serverInfo : servers) {
+            probeServer(serverInfo);
+            serverNames.add(serverInfo.getName());
+        }
+
+        // Remove servers that aren't registered anymore
+        lock.writeLock().lock();
+        try {
+            detectedProtocolIds.keySet().retainAll(serverNames);
+        } finally {
+            lock.writeLock().unlock();
+        }
     }
 
-    public static ProtocolDetectorService getInstance() {
-        return instance;
+    @Override
+    protected Map<String, Integer> configuredServers() {
+        return ((BungeeViaConfig) Via.getConfig()).getBungeeServerProtocols();
     }
 
-    public BungeePlugin getPlugin() {
-        return plugin;
+    @Override
+    protected int lowestSupportedProtocolVersion() {
+        return BungeeVersionProvider.getLowestSupportedVersion();
     }
 }

common/src/main/java/com/viaversion/viaversion/ViaManagerImpl.java

@@ -157,7 +157,7 @@ public class ViaManagerImpl implements ViaManager {
         loader.load();
         // Common tasks
         mappingLoadingTask = Via.getPlatform().runRepeatingSync(() -> {
-            if (protocolManager.checkForMappingCompletion()) {
+            if (protocolManager.checkForMappingCompletion() && mappingLoadingTask != null) {
                 mappingLoadingTask.cancel();
                 mappingLoadingTask = null;
             }
@@ -235,9 +235,9 @@ public class ViaManagerImpl implements ViaManager {
         }
     }
 
-    private final void unsupportedSoftwareWarning() {
+    private void unsupportedSoftwareWarning() {
         boolean found = false;
-        for (UnsupportedSoftware software : platform.getUnsupportedSoftwareClasses()) {
+        for (final UnsupportedSoftware software : platform.getUnsupportedSoftwareClasses()) {
             if (!software.findMatch()) {
                 continue;
             }

common/src/main/java/com/viaversion/viaversion/configuration/AbstractViaConfig.java

@@ -31,6 +31,7 @@ import org.checkerframework.checker.nullness.qual.Nullable;
 
 import java.io.File;
 import java.util.HashMap;
+import java.util.List;
 import java.util.Map;
 import java.util.function.IntPredicate;
 
@@ -89,6 +90,7 @@ public abstract class AbstractViaConfig extends Config implements ViaVersionConf
     private JsonElement resourcePack1_17PromptMessage;
     private WorldIdentifiers map1_16WorldNames;
     private boolean cache1_17Light;
+    private Map<String, String> chatTypeFormats;
 
     protected AbstractViaConfig(File configFile) {
         super(configFile);
@@ -157,13 +159,16 @@ public abstract class AbstractViaConfig extends Config implements ViaVersionConf
                 worlds.getOrDefault("nether", WorldIdentifiers.NETHER_DEFAULT),
                 worlds.getOrDefault("end", WorldIdentifiers.END_DEFAULT));
         cache1_17Light = getBoolean("cache-1_17-light", true);
+        chatTypeFormats = get("chat-types-1_19", Map.class, new HashMap<String, String>());
     }
 
     private BlockedProtocolVersions loadBlockedProtocolVersions() {
-        IntSet blockedProtocols = new IntOpenHashSet(getIntegerList("block-protocols"));
+        List<Integer> blockProtocols = getListSafe("block-protocols", Integer.class, "Invalid blocked version protocol found in config: '%s'");
+        List<String> blockVersions = getListSafe("block-versions", String.class, "Invalid blocked version found in config: '%s'");
+        IntSet blockedProtocols = new IntOpenHashSet(blockProtocols);
         int lowerBound = -1;
         int upperBound = -1;
-        for (String s : getStringList("block-versions")) {
+        for (String s : blockVersions) {
             if (s.isEmpty()) {
                 continue;
             }
@@ -523,4 +528,9 @@ public abstract class AbstractViaConfig extends Config implements ViaVersionConf
     public boolean cache1_17Light() {
         return cache1_17Light;
     }
+
+    @Override
+    public @Nullable String chatTypeFormat(final String translationKey) {
+        return chatTypeFormats.get(translationKey);
+    }
 }

common/src/main/java/com/viaversion/viaversion/connection/ConnectionManagerImpl.java

@@ -20,6 +20,7 @@ package com.viaversion.viaversion.connection;
 import com.viaversion.viaversion.api.Via;
 import com.viaversion.viaversion.api.connection.ConnectionManager;
 import com.viaversion.viaversion.api.connection.UserConnection;
+import io.netty.channel.Channel;
 import io.netty.channel.ChannelFutureListener;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -37,17 +38,29 @@ public class ConnectionManagerImpl implements ConnectionManager {
     @Override
     public void onLoginSuccess(UserConnection connection) {
         Objects.requireNonNull(connection, "connection is null!");
-        connections.add(connection);
+        Channel channel = connection.getChannel();
+
+        // This user has already disconnected...
+        if (channel != null && !channel.isOpen()) return;
+
+        boolean newlyAdded = connections.add(connection);
 
         if (isFrontEnd(connection)) {
             UUID id = connection.getProtocolInfo().getUuid();
-            if (clients.put(id, connection) != null) {
+            UserConnection previous = clients.put(id, connection);
+            if (previous != null && previous != connection) {
                 Via.getPlatform().getLogger().warning("Duplicate UUID on frontend connection! (" + id + ")");
             }
         }
 
-        if (connection.getChannel() != null) {
-            connection.getChannel().closeFuture().addListener((ChannelFutureListener) future -> onDisconnect(connection));
+        if (channel != null) {
+            // We managed to add a user that had already disconnected!
+            // Let's clean up the mess here and now
+            if (!channel.isOpen()) {
+                onDisconnect(connection);
+            } else if (newlyAdded) { // Setup to clean-up on disconnect
+                channel.closeFuture().addListener((ChannelFutureListener) future -> onDisconnect(connection));
+            }
         }
     }
 

common/src/main/java/com/viaversion/viaversion/connection/UserConnectionImpl.java

@@ -93,6 +93,11 @@ public class UserConnectionImpl implements UserConnection {
         return storedObjects.containsKey(objectClass);
     }
 
+    @Override
+    public <T extends StorableObject> @Nullable T remove(Class<T> objectClass) {
+        return (T) storedObjects.remove(objectClass);
+    }
+
     @Override
     public void put(StorableObject object) {
         storedObjects.put(object.getClass(), object);
@@ -110,13 +115,23 @@ public class UserConnectionImpl implements UserConnection {
 
     @Override
     public void addEntityTracker(Class<? extends Protocol> protocolClass, EntityTracker tracker) {
-        entityTrackers.put(protocolClass, tracker);
+        if (!entityTrackers.containsKey(protocolClass)) {
+            entityTrackers.put(protocolClass, tracker);
+        }
     }
 
     @Override
-    public void clearStoredObjects() {
-        storedObjects.clear();
-        entityTrackers.clear();
+    public void clearStoredObjects(boolean isServerSwitch) {
+        if (isServerSwitch) {
+            storedObjects.values().removeIf(StorableObject::clearOnServerSwitch);
+            for (EntityTracker tracker : entityTrackers.values()) {
+                tracker.clearEntities();
+                tracker.trackClientEntity();
+            }
+        } else {
+            storedObjects.clear();
+            entityTrackers.clear();
+        }
     }
 
     @Override

common/src/main/java/com/viaversion/viaversion/data/entity/DimensionDataImpl.java

@@ -0,0 +1,69 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.viaversion.viaversion.data.entity;
+
+import com.github.steveice10.opennbt.tag.builtin.CompoundTag;
+import com.github.steveice10.opennbt.tag.builtin.IntTag;
+import com.github.steveice10.opennbt.tag.builtin.NumberTag;
+import com.github.steveice10.opennbt.tag.builtin.Tag;
+import com.viaversion.viaversion.api.data.entity.DimensionData;
+
+public final class DimensionDataImpl implements DimensionData {
+
+    private final int minY;
+    private final int height;
+
+    public DimensionDataImpl(final int minY, final int height) {
+        this.minY = minY;
+        this.height = height;
+    }
+
+    public DimensionDataImpl(final CompoundTag dimensionData) {
+        final Tag height = dimensionData.get("height");
+        if (height instanceof IntTag) {
+            this.height = ((NumberTag) height).asInt();
+        } else {
+            throw new IllegalArgumentException("height missing in dimension data: " + dimensionData);
+        }
+
+        final Tag minY = dimensionData.get("min_y");
+        if (minY instanceof IntTag) {
+            this.minY = ((NumberTag) minY).asInt();
+        } else {
+            throw new IllegalArgumentException("min_y missing in dimension data: " + dimensionData);
+        }
+    }
+
+    @Override
+    public int minY() {
+        return minY;
+    }
+
+    @Override
+    public int height() {
+        return height;
+    }
+
+    @Override
+    public String toString() {
+        return "DimensionData{" +
+                "minY=" + minY +
+                ", height=" + height +
+                '}';
+    }
+}

common/src/main/java/com/viaversion/viaversion/data/entity/EntityTrackerBase.java

@@ -21,6 +21,7 @@ package com.viaversion.viaversion.data.entity;
 import com.google.common.base.Preconditions;
 import com.viaversion.viaversion.api.connection.UserConnection;
 import com.viaversion.viaversion.api.data.entity.ClientEntityIdChangeListener;
+import com.viaversion.viaversion.api.data.entity.DimensionData;
 import com.viaversion.viaversion.api.data.entity.EntityTracker;
 import com.viaversion.viaversion.api.data.entity.StoredEntityData;
 import com.viaversion.viaversion.api.minecraft.entities.EntityType;
@@ -28,6 +29,9 @@ import it.unimi.dsi.fastutil.ints.Int2ObjectMap;
 import org.checkerframework.checker.nullness.qual.Nullable;
 import space.vectrix.flare.fastutil.Int2ObjectSyncMap;
 
+import java.util.Collections;
+import java.util.Map;
+
 public class EntityTrackerBase implements EntityTracker, ClientEntityIdChangeListener {
     private final Int2ObjectMap<EntityType> entityTypes = Int2ObjectSyncMap.hashmap();
     private final Int2ObjectMap<StoredEntityData> entityData;
@@ -38,6 +42,7 @@ public class EntityTrackerBase implements EntityTracker, ClientEntityIdChangeLis
     private int currentMinY;
     private String currentWorld;
     private int biomesSent = -1;
+    private Map<String, DimensionData> dimensions = Collections.emptyMap();
 
     public EntityTrackerBase(UserConnection connection, @Nullable EntityType playerType) {
         this(connection, playerType, false);
@@ -118,6 +123,15 @@ public class EntityTrackerBase implements EntityTracker, ClientEntityIdChangeLis
         this.clientEntityId = clientEntityId;
     }
 
+    @Override
+    public boolean trackClientEntity() {
+        if (clientEntityId != -1) {
+            entityTypes.put(clientEntityId, playerType);
+            return true;
+        }
+        return false;
+    }
+
     @Override
     public int currentWorldSectionHeight() {
         return currentWorldSectionHeight;
@@ -157,4 +171,19 @@ public class EntityTrackerBase implements EntityTracker, ClientEntityIdChangeLis
     public void setBiomesSent(int biomesSent) {
         this.biomesSent = biomesSent;
     }
+
+    @Override
+    public EntityType playerType() {
+        return playerType;
+    }
+
+    @Override
+    public @Nullable DimensionData dimensionData(String dimension) {
+        return dimensions.get(dimension);
+    }
+
+    @Override
+    public void setDimensions(Map<String, DimensionData> dimensions) {
+        this.dimensions = dimensions;
+    }
 }

common/src/main/java/com/viaversion/viaversion/data/entity/StoredEntityImpl.java

@@ -42,6 +42,11 @@ public final class StoredEntityImpl implements StoredEntityData {
         return (T) storedObjects.get(objectClass);
     }
 
+    @Override
+    public <T> @Nullable T remove(Class<T> objectClass) {
+        return (T) storedObjects.remove(objectClass);
+    }
+
     @Override
     public boolean has(Class<?> objectClass) {
         return storedObjects.containsKey(objectClass);

common/src/main/java/com/viaversion/viaversion/debug/DebugHandlerImpl.java

@@ -18,7 +18,11 @@
 package com.viaversion.viaversion.debug;
 
 import com.viaversion.viaversion.api.debug.DebugHandler;
+import com.viaversion.viaversion.api.protocol.packet.Direction;
+import com.viaversion.viaversion.api.protocol.packet.PacketType;
 import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
+import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
+import it.unimi.dsi.fastutil.ints.IntSet;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -26,7 +30,9 @@ import java.util.Set;
 public final class DebugHandlerImpl implements DebugHandler {
 
     private final Set<String> packetTypesToLog = new HashSet<>();
-    private boolean logPostPacketTransform = true;
+    private final IntSet clientboundPacketIdsToLog = new IntOpenHashSet();
+    private final IntSet serverboundPacketIdsToLog = new IntOpenHashSet();
+    private boolean logPostPacketTransform;
     private boolean enabled;
 
     @Override
@@ -44,6 +50,11 @@ public final class DebugHandlerImpl implements DebugHandler {
         packetTypesToLog.add(packetTypeName);
     }
 
+    @Override
+    public void addPacketTypeToLog(PacketType packetType) {
+        (packetType.direction() == Direction.SERVERBOUND ? serverboundPacketIdsToLog : clientboundPacketIdsToLog).add(packetType.getId());
+    }
+
     @Override
     public boolean removePacketTypeNameToLog(final String packetTypeName) {
         return packetTypesToLog.remove(packetTypeName);
@@ -65,7 +76,9 @@ public final class DebugHandlerImpl implements DebugHandler {
     }
 
     @Override
-    public boolean shouldLog(final PacketWrapper wrapper) {
-        return packetTypesToLog.isEmpty() || (wrapper.getPacketType() != null && packetTypesToLog.contains(wrapper.getPacketType().getName()));
+    public boolean shouldLog(final PacketWrapper wrapper, final Direction direction) {
+        return packetTypesToLog.isEmpty() && serverboundPacketIdsToLog.isEmpty() && clientboundPacketIdsToLog.isEmpty()
+                || (wrapper.getPacketType() != null && packetTypesToLog.contains(wrapper.getPacketType().getName()))
+                || (direction == Direction.SERVERBOUND ? serverboundPacketIdsToLog : clientboundPacketIdsToLog).contains(wrapper.getId());
     }
 }

common/src/main/java/com/viaversion/viaversion/platform/AbstractProtocolDetectorService.java

@@ -0,0 +1,100 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2022 ViaVersion and contributors
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package com.viaversion.viaversion.platform;
+
+import com.viaversion.viaversion.api.platform.ProtocolDetectorService;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
+
+import java.util.Map;
+import java.util.concurrent.locks.ReadWriteLock;
+import java.util.concurrent.locks.ReentrantReadWriteLock;
+
+public abstract class AbstractProtocolDetectorService implements ProtocolDetectorService {
+    protected final Object2IntMap<String> detectedProtocolIds = new Object2IntOpenHashMap<>();
+    protected final ReadWriteLock lock = new ReentrantReadWriteLock();
+
+    protected AbstractProtocolDetectorService() {
+        detectedProtocolIds.defaultReturnValue(-1);
+    }
+
+    @Override
+    public int serverProtocolVersion(final String serverName) {
+        // Step 1. Check detected
+        lock.readLock().lock();
+        final int detectedProtocol;
+        try {
+            detectedProtocol = detectedProtocolIds.getInt(serverName);
+        } finally {
+            lock.readLock().unlock();
+        }
+        if (detectedProtocol != -1) {
+            return detectedProtocol;
+        }
+
+        // Step 2. Check config (CME moment?)
+        final Map<String, Integer> servers = configuredServers();
+        final Integer protocol = servers.get(serverName);
+        if (protocol != null) {
+            return protocol;
+        }
+
+        // Step 3. Use Default (CME moment intensifies?)
+        final Integer defaultProtocol = servers.get("default");
+        if (defaultProtocol != null) {
+            return defaultProtocol;
+        }
+
+        // Step 4: Use the proxy's lowest supported... *cries*
+        return lowestSupportedProtocolVersion();
+    }
+
+    @Override
+    public void setProtocolVersion(final String serverName, final int protocolVersion) {
+        lock.writeLock().lock();
+        try {
+            detectedProtocolIds.put(serverName, protocolVersion);
+        } finally {
+            lock.writeLock().unlock();
+        }
+    }
+
+    @Override
+    public int uncacheProtocolVersion(final String serverName) {
+        lock.writeLock().lock();
+        try {
+            return detectedProtocolIds.removeInt(serverName);
+        } finally {
+            lock.writeLock().unlock();
+        }
+    }
+
+    @Override
+    public Object2IntMap<String> detectedProtocolVersions() {
+        lock.readLock().lock();
+        try {
+            return new Object2IntOpenHashMap<>(detectedProtocolIds);
+        } finally {
+            lock.readLock().unlock();
+        }
+    }
+
+    protected abstract Map<String, Integer> configuredServers();
+
+    protected abstract int lowestSupportedProtocolVersion();
+}

common/src/main/java/com/viaversion/viaversion/protocol/ProtocolManagerImpl.java

@@ -66,6 +66,8 @@ import com.viaversion.viaversion.protocols.protocol1_17_1to1_17.Protocol1_17_1To
 import com.viaversion.viaversion.protocols.protocol1_17to1_16_4.Protocol1_17To1_16_4;
 import com.viaversion.viaversion.protocols.protocol1_18_2to1_18.Protocol1_18_2To1_18;
 import com.viaversion.viaversion.protocols.protocol1_18to1_17_1.Protocol1_18To1_17_1;
+import com.viaversion.viaversion.protocols.protocol1_19_1to1_19.Protocol1_19_1To1_19;
+import com.viaversion.viaversion.protocols.protocol1_19to1_18_2.Protocol1_19To1_18_2;
 import com.viaversion.viaversion.protocols.protocol1_9_1_2to1_9_3_4.Protocol1_9_1_2To1_9_3_4;
 import com.viaversion.viaversion.protocols.protocol1_9_1to1_9.Protocol1_9_1To1_9;
 import com.viaversion.viaversion.protocols.protocol1_9_3to1_9_1_2.Protocol1_9_3To1_9_1_2;
@@ -117,7 +119,7 @@ public class ProtocolManagerImpl implements ProtocolManager {
     private boolean mappingsLoaded;
 
     private ServerProtocolVersion serverProtocolVersion = new ServerProtocolVersionSingleton(-1);
-    private boolean onlyCheckLoweringPathEntries = true;
+    private int maxPathDeltaIncrease; // Only allow lowering path entries by default
     private int maxProtocolPathSize = 50;
 
     public ProtocolManagerImpl() {
@@ -171,6 +173,9 @@ public class ProtocolManagerImpl implements ProtocolManager {
         registerProtocol(new Protocol1_17_1To1_17(), ProtocolVersion.v1_17_1, ProtocolVersion.v1_17);
         registerProtocol(new Protocol1_18To1_17_1(), ProtocolVersion.v1_18, ProtocolVersion.v1_17_1);
         registerProtocol(new Protocol1_18_2To1_18(), ProtocolVersion.v1_18_2, ProtocolVersion.v1_18);
+
+        registerProtocol(new Protocol1_19To1_18_2(), ProtocolVersion.v1_19, ProtocolVersion.v1_18_2);
+        registerProtocol(new Protocol1_19_1To1_19(), ProtocolVersion.v1_19_1, ProtocolVersion.v1_19);
     }
 
     @Override
@@ -312,7 +317,7 @@ public class ProtocolManagerImpl implements ProtocolManager {
             if (current.containsKey(translatedToVersion)) continue;
 
             // Check if the new version is farther away than the current client version
-            if (onlyCheckLoweringPathEntries && Math.abs(serverVersion - translatedToVersion) > Math.abs(serverVersion - clientVersion)) {
+            if (maxPathDeltaIncrease != -1 && Math.abs(serverVersion - translatedToVersion) - Math.abs(serverVersion - clientVersion) > maxPathDeltaIncrease) {
                 continue;
             }
 
@@ -380,13 +385,13 @@ public class ProtocolManagerImpl implements ProtocolManager {
     }
 
     @Override
-    public void setOnlyCheckLoweringPathEntries(boolean onlyCheckLoweringPathEntries) {
-        this.onlyCheckLoweringPathEntries = onlyCheckLoweringPathEntries;
+    public void setMaxPathDeltaIncrease(final int maxPathDeltaIncrease) {
+        this.maxPathDeltaIncrease = Math.max(-1, maxPathDeltaIncrease);
     }
 
     @Override
-    public boolean onlyCheckLoweringPathEntries() {
-        return onlyCheckLoweringPathEntries;
+    public int getMaxPathDeltaIncrease() {
+        return maxPathDeltaIncrease;
     }
 
     @Override