Default rewriter registrations across protocols

In total it doesn't (yet) reduce the lines of code (though there is also some other changes adding code here), but makes adding single rewriter calls to a range of protocols much easier than having to individually check an ever increasing number of classes. This also moved Protocol#registerPackets until after mappings have been loaded (which makes onMappingDataLoaded redundant for now, but will become relevant later again)

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

@@ -0,0 +1,123 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.common.base.Preconditions;
+import com.viaversion.viaversion.api.data.MappingDataLoader.IdentifiersPair;
+import com.viaversion.viaversion.util.Key;
+import it.unimi.dsi.fastutil.objects.Object2IntMap;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+public class FullIdentityMappings implements FullMappings {
+    private static final String[] EMPTY_ARRAY = new String[0];
+    private final Object2IntMap<String> stringToId;
+    private final String[] idToString;
+    private final Mappings mappings;
+
+    public FullIdentityMappings(final IdentifiersPair identifiersPair, final Mappings mappings) {
+        Preconditions.checkNotNull(mappings, "Mappings cannot be null");
+        this.mappings = mappings;
+        this.stringToId = FullMappingsBase.toInverseMap(identifiersPair.unmapped());
+        this.idToString = identifiersPair.unmapped().toArray(EMPTY_ARRAY);
+    }
+
+    private FullIdentityMappings(final Object2IntMap<String> stringToId, final String[] idToString, final Mappings mappings) {
+        this.stringToId = stringToId;
+        this.idToString = idToString;
+        this.mappings = mappings;
+    }
+
+    @Override
+    public int id(final String identifier) {
+        return stringToId.getInt(Key.stripMinecraftNamespace(identifier));
+    }
+
+    @Override
+    public int mappedId(final String mappedIdentifier) {
+        return id(mappedIdentifier);
+    }
+
+    @Override
+    public String identifier(final int id) {
+        if (id < 0 || id >= idToString.length) {
+            return null;
+        }
+        final String identifier = idToString[id];
+        return Key.namespaced(identifier);
+    }
+
+    @Override
+    public @Nullable String identifier(final String mappedIdentifier) {
+        final int mappedId = mappedId(mappedIdentifier);
+        if (mappedId == -1) {
+            return null;
+        }
+        final int id = mappings.inverse().getNewId(mappedId);
+        return id != -1 ? identifier(id) : null;
+    }
+
+    @Override
+    public @Nullable String mappedIdentifier(final int mappedId) {
+        return identifier(mappedId);
+    }
+
+    @Override
+    public @Nullable String mappedIdentifier(final String identifier) {
+        return identifier(identifier);
+    }
+
+    @Override
+    public int getNewId(int id) {
+        return mappings.getNewId(id);
+    }
+
+    @Override
+    public void setNewId(int id, int mappedId) {
+        mappings.setNewId(id, mappedId);
+    }
+
+    @Override
+    public int size() {
+        return mappings.size();
+    }
+
+    @Override
+    public int mappedSize() {
+        return mappings.mappedSize();
+    }
+
+    @Override
+    public boolean isIdentity() {
+        return true;
+    }
+
+    @Override
+    public boolean isIntIdIdentity() {
+        return true;
+    }
+
+    @Override
+    public FullMappings inverse() {
+        return new FullIdentityMappings(stringToId, idToString, mappings.inverse());
+    }
+}

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

@@ -77,6 +77,14 @@ public interface FullMappings extends BiMappings {
      */
     @Nullable String mappedIdentifier(String identifier);
 
+    /**
+     * Returns whether the int id mappings are identity mappings.
+     *
+     * @return whether the int id mappings are identity mappings
+     * @see #isIdentity()
+     */
+    boolean isIntIdIdentity();
+
     @Override
     FullMappings inverse();
 }

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

@@ -23,6 +23,7 @@
 package com.viaversion.viaversion.api.data;
 
 import com.google.common.base.Preconditions;
+import com.viaversion.viaversion.api.data.MappingDataLoader.IdentifiersPair;
 import com.viaversion.viaversion.util.Key;
 import it.unimi.dsi.fastutil.objects.Object2IntMap;
 import it.unimi.dsi.fastutil.objects.Object2IntOpenHashMap;
@@ -37,13 +38,13 @@ public class FullMappingsBase implements FullMappings {
     private final String[] mappedIdToString;
     private final Mappings mappings;
 
-    public FullMappingsBase(final List<String> unmappedIdentifiers, final List<String> mappedIdentifiers, final Mappings mappings) {
+    public FullMappingsBase(final IdentifiersPair identifiersPair, final Mappings mappings) {
         Preconditions.checkNotNull(mappings, "Mappings cannot be null");
         this.mappings = mappings;
-        this.stringToId = toInverseMap(unmappedIdentifiers);
-        this.mappedStringToId = toInverseMap(mappedIdentifiers);
-        this.idToString = unmappedIdentifiers.toArray(EMPTY_ARRAY);
-        this.mappedIdToString = mappedIdentifiers.toArray(EMPTY_ARRAY);
+        this.stringToId = toInverseMap(identifiersPair.unmapped());
+        this.idToString = identifiersPair.unmapped().toArray(EMPTY_ARRAY);
+        this.mappedStringToId = toInverseMap(identifiersPair.mapped());
+        this.mappedIdToString = identifiersPair.mapped().toArray(EMPTY_ARRAY);
     }
 
     private FullMappingsBase(final Object2IntMap<String> stringToId, final Object2IntMap<String> mappedStringToId, final String[] idToString, final String[] mappedIdToString, final Mappings mappings) {
@@ -54,7 +55,11 @@ public class FullMappingsBase implements FullMappings {
         this.mappings = mappings;
     }
 
-    private static Object2IntMap<String> toInverseMap(final List<String> list) {
+    public static FullMappings of(final IdentifiersPair identifiersPair, final Mappings mappings) {
+        return mappings.isIdentity() && identifiersPair.identity() ? new FullIdentityMappings(identifiersPair, mappings) : new FullMappingsBase(identifiersPair, mappings);
+    }
+
+    static Object2IntMap<String> toInverseMap(final List<String> list) {
         final Object2IntMap<String> map = new Object2IntOpenHashMap<>(list.size());
         map.defaultReturnValue(-1);
         for (int i = 0; i < list.size(); i++) {
@@ -135,6 +140,11 @@ public class FullMappingsBase implements FullMappings {
         return mappings.mappedSize();
     }
 
+    @Override
+    public boolean isIntIdIdentity() {
+        return mappings.isIdentity();
+    }
+
     @Override
     public FullMappings inverse() {
         return new FullMappingsBase(mappedStringToId, stringToId, mappedIdToString, idToString, mappings.inverse());

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

@@ -38,4 +38,9 @@ public record IdentityMappings(int size, int mappedSize) implements Mappings {
     public Mappings inverse() {
         return new IdentityMappings(mappedSize, size);
     }
+
+    @Override
+    public boolean isIdentity() {
+        return true;
+    }
 }

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

@@ -26,6 +26,7 @@ import com.viaversion.nbt.tag.CompoundTag;
 import com.viaversion.nbt.tag.IntArrayTag;
 import com.viaversion.nbt.tag.Tag;
 import com.viaversion.viaversion.api.Via;
+import com.viaversion.viaversion.api.data.MappingDataLoader.IdentifiersPair;
 import com.viaversion.viaversion.api.minecraft.RegistryType;
 import com.viaversion.viaversion.api.minecraft.TagData;
 import it.unimi.dsi.fastutil.ints.IntOpenHashSet;
@@ -96,14 +97,13 @@ public class MappingDataBase implements MappingData {
             attributeMappings = loadFullMappings(data, unmappedIdentifierData, mappedIdentifierData, "attributes");
             blockEntityMappings = loadFullMappings(data, unmappedIdentifierData, mappedIdentifierData, "blockentities");
 
-            final List<String> unmappedParticles = identifiersFromGlobalIds(unmappedIdentifierData, "particles");
-            final List<String> mappedParticles = identifiersFromGlobalIds(mappedIdentifierData, "particles");
-            if (unmappedParticles != null && mappedParticles != null) {
+            final IdentifiersPair particleIdentifiers = identifiersFromGlobalIds(unmappedIdentifierData, mappedIdentifierData, "particles");
+            if (particleIdentifiers != null) {
                 Mappings particleMappings = loadMappings(data, "particles");
                 if (particleMappings == null) {
-                    particleMappings = new IdentityMappings(unmappedParticles.size(), mappedParticles.size());
+                    particleMappings = new IdentityMappings(particleIdentifiers.unmapped().size(), particleIdentifiers.mapped().size());
                 }
-                this.particleMappings = new ParticleMappings(unmappedParticles, mappedParticles, particleMappings);
+                this.particleMappings = new ParticleMappings(particleIdentifiers, particleMappings);
             }
         } else {
             // Might not have identifiers in older versions
@@ -132,6 +132,10 @@ public class MappingDataBase implements MappingData {
         return MappingDataLoader.INSTANCE.identifiersFromGlobalIds(mappingsTag, key);
     }
 
+    protected @Nullable IdentifiersPair identifiersFromGlobalIds(final CompoundTag unmappedTag, final CompoundTag mappedTag, final String key) {
+        return MappingDataLoader.INSTANCE.identifiersFromGlobalIds(unmappedTag, mappedTag, key);
+    }
+
     protected @Nullable CompoundTag readMappingsFile(final String name) {
         return MappingDataLoader.INSTANCE.loadNBT(name);
     }
@@ -158,14 +162,12 @@ public class MappingDataBase implements MappingData {
             return null;
         }
 
-        final List<String> unmappedIdentifiers = identifiersFromGlobalIds(unmappedIdentifiersTag, key);
-        final List<String> mappedIdentifiers = identifiersFromGlobalIds(mappedIdentifiersTag, key);
+        final IdentifiersPair identifiersPair = identifiersFromGlobalIds(unmappedIdentifiersTag, mappedIdentifiersTag, key);
         Mappings mappings = loadBiMappings(data, key); // Load as bi-mappings to keep the inverse cached
         if (mappings == null) {
-            mappings = new IdentityMappings(unmappedIdentifiers.size(), mappedIdentifiers.size());
+            mappings = new IdentityMappings(identifiersPair.unmapped().size(), identifiersPair.mapped().size());
         }
-
-        return new FullMappingsBase(unmappedIdentifiers, mappedIdentifiers, mappings);
+        return FullMappingsBase.of(identifiersPair, mappings);
     }
 
     protected @Nullable BiMappings loadBiMappings(final CompoundTag data, final String key) {

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

@@ -272,13 +272,60 @@ public class MappingDataLoader {
 
     public @Nullable List<String> identifiersFromGlobalIds(final CompoundTag mappingsTag, final String key) {
         final Mappings mappings = loadMappings(mappingsTag, key);
-        if (mappings == null) {
+        return mappings != null ? identifiers(mappings, key) : null;
+
+    }
+
+    /**
+     * Returns a pair of identifier lists, also keeping track of whether the two lists are equal.
+     *
+     * @param unmappedTag unmapped mappings tag
+     * @param mappedTag   mapped mappings tag
+     * @param key         mappings key
+     * @return pair of identifier lists
+     */
+    public @Nullable IdentifiersPair identifiersFromGlobalIds(final CompoundTag unmappedTag, final CompoundTag mappedTag, final String key) {
+        final Mappings unmapped = loadMappings(unmappedTag, key);
+        if (unmapped == null) {
             return null;
         }
 
+        final Mappings mapped = loadMappings(mappedTag, key);
+        if (mapped == null) {
+            return null;
+        }
+
+        final int size = unmapped.size();
+        if (size != mapped.size()) {
+            return new IdentifiersPair(identifiers(unmapped, key), identifiers(mapped, key), false);
+        }
+
+        // Small optimization to only load one array and reduce loading for full mappings
+        final List<String> unmappedIdentifiers = new ArrayList<>(size);
+        final List<String> mappedIdentifiers = new ArrayList<>(size);
+        boolean identity = true;
+        for (int i = 0; i < size; i++) {
+            final int unmappedGlobalId = unmapped.getNewId(i);
+            final int mappedGlobalId = mapped.getNewId(i);
+            final String unmappedIdentifier = identifierFromGlobalId(key, unmappedGlobalId);
+            if (unmappedGlobalId == mappedGlobalId) {
+                unmappedIdentifiers.add(unmappedIdentifier);
+                mappedIdentifiers.add(unmappedIdentifier);
+                continue;
+            }
+
+            identity = false;
+            unmappedIdentifiers.add(unmappedIdentifier);
+            mappedIdentifiers.add(identifierFromGlobalId(key, mappedGlobalId));
+        }
+        return identity ? new IdentifiersPair(unmappedIdentifiers) : new IdentifiersPair(unmappedIdentifiers, mappedIdentifiers);
+    }
+
+    private List<String> identifiers(final Mappings mappings, final String key) {
         final List<String> identifiers = new ArrayList<>(mappings.size());
         for (int i = 0; i < mappings.size(); i++) {
-            identifiers.add(identifierFromGlobalId(key, mappings.getNewId(i)));
+            final int globalId = mappings.getNewId(i);
+            identifiers.add(identifierFromGlobalId(key, globalId));
         }
         return identifiers;
     }
@@ -342,4 +389,15 @@ public class MappingDataLoader {
 
         T create(V mappings, int mappedSize);
     }
+
+    public record IdentifiersPair(List<String> unmapped, List<String> mapped, boolean identity) {
+
+        public IdentifiersPair(final List<String> unmapped, final List<String> mapped) {
+            this(unmapped, mapped, false);
+        }
+
+        public IdentifiersPair(final List<String> identifiers) {
+            this(identifiers, identifiers, true);
+        }
+    }
 }

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

@@ -22,6 +22,8 @@
  */
 package com.viaversion.viaversion.api.data;
 
+import org.checkerframework.checker.nullness.qual.Nullable;
+
 public interface Mappings {
 
     /**
@@ -84,4 +86,40 @@ public interface Mappings {
      * @return mappings with keys and values swapped
      */
     Mappings inverse();
+
+
+    /**
+     * Returns whether the mappings are unchanged identity mappings.
+     *
+     * @return whether the mappings are unchanged identity mappings
+     */
+    default boolean isIdentity() {
+        return false;
+    }
+
+    /**
+     * Returns whether the mappings null or identity mappings.
+     *
+     * @param mappings mappings
+     * @return whether the mappings are identity mappings
+     * @see #isFullIdentity(Mappings)
+     */
+    static boolean isIntIdIdentity(@Nullable final Mappings mappings) {
+        if (mappings == null) {
+            return true;
+        }
+        return mappings instanceof FullMappings fullMappings ? fullMappings.isIntIdIdentity() : mappings.isIdentity();
+    }
+
+    /**
+     * Returns whether the mappings null or full identity mappings.
+     * Stronger than {@link #isIntIdIdentity(Mappings)}, but equal to that if not {@link FullMappings}.
+     *
+     * @param mappings mappings
+     * @return whether the mappings are full identity mappings
+     * @see #isIntIdIdentity(Mappings)
+     */
+    static boolean isFullIdentity(@Nullable final Mappings mappings) {
+        return mappings == null || mappings.isIdentity();
+    }
 }

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

@@ -22,16 +22,16 @@
  */
 package com.viaversion.viaversion.api.data;
 
+import com.viaversion.viaversion.api.data.MappingDataLoader.IdentifiersPair;
 import it.unimi.dsi.fastutil.ints.IntArrayList;
 import it.unimi.dsi.fastutil.ints.IntList;
-import java.util.List;
 
 public class ParticleMappings extends FullMappingsBase {
     private final IntList itemParticleIds = new IntArrayList(4);
     private final IntList blockParticleIds = new IntArrayList(4);
 
-    public ParticleMappings(final List<String> unmappedIdentifiers, final List<String> mappedIdentifiers, final Mappings mappings) {
-        super(unmappedIdentifiers, mappedIdentifiers, mappings);
+    public ParticleMappings(final IdentifiersPair identifiersPair, final Mappings mappings) {
+        super(identifiersPair, mappings);
         addBlockParticle("block");
         addBlockParticle("falling_dust");
         addBlockParticle("block_marker");

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

@@ -1,36 +0,0 @@
-/*
- * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
- * Copyright (C) 2016-2026 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.protocol;
-
-/**
- * A simple protocol which does not have any packet types.
- * <p>
- * {@link AbstractProtocol} should be preferred over this class in most cases.
- */
-public abstract class AbstractSimpleProtocol extends AbstractProtocol<SimpleProtocol.DummyPacketTypes, SimpleProtocol.DummyPacketTypes,
-    SimpleProtocol.DummyPacketTypes, SimpleProtocol.DummyPacketTypes> implements SimpleProtocol {
-
-    protected AbstractSimpleProtocol() {
-        super(null, null, null, null);
-    }
-}

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

@@ -260,6 +260,22 @@ public interface Protocol<CU extends ClientboundPacketType, CM extends Clientbou
      */
     void appendServerbound(SU type, PacketHandler handler);
 
+    /**
+     * Replaces a clientbound packet type handler with another.
+     *
+     * @param type    clientbound packet type
+     * @param handler packet handler
+     */
+    void replaceClientbound(CU type, @Nullable PacketHandler handler);
+
+    /**
+     * Replaces a serverbound packet type handler with another.
+     *
+     * @param type    serverbound packet type
+     * @param handler packet handler
+     */
+    void replaceServerbound(SU type, @Nullable PacketHandler handler);
+
     /**
      * Transform a packet using this protocol
      *
@@ -441,4 +457,13 @@ public interface Protocol<CU extends ClientboundPacketType, CM extends Clientbou
     default boolean isBaseProtocol() {
         return false;
     }
+
+    /**
+     * Marks this protocol as dependent on another. Before being initialized, it will wait for the dependency's completion.
+     *
+     * @return protocol class to depend on
+     */
+    default @Nullable Class<? extends Protocol<?, ?, ?, ?>> dependsOn() {
+        return null;
+    }
 }

api/src/main/java/com/viaversion/viaversion/api/protocol/packet/mapping/PacketIdMapping.java

@@ -50,6 +50,11 @@ final class PacketIdMapping implements PacketMapping {
         }
     }
 
+    @Override
+    public void setHandler(@Nullable final PacketHandler handler) {
+        this.handler = handler;
+    }
+
     @Override
     public @Nullable PacketHandler handler() {
         return handler;

api/src/main/java/com/viaversion/viaversion/api/protocol/packet/mapping/PacketMapping.java

@@ -39,6 +39,13 @@ public interface PacketMapping {
      */
     void applyType(PacketWrapper wrapper);
 
+    /**
+     * Replaces the current packet handler.
+     *
+     * @param handler packet transformer
+     */
+    void setHandler(@Nullable PacketHandler handler);
+
     /**
      * Returns a packet transformer to transform a packet from one protocol version to another.
      *

api/src/main/java/com/viaversion/viaversion/api/protocol/packet/mapping/PacketTypeMapping.java

@@ -52,6 +52,11 @@ final class PacketTypeMapping implements PacketMapping {
         }
     }
 
+    @Override
+    public void setHandler(@Nullable final PacketHandler handler) {
+        this.handler = handler;
+    }
+
     @Override
     public @Nullable PacketHandler handler() {
         return handler;

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

@@ -26,6 +26,7 @@ import com.google.gson.JsonElement;
 import com.viaversion.nbt.tag.CompoundTag;
 import com.viaversion.nbt.tag.Tag;
 import com.viaversion.viaversion.api.connection.UserConnection;
+import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 public interface ComponentRewriter {
@@ -37,4 +38,6 @@ public interface ComponentRewriter {
     JsonElement processText(UserConnection connection, @Nullable String json);
 
     void handleShowItem(UserConnection connection, CompoundTag itemTag);
+
+    void passthroughAndProcess(PacketWrapper wrapper);
 }

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

@@ -28,6 +28,7 @@ import com.viaversion.viaversion.api.minecraft.entities.EntityType;
 import com.viaversion.viaversion.api.minecraft.entitydata.EntityData;
 import com.viaversion.viaversion.api.protocol.Protocol;
 import java.util.List;
+import org.checkerframework.checker.nullness.qual.Nullable;
 
 public interface EntityRewriter<T extends Protocol<?, ?, ?, ?>> extends Rewriter<T> {
 
@@ -39,6 +40,11 @@ public interface EntityRewriter<T extends Protocol<?, ?, ?, ?>> extends Rewriter
      */
     EntityType typeFromId(int type);
 
+    default @Nullable EntityType typeFromId(final String type) {
+        final int id = protocol().getMappingData().getEntityMappings().id(type);
+        return id == -1 ? null : typeFromId(id);
+    }
+
     /**
      * Returns the entity type from the given id.
      * From 1.14 and onwards, this is the same exact value as {@link #typeFromId(int)}.

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

@@ -23,16 +23,21 @@
 package com.viaversion.viaversion.api.rewriter;
 
 import com.viaversion.nbt.tag.CompoundTag;
+import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
 import com.viaversion.viaversion.api.connection.UserConnection;
 import com.viaversion.viaversion.util.KeyMappings;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 public interface RegistryDataRewriter {
 
+    void handle(PacketWrapper wrapper);
+
     @Nullable
     KeyMappings getMappings(String registryKey);
 
     boolean shouldRemoveRegistry(String registryKey);
 
+    boolean hasRegistriesToRemove();
+
     void updateDialog(UserConnection connection, CompoundTag tag);
 }

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

@@ -105,7 +105,8 @@ public class BukkitViaInjector extends LegacyViaInjector {
         // Grab the ping class and find the field to access it
         Class<?> pingClazz = NMSUtil.nms(
             "ServerPing",
-            "net.minecraft.network.protocol.status.ServerPing"
+            "net.minecraft.network.protocol.status.ServerPing",
+            "net.minecraft.network.protocol.status.ServerStatus"
         );
         Object ping = null;
         for (Field field : serverClazz.getDeclaredFields()) {
@@ -120,7 +121,8 @@ public class BukkitViaInjector extends LegacyViaInjector {
         // Now get the ServerData inside ServerPing
         Class<?> serverDataClass = NMSUtil.nms(
             "ServerPing$ServerData",
-            "net.minecraft.network.protocol.status.ServerPing$ServerData"
+            "net.minecraft.network.protocol.status.ServerPing$ServerData",
+            "net.minecraft.network.protocol.status.ServerStatus$Version"
         );
         Object serverData = null;
         for (Field field : pingClazz.getDeclaredFields()) {
@@ -155,7 +157,8 @@ public class BukkitViaInjector extends LegacyViaInjector {
         );
         Class<?> connectionClass = NMSUtil.nms(
             "ServerConnection",
-            "net.minecraft.server.network.ServerConnection"
+            "net.minecraft.server.network.ServerConnection",
+            "net.minecraft.server.network.ServerConnectionListener"
         );
 
         Object server = ReflectionUtil.invokeStatic(serverClass, "getServer");

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

@@ -2,23 +2,18 @@
  * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
  * Copyright (C) 2016-2026 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:
+ * 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.
  *
- * The above copyright notice and this permission notice shall be included in all
- * copies or substantial portions of the Software.
+ * 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.
  *
- * 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.
+ * 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.api.protocol;
 
@@ -39,10 +34,15 @@ import com.viaversion.viaversion.api.protocol.packet.provider.PacketTypeMap;
 import com.viaversion.viaversion.api.protocol.packet.provider.PacketTypesProvider;
 import com.viaversion.viaversion.api.protocol.packet.provider.SimplePacketTypesProvider;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandler;
+import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
 import com.viaversion.viaversion.api.rewriter.MappingDataListener;
 import com.viaversion.viaversion.api.rewriter.Rewriter;
 import com.viaversion.viaversion.exception.CancelException;
 import com.viaversion.viaversion.exception.InformativeException;
+import com.viaversion.viaversion.protocol.shared_registration.SharedRegistrations;
+import com.viaversion.viaversion.rewriter.RecipeDisplayRewriter;
+import com.viaversion.viaversion.rewriter.TagRewriter;
+import com.viaversion.viaversion.rewriter.text.ComponentRewriterBase;
 import com.viaversion.viaversion.util.ProtocolLogger;
 import com.viaversion.viaversion.util.ProtocolUtil;
 import java.util.HashMap;
@@ -74,6 +74,8 @@ public abstract class AbstractProtocol<CU extends ClientboundPacketType, CM exte
     private final Map<Class<?>, Object> storedObjects = new HashMap<>();
     private boolean initialized;
     private ProtocolLogger logger;
+    private ProtocolVersion serverVersion;
+    private ProtocolVersion clientVersion;
 
     @Deprecated
     protected AbstractProtocol() {
@@ -104,6 +106,11 @@ public abstract class AbstractProtocol<CU extends ClientboundPacketType, CM exte
         if (logger == null) {
             logger = createLogger();
         }
+
+        // Apply shared registrations based on protocol version range
+        // Run before registerPackets, so implementations have to call append intentionally
+        applySharedRegistrations();
+
         registerPackets();
         registerConfigurationChangeHandlers();
 
@@ -128,6 +135,13 @@ public abstract class AbstractProtocol<CU extends ClientboundPacketType, CM exte
         }
     }
 
+    /**
+     * Applies shared registrations. Can be overridden to remove or add registrations.
+     */
+    protected void applySharedRegistrations() {
+        SharedRegistrations.defaultRegistrations().applyMatching(this);
+    }
+
     protected ProtocolLogger createLogger() {
         return new ProtocolLogger(getClass());
     }
@@ -177,6 +191,20 @@ public abstract class AbstractProtocol<CU extends ClientboundPacketType, CM exte
         }
     }
 
+    @Override
+    public void replaceClientbound(final CU type, @Nullable final PacketHandler handler) {
+        final PacketMapping mapping = clientboundMappings.mappedPacket(type.state(), type.getId());
+        Preconditions.checkNotNull(mapping, "Packet %s has no handler to replace", type);
+        mapping.setHandler(handler);
+    }
+
+    @Override
+    public void replaceServerbound(final SU type, @Nullable final PacketHandler handler) {
+        final PacketMapping mapping = serverboundMappings.mappedPacket(type.state(), type.getId());
+        Preconditions.checkNotNull(mapping, "Packet %s has no handler to replace", type);
+        mapping.setHandler(handler);
+    }
+
     private <U extends PacketType, M extends PacketType> void registerPacketIdChanges(
         Map<State, PacketTypeMap<U>> unmappedPacketTypes,
         Map<State, PacketTypeMap<M>> mappedPacketTypes,
@@ -214,6 +242,7 @@ public abstract class AbstractProtocol<CU extends ClientboundPacketType, CM exte
     @Override
     public final void loadMappingData() {
         getMappingData().load();
+        initialize();
         onMappingDataLoaded();
     }
 
@@ -289,6 +318,46 @@ public abstract class AbstractProtocol<CU extends ClientboundPacketType, CM exte
         return packetTypesProvider.unmappedClientboundType(State.CONFIGURATION, "FINISH_CONFIGURATION");
     }
 
+    /**
+     * Returns the server protocol version for this protocol,
+     * or null if not set (e.g. for base protocols).
+     *
+     * @return the server protocol version
+     */
+    public @Nullable ProtocolVersion getServerVersion() {
+        return serverVersion;
+    }
+
+    /**
+     * Sets the server protocol version for this protocol.
+     * Called by the protocol manager before {@link #initialize()}.
+     *
+     * @param serverVersion the server protocol version
+     */
+    public void setServerVersion(final ProtocolVersion serverVersion) {
+        this.serverVersion = serverVersion;
+    }
+
+    /**
+     * Returns the client protocol version for this protocol,
+     * or null if not set (e.g. for base protocols).
+     *
+     * @return the client protocol version for this protocol
+     */
+    public @Nullable ProtocolVersion getClientVersion() {
+        return clientVersion;
+    }
+
+    /**
+     * Sets the client protocol version for this protocol.
+     * Called by the protocol manager before {@link #initialize()}.
+     *
+     * @param clientVersion the client protocol version for this protocol
+     */
+    public void setClientVersion(final ProtocolVersion clientVersion) {
+        this.clientVersion = clientVersion;
+    }
+
     // ---------------------------------------------------------------------------------
 
     @Override
@@ -373,8 +442,7 @@ public abstract class AbstractProtocol<CU extends ClientboundPacketType, CM exte
 
         PacketMapping packetMapping = PacketMapping.of(mappedPacketType, handler);
         if (!override && packetMappings.hasMapping(packetType)) {
-            getLogger().log(Level.WARNING, packetType + " already registered!" +
-                " If override is intentional, set override to true. Stacktrace: ", new Exception());
+            throw new IllegalArgumentException("Packet type " + packetType + " already registered! If override is intentional, set override to true.");
         }
         packetMappings.addMapping(packetType, packetMapping);
     }
@@ -443,6 +511,39 @@ public abstract class AbstractProtocol<CU extends ClientboundPacketType, CM exte
         return logger;
     }
 
+    @Override
+    public @Nullable TagRewriter<CU> getTagRewriter() {
+        return null;
+    }
+
+    @Override
+    public @Nullable ComponentRewriterBase<CU> getComponentRewriter() {
+        return null;
+    }
+
+    @Override
+    public com.viaversion.viaversion.rewriter.@Nullable ParticleRewriter<CU> getParticleRewriter() {
+        return null;
+    }
+
+    @Override
+    public com.viaversion.viaversion.rewriter.@Nullable EntityRewriter<CU, ?> getEntityRewriter() {
+        return null;
+    }
+
+    @Override
+    public com.viaversion.viaversion.rewriter.@Nullable ItemRewriter<CU, SU, ?> getItemRewriter() {
+        return null;
+    }
+
+    public com.viaversion.viaversion.rewriter.@Nullable BlockRewriter<CU> getBlockRewriter() {
+        return null;
+    }
+
+    public @Nullable RecipeDisplayRewriter<CU> getRecipeRewriter() {
+        return null;
+    }
+
     private void printRemapError(Direction direction, State state, int unmappedPacketId, int mappedPacketId, InformativeException e) {
         // Don't print errors during handshake/login/status
         if (state != State.PLAY && direction == Direction.SERVERBOUND && !Via.getManager().debugHandler().enabled()) {

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

@@ -0,0 +1,34 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol;
+
+import com.viaversion.viaversion.api.protocol.AbstractProtocol;
+import com.viaversion.viaversion.api.protocol.SimpleProtocol;
+
+/**
+ * A simple protocol which does not have any packet types.
+ * <p>
+ * {@link AbstractProtocol} should be preferred over this class in most cases.
+ */
+public abstract class AbstractSimpleProtocol extends AbstractProtocol<SimpleProtocol.DummyPacketTypes, SimpleProtocol.DummyPacketTypes,
+    SimpleProtocol.DummyPacketTypes, SimpleProtocol.DummyPacketTypes> implements SimpleProtocol {
+
+    protected AbstractSimpleProtocol() {
+        super(null, null, null, null);
+    }
+}

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

@@ -23,6 +23,7 @@ import com.google.common.collect.Range;
 import com.viaversion.viaversion.api.Via;
 import com.viaversion.viaversion.api.connection.UserConnection;
 import com.viaversion.viaversion.api.data.MappingDataLoader;
+import com.viaversion.viaversion.api.protocol.AbstractProtocol;
 import com.viaversion.viaversion.api.protocol.Protocol;
 import com.viaversion.viaversion.api.protocol.ProtocolManager;
 import com.viaversion.viaversion.api.protocol.ProtocolPathEntry;
@@ -38,6 +39,7 @@ import com.viaversion.viaversion.api.protocol.version.ServerProtocolVersion;
 import com.viaversion.viaversion.api.protocol.version.VersionType;
 import com.viaversion.viaversion.protocol.packet.PacketWrapperImpl;
 import com.viaversion.viaversion.protocol.packet.VersionedPacketTransformerImpl;
+import com.viaversion.viaversion.protocol.shared_registration.def.DefaultRegistrations;
 import com.viaversion.viaversion.protocols.base.InitialBaseProtocol;
 import com.viaversion.viaversion.protocols.base.v1_16.ClientboundBaseProtocol1_16;
 import com.viaversion.viaversion.protocols.base.v1_7.ClientboundBaseProtocol1_7;
@@ -146,6 +148,8 @@ public class ProtocolManagerImpl implements ProtocolManager {
             worker.setName("Via-Mappingloader-" + threadIndex.incrementAndGet());
             return worker;
         }, ForkJoinWorkerThread.getDefaultUncaughtExceptionHandler(), true);
+
+        DefaultRegistrations.apply();
     }
 
     public void registerProtocols() {
@@ -225,8 +229,11 @@ public class ProtocolManagerImpl implements ProtocolManager {
 
     @Override
     public void registerProtocol(Protocol protocol, List<ProtocolVersion> supportedClientVersion, ProtocolVersion serverVersion) {
-        // Register the protocol's handlers
-        protocol.initialize();
+        // Set the server version on AbstractProtocol instances before initialization
+        if (protocol instanceof AbstractProtocol<?, ?, ?, ?> abstractProtocol) {
+            abstractProtocol.setServerVersion(serverVersion);
+            abstractProtocol.setClientVersion(supportedClientVersion.stream().max(ProtocolVersion::compareTo).orElseThrow());
+        }
 
         // Clear cache as this may make new routes.
         if (!pathCache.isEmpty()) {
@@ -248,14 +255,22 @@ public class ProtocolManagerImpl implements ProtocolManager {
             refreshVersions();
         }
 
-        if (protocol.hasMappingDataToLoad()) {
-            if (mappingLoaderExecutor != null) {
-                // Submit mapping data loading
-                addMappingLoaderFuture(protocol.getClass(), protocol::loadMappingData);
+        // Load mapping data and register the protocol's handlers
+        if (!protocol.hasMappingDataToLoad()) {
+            protocol.initialize();
+            return;
+        }
+
+        // Submit mapping data loading
+        if (mappingLoaderExecutor != null) {
+            if (protocol.dependsOn() != null) {
+                addMappingLoaderFuture(protocol.getClass(), protocol.dependsOn(), protocol::loadMappingData);
             } else {
-                // Late protocol adding - just do it on the current thread
-                protocol.loadMappingData();
+                addMappingLoaderFuture(protocol.getClass(), protocol::loadMappingData);
             }
+        } else {
+            // Late protocol adding - just do it on the current thread
+            protocol.loadMappingData();
         }
     }
 
@@ -573,7 +588,7 @@ public class ProtocolManagerImpl implements ProtocolManager {
 
     private Function<Throwable, Void> mappingLoaderThrowable(Class<? extends Protocol> protocolClass) {
         return throwable -> {
-            Via.getPlatform().getLogger().log(Level.SEVERE, "Error during mapping loading of " + protocolClass.getSimpleName(), throwable);
+            Via.getPlatform().getLogger().log(Level.SEVERE, "Error during loading of " + protocolClass.getSimpleName(), throwable);
             return null;
         };
     }

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/PacketBound.java

@@ -0,0 +1,23 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration;
+
+public enum PacketBound {
+    ADDED_AT_MIN,
+    REMOVED_AT_MAX
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/RegistrationBuilder.java

@@ -0,0 +1,151 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration;
+
+import com.google.common.base.Preconditions;
+import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType;
+import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType;
+import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
+import com.viaversion.viaversion.api.protocol.version.VersionType;
+import com.viaversion.viaversion.protocol.shared_registration.SharedRegistrations.RegistrationAction;
+import java.util.ArrayList;
+import java.util.List;
+import java.util.function.Consumer;
+import java.util.function.Function;
+
+public final class RegistrationBuilder {
+    private final List<VersionedTemplateGroup> groups = new ArrayList<>();
+    private final SharedRegistrations registrations;
+    private VersionType versionType;
+
+    RegistrationBuilder(final SharedRegistrations registrations) {
+        this.registrations = registrations;
+    }
+
+    /**
+     * Adds a registration for an open-ended version range.
+     *
+     * @param min    minimum version, inclusive
+     * @param action registration action
+     * @return this
+     */
+    public RegistrationBuilder since(final ProtocolVersion min, final RegistrationAction<?, ?> action) {
+        checkVersionType(min);
+        groups.add(new VersionedTemplateGroup(action, min, null));
+        return this;
+    }
+
+    /**
+     * Adds a registration for a version range.
+     *
+     * @param min    minimum version, inclusive
+     * @param max    maximum version, exclusive
+     * @param action registration action
+     * @return this
+     */
+    public RegistrationBuilder range(final ProtocolVersion min, final ProtocolVersion max, final RegistrationAction<?, ?> action) {
+        checkVersionType(min);
+        checkVersionType(max);
+        groups.add(new VersionedTemplateGroup(action, min, max));
+        return this;
+    }
+
+    public <CU extends ClientboundPacketType, SU extends ServerboundPacketType> RegistrationBuilder ranges(
+        final ProtocolVersion min, final Consumer<RangesBuilder<CU, SU>> consumer
+    ) {
+        consumer.accept(new RangesBuilder<>(min));
+        return this;
+    }
+
+    public <CU extends ClientboundPacketType, SU extends ServerboundPacketType, R> RegistrationBuilder ranges(
+        final Function<RegistrationContext<CU, SU>, R> adapter, final ProtocolVersion min,
+        final Consumer<TypedRangesBuilder<CU, SU, R>> consumer
+    ) {
+        consumer.accept(new TypedRangesBuilder<>(adapter, min));
+        return this;
+    }
+
+    public void register() {
+        registrations.register(versionType, groups);
+    }
+
+    private void checkVersionType(final ProtocolVersion version) {
+        if (versionType == null) {
+            versionType = version.getVersionType();
+        } else if (versionType != version.getVersionType()) {
+            throw new IllegalArgumentException("Cannot mix different version types in the same registration builder");
+        }
+    }
+
+    public class RangesBuilder<CU extends ClientboundPacketType, SU extends ServerboundPacketType> {
+        private ProtocolVersion currentMin;
+        private boolean completed;
+
+        private RangesBuilder(final ProtocolVersion min) {
+            this.currentMin = min;
+        }
+
+        public RangesBuilder<CU, SU> to(final ProtocolVersion max, final RegistrationAction<CU, SU> action) {
+            Preconditions.checkState(!completed, "Range chain already completed");
+            RegistrationBuilder.this.range(currentMin, max, action);
+            currentMin = max;
+            return this;
+        }
+
+        public RegistrationBuilder since(final RegistrationAction<CU, SU> action) {
+            Preconditions.checkState(!completed, "Range chain already completed");
+            completed = true;
+            return RegistrationBuilder.this.since(currentMin, action);
+        }
+    }
+
+    public final class TypedRangesBuilder<CU extends ClientboundPacketType, SU extends ServerboundPacketType, R> extends RangesBuilder<CU, SU> {
+        private final Function<RegistrationContext<CU, SU>, R> adapter;
+
+        private TypedRangesBuilder(final Function<RegistrationContext<CU, SU>, R> adapter, final ProtocolVersion min) {
+            super(min);
+            this.adapter = adapter;
+        }
+
+        public TypedRangesBuilder<CU, SU, R> to(final ProtocolVersion max, final TypedRegistrationAction<CU, SU, R> action) {
+            to(max, wrapAction(action));
+            return this;
+        }
+
+        public TypedRangesBuilder<CU, SU, R> since(final TypedRegistrationAction<CU, SU, R> action) {
+            since(wrapAction(action));
+            return this;
+        }
+
+        private RegistrationAction<CU, SU> wrapAction(final TypedRegistrationAction<CU, SU, R> action) {
+            return ctx -> {
+                final R rewriter = adapter.apply(ctx);
+                if (rewriter != null) {
+                    action.accept(ctx, rewriter);
+                }
+            };
+        }
+    }
+
+    @FunctionalInterface
+    public interface TypedRegistrationAction<CU extends ClientboundPacketType, SU extends ServerboundPacketType, R> {
+
+        void accept(RegistrationContext<CU, SU> ctx, R r);
+    }
+
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/RegistrationContext.java

@@ -0,0 +1,127 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration;
+
+import com.google.common.base.Preconditions;
+import com.viaversion.viaversion.api.protocol.AbstractProtocol;
+import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType;
+import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType;
+import com.viaversion.viaversion.api.protocol.remapper.PacketHandler;
+import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
+import java.util.function.Consumer;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+public record RegistrationContext<CU extends ClientboundPacketType, SU extends ServerboundPacketType>(
+    AbstractProtocol<CU, ?, ?, SU> protocol,
+    ProtocolVersion min,
+    @Nullable ProtocolVersion max
+) {
+
+    public <P extends AbstractProtocol<CU, ?, ?, SU>> P protocol(@SuppressWarnings("unused") final Class<P> protocolClass) {
+        //noinspection unchecked
+        return (P) protocol;
+    }
+
+    public <P extends AbstractProtocol<CU, ?, ?, SU>> P castProtocol() {
+        //noinspection unchecked
+        return (P) protocol;
+    }
+
+    public void clientbound(final ClientboundPacketType type, final Consumer<CU> action) {
+        action.accept(clientboundPacketType(type));
+    }
+
+    public void clientbound(final ClientboundPacketType type, final Consumer<CU> action, final PacketBound... markers) {
+        if (!shouldSkip(markers)) {
+            action.accept(clientboundPacketType(type));
+        }
+    }
+
+    public void clientboundHandler(final ClientboundPacketType type, final PacketHandler handler) {
+        protocol.registerClientbound(clientboundPacketType(type), handler);
+    }
+
+    public void clientboundHandler(final ClientboundPacketType type, final PacketHandler handler, final PacketBound... markers) {
+        if (!shouldSkip(markers)) {
+            protocol.registerClientbound(clientboundPacketType(type), handler);
+        }
+    }
+
+    public void serverbound(final ServerboundPacketType type, final Consumer<SU> action) {
+        action.accept(serverboundPacketType(type));
+    }
+
+    public void serverbound(final ServerboundPacketType type, final Consumer<SU> action, final PacketBound... markers) {
+        if (!shouldSkip(markers)) {
+            action.accept(serverboundPacketType(type));
+        }
+    }
+
+    public void serverboundHandler(final ServerboundPacketType type, final PacketHandler handler) {
+        protocol.registerServerbound(serverboundPacketType(type), handler);
+    }
+
+    public void serverboundHandler(final ServerboundPacketType type, final PacketHandler handler, final PacketBound... markers) {
+        if (!shouldSkip(markers)) {
+            protocol.registerServerbound(serverboundPacketType(type), handler);
+        }
+    }
+
+    private boolean shouldSkip(final PacketBound... markers) {
+        if (markers.length == 0) {
+            return false;
+        }
+
+        final ProtocolVersion serverVersion = protocol.getServerVersion();
+        final ProtocolVersion clientVersion = protocol.getClientVersion();
+        final ProtocolVersion lowerVersion = serverVersion.olderThan(clientVersion) ? serverVersion : clientVersion;
+        final ProtocolVersion higherVersion = serverVersion.newerThan(clientVersion) ? serverVersion : clientVersion;
+        for (final PacketBound marker : markers) {
+            switch (marker) {
+                case ADDED_AT_MIN -> {
+                    if (lowerVersion.olderThan(min)) {
+                        return true;
+                    }
+                }
+                case REMOVED_AT_MAX -> {
+                    Preconditions.checkArgument(max != null, "Cannot use REMOVED_AT_MAX in an open-ended range");
+                    if (higherVersion.newerThanOrEqualTo(max)) {
+                        return true;
+                    }
+                }
+            }
+        }
+        return false;
+    }
+
+    private SU serverboundPacketType(final ServerboundPacketType genericPacketType) {
+        final SU type = protocol.getPacketTypesProvider().unmappedServerboundType(genericPacketType.state(), genericPacketType.getName());
+        if (type == null) {
+            throw new IllegalArgumentException("Could not find serverbound packet type for " + genericPacketType.state() + " " + genericPacketType.getName());
+        }
+        return type;
+    }
+
+    private CU clientboundPacketType(final ClientboundPacketType genericPacketType) {
+        final CU type = protocol.getPacketTypesProvider().unmappedClientboundType(genericPacketType.state(), genericPacketType.getName());
+        if (type == null) {
+            throw new IllegalArgumentException("Could not find clientbound packet type for " + genericPacketType.state() + " " + genericPacketType.getName() + " in " + protocol.getClass().getSimpleName());
+        }
+        return type;
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/SharedRegistrations.java

@@ -0,0 +1,102 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration;
+
+import com.viaversion.viaversion.api.protocol.AbstractProtocol;
+import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType;
+import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType;
+import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
+import com.viaversion.viaversion.api.protocol.version.VersionType;
+import java.util.ArrayList;
+import java.util.Comparator;
+import java.util.EnumMap;
+import java.util.List;
+
+/**
+ * Central registry for shared packet registrations that are automatically applied
+ * to protocols based on their version range.
+ * <p>
+ * Registrations are done BEFORE registerPackets in {@link AbstractProtocol}.
+ */
+public final class SharedRegistrations {
+    private static final SharedRegistrations DEFAULT_REGISTRATIONS = new SharedRegistrations();
+
+    private final EnumMap<VersionType, List<VersionedTemplateGroup>> versionedTemplates = new EnumMap<>(VersionType.class);
+
+    /**
+     * Returns the default ViaVersion registration set.
+     */
+    public static SharedRegistrations defaultRegistrations() {
+        return DEFAULT_REGISTRATIONS;
+    }
+
+    /**
+     * Creates an independent shared registration set that external projects can populate and apply.
+     */
+    public static SharedRegistrations create() {
+        return new SharedRegistrations();
+    }
+
+    public RegistrationBuilder registrations() {
+        return new RegistrationBuilder(this);
+    }
+
+    /**
+     * Applies all shared registrations whose version range matches the given protocol.
+     *
+     * @param protocol the protocol to apply shared registrations to
+     */
+    public void applyMatching(final AbstractProtocol<?, ?, ?, ?> protocol) {
+        if (protocol.isBaseProtocol()) {
+            return;
+        }
+
+        final ProtocolVersion version = protocol.getServerVersion();
+        final List<VersionedTemplateGroup> groups = versionedTemplates.get(version.getVersionType());
+        if (groups == null) {
+            return;
+        }
+
+        for (final VersionedTemplateGroup group : groups) {
+            if (group.min().newerThan(version)) { // TODO binary search?
+                // Sorted by the minimum, so we can stop early if we're out
+                break;
+            }
+
+            if (group.max() != null && version.newerThanOrEqualTo(group.max())) {
+                continue;
+            }
+
+            final RegistrationContext<?, ?> context = new RegistrationContext<>(protocol, group.min(), group.max());
+            //noinspection unchecked,rawtypes
+            ((RegistrationAction) group.action()).accept(context);
+        }
+    }
+
+    @FunctionalInterface
+    public interface RegistrationAction<CU extends ClientboundPacketType, SU extends ServerboundPacketType> {
+
+        void accept(RegistrationContext<CU, SU> context);
+    }
+
+    void register(final VersionType versionType, final List<VersionedTemplateGroup> toAdd) {
+        final List<VersionedTemplateGroup> groups = versionedTemplates.computeIfAbsent(versionType, $ -> new ArrayList<>());
+        groups.addAll(toAdd);
+        groups.sort(Comparator.comparing(VersionedTemplateGroup::min, Comparator.nullsFirst(Comparator.naturalOrder())));
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/VersionedTemplateGroup.java

@@ -0,0 +1,32 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration;
+
+import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
+import com.viaversion.viaversion.protocol.shared_registration.SharedRegistrations.RegistrationAction;
+
+record VersionedTemplateGroup(
+    RegistrationAction<?, ?> action,
+    ProtocolVersion min,
+    ProtocolVersion max
+) {
+
+    public boolean contains(final ProtocolVersion version) {
+        return version.newerThanOrEqualTo(min) && (max == null || version.olderThan(max));
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/def/BlockRegistrations.java

@@ -0,0 +1,95 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration.def;
+
+import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType;
+import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType;
+import com.viaversion.viaversion.protocol.shared_registration.PacketBound;
+import com.viaversion.viaversion.protocol.shared_registration.RegistrationContext;
+import com.viaversion.viaversion.protocols.v1_12_2to1_13.packet.ClientboundPackets1_13;
+import com.viaversion.viaversion.protocols.v1_14_3to1_14_4.packet.ClientboundPackets1_14_4;
+import com.viaversion.viaversion.protocols.v1_16_1to1_16_2.packet.ClientboundPackets1_16_2;
+import com.viaversion.viaversion.protocols.v1_17_1to1_18.packet.ClientboundPackets1_18;
+import com.viaversion.viaversion.protocols.v1_18_2to1_19.packet.ClientboundPackets1_19;
+import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ClientboundPackets1_19_4;
+import com.viaversion.viaversion.protocols.v1_20_5to1_21.packet.ClientboundPackets1_21;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+final class BlockRegistrations {
+
+    static <CU extends ClientboundPacketType> void registerBlockPackets1_13(final RegistrationContext<CU, ?> ctx, final BlockRewriter<CU> br) {
+        common1_13(ctx, br);
+        ctx.clientbound(ClientboundPackets1_13.CHUNK_BLOCKS_UPDATE, br::registerChunkBlocksUpdate);
+    }
+
+    private static <CU extends ClientboundPacketType> void common1_13(RegistrationContext<CU, ?> ctx, BlockRewriter<CU> br) {
+        ctx.clientbound(ClientboundPackets1_13.BLOCK_EVENT, br::registerBlockEvent);
+        ctx.clientbound(ClientboundPackets1_13.BLOCK_UPDATE, br::registerBlockUpdate);
+        ctx.clientbound(ClientboundPackets1_13.LEVEL_EVENT, br::registerLevelEvent1_13);
+    }
+
+    static <CU extends ClientboundPacketType> void registerBlockPackets1_14_4(final RegistrationContext<CU, ?> ctx, final BlockRewriter<CU> br) {
+        common1_13(ctx, br);
+        ctx.clientbound(ClientboundPackets1_14_4.CHUNK_BLOCKS_UPDATE, br::registerChunkBlocksUpdate, PacketBound.REMOVED_AT_MAX);
+        ctx.clientbound(ClientboundPackets1_14_4.BLOCK_BREAK_ACK, br::registerBlockBreakAck, PacketBound.ADDED_AT_MIN);
+    }
+
+    static <CU extends ClientboundPacketType> void registerBlockPackets1_16_2(final RegistrationContext<CU, ?> ctx, final BlockRewriter<CU> br) {
+        common1_13(ctx, br);
+        ctx.clientbound(ClientboundPackets1_16_2.BLOCK_BREAK_ACK, br::registerBlockBreakAck);
+        ctx.clientbound(ClientboundPackets1_16_2.SECTION_BLOCKS_UPDATE, br::registerSectionBlocksUpdate, PacketBound.ADDED_AT_MIN);
+    }
+
+    static <CU extends ClientboundPacketType> void registerBlockPackets1_18(final RegistrationContext<CU, ?> ctx, final BlockRewriter<CU> br) {
+        common1_13(ctx, br);
+        ctx.clientbound(ClientboundPackets1_18.BLOCK_BREAK_ACK, br::registerBlockBreakAck, PacketBound.REMOVED_AT_MAX);
+        ctx.clientbound(ClientboundPackets1_18.LEVEL_CHUNK_WITH_LIGHT, br::registerLevelChunk1_18, PacketBound.ADDED_AT_MIN);
+        ctx.clientbound(ClientboundPackets1_18.SECTION_BLOCKS_UPDATE, br::registerSectionBlocksUpdate);
+        ctx.clientbound(ClientboundPackets1_18.BLOCK_ENTITY_DATA, br::registerBlockEntityData1_18);
+    }
+
+    static <CU extends ClientboundPacketType> void registerBlockPackets1_19(final RegistrationContext<CU, ?> ctx, final BlockRewriter<CU> br) {
+        common1_19(ctx, br);
+        ctx.clientbound(ClientboundPackets1_19.LEVEL_EVENT, br::registerLevelEvent1_13);
+        ctx.clientbound(ClientboundPackets1_19.SECTION_BLOCKS_UPDATE, br::registerSectionBlocksUpdate);
+    }
+
+    private static <CU extends ClientboundPacketType> void common1_19(RegistrationContext<CU, ?> ctx, BlockRewriter<CU> br) {
+        ctx.clientbound(ClientboundPackets1_19.BLOCK_EVENT, br::registerBlockEvent);
+        ctx.clientbound(ClientboundPackets1_19.BLOCK_UPDATE, br::registerBlockUpdate);
+        ctx.clientbound(ClientboundPackets1_19.LEVEL_CHUNK_WITH_LIGHT, br::registerLevelChunk1_18);
+        ctx.clientbound(ClientboundPackets1_19.BLOCK_ENTITY_DATA, br::registerBlockEntityData1_18);
+    }
+
+    static <CU extends ClientboundPacketType> void registerBlockPackets1_20(final RegistrationContext<CU, ?> ctx, final BlockRewriter<CU> br) {
+        common1_19(ctx, br);
+        ctx.clientbound(ClientboundPackets1_19_4.LEVEL_EVENT, br::registerLevelEvent1_13);
+        ctx.clientbound(ClientboundPackets1_19_4.SECTION_BLOCKS_UPDATE, br::registerSectionBlocksUpdate1_20);
+    }
+
+    static <CU extends ClientboundPacketType> void registerBlockPackets1_21(final RegistrationContext<CU, ?> ctx, final BlockRewriter<CU> br) {
+        common1_19(ctx, br);
+        ctx.clientbound(ClientboundPackets1_21.LEVEL_EVENT, br::registerLevelEvent1_21);
+        ctx.clientbound(ClientboundPackets1_21.SECTION_BLOCKS_UPDATE, br::registerSectionBlocksUpdate1_20);
+    }
+
+    static @Nullable <CU extends ClientboundPacketType, SU extends ServerboundPacketType> BlockRewriter<CU> block(final RegistrationContext<CU, SU> ctx) {
+        return ctx.protocol().getBlockRewriter();
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/def/DefaultRegistrations.java

@@ -0,0 +1,111 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration.def;
+
+import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
+import com.viaversion.viaversion.protocol.shared_registration.SharedRegistrations;
+
+public final class DefaultRegistrations {
+
+    public static void apply() {
+        SharedRegistrations.defaultRegistrations().registrations()
+            .ranges(EntityRegistrations::entity, ProtocolVersion.v1_13, b -> b
+                .to(ProtocolVersion.v1_14_4, EntityRegistrations::registerEntityPackets1_13)
+                .to(ProtocolVersion.v1_16_2, EntityRegistrations::registerEntityPackets1_14_4)
+                .to(ProtocolVersion.v1_17_1, EntityRegistrations::registerEntityPackets1_16_2)
+                .to(ProtocolVersion.v1_19, EntityRegistrations::registerEntityPackets1_17_1)
+                .to(ProtocolVersion.v1_20_5, EntityRegistrations::registerEntityPackets1_19)
+                .to(ProtocolVersion.v1_21_4, EntityRegistrations::registerEntityPackets1_20_5)
+                .to(ProtocolVersion.v1_21_9, EntityRegistrations::registerEntityPackets1_21_4)
+                .since(EntityRegistrations::registerEntityPackets1_21_9)
+            )
+
+            .ranges(ItemRegistrations::item, ProtocolVersion.v1_13, b -> b
+                .to(ProtocolVersion.v1_14, ItemRegistrations::registerItemPackets1_13)
+                .to(ProtocolVersion.v1_14_4, ItemRegistrations::registerItemPackets1_14)
+                .to(ProtocolVersion.v1_16, ItemRegistrations::registerItemPackets1_14_4)
+                .to(ProtocolVersion.v1_17_1, ItemRegistrations::registerItemPackets1_16)
+                .to(ProtocolVersion.v1_19_1, ItemRegistrations::registerItemPackets1_17_1)
+                .to(ProtocolVersion.v1_20_3, ItemRegistrations::registerItemPackets1_19_1)
+                .to(ProtocolVersion.v1_20_5, ItemRegistrations::registerItemPackets1_20_3)
+                .to(ProtocolVersion.v1_21, ItemRegistrations::registerItemPackets1_20_5)
+                .to(ProtocolVersion.v1_21_2, ItemRegistrations::registerItemPackets1_21)
+                .to(ProtocolVersion.v1_21_5, ItemRegistrations::registerItemPackets1_21_2)
+            )
+            .ranges(ItemRegistrations::structuredItem, ProtocolVersion.v1_21_5, b -> b
+                .to(ProtocolVersion.v1_21_6, ItemRegistrations::registerItemPackets1_21_5)
+                .since(ItemRegistrations::registerItemPackets1_21_6)
+            )
+
+            .ranges(BlockRegistrations::block, ProtocolVersion.v1_13, steps -> steps
+                .to(ProtocolVersion.v1_14_4, BlockRegistrations::registerBlockPackets1_13)
+                .to(ProtocolVersion.v1_16_2, BlockRegistrations::registerBlockPackets1_14_4)
+                .to(ProtocolVersion.v1_18, BlockRegistrations::registerBlockPackets1_16_2)
+                .to(ProtocolVersion.v1_19, BlockRegistrations::registerBlockPackets1_18)
+                .to(ProtocolVersion.v1_20, BlockRegistrations::registerBlockPackets1_19)
+                .to(ProtocolVersion.v1_21, BlockRegistrations::registerBlockPackets1_20)
+                .since(BlockRegistrations::registerBlockPackets1_21)
+            )
+
+            .ranges(ParticleRegistrations::particle, ProtocolVersion.v1_13, steps -> steps
+                .to(ProtocolVersion.v1_15_2, ParticleRegistrations::registerParticlePackets1_13)
+                .to(ProtocolVersion.v1_19, ParticleRegistrations::registerParticlePackets1_15_2)
+                .to(ProtocolVersion.v1_20, ParticleRegistrations::registerParticlePackets1_19)
+                .to(ProtocolVersion.v1_20_5, ParticleRegistrations::registerParticlePackets1_20)
+                .to(ProtocolVersion.v1_21_2, ParticleRegistrations::registerParticlePackets1_20_5)
+                .to(ProtocolVersion.v1_21_4, ParticleRegistrations::registerParticlePackets1_21_2)
+                .to(ProtocolVersion.v1_21_9, ParticleRegistrations::registerParticlePackets1_21_4)
+                .since(ParticleRegistrations::registerParticlePackets1_21_9)
+            )
+
+            .ranges(TextComponentRegistrations::text, ProtocolVersion.v1_12_2, b -> b
+                .to(ProtocolVersion.v1_14, TextComponentRegistrations::registerComponents1_12_2)
+                .to(ProtocolVersion.v1_16_2, TextComponentRegistrations::registerComponents1_14)
+                .to(ProtocolVersion.v1_17, TextComponentRegistrations::registerComponents1_16_2)
+                .to(ProtocolVersion.v1_19, TextComponentRegistrations::registerComponents1_17)
+                .to(ProtocolVersion.v1_20_3, TextComponentRegistrations::registerComponents1_19)
+                .to(ProtocolVersion.v1_20_5, TextComponentRegistrations::registerComponents1_20_3)
+                .to(ProtocolVersion.v1_21, TextComponentRegistrations::registerComponents1_20_5)
+                .to(ProtocolVersion.v1_21_2, TextComponentRegistrations::registerComponents1_21)
+                .to(ProtocolVersion.v1_21_4, TextComponentRegistrations::registerComponents1_21_2)
+                .to(ProtocolVersion.v1_21_5, TextComponentRegistrations::registerComponents1_21_4)
+            )
+            .ranges(TextComponentRegistrations::nbtText, ProtocolVersion.v1_21_5, b -> b
+                .since(TextComponentRegistrations::registerComponents1_21_5)
+            )
+
+            .ranges(ProtocolVersion.v1_17_1, sbeps -> sbeps
+                .to(ProtocolVersion.v1_20_2, RegistryRegistrations::registerTags1_17_1)
+                .since(RegistryRegistrations::registerTags1_20_2)
+            )
+
+            .ranges(ProtocolVersion.v1_10, b -> b
+                .to(ProtocolVersion.v1_14, RegistryRegistrations::registerSounds1_10)
+                .to(ProtocolVersion.v1_19_3, RegistryRegistrations::registerSounds1_14)
+                .since(RegistryRegistrations::registerSounds1_19_3)
+            )
+
+            .since(ProtocolVersion.v1_13, RegistryRegistrations::registerStatistics1_13)
+            .since(ProtocolVersion.v1_19, RegistryRegistrations::registerCommands1_19)
+            .since(ProtocolVersion.v1_21, RegistryRegistrations::registerRegistryData1_21)
+            .since(ProtocolVersion.v1_21, RegistryRegistrations::registerAttributes1_21)
+            .since(ProtocolVersion.v1_21_2, RegistryRegistrations::registerRecipePackets1_21_2)
+
+            .register();
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/def/EntityRegistrations.java

@@ -0,0 +1,96 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration.def;
+
+import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType;
+import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType;
+import com.viaversion.viaversion.protocol.shared_registration.PacketBound;
+import com.viaversion.viaversion.protocol.shared_registration.RegistrationContext;
+import com.viaversion.viaversion.protocols.v1_12_2to1_13.packet.ClientboundPackets1_13;
+import com.viaversion.viaversion.protocols.v1_14_3to1_14_4.packet.ClientboundPackets1_14_4;
+import com.viaversion.viaversion.protocols.v1_18_2to1_19.packet.ClientboundPackets1_19;
+import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ClientboundPackets1_20_5;
+import com.viaversion.viaversion.protocols.v1_21_7to1_21_9.packet.ClientboundPackets1_21_9;
+import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPackets1_21_2;
+import com.viaversion.viaversion.protocols.v1_8to1_9.packet.ClientboundPackets1_9;
+import com.viaversion.viaversion.rewriter.EntityRewriter;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+final class EntityRegistrations {
+
+    static <CU extends ClientboundPacketType> void registerEntityPackets1_13(final RegistrationContext<CU, ?> ctx, final EntityRewriter<CU, ?> er) {
+        ctx.clientbound(ClientboundPackets1_13.REMOVE_ENTITIES, er::registerRemoveEntities);
+    }
+
+    static <CU extends ClientboundPacketType> void registerEntityPackets1_14_4(final RegistrationContext<CU, ?> ctx, final EntityRewriter<CU, ?> er) {
+        ctx.clientbound(ClientboundPackets1_14_4.REMOVE_ENTITIES, er::registerRemoveEntities);
+        ctx.clientbound(ClientboundPackets1_14_4.ADD_ENTITY, er::registerTrackerWithData);
+        ctx.clientbound(ClientboundPackets1_14_4.ADD_MOB, er::registerTracker);
+    }
+
+    static <CU extends ClientboundPacketType> void registerEntityPackets1_16_2(final RegistrationContext<CU, ?> ctx, final EntityRewriter<CU, ?> er) {
+        // remove_entities got temporarily changed to only take a single entity...
+        ctx.clientbound(ClientboundPackets1_14_4.ADD_ENTITY, er::registerTrackerWithData);
+        ctx.clientbound(ClientboundPackets1_14_4.ADD_MOB, er::registerTracker);
+    }
+
+    static <CU extends ClientboundPacketType> void registerEntityPackets1_17_1(final RegistrationContext<CU, ?> ctx, final EntityRewriter<CU, ?> er) {
+        ctx.clientbound(ClientboundPackets1_14_4.REMOVE_ENTITIES, er::registerRemoveEntities);
+        ctx.clientbound(ClientboundPackets1_14_4.ADD_ENTITY, er::registerTrackerWithData);
+        ctx.clientbound(ClientboundPackets1_14_4.ADD_MOB, er::registerTracker, PacketBound.REMOVED_AT_MAX);
+    }
+
+    static <CU extends ClientboundPacketType> void registerEntityPackets1_19(final RegistrationContext<CU, ?> ctx, final EntityRewriter<CU, ?> er) {
+        ctx.clientbound(ClientboundPackets1_9.REMOVE_ENTITIES, er::registerRemoveEntities);
+        ctx.clientbound(ClientboundPackets1_19.ADD_ENTITY, er::registerTrackerWithData1_19);
+    }
+
+    static <CU extends ClientboundPacketType> void registerEntityPackets1_20_5(final RegistrationContext<CU, ?> ctx, final EntityRewriter<CU, ?> er) {
+        common1_20_5(ctx, er);
+        ctx.clientbound(ClientboundPackets1_19.ADD_ENTITY, er::registerTrackerWithData1_19);
+    }
+
+    static <CU extends ClientboundPacketType> void registerEntityPackets1_21_4(final RegistrationContext<CU, ?> ctx, final EntityRewriter<CU, ?> er) {
+        common1_20_5(ctx, er);
+        registerGameModeTrackers1_21_4(ctx, er);
+        ctx.clientbound(ClientboundPackets1_21_2.ADD_ENTITY, er::registerTrackerWithData1_19);
+    }
+
+    static <CU extends ClientboundPacketType> void registerEntityPackets1_21_9(final RegistrationContext<CU, ?> ctx, final EntityRewriter<CU, ?> er) {
+        common1_20_5(ctx, er);
+        registerGameModeTrackers1_21_4(ctx, er);
+        ctx.clientbound(ClientboundPackets1_21_9.ADD_ENTITY, er::registerTrackerWithData1_21_9);
+    }
+
+    private static <CU extends ClientboundPacketType> void common1_20_5(final RegistrationContext<CU, ?> ctx, final EntityRewriter<CU, ?> er) {
+        ctx.clientbound(ClientboundPackets1_20_5.SET_ENTITY_DATA, er::registerSetEntityData);
+        ctx.clientbound(ClientboundPackets1_20_5.REMOVE_ENTITIES, er::registerRemoveEntities);
+        ctx.clientbound(ClientboundPackets1_20_5.LOGIN, er::registerLogin1_20_5);
+        ctx.clientbound(ClientboundPackets1_20_5.RESPAWN, er::registerRespawn1_20_5);
+    }
+
+    private static <CU extends ClientboundPacketType> void registerGameModeTrackers1_21_4(final RegistrationContext<CU, ?> ctx, final EntityRewriter<CU, ?> er) {
+        ctx.clientbound(ClientboundPackets1_21_2.GAME_EVENT, er::registerGameEvent);
+        ctx.clientbound(ClientboundPackets1_21_2.PLAYER_ABILITIES, er::registerPlayerAbilities);
+    }
+
+
+    static @Nullable <CU extends ClientboundPacketType, SU extends ServerboundPacketType> EntityRewriter<CU, ?> entity(final RegistrationContext<CU, SU> ctx) {
+        return ctx.protocol().getEntityRewriter();
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/def/ItemRegistrations.java

@@ -0,0 +1,185 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration.def;
+
+import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType;
+import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType;
+import com.viaversion.viaversion.protocol.shared_registration.PacketBound;
+import com.viaversion.viaversion.protocol.shared_registration.RegistrationContext;
+import com.viaversion.viaversion.protocols.v1_12_2to1_13.packet.ClientboundPackets1_13;
+import com.viaversion.viaversion.protocols.v1_12_2to1_13.packet.ServerboundPackets1_13;
+import com.viaversion.viaversion.protocols.v1_13_2to1_14.packet.ClientboundPackets1_14;
+import com.viaversion.viaversion.protocols.v1_14_3to1_14_4.packet.ClientboundPackets1_14_4;
+import com.viaversion.viaversion.protocols.v1_15_2to1_16.packet.ClientboundPackets1_16;
+import com.viaversion.viaversion.protocols.v1_16_4to1_17.packet.ServerboundPackets1_17;
+import com.viaversion.viaversion.protocols.v1_17to1_17_1.packet.ClientboundPackets1_17_1;
+import com.viaversion.viaversion.protocols.v1_19_1to1_19_3.packet.ServerboundPackets1_19_3;
+import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ClientboundPackets1_19_4;
+import com.viaversion.viaversion.protocols.v1_19to1_19_1.packet.ClientboundPackets1_19_1;
+import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ClientboundPackets1_20_3;
+import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ServerboundPackets1_20_3;
+import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ClientboundPackets1_20_5;
+import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ServerboundPackets1_20_5;
+import com.viaversion.viaversion.protocols.v1_20_5to1_21.packet.ClientboundPackets1_21;
+import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ClientboundPackets1_20_2;
+import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ServerboundPackets1_20_2;
+import com.viaversion.viaversion.protocols.v1_21_4to1_21_5.packet.ClientboundPackets1_21_5;
+import com.viaversion.viaversion.protocols.v1_21_4to1_21_5.packet.ServerboundPackets1_21_5;
+import com.viaversion.viaversion.protocols.v1_21_5to1_21_6.packet.ClientboundConfigurationPackets1_21_6;
+import com.viaversion.viaversion.protocols.v1_21_5to1_21_6.packet.ClientboundPackets1_21_6;
+import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPackets1_21_2;
+import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ServerboundPackets1_21_2;
+import com.viaversion.viaversion.rewriter.ItemRewriter;
+import com.viaversion.viaversion.rewriter.StructuredItemRewriter;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+final class ItemRegistrations {
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_13(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        common1_13(ctx, ir);
+        ctx.clientbound(ClientboundPackets1_13.SET_EQUIPPED_ITEM, ir::registerSetEquippedItem);
+    }
+
+    private static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void common1_13(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        ctx.clientbound(ClientboundPackets1_13.CONTAINER_SET_DATA, ir::registerContainerSetData);
+        ctx.clientbound(ClientboundPackets1_13.CONTAINER_SET_SLOT, ir::registerSetSlot);
+        ctx.clientbound(ClientboundPackets1_13.CONTAINER_SET_CONTENT, ir::registerSetContent);
+        ctx.clientbound(ClientboundPackets1_13.UPDATE_ADVANCEMENTS, ir::registerAdvancements);
+        ctx.clientbound(ClientboundPackets1_13.COOLDOWN, ir::registerCooldown);
+        ctx.serverbound(ServerboundPackets1_13.CONTAINER_CLICK, ir::registerContainerClick);
+        ctx.serverbound(ServerboundPackets1_13.SET_CREATIVE_MODE_SLOT, ir::registerSetCreativeModeSlot);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_14(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        common1_13(ctx, ir);
+        ctx.clientbound(ClientboundPackets1_14.SET_EQUIPPED_ITEM, ir::registerSetEquippedItem);
+        ctx.clientbound(ClientboundPackets1_14.OPEN_SCREEN, ir::registerOpenScreen);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_14_4(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        common1_13(ctx, ir);
+        ctx.clientbound(ClientboundPackets1_14_4.SET_EQUIPPED_ITEM, ir::registerSetEquippedItem, PacketBound.REMOVED_AT_MAX);
+        ctx.clientbound(ClientboundPackets1_14_4.OPEN_SCREEN, ir::registerOpenScreen);
+        ctx.clientbound(ClientboundPackets1_14_4.MERCHANT_OFFERS, ir::registerMerchantOffers1_14_4);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_16(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        common1_13(ctx, ir);
+        ctx.clientbound(ClientboundPackets1_16.SET_EQUIPMENT, ir::registerSetEquipment, PacketBound.ADDED_AT_MIN);
+        ctx.clientbound(ClientboundPackets1_16.OPEN_SCREEN, ir::registerOpenScreen);
+        ctx.clientbound(ClientboundPackets1_16.MERCHANT_OFFERS, ir::registerMerchantOffers1_14_4);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_17_1(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        ctx.clientbound(ClientboundPackets1_17_1.CONTAINER_SET_DATA, ir::registerContainerSetData);
+        ctx.clientbound(ClientboundPackets1_17_1.CONTAINER_SET_SLOT, ir::registerSetSlot1_17_1);
+        ctx.clientbound(ClientboundPackets1_17_1.CONTAINER_SET_CONTENT, ir::registerSetContent1_17_1);
+        ctx.clientbound(ClientboundPackets1_17_1.UPDATE_ADVANCEMENTS, ir::registerAdvancements);
+        ctx.clientbound(ClientboundPackets1_17_1.COOLDOWN, ir::registerCooldown);
+        ctx.serverbound(ServerboundPackets1_17.CONTAINER_CLICK, ir::registerContainerClick1_17_1);
+        ctx.serverbound(ServerboundPackets1_17.SET_CREATIVE_MODE_SLOT, ir::registerSetCreativeModeSlot);
+        ctx.clientbound(ClientboundPackets1_17_1.SET_EQUIPMENT, ir::registerSetEquipment);
+        ctx.clientbound(ClientboundPackets1_17_1.OPEN_SCREEN, ir::registerOpenScreen);
+        ctx.clientbound(ClientboundPackets1_17_1.MERCHANT_OFFERS, ir::registerMerchantOffers1_14_4);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_19_1(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        ctx.clientbound(ClientboundPackets1_19_1.CONTAINER_SET_DATA, ir::registerContainerSetData);
+        ctx.clientbound(ClientboundPackets1_19_1.CONTAINER_SET_SLOT, ir::registerSetSlot1_17_1);
+        ctx.clientbound(ClientboundPackets1_19_1.CONTAINER_SET_CONTENT, ir::registerSetContent1_17_1);
+        ctx.clientbound(ClientboundPackets1_19_1.UPDATE_ADVANCEMENTS, ir::registerAdvancements);
+        ctx.clientbound(ClientboundPackets1_19_1.COOLDOWN, ir::registerCooldown);
+        ctx.serverbound(ServerboundPackets1_19_3.CONTAINER_CLICK, ir::registerContainerClick1_17_1);
+        ctx.serverbound(ServerboundPackets1_19_3.SET_CREATIVE_MODE_SLOT, ir::registerSetCreativeModeSlot);
+        ctx.clientbound(ClientboundPackets1_19_1.SET_EQUIPMENT, ir::registerSetEquipment);
+        ctx.clientbound(ClientboundPackets1_19_1.OPEN_SCREEN, ir::registerOpenScreen);
+        ctx.clientbound(ClientboundPackets1_19_1.MERCHANT_OFFERS, ir::registerMerchantOffers1_19);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_20_3(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        ctx.clientbound(ClientboundPackets1_20_3.CONTAINER_SET_DATA, ir::registerContainerSetData);
+        ctx.clientbound(ClientboundPackets1_20_3.CONTAINER_SET_SLOT, ir::registerSetSlot1_17_1);
+        ctx.clientbound(ClientboundPackets1_20_3.CONTAINER_SET_CONTENT, ir::registerSetContent1_17_1);
+        ctx.clientbound(ClientboundPackets1_20_5.UPDATE_ADVANCEMENTS, ir::registerAdvancements1_20_3);
+        ctx.clientbound(ClientboundPackets1_20_3.COOLDOWN, ir::registerCooldown);
+        ctx.serverbound(ServerboundPackets1_20_3.CONTAINER_CLICK, ir::registerContainerClick1_17_1);
+        ctx.serverbound(ServerboundPackets1_20_2.SET_CREATIVE_MODE_SLOT, ir::registerSetCreativeModeSlot);
+        ctx.clientbound(ClientboundPackets1_20_5.SET_EQUIPMENT, ir::registerSetEquipment);
+        ctx.clientbound(ClientboundPackets1_19_4.OPEN_SCREEN, ir::registerOpenScreen);
+        ctx.clientbound(ClientboundPackets1_20_2.MERCHANT_OFFERS, ir::registerMerchantOffers1_19);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_20_5(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        ctx.clientbound(ClientboundPackets1_20_3.CONTAINER_SET_DATA, ir::registerContainerSetData);
+        registerItemPackets1_21(ctx, ir);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_21(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        ctx.clientbound(ClientboundPackets1_21.CONTAINER_SET_SLOT, ir::registerSetSlot1_17_1);
+        ctx.clientbound(ClientboundPackets1_21.CONTAINER_SET_CONTENT, ir::registerSetContent1_17_1);
+        ctx.clientbound(ClientboundPackets1_21.UPDATE_ADVANCEMENTS, ir::registerAdvancements1_20_3);
+        ctx.clientbound(ClientboundPackets1_21.COOLDOWN, ir::registerCooldown);
+        ctx.serverbound(ServerboundPackets1_20_5.CONTAINER_CLICK, ir::registerContainerClick1_17_1);
+        ctx.serverbound(ServerboundPackets1_20_5.SET_CREATIVE_MODE_SLOT, ir::registerSetCreativeModeSlot);
+        ctx.clientbound(ClientboundPackets1_21.SET_EQUIPMENT, ir::registerSetEquipment);
+        ctx.clientbound(ClientboundPackets1_21.OPEN_SCREEN, ir::registerOpenScreen);
+        ctx.clientbound(ClientboundPackets1_21.MERCHANT_OFFERS, ir::registerMerchantOffers1_20_5);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_21_2(final RegistrationContext<CU, SU> ctx, final ItemRewriter<CU, SU, ?> ir) {
+        ctx.clientbound(ClientboundPackets1_21_2.CONTAINER_SET_SLOT, ir::registerSetSlot1_21_2);
+        ctx.clientbound(ClientboundPackets1_21_2.CONTAINER_SET_CONTENT, ir::registerSetContent1_21_2);
+        ctx.clientbound(ClientboundPackets1_21_2.UPDATE_ADVANCEMENTS, ir::registerAdvancements1_20_3);
+        ctx.clientbound(ClientboundPackets1_21_2.COOLDOWN, ir::registerCooldown1_21_2);
+        ctx.serverbound(ServerboundPackets1_21_2.CONTAINER_CLICK, ir::registerContainerClick1_21_2);
+        ctx.serverbound(ServerboundPackets1_21_2.SET_CREATIVE_MODE_SLOT, ir::registerSetCreativeModeSlot);
+        ctx.clientbound(ClientboundPackets1_21_2.SET_EQUIPMENT, ir::registerSetEquipment);
+        ctx.clientbound(ClientboundPackets1_21_2.OPEN_SCREEN, ir::registerOpenScreen);
+        ctx.clientbound(ClientboundPackets1_21_2.MERCHANT_OFFERS, ir::registerMerchantOffers1_20_5);
+        ctx.clientbound(ClientboundPackets1_21_2.SET_PLAYER_INVENTORY, ir::registerSetPlayerInventory, PacketBound.ADDED_AT_MIN);
+        ctx.clientbound(ClientboundPackets1_21_2.SET_CURSOR_ITEM, ir::registerSetCursorItem, PacketBound.ADDED_AT_MIN);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_21_5(final RegistrationContext<CU, SU> ctx, final StructuredItemRewriter<CU, SU, ?> ir) {
+        ctx.clientbound(ClientboundPackets1_21_5.CONTAINER_SET_SLOT, ir::registerSetSlot1_21_2);
+        ctx.clientbound(ClientboundPackets1_21_5.CONTAINER_SET_CONTENT, ir::registerSetContent1_21_2);
+        ctx.clientbound(ClientboundPackets1_21_5.UPDATE_ADVANCEMENTS, ir::registerAdvancements1_20_3);
+        ctx.clientbound(ClientboundPackets1_21_5.COOLDOWN, ir::registerCooldown1_21_2);
+        ctx.serverbound(ServerboundPackets1_21_5.CONTAINER_CLICK, ir::registerContainerClick1_21_5);
+        ctx.serverbound(ServerboundPackets1_21_5.SET_CREATIVE_MODE_SLOT, ir::registerSetCreativeModeSlot1_21_5);
+        ctx.clientbound(ClientboundPackets1_21_5.SET_EQUIPMENT, ir::registerSetEquipment);
+        ctx.clientbound(ClientboundPackets1_21_5.OPEN_SCREEN, ir::registerOpenScreen);
+        ctx.clientbound(ClientboundPackets1_21_5.MERCHANT_OFFERS, ir::registerMerchantOffers1_20_5);
+        ctx.clientbound(ClientboundPackets1_21_5.SET_PLAYER_INVENTORY, ir::registerSetPlayerInventory);
+        ctx.clientbound(ClientboundPackets1_21_5.SET_CURSOR_ITEM, ir::registerSetCursorItem);
+    }
+
+    static <CU extends ClientboundPacketType, SU extends ServerboundPacketType> void registerItemPackets1_21_6(final RegistrationContext<CU, SU> ctx, final StructuredItemRewriter<CU, SU, ?> ir) {
+        registerItemPackets1_21_5(ctx, ir);
+        ctx.clientbound(ClientboundPackets1_21_6.SHOW_DIALOG, ir::registerShowDialog, PacketBound.ADDED_AT_MIN);
+        ctx.clientbound(ClientboundConfigurationPackets1_21_6.SHOW_DIALOG, ir::registerShowDialogDirect, PacketBound.ADDED_AT_MIN);
+    }
+
+    static @Nullable <CU extends ClientboundPacketType, SU extends ServerboundPacketType> ItemRewriter<CU, SU, ?> item(final RegistrationContext<CU, SU> ctx) {
+        return ctx.protocol().getItemRewriter();
+    }
+
+    static @Nullable <CU extends ClientboundPacketType, SU extends ServerboundPacketType> StructuredItemRewriter<CU, SU, ?> structuredItem(final RegistrationContext<CU, SU> ctx) {
+        return (StructuredItemRewriter<CU, SU, ?>) ctx.protocol().getItemRewriter();
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/def/ParticleRegistrations.java

@@ -0,0 +1,74 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration.def;
+
+import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType;
+import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType;
+import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.protocol.shared_registration.RegistrationContext;
+import com.viaversion.viaversion.protocols.v1_12_2to1_13.packet.ClientboundPackets1_13;
+import com.viaversion.viaversion.protocols.v1_14_4to1_15.packet.ClientboundPackets1_15;
+import com.viaversion.viaversion.protocols.v1_18_2to1_19.packet.ClientboundPackets1_19;
+import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ClientboundPackets1_20_5;
+import com.viaversion.viaversion.protocols.v1_21_7to1_21_9.packet.ClientboundPackets1_21_9;
+import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPackets1_21_2;
+import com.viaversion.viaversion.rewriter.ParticleRewriter;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+final class ParticleRegistrations {
+
+    static <CU extends ClientboundPacketType> void registerParticlePackets1_13(final RegistrationContext<CU, ?> ctx, final ParticleRewriter<CU> pr) {
+        ctx.clientbound(ClientboundPackets1_13.LEVEL_PARTICLES, type -> pr.registerLevelParticles1_13(type, Types.FLOAT));
+    }
+
+    static <CU extends ClientboundPacketType> void registerParticlePackets1_15_2(final RegistrationContext<CU, ?> ctx, final ParticleRewriter<CU> pr) {
+        ctx.clientbound(ClientboundPackets1_15.LEVEL_PARTICLES, type -> pr.registerLevelParticles1_13(type, Types.DOUBLE));
+    }
+
+    static <CU extends ClientboundPacketType> void registerParticlePackets1_19(final RegistrationContext<CU, ?> ctx, final ParticleRewriter<CU> pr) {
+        ctx.clientbound(ClientboundPackets1_19.LEVEL_PARTICLES, pr::registerLevelParticles1_19);
+    }
+
+    static <CU extends ClientboundPacketType> void registerParticlePackets1_20(final RegistrationContext<CU, ?> ctx, final ParticleRewriter<CU> pr) {
+        ctx.clientbound(ClientboundPackets1_19.LEVEL_PARTICLES, pr::registerLevelParticles1_19);
+    }
+
+    static <CU extends ClientboundPacketType> void registerParticlePackets1_20_5(final RegistrationContext<CU, ?> ctx, final ParticleRewriter<CU> pr) {
+        ctx.clientbound(ClientboundPackets1_20_5.LEVEL_PARTICLES, pr::registerLevelParticles1_20_5);
+        ctx.clientbound(ClientboundPackets1_20_5.EXPLODE, pr::registerExplode1_20_5);
+    }
+
+    static <CU extends ClientboundPacketType> void registerParticlePackets1_21_2(final RegistrationContext<CU, ?> ctx, final ParticleRewriter<CU> pr) {
+        ctx.clientbound(ClientboundPackets1_21_2.LEVEL_PARTICLES, pr::registerLevelParticles1_20_5);
+        ctx.clientbound(ClientboundPackets1_21_2.EXPLODE, pr::registerExplode1_21_2);
+    }
+
+    static <CU extends ClientboundPacketType> void registerParticlePackets1_21_4(final RegistrationContext<CU, ?> ctx, final ParticleRewriter<CU> pr) {
+        ctx.clientbound(ClientboundPackets1_21_2.LEVEL_PARTICLES, pr::registerLevelParticles1_21_4);
+        ctx.clientbound(ClientboundPackets1_21_2.EXPLODE, pr::registerExplode1_21_2);
+    }
+
+    static <CU extends ClientboundPacketType> void registerParticlePackets1_21_9(final RegistrationContext<CU, ?> ctx, final ParticleRewriter<CU> pr) {
+        ctx.clientbound(ClientboundPackets1_21_9.LEVEL_PARTICLES, pr::registerLevelParticles1_21_4);
+        ctx.clientbound(ClientboundPackets1_21_9.EXPLODE, pr::registerExplode1_21_9);
+    }
+
+    static @Nullable <CU extends ClientboundPacketType, SU extends ServerboundPacketType> ParticleRewriter<CU> particle(final RegistrationContext<CU, SU> ctx) {
+        return ctx.protocol().getParticleRewriter();
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/def/RegistryRegistrations.java

@@ -0,0 +1,102 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration.def;
+
+import com.viaversion.viaversion.api.data.Mappings;
+import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType;
+import com.viaversion.viaversion.protocol.shared_registration.PacketBound;
+import com.viaversion.viaversion.protocol.shared_registration.RegistrationContext;
+import com.viaversion.viaversion.protocols.v1_12_2to1_13.packet.ClientboundPackets1_13;
+import com.viaversion.viaversion.protocols.v1_13_2to1_14.packet.ClientboundPackets1_14;
+import com.viaversion.viaversion.protocols.v1_17to1_17_1.packet.ClientboundPackets1_17_1;
+import com.viaversion.viaversion.protocols.v1_19_1to1_19_3.packet.ClientboundPackets1_19_3;
+import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.rewriter.CommandRewriter1_19_4;
+import com.viaversion.viaversion.protocols.v1_20_5to1_21.packet.ClientboundConfigurationPackets1_21;
+import com.viaversion.viaversion.protocols.v1_20_5to1_21.packet.ClientboundPackets1_21;
+import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ClientboundConfigurationPackets1_20_2;
+import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ClientboundPackets1_20_2;
+import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPackets1_21_2;
+import com.viaversion.viaversion.protocols.v1_9_1to1_9_3.packet.ClientboundPackets1_9_3;
+import com.viaversion.viaversion.rewriter.AttributeRewriter;
+import com.viaversion.viaversion.rewriter.RecipeDisplayRewriter;
+import com.viaversion.viaversion.rewriter.SoundRewriter;
+import com.viaversion.viaversion.rewriter.StatisticsRewriter;
+
+final class RegistryRegistrations {
+
+    static <CU extends ClientboundPacketType> void registerTags1_17_1(final RegistrationContext<CU, ?> ctx) {
+        if (ctx.protocol().getTagRewriter() == null) return;
+        ctx.clientbound(ClientboundPackets1_17_1.UPDATE_TAGS, ctx.protocol().getTagRewriter()::registerGeneric);
+    }
+
+    static <CU extends ClientboundPacketType> void registerTags1_20_2(final RegistrationContext<CU, ?> ctx) {
+        if (ctx.protocol().getTagRewriter() == null) return;
+        ctx.clientbound(ClientboundPackets1_20_2.UPDATE_TAGS, ctx.protocol().getTagRewriter()::registerGeneric);
+        ctx.clientbound(ClientboundConfigurationPackets1_20_2.UPDATE_TAGS, ctx.protocol().getTagRewriter()::registerGeneric, PacketBound.ADDED_AT_MIN);
+    }
+
+
+    static <CU extends ClientboundPacketType> void registerRegistryData1_21(final RegistrationContext<CU, ?> ctx) {
+        if (ctx.protocol().getRegistryDataRewriter() == null) return;
+        ctx.clientboundHandler(ClientboundConfigurationPackets1_21.REGISTRY_DATA, ctx.protocol().getRegistryDataRewriter()::handle);
+    }
+
+
+    static <CU extends ClientboundPacketType> void registerRecipePackets1_21_2(final RegistrationContext<CU, ?> ctx) {
+        final RecipeDisplayRewriter<CU> rr = ctx.protocol().getRecipeRewriter();
+        if (rr == null) return;
+        ctx.clientbound(ClientboundPackets1_21_2.UPDATE_RECIPES, rr::registerUpdateRecipes);
+        ctx.clientbound(ClientboundPackets1_21_2.RECIPE_BOOK_ADD, rr::registerRecipeBookAdd, PacketBound.ADDED_AT_MIN);
+        ctx.clientbound(ClientboundPackets1_21_2.PLACE_GHOST_RECIPE, rr::registerPlaceGhostRecipe);
+    }
+
+
+    static <CU extends ClientboundPacketType> void registerStatistics1_13(final RegistrationContext<CU, ?> ctx) {
+        ctx.clientbound(ClientboundPackets1_13.AWARD_STATS, new StatisticsRewriter<>(ctx.protocol())::register);
+    }
+
+
+    static <CU extends ClientboundPacketType> void registerSounds1_10(final RegistrationContext<CU, ?> ctx) {
+        ctx.clientbound(ClientboundPackets1_9_3.SOUND, new SoundRewriter<>(ctx.protocol())::registerSound);
+    }
+
+    static <CU extends ClientboundPacketType> void registerSounds1_14(final RegistrationContext<CU, ?> ctx) {
+        final SoundRewriter<CU> sr = new SoundRewriter<>(ctx.protocol());
+        ctx.clientbound(ClientboundPackets1_14.SOUND, sr::registerSound);
+        ctx.clientbound(ClientboundPackets1_14.SOUND_ENTITY, sr::registerSound, PacketBound.ADDED_AT_MIN);
+    }
+
+    static <CU extends ClientboundPacketType> void registerSounds1_19_3(final RegistrationContext<CU, ?> ctx) {
+        final SoundRewriter<CU> sr = new SoundRewriter<>(ctx.protocol());
+        ctx.clientbound(ClientboundPackets1_19_3.SOUND, sr::registerSound1_19_3);
+        ctx.clientbound(ClientboundPackets1_19_3.SOUND_ENTITY, sr::registerSound1_19_3);
+    }
+
+
+    static <CU extends ClientboundPacketType> void registerCommands1_19(final RegistrationContext<CU, ?> ctx) {
+        if ((ctx.protocol().getMappingData() != null && !Mappings.isIntIdIdentity(ctx.protocol().getMappingData().getArgumentTypeMappings()))
+            || (ctx.protocol().getRegistryDataRewriter() != null && ctx.protocol().getRegistryDataRewriter().hasRegistriesToRemove())) {
+            ctx.clientbound(ClientboundPackets1_19_3.COMMANDS, new CommandRewriter1_19_4<>(ctx.protocol())::registerDeclareCommands1_19);
+        }
+    }
+
+
+    static <CU extends ClientboundPacketType> void registerAttributes1_21(final RegistrationContext<CU, ?> ctx) {
+        ctx.clientbound(ClientboundPackets1_21.UPDATE_ATTRIBUTES, new AttributeRewriter<>(ctx.protocol())::register1_21);
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocol/shared_registration/def/TextComponentRegistrations.java

@@ -0,0 +1,203 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocol.shared_registration.def;
+
+import com.viaversion.viaversion.api.minecraft.item.data.ChatType;
+import com.viaversion.viaversion.api.protocol.packet.ClientboundPacketType;
+import com.viaversion.viaversion.api.protocol.packet.ServerboundPacketType;
+import com.viaversion.viaversion.api.type.Type;
+import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.protocol.shared_registration.PacketBound;
+import com.viaversion.viaversion.protocol.shared_registration.RegistrationContext;
+import com.viaversion.viaversion.protocols.v1_12to1_12_1.packet.ClientboundPackets1_12_1;
+import com.viaversion.viaversion.protocols.v1_15_2to1_16.packet.ClientboundPackets1_16;
+import com.viaversion.viaversion.protocols.v1_16_1to1_16_2.packet.ClientboundPackets1_16_2;
+import com.viaversion.viaversion.protocols.v1_17to1_17_1.packet.ClientboundPackets1_17_1;
+import com.viaversion.viaversion.protocols.v1_18_2to1_19.packet.ClientboundPackets1_19;
+import com.viaversion.viaversion.protocols.v1_19to1_19_1.packet.ClientboundPackets1_19_1;
+import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ClientboundConfigurationPackets1_20_3;
+import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ClientboundPackets1_20_3;
+import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ClientboundConfigurationPackets1_20_5;
+import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ClientboundPackets1_20_5;
+import com.viaversion.viaversion.protocols.v1_20_5to1_21.packet.ClientboundPackets1_21;
+import com.viaversion.viaversion.protocols.v1_21_4to1_21_5.packet.ClientboundPackets1_21_5;
+import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPackets1_21_2;
+import com.viaversion.viaversion.rewriter.text.ComponentRewriterBase;
+import com.viaversion.viaversion.rewriter.text.JsonNBTComponentRewriter;
+import com.viaversion.viaversion.rewriter.text.NBTComponentRewriter;
+import org.checkerframework.checker.nullness.qual.Nullable;
+
+final class TextComponentRegistrations {
+
+    static <CU extends ClientboundPacketType> void registerComponents1_12_2(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        ctx.clientbound(ClientboundPackets1_12_1.CHAT, cr::registerComponentPacket);
+        registerCombatAndTitle1_12_2(ctx, cr);
+        registerComponentsFrom1_12_2(ctx, cr);
+    }
+
+    static <CU extends ClientboundPacketType> void registerComponents1_14(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        ctx.clientbound(ClientboundPackets1_12_1.CHAT, cr::registerComponentPacket);
+        registerCombatAndTitle1_12_2(ctx, cr);
+        registerComponentsFrom1_12_2(ctx, cr);
+        ctx.clientbound(ClientboundPackets1_16_2.SET_OBJECTIVE, cr::registerSetObjective);
+        ctx.clientbound(ClientboundPackets1_16_2.SET_PLAYER_TEAM, cr::registerSetPlayerTeam1_13);
+    }
+
+    static <CU extends ClientboundPacketType> void registerComponents1_16_2(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        ctx.clientbound(ClientboundPackets1_16.CHAT, cr::registerComponentPacket);
+        registerComponentsFrom1_12_2(ctx, cr);
+        ctx.clientbound(ClientboundPackets1_16_2.SET_OBJECTIVE, cr::registerSetObjective);
+        ctx.clientbound(ClientboundPackets1_16_2.SET_PLAYER_TEAM, cr::registerSetPlayerTeam1_13);
+        if (!(cr instanceof final JsonNBTComponentRewriter<CU> jcr)) return;
+        ctx.clientbound(ClientboundPackets1_12_1.PLAYER_COMBAT, jcr::registerPlayerCombat, PacketBound.REMOVED_AT_MAX);
+        ctx.clientbound(ClientboundPackets1_12_1.SET_TITLES, jcr::registerTitle, PacketBound.REMOVED_AT_MAX);
+    }
+
+    static <CU extends ClientboundPacketType> void registerComponents1_17(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        ctx.clientbound(ClientboundPackets1_16.CHAT, cr::registerComponentPacket, PacketBound.REMOVED_AT_MAX);
+        registerComponentsFrom1_12_2(ctx, cr);
+        ctx.clientbound(ClientboundPackets1_17_1.SET_ACTION_BAR_TEXT, cr::registerComponentPacket, PacketBound.ADDED_AT_MIN);
+        ctx.clientbound(ClientboundPackets1_17_1.SET_TITLE_TEXT, cr::registerComponentPacket, PacketBound.ADDED_AT_MIN);
+        ctx.clientbound(ClientboundPackets1_17_1.SET_SUBTITLE_TEXT, cr::registerComponentPacket, PacketBound.ADDED_AT_MIN);
+        ctx.clientbound(ClientboundPackets1_16_2.SET_OBJECTIVE, cr::registerSetObjective);
+        if (cr instanceof final JsonNBTComponentRewriter<CU> jcr) {
+            ctx.clientbound(ClientboundPackets1_17_1.PLAYER_COMBAT_KILL, jcr::registerPlayerCombatKill, PacketBound.ADDED_AT_MIN);
+        }
+        ctx.clientbound(ClientboundPackets1_16_2.SET_PLAYER_TEAM, cr::registerSetPlayerTeam1_13);
+    }
+
+    static <CU extends ClientboundPacketType> void registerComponents1_19(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        registerComponentsFrom1_12_2(ctx, cr);
+        registerActionBarTitleSubtitle1_17_1(ctx, cr);
+        ctx.clientbound(ClientboundPackets1_16_2.SET_OBJECTIVE, cr::registerSetObjective);
+        if (cr instanceof final JsonNBTComponentRewriter<CU> jcr) {
+            ctx.clientbound(ClientboundPackets1_17_1.PLAYER_COMBAT_KILL, jcr::registerPlayerCombatKill);
+        }
+        ctx.clientbound(ClientboundPackets1_16_2.SET_PLAYER_TEAM, cr::registerSetPlayerTeam1_13);
+        ctx.clientbound(ClientboundPackets1_19.SYSTEM_CHAT, cr::registerComponentPacket, PacketBound.ADDED_AT_MIN);
+        ctx.clientbound(ClientboundPackets1_19.SERVER_DATA, cr::registerComponentPacket, PacketBound.ADDED_AT_MIN);
+    }
+
+    static <CU extends ClientboundPacketType> void registerComponents1_20_3(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        registerComponentsFrom1_12_2(ctx, cr);
+        registerActionBarTitleSubtitle1_17_1(ctx, cr);
+        ctx.clientbound(ClientboundPackets1_16_2.SET_OBJECTIVE, cr::registerSetObjective);
+        ctx.clientbound(ClientboundPackets1_19_1.SYSTEM_CHAT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundConfigurationPackets1_20_3.DISCONNECT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_20_3.DISGUISED_CHAT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_20_3.SET_SCORE, cr::registerSetScore1_20_3);
+        ctx.clientbound(ClientboundPackets1_20_3.PLAYER_COMBAT_KILL, cr::registerPlayerCombatKill1_20);
+        ctx.clientbound(ClientboundPackets1_20_5.SET_PLAYER_TEAM, cr::registerSetPlayerTeam1_13);
+        ctx.clientbound(ClientboundPackets1_19.SERVER_DATA, cr::registerComponentPacket);
+        if (cr instanceof final JsonNBTComponentRewriter<CU> jcr) {
+            ctx.clientbound(ClientboundPackets1_20_3.PLAYER_CHAT, cu -> jcr.registerPlayerChat(cu, Types.VAR_INT));
+            ctx.clientbound(ClientboundPackets1_20_3.PLAYER_INFO_UPDATE, jcr::registerPlayerInfoUpdate1_20_3);
+        }
+    }
+
+    static <CU extends ClientboundPacketType> void registerCombatAndTitle1_12_2(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        if (!(cr instanceof final JsonNBTComponentRewriter<CU> jcr)) return;
+        ctx.clientbound(ClientboundPackets1_12_1.PLAYER_COMBAT, jcr::registerPlayerCombat);
+        ctx.clientbound(ClientboundPackets1_12_1.SET_TITLES, jcr::registerTitle);
+    }
+
+    private static <CU extends ClientboundPacketType> void registerComponentsFrom1_12_2(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        // not including set_score, player_info, update_advancements, and open_screen
+        ctx.clientbound(ClientboundPackets1_12_1.BOSS_EVENT, cr::registerBossEvent);
+        ctx.clientbound(ClientboundPackets1_12_1.DISCONNECT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_12_1.TAB_LIST, cr::registerTabList);
+        cr.registerLoginDisconnect();
+    }
+
+    static <CU extends ClientboundPacketType> void registerActionBarTitleSubtitle1_17_1(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        ctx.clientbound(ClientboundPackets1_17_1.SET_ACTION_BAR_TEXT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_17_1.SET_TITLE_TEXT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_17_1.SET_SUBTITLE_TEXT, cr::registerComponentPacket);
+    }
+
+    static <CU extends ClientboundPacketType> void registerComponents1_20_5(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        common1_20_5(ctx, cr);
+        ctx.clientbound(ClientboundPackets1_20_5.SET_PLAYER_TEAM, cr::registerSetPlayerTeam1_13);
+        ctx.clientbound(ClientboundPackets1_20_5.DISGUISED_CHAT, cr::registerComponentPacket);
+        if (cr instanceof final JsonNBTComponentRewriter<CU> jcr) {
+            ctx.clientbound(ClientboundPackets1_20_5.PLAYER_CHAT, cu -> jcr.registerPlayerChat(cu, Types.VAR_INT));
+            ctx.clientbound(ClientboundPackets1_20_5.PLAYER_INFO_UPDATE, jcr::registerPlayerInfoUpdate1_20_3);
+        }
+    }
+
+    private static <CU extends ClientboundPacketType> void common1_20_5(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        ctx.clientbound(ClientboundConfigurationPackets1_20_5.DISCONNECT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_20_5.DISCONNECT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_20_5.SET_ACTION_BAR_TEXT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_20_5.SET_TITLE_TEXT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_20_5.SET_SUBTITLE_TEXT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_20_5.BOSS_EVENT, cr::registerBossEvent);
+        ctx.clientbound(ClientboundPackets1_20_5.TAB_LIST, cr::registerTabList);
+        ctx.clientbound(ClientboundPackets1_20_5.SET_OBJECTIVE, cr::registerSetObjective);
+        ctx.clientbound(ClientboundPackets1_20_5.SET_SCORE, cr::registerSetScore1_20_3);
+        ctx.clientbound(ClientboundPackets1_20_5.SYSTEM_CHAT, cr::registerComponentPacket);
+        ctx.clientbound(ClientboundPackets1_20_5.PLAYER_COMBAT_KILL, cr::registerPlayerCombatKill1_20);
+        ctx.clientbound(ClientboundPackets1_20_5.SERVER_DATA, cr::registerComponentPacket);
+        cr.registerLoginDisconnect();
+    }
+
+    static <CU extends ClientboundPacketType> void registerComponents1_21(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        common1_21_1(ctx, cr, Types.VAR_INT);
+    }
+
+    private static <CU extends ClientboundPacketType> void common1_21_1(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr, final Type<?> chatType) {
+        common1_20_5(ctx, cr);
+        ctx.clientbound(ClientboundPackets1_21.SET_PLAYER_TEAM, cr::registerSetPlayerTeam1_13);
+        ctx.clientbound(ClientboundPackets1_21.DISGUISED_CHAT, cr::registerDisguisedChat);
+        if (cr instanceof final JsonNBTComponentRewriter<CU> jcr) {
+            ctx.clientbound(ClientboundPackets1_21.PLAYER_CHAT, cu -> jcr.registerPlayerChat(cu, chatType));
+            ctx.clientbound(ClientboundPackets1_21.PLAYER_INFO_UPDATE, jcr::registerPlayerInfoUpdate1_20_3);
+        }
+    }
+
+    static <CU extends ClientboundPacketType> void registerComponents1_21_2(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        common1_21_1(ctx, cr, ChatType.TYPE);
+    }
+
+    static <CU extends ClientboundPacketType> void registerComponents1_21_4(final RegistrationContext<CU, ?> ctx, final ComponentRewriterBase<CU> cr) {
+        common1_20_5(ctx, cr);
+        ctx.clientbound(ClientboundPackets1_21_2.SET_PLAYER_TEAM, cr::registerSetPlayerTeam1_13);
+        ctx.clientbound(ClientboundPackets1_21_2.DISGUISED_CHAT, cr::registerDisguisedChat);
+        ctx.clientbound(ClientboundPackets1_21_2.PLAYER_INFO_UPDATE, cr::registerPlayerInfoUpdate1_21_4);
+        if (cr instanceof final JsonNBTComponentRewriter<CU> jcr) {
+            ctx.clientbound(ClientboundPackets1_21_2.PLAYER_CHAT, cu -> jcr.registerPlayerChat(cu, ChatType.TYPE));
+        }
+    }
+
+    static <CU extends ClientboundPacketType> void registerComponents1_21_5(final RegistrationContext<CU, ?> ctx, final NBTComponentRewriter<CU> cr) {
+        common1_20_5(ctx, cr);
+        ctx.clientbound(ClientboundPackets1_21_5.SET_PLAYER_TEAM, cr::registerSetPlayerTeam1_21_5);
+        ctx.clientbound(ClientboundPackets1_21_5.DISGUISED_CHAT, cr::registerDisguisedChat);
+        ctx.clientbound(ClientboundPackets1_21_5.PLAYER_INFO_UPDATE, cr::registerPlayerInfoUpdate1_21_4);
+        ctx.clientbound(ClientboundPackets1_21_5.PLAYER_CHAT, cr::registerPlayerChat1_21_5);
+    }
+
+    static @Nullable <CU extends ClientboundPacketType, SU extends ServerboundPacketType> ComponentRewriterBase<CU> text(final RegistrationContext<CU, SU> ctx) {
+        return ctx.protocol().getComponentRewriter();
+    }
+
+
+    static @Nullable <CU extends ClientboundPacketType, SU extends ServerboundPacketType> NBTComponentRewriter<CU> nbtText(final RegistrationContext<CU, SU> ctx) {
+        return (NBTComponentRewriter<CU>) ctx.protocol().getComponentRewriter();
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocols/template/BlockItemPacketRewriter99_1.java

@@ -21,19 +21,11 @@ import com.viaversion.nbt.tag.CompoundTag;
 import com.viaversion.viaversion.api.connection.UserConnection;
 import com.viaversion.viaversion.api.minecraft.data.StructuredDataContainer;
 import com.viaversion.viaversion.api.minecraft.item.Item;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType26_1;
 import com.viaversion.viaversion.protocols.v1_21_11to26_1.packet.ClientboundPacket26_1;
-import com.viaversion.viaversion.protocols.v1_21_11to26_1.packet.ClientboundPackets26_1;
-import com.viaversion.viaversion.protocols.v1_21_4to1_21_5.rewriter.RecipeDisplayRewriter1_21_5;
-import com.viaversion.viaversion.protocols.v1_21_5to1_21_6.packet.ServerboundPackets1_21_6;
 import com.viaversion.viaversion.protocols.v1_21_7to1_21_9.packet.ServerboundPacket1_21_9;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
-import com.viaversion.viaversion.rewriter.RecipeDisplayRewriter;
 import com.viaversion.viaversion.rewriter.StructuredItemRewriter;
-import com.viaversion.viaversion.rewriter.block.BlockRewriter1_21_5;
 
 // To replace if needed:
-//   ChunkType26_1
 //   RecipeDisplayRewriter
 final class BlockItemPacketRewriter99_1 extends StructuredItemRewriter<ClientboundPacket26_1, ServerboundPacket1_21_9, Protocol98_1To99_1> {
 
@@ -43,37 +35,10 @@ final class BlockItemPacketRewriter99_1 extends StructuredItemRewriter<Clientbou
 
     @Override
     public void registerPackets() {
-        // Register block and block state id changes
-        // Other places using block state id mappings: Spawn particle, entity data, entity spawn (falling blocks)
-        // Tags and statistics use block (!) ids
-        final BlockRewriter<ClientboundPacket26_1> blockRewriter = new BlockRewriter1_21_5<>(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets26_1.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets26_1.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate1_20(ClientboundPackets26_1.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerLevelEvent1_21(ClientboundPackets26_1.LEVEL_EVENT, 2001);
-        blockRewriter.registerLevelChunk1_19(ClientboundPackets26_1.LEVEL_CHUNK_WITH_LIGHT, ChunkType26_1::new);
-        blockRewriter.registerBlockEntityData(ClientboundPackets26_1.BLOCK_ENTITY_DATA);
+        // Common block, item, recipe, and entity registrations are handled by SharedRegistrations
 
-        // Registers item id changes
-        // Other places using item ids are: Entity data, tags, statistics, effect
         // registerOpenScreen(ClientboundPackets26_1.OPEN_SCREEN); If a new container type was added; also remove from the component rewriter registration
-        registerSetCursorItem(ClientboundPackets26_1.SET_CURSOR_ITEM);
-        registerSetPlayerInventory(ClientboundPackets26_1.SET_PLAYER_INVENTORY);
-        registerCooldown1_21_2(ClientboundPackets26_1.COOLDOWN);
-        registerSetContent1_21_2(ClientboundPackets26_1.CONTAINER_SET_CONTENT);
-        registerSetSlot1_21_2(ClientboundPackets26_1.CONTAINER_SET_SLOT);
-        registerAdvancements1_20_3(ClientboundPackets26_1.UPDATE_ADVANCEMENTS);
-        registerSetEquipment(ClientboundPackets26_1.SET_EQUIPMENT);
-        registerMerchantOffers1_20_5(ClientboundPackets26_1.MERCHANT_OFFERS);
-        registerContainerClick1_21_5(ServerboundPackets1_21_6.CONTAINER_CLICK);
-        registerSetCreativeModeSlot1_21_5(ServerboundPackets1_21_6.SET_CREATIVE_MODE_SLOT);
-
-        final RecipeDisplayRewriter<ClientboundPacket26_1> recipeRewriter = new RecipeDisplayRewriter1_21_5<>(protocol);
-        recipeRewriter.registerUpdateRecipes(ClientboundPackets26_1.UPDATE_RECIPES);
-        recipeRewriter.registerRecipeBookAdd(ClientboundPackets26_1.RECIPE_BOOK_ADD);
-        recipeRewriter.registerPlaceGhostRecipe(ClientboundPackets26_1.PLACE_GHOST_RECIPE);
-        // OR do this if serialization of recipes changed and override the relevant method
-        // Add new serializers to RecipeDisplayRewriter, or extend the last one for changes
+        // OR add new serializers to RecipeDisplayRewriter, or extend the last one for changes
     }
 
     @Override

common/src/main/java/com/viaversion/viaversion/protocols/template/EntityPacketRewriter99_1.java

@@ -35,14 +35,8 @@ final class EntityPacketRewriter99_1 extends EntityRewriter<ClientboundPacket26_
 
     @Override
     public void registerPackets() {
-        // Tracks entities, applies entity data rewrites registered below, untracks entities
-        registerTrackerWithData1_21_9(ClientboundPackets26_1.ADD_ENTITY, EntityTypes1_21_11.FALLING_BLOCK);
-        registerSetEntityData(ClientboundPackets26_1.SET_ENTITY_DATA);
-        registerRemoveEntities(ClientboundPackets26_1.REMOVE_ENTITIES);
-        registerPlayerAbilities(ClientboundPackets26_1.PLAYER_ABILITIES);
-        registerGameEvent(ClientboundPackets26_1.GAME_EVENT);
-        registerLogin1_20_5(ClientboundPackets26_1.LOGIN);
-        registerRespawn1_20_5(ClientboundPackets26_1.RESPAWN);
+        // Common entity registrations (SET_ENTITY_DATA, REMOVE_ENTITIES, PLAYER_ABILITIES,
+        // GAME_EVENT, LOGIN, RESPAWN) are handled by SharedRegistrations.
     }
 
     @Override

common/src/main/java/com/viaversion/viaversion/protocols/template/Protocol98_1To99_1.java

@@ -23,25 +23,25 @@ import com.viaversion.viaversion.api.data.MappingDataBase;
 import com.viaversion.viaversion.api.minecraft.data.version.StructuredDataKeys1_21_11;
 import com.viaversion.viaversion.api.minecraft.entities.EntityTypes1_21_11;
 import com.viaversion.viaversion.api.minecraft.entitydata.types.EntityDataTypes26_1;
-import com.viaversion.viaversion.api.protocol.AbstractProtocol;
 import com.viaversion.viaversion.api.protocol.packet.provider.PacketTypesProvider;
 import com.viaversion.viaversion.api.protocol.packet.provider.SimplePacketTypesProvider;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType26_1;
 import com.viaversion.viaversion.api.type.types.version.Types1_20_5;
 import com.viaversion.viaversion.api.type.types.version.VersionedTypes;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
 import com.viaversion.viaversion.data.item.ItemHasherBase;
+import com.viaversion.viaversion.api.protocol.AbstractProtocol;
 import com.viaversion.viaversion.protocols.v1_21_11to26_1.packet.ClientboundPacket26_1;
 import com.viaversion.viaversion.protocols.v1_21_11to26_1.packet.ClientboundPackets26_1;
 import com.viaversion.viaversion.protocols.v1_21_5to1_21_6.packet.ServerboundPackets1_21_6;
 import com.viaversion.viaversion.protocols.v1_21_7to1_21_9.packet.ClientboundConfigurationPackets1_21_9;
 import com.viaversion.viaversion.protocols.v1_21_7to1_21_9.packet.ServerboundConfigurationPackets1_21_9;
 import com.viaversion.viaversion.protocols.v1_21_7to1_21_9.packet.ServerboundPacket1_21_9;
-import com.viaversion.viaversion.rewriter.AttributeRewriter;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
 import com.viaversion.viaversion.rewriter.RegistryDataRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
+import com.viaversion.viaversion.rewriter.block.BlockRewriter1_21_5;
 import com.viaversion.viaversion.rewriter.text.NBTComponentRewriter;
 
 import static com.viaversion.viaversion.util.ProtocolUtil.packetTypeMap;
@@ -51,12 +51,14 @@ import static com.viaversion.viaversion.util.ProtocolUtil.packetTypeMap;
 //   ServerboundPacket1_21_9
 //   EntityDataTypes26_1 (MAPPED type)
 //   VersionedTypes.V26_1
+//   ChunkType26_1::new
 //   98.1, 99.1
 final class Protocol98_1To99_1 extends AbstractProtocol<ClientboundPacket26_1, ClientboundPacket26_1, ServerboundPacket1_21_9, ServerboundPacket1_21_9> {
 
     public static final MappingData MAPPINGS = new MappingDataBase("98.1", "99.1");
     private final EntityPacketRewriter99_1 entityRewriter = new EntityPacketRewriter99_1(this);
     private final BlockItemPacketRewriter99_1 itemRewriter = new BlockItemPacketRewriter99_1(this);
+    private final BlockRewriter<ClientboundPacket26_1> blockRewriter = new BlockRewriter1_21_5<>(this, ChunkType26_1::new);
     private final ParticleRewriter<ClientboundPacket26_1> particleRewriter = new ParticleRewriter<>(this);
     private final TagRewriter<ClientboundPacket26_1> tagRewriter = new TagRewriter<>(this);
     private final NBTComponentRewriter<ClientboundPacket26_1> componentRewriter = new ComponentRewriter99_1(this);
@@ -71,40 +73,9 @@ final class Protocol98_1To99_1 extends AbstractProtocol<ClientboundPacket26_1, C
     protected void registerPackets() {
         super.registerPackets();
 
-        registerClientbound(ClientboundConfigurationPackets1_21_9.REGISTRY_DATA, registryDataRewriter::handle);
-
-        tagRewriter.registerGeneric(ClientboundPackets26_1.UPDATE_TAGS);
-        tagRewriter.registerGeneric(ClientboundConfigurationPackets1_21_9.UPDATE_TAGS);
-
-        // If needed for item or component changes
-        componentRewriter.registerOpenScreen1_14(ClientboundPackets26_1.OPEN_SCREEN);
-        componentRewriter.registerComponentPacket(ClientboundPackets26_1.SET_ACTION_BAR_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets26_1.SET_TITLE_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets26_1.SET_SUBTITLE_TEXT);
-        componentRewriter.registerBossEvent(ClientboundPackets26_1.BOSS_EVENT);
-        componentRewriter.registerComponentPacket(ClientboundPackets26_1.DISCONNECT);
-        componentRewriter.registerComponentPacket(ClientboundConfigurationPackets1_21_9.DISCONNECT);
-        componentRewriter.registerTabList(ClientboundPackets26_1.TAB_LIST);
-        componentRewriter.registerSetPlayerTeam1_21_5(ClientboundPackets26_1.SET_PLAYER_TEAM);
-        componentRewriter.registerPlayerCombatKill1_20(ClientboundPackets26_1.PLAYER_COMBAT_KILL);
-        componentRewriter.registerPlayerInfoUpdate1_21_4(ClientboundPackets26_1.PLAYER_INFO_UPDATE);
-        componentRewriter.registerComponentPacket(ClientboundPackets26_1.SYSTEM_CHAT);
-        componentRewriter.registerDisguisedChat(ClientboundPackets26_1.DISGUISED_CHAT);
-        componentRewriter.registerPlayerChat1_21_5(ClientboundPackets26_1.PLAYER_CHAT);
-        componentRewriter.registerSetObjective(ClientboundPackets26_1.SET_OBJECTIVE);
-        componentRewriter.registerSetScore1_20_3(ClientboundPackets26_1.SET_SCORE);
-        componentRewriter.registerPing();
-
-        // If needed for any particle, item, or block changes. Extend ParticleRewriter for particle serializer changes
-        particleRewriter.registerLevelParticles1_21_4(ClientboundPackets26_1.LEVEL_PARTICLES);
-        particleRewriter.registerExplode1_21_9(ClientboundPackets26_1.EXPLODE); // Rewrites the included sound and particles
-
-        final SoundRewriter<ClientboundPacket26_1> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound1_19_3(ClientboundPackets26_1.SOUND);
-        soundRewriter.registerSound1_19_3(ClientboundPackets26_1.SOUND_ENTITY);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets26_1.AWARD_STATS);
-        new AttributeRewriter<>(this).register1_21(ClientboundPackets26_1.UPDATE_ATTRIBUTES);
+        // Common registrations (tags, components, particles, sounds, statistics, attributes)
+        // are automatically applied via SharedRegistrations based on the protocol's version range.
+        // Only protocol-specific registrations need to be added here.
 
         // Uncomment if an existing type changed serialization format. Mappings for argument type keys can also be defined in mapping files
         /*new CommandRewriter1_19_4<>(this) {
@@ -173,6 +144,11 @@ final class Protocol98_1To99_1 extends AbstractProtocol<ClientboundPacket26_1, C
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPacket26_1> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public RegistryDataRewriter getRegistryDataRewriter() {
         return registryDataRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_10to1_11/Protocol1_10To1_11.java

@@ -37,7 +37,6 @@ import com.viaversion.viaversion.protocols.v1_10to1_11.rewriter.ItemPacketRewrit
 import com.viaversion.viaversion.protocols.v1_10to1_11.storage.EntityTracker1_11;
 import com.viaversion.viaversion.protocols.v1_9_1to1_9_3.packet.ClientboundPackets1_9_3;
 import com.viaversion.viaversion.protocols.v1_9_1to1_9_3.packet.ServerboundPackets1_9_3;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
 
 public class Protocol1_10To1_11 extends AbstractProtocol<ClientboundPackets1_9_3, ClientboundPackets1_9_3, ServerboundPackets1_9_3, ServerboundPackets1_9_3> {
 
@@ -59,7 +58,15 @@ public class Protocol1_10To1_11 extends AbstractProtocol<ClientboundPackets1_9_3
     protected void registerPackets() {
         super.registerPackets();
 
-        new SoundRewriter<>(this, this::getNewSoundId).registerSound(ClientboundPackets1_9_3.SOUND);
+        registerClientbound(ClientboundPackets1_9_3.SOUND, wrapper -> {
+            int soundId = wrapper.read(Types.VAR_INT);
+            int mappedId = getNewSoundId(soundId);
+            if (mappedId == -1) {
+                wrapper.cancel();
+            } else {
+                wrapper.write(Types.VAR_INT, mappedId);
+            }
+        });
 
         registerClientbound(ClientboundPackets1_9_3.SET_TITLES, new PacketHandlers() {
             @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_11_1to1_12/Protocol1_11_1To1_12.java

@@ -43,7 +43,6 @@ import com.viaversion.viaversion.protocols.v1_11_1to1_12.rewriter.EntityPacketRe
 import com.viaversion.viaversion.protocols.v1_11_1to1_12.rewriter.ItemPacketRewriter1_12;
 import com.viaversion.viaversion.protocols.v1_9_1to1_9_3.packet.ClientboundPackets1_9_3;
 import com.viaversion.viaversion.protocols.v1_9_1to1_9_3.packet.ServerboundPackets1_9_3;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
 
 public class Protocol1_11_1To1_12 extends AbstractProtocol<ClientboundPackets1_9_3, ClientboundPackets1_12, ServerboundPackets1_9_3, ServerboundPackets1_12> {
 
@@ -58,6 +57,16 @@ public class Protocol1_11_1To1_12 extends AbstractProtocol<ClientboundPackets1_9
     protected void registerPackets() {
         super.registerPackets();
 
+        registerClientbound(ClientboundPackets1_9_3.SOUND, wrapper -> {
+            int soundId = wrapper.read(Types.VAR_INT);
+            int mappedId = getNewSoundId(soundId);
+            if (mappedId == -1) {
+                wrapper.cancel();
+            } else {
+                wrapper.write(Types.VAR_INT, mappedId);
+            }
+        });
+
         registerClientbound(ClientboundPackets1_9_3.CHAT, wrapper -> {
             final JsonElement element = wrapper.passthrough(Types.COMPONENT);
             TranslateRewriter.toClient(wrapper.user(), element);
@@ -96,9 +105,6 @@ public class Protocol1_11_1To1_12 extends AbstractProtocol<ClientboundPackets1_9
             }
         });
 
-        new SoundRewriter<>(this, this::getNewSoundId).registerSound(ClientboundPackets1_9_3.SOUND);
-
-
         // New packet at 0x01
         cancelServerbound(ServerboundPackets1_12.CRAFTING_RECIPE_PLACEMENT);
 

common/src/main/java/com/viaversion/viaversion/protocols/v1_12_2to1_13/Protocol1_12_2To1_13.java

@@ -40,7 +40,6 @@ import com.viaversion.viaversion.api.type.Types;
 import com.viaversion.viaversion.api.type.types.misc.ParticleType;
 import com.viaversion.viaversion.api.type.types.version.Types1_13;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
-import com.viaversion.viaversion.protocols.base.ClientboundLoginPackets;
 import com.viaversion.viaversion.protocols.base.ClientboundStatusPackets;
 import com.viaversion.viaversion.protocols.base.ServerboundLoginPackets;
 import com.viaversion.viaversion.protocols.v1_12_2to1_13.blockconnections.ConnectionData;
@@ -181,10 +180,6 @@ public class Protocol1_12_2To1_13 extends AbstractProtocol<ClientboundPackets1_1
 
         WorldPacketRewriter1_13.register(this);
 
-        registerClientbound(State.LOGIN, ClientboundLoginPackets.LOGIN_DISCONNECT, wrapper -> {
-            componentRewriter.processText(wrapper.user(), wrapper.passthrough(Types.COMPONENT));
-        });
-
         registerClientbound(State.STATUS, ClientboundStatusPackets.STATUS_RESPONSE, new PacketHandlers() {
             @Override
             public void register() {
@@ -253,9 +248,6 @@ public class Protocol1_12_2To1_13 extends AbstractProtocol<ClientboundPackets1_1
         });
 
 
-        componentRewriter.registerBossEvent(ClientboundPackets1_12_1.BOSS_EVENT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_12_1.CHAT);
-
         registerClientbound(ClientboundPackets1_12_1.COMMAND_SUGGESTIONS, wrapper -> {
             wrapper.write(Types.VAR_INT, wrapper.user().get(TabCompleteTracker.class).getTransactionId());
 
@@ -329,8 +321,6 @@ public class Protocol1_12_2To1_13 extends AbstractProtocol<ClientboundPackets1_1
             }
         });
 
-        componentRewriter.registerComponentPacket(ClientboundPackets1_12_1.DISCONNECT);
-
         registerClientbound(ClientboundPackets1_12_1.LEVEL_EVENT, new PacketHandlers() {
             @Override
             public void register() {
@@ -359,8 +349,6 @@ public class Protocol1_12_2To1_13 extends AbstractProtocol<ClientboundPackets1_1
             }
         });
 
-        componentRewriter.registerPlayerCombat(ClientboundPackets1_12_1.PLAYER_COMBAT);
-
         registerClientbound(ClientboundPackets1_12_1.MAP_ITEM_DATA, new PacketHandlers() {
             @Override
             public void register() {
@@ -510,17 +498,6 @@ public class Protocol1_12_2To1_13 extends AbstractProtocol<ClientboundPackets1_1
             }
         });
 
-        componentRewriter.registerTitle(ClientboundPackets1_12_1.SET_TITLES);
-
-        // New 0x4C - Stop Sound
-
-        new SoundRewriter<>(this).registerSound(ClientboundPackets1_12_1.SOUND);
-
-        registerClientbound(ClientboundPackets1_12_1.TAB_LIST, wrapper -> {
-            componentRewriter.processText(wrapper.user(), wrapper.passthrough(Types.COMPONENT));
-            componentRewriter.processText(wrapper.user(), wrapper.passthrough(Types.COMPONENT));
-        });
-
         registerClientbound(ClientboundPackets1_12_1.UPDATE_ADVANCEMENTS, wrapper -> {
             wrapper.passthrough(Types.BOOLEAN); // Reset/clear
             int size = wrapper.passthrough(Types.VAR_INT); // Mapping size

common/src/main/java/com/viaversion/viaversion/protocols/v1_13_2to1_14/Protocol1_13_2To1_14.java

@@ -23,7 +23,6 @@ import com.viaversion.viaversion.api.minecraft.RegistryType;
 import com.viaversion.viaversion.api.minecraft.entities.EntityTypes1_14;
 import com.viaversion.viaversion.api.protocol.AbstractProtocol;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
-import com.viaversion.viaversion.api.type.Types;
 import com.viaversion.viaversion.api.type.types.misc.ParticleType;
 import com.viaversion.viaversion.api.type.types.version.Types1_13_2;
 import com.viaversion.viaversion.api.type.types.version.Types1_14;
@@ -38,10 +37,9 @@ import com.viaversion.viaversion.protocols.v1_13_2to1_14.rewriter.ItemPacketRewr
 import com.viaversion.viaversion.protocols.v1_13_2to1_14.rewriter.PlayerPacketRewriter1_14;
 import com.viaversion.viaversion.protocols.v1_13_2to1_14.rewriter.WorldPacketRewriter1_14;
 import com.viaversion.viaversion.protocols.v1_13_2to1_14.storage.EntityTracker1_14;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.CommandRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.rewriter.text.JsonNBTComponentRewriter;
 import com.viaversion.viaversion.util.ProtocolLogger;
@@ -55,6 +53,7 @@ public class Protocol1_13_2To1_14 extends AbstractProtocol<ClientboundPackets1_1
     private final ItemPacketRewriter1_14 itemRewriter = new ItemPacketRewriter1_14(this);
     private final ParticleRewriter<ClientboundPackets1_13> particleRewriter = new ParticleRewriter<>(this);
     private final TagRewriter<ClientboundPackets1_13> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_13> blockRewriter = BlockRewriter.for1_14(this);
 
     public Protocol1_13_2To1_14() {
         super(ClientboundPackets1_13.class, ClientboundPackets1_14.class, ServerboundPackets1_13.class, ServerboundPackets1_14.class);
@@ -67,11 +66,6 @@ public class Protocol1_13_2To1_14 extends AbstractProtocol<ClientboundPackets1_1
         WorldPacketRewriter1_14.register(this);
         PlayerPacketRewriter1_14.register(this);
 
-        new SoundRewriter<>(this).registerSound(ClientboundPackets1_13.SOUND);
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_13.AWARD_STATS);
-
-        particleRewriter.registerLevelParticles1_13(ClientboundPackets1_13.LEVEL_PARTICLES, Types.FLOAT);
-
         JsonNBTComponentRewriter<ClientboundPackets1_13> componentRewriter = new ComponentRewriter1_14<>(this);
         componentRewriter.registerComponentPacket(ClientboundPackets1_13.CHAT);
 
@@ -151,6 +145,11 @@ public class Protocol1_13_2To1_14 extends AbstractProtocol<ClientboundPackets1_1
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_13> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_13> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_13_2to1_14/rewriter/EntityPacketRewriter1_14.java

@@ -252,7 +252,6 @@ public class EntityPacketRewriter1_14 extends EntityRewriter<ClientboundPackets1
             }
         });
 
-        registerRemoveEntities(ClientboundPackets1_13.REMOVE_ENTITIES);
         registerSetEntityData(ClientboundPackets1_13.SET_ENTITY_DATA, Types1_13_2.ENTITY_DATA_LIST, Types1_14.ENTITY_DATA_LIST);
     }
 

common/src/main/java/com/viaversion/viaversion/protocols/v1_13_2to1_14/rewriter/ItemPacketRewriter1_14.java

@@ -64,9 +64,6 @@ public class ItemPacketRewriter1_14 extends ItemRewriter<ClientboundPackets1_13,
 
     @Override
     public void registerPackets() {
-        registerCooldown(ClientboundPackets1_13.COOLDOWN);
-        registerAdvancements(ClientboundPackets1_13.UPDATE_ADVANCEMENTS);
-
         protocol.registerClientbound(ClientboundPackets1_13.OPEN_SCREEN, null, wrapper -> {
             Short windowId = wrapper.read(Types.UNSIGNED_BYTE);
             String type = wrapper.read(Types.STRING);
@@ -112,9 +109,6 @@ public class ItemPacketRewriter1_14 extends ItemRewriter<ClientboundPackets1_13,
             }
         });
 
-        registerSetContent(ClientboundPackets1_13.CONTAINER_SET_CONTENT);
-        registerSetSlot(ClientboundPackets1_13.CONTAINER_SET_SLOT);
-
         protocol.registerClientbound(ClientboundPackets1_13.CUSTOM_PAYLOAD, new PacketHandlers() {
             @Override
             public void register() {
@@ -166,8 +160,6 @@ public class ItemPacketRewriter1_14 extends ItemRewriter<ClientboundPackets1_13,
             }
         });
 
-        registerSetEquippedItem(ClientboundPackets1_13.SET_EQUIPPED_ITEM);
-
         RecipeRewriter<ClientboundPackets1_13> recipeRewriter = new RecipeRewriter<>(protocol);
         protocol.registerClientbound(ClientboundPackets1_13.UPDATE_RECIPES, wrapper -> {
             int size = wrapper.passthrough(Types.VAR_INT);
@@ -188,8 +180,6 @@ public class ItemPacketRewriter1_14 extends ItemRewriter<ClientboundPackets1_13,
         });
 
 
-        registerContainerClick(ServerboundPackets1_14.CONTAINER_CLICK);
-
         protocol.registerServerbound(ServerboundPackets1_14.SELECT_TRADE, wrapper -> {
             // Selecting trade now moves the items, we need to resync the inventory
             PacketWrapper resyncPacket = wrapper.create(ServerboundPackets1_13.CONTAINER_CLICK);
@@ -204,8 +194,6 @@ public class ItemPacketRewriter1_14 extends ItemRewriter<ClientboundPackets1_13,
             resyncPacket.write(Types.ITEM1_13_2, new DataItem(1, (byte) 1, tag)); // 5 - Clicked Item
             resyncPacket.scheduleSendToServer(Protocol1_13_2To1_14.class);
         });
-
-        registerSetCreativeModeSlot(ServerboundPackets1_14.SET_CREATIVE_MODE_SLOT);
     }
 
     @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_13_2to1_14/rewriter/WorldPacketRewriter1_14.java

@@ -37,7 +37,6 @@ import com.viaversion.viaversion.protocols.v1_12_2to1_13.packet.ClientboundPacke
 import com.viaversion.viaversion.protocols.v1_13_2to1_14.Protocol1_13_2To1_14;
 import com.viaversion.viaversion.protocols.v1_13_2to1_14.packet.ClientboundPackets1_14;
 import com.viaversion.viaversion.protocols.v1_13_2to1_14.storage.EntityTracker1_14;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.util.CompactArrayUtil;
 import java.util.Arrays;
 
@@ -53,8 +52,6 @@ public class WorldPacketRewriter1_14 {
     }
 
     public static void register(Protocol1_13_2To1_14 protocol) {
-        BlockRewriter<ClientboundPackets1_13> blockRewriter = BlockRewriter.for1_14(protocol);
-
         protocol.registerClientbound(ClientboundPackets1_13.BLOCK_DESTRUCTION, new PacketHandlers() {
             @Override
             public void register() {
@@ -69,7 +66,7 @@ public class WorldPacketRewriter1_14 {
                 map(Types.BLOCK_POSITION1_8, Types.BLOCK_POSITION1_14);
             }
         });
-        protocol.registerClientbound(ClientboundPackets1_13.BLOCK_EVENT, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_13.BLOCK_EVENT, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.BLOCK_POSITION1_8, Types.BLOCK_POSITION1_14); // Location
@@ -79,7 +76,7 @@ public class WorldPacketRewriter1_14 {
                 handler(wrapper -> wrapper.set(Types.VAR_INT, 0, protocol.getMappingData().getNewBlockId(wrapper.get(Types.VAR_INT, 0))));
             }
         });
-        protocol.registerClientbound(ClientboundPackets1_13.BLOCK_UPDATE, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_13.BLOCK_UPDATE, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.BLOCK_POSITION1_8, Types.BLOCK_POSITION1_14);
@@ -102,8 +99,6 @@ public class WorldPacketRewriter1_14 {
             }
         });
 
-        blockRewriter.registerChunkBlocksUpdate(ClientboundPackets1_13.CHUNK_BLOCKS_UPDATE);
-
         protocol.registerClientbound(ClientboundPackets1_13.EXPLODE, new PacketHandlers() {
             @Override
             public void register() {
@@ -247,7 +242,7 @@ public class WorldPacketRewriter1_14 {
             }
         });
 
-        protocol.registerClientbound(ClientboundPackets1_13.LEVEL_EVENT, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_13.LEVEL_EVENT, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.INT); // Effect Id

common/src/main/java/com/viaversion/viaversion/protocols/v1_13to1_13_1/Protocol1_13To1_13_1.java

@@ -35,8 +35,8 @@ import com.viaversion.viaversion.protocols.v1_12_2to1_13.packet.ServerboundPacke
 import com.viaversion.viaversion.protocols.v1_13to1_13_1.rewriter.EntityPacketRewriter1_13_1;
 import com.viaversion.viaversion.protocols.v1_13to1_13_1.rewriter.ItemPacketRewriter1_13_1;
 import com.viaversion.viaversion.protocols.v1_13to1_13_1.rewriter.WorldPacketRewriter1_13_1;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 
 public class Protocol1_13To1_13_1 extends AbstractProtocol<ClientboundPackets1_13, ClientboundPackets1_13, ServerboundPackets1_13, ServerboundPackets1_13> {
@@ -46,6 +46,7 @@ public class Protocol1_13To1_13_1 extends AbstractProtocol<ClientboundPackets1_1
     private final ItemPacketRewriter1_13_1 itemRewriter = new ItemPacketRewriter1_13_1(this);
     private final ParticleRewriter<ClientboundPackets1_13> particleRewriter = new ParticleRewriter<>(this);
     private final TagRewriter<ClientboundPackets1_13> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_13> blockRewriter = BlockRewriter.legacy(this);
 
     public Protocol1_13To1_13_1() {
         super(ClientboundPackets1_13.class, ClientboundPackets1_13.class, ServerboundPackets1_13.class, ServerboundPackets1_13.class);
@@ -130,9 +131,6 @@ public class Protocol1_13To1_13_1 extends AbstractProtocol<ClientboundPackets1_1
         });
 
         tagRewriter.register(ClientboundPackets1_13.UPDATE_TAGS, RegistryType.ITEM);
-        particleRewriter.registerLevelParticles1_13(ClientboundPackets1_13.LEVEL_PARTICLES, Types.FLOAT);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_13.AWARD_STATS);
     }
 
     @Override
@@ -156,6 +154,11 @@ public class Protocol1_13To1_13_1 extends AbstractProtocol<ClientboundPackets1_1
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_13> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_13> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_13to1_13_1/rewriter/EntityPacketRewriter1_13_1.java

@@ -133,7 +133,6 @@ public class EntityPacketRewriter1_13_1 extends EntityRewriter<ClientboundPacket
             }
         });
 
-        registerRemoveEntities(ClientboundPackets1_13.REMOVE_ENTITIES);
         registerSetEntityData(ClientboundPackets1_13.SET_ENTITY_DATA, Types1_13.ENTITY_DATA_LIST);
     }
 

common/src/main/java/com/viaversion/viaversion/protocols/v1_13to1_13_1/rewriter/ItemPacketRewriter1_13_1.java

@@ -36,11 +36,6 @@ public class ItemPacketRewriter1_13_1 extends ItemRewriter<ClientboundPackets1_1
 
     @Override
     public void registerPackets() {
-        registerSetSlot(ClientboundPackets1_13.CONTAINER_SET_SLOT);
-        registerSetContent(ClientboundPackets1_13.CONTAINER_SET_CONTENT);
-        registerAdvancements(ClientboundPackets1_13.UPDATE_ADVANCEMENTS);
-        registerCooldown(ClientboundPackets1_13.COOLDOWN);
-
         protocol.registerClientbound(ClientboundPackets1_13.CUSTOM_PAYLOAD, new PacketHandlers() {
             @Override
             public void register() {
@@ -72,8 +67,6 @@ public class ItemPacketRewriter1_13_1 extends ItemRewriter<ClientboundPackets1_1
             }
         });
 
-        registerSetEquippedItem(ClientboundPackets1_13.SET_EQUIPPED_ITEM);
-
         RecipeRewriter<ClientboundPackets1_13> recipeRewriter = new RecipeRewriter<>(protocol) {
             @Override
             protected Type<Item> itemType() {
@@ -94,8 +87,5 @@ public class ItemPacketRewriter1_13_1 extends ItemRewriter<ClientboundPackets1_1
                 recipeRewriter.handleRecipeType(wrapper, type);
             }
         });
-
-        registerContainerClick(ServerboundPackets1_13.CONTAINER_CLICK);
-        registerSetCreativeModeSlot(ServerboundPackets1_13.SET_CREATIVE_MODE_SLOT);
     }
 }

common/src/main/java/com/viaversion/viaversion/protocols/v1_13to1_13_1/rewriter/WorldPacketRewriter1_13_1.java

@@ -24,25 +24,18 @@ import com.viaversion.viaversion.api.type.Types;
 import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_13;
 import com.viaversion.viaversion.protocols.v1_12_2to1_13.packet.ClientboundPackets1_13;
 import com.viaversion.viaversion.protocols.v1_13to1_13_1.Protocol1_13To1_13_1;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 
 public class WorldPacketRewriter1_13_1 {
 
     public static void register(Protocol1_13To1_13_1 protocol) {
-        BlockRewriter<ClientboundPackets1_13> blockRewriter = BlockRewriter.legacy(protocol);
-
         protocol.registerClientbound(ClientboundPackets1_13.LEVEL_CHUNK, wrapper -> {
             ClientWorld clientWorld = wrapper.user().getClientWorld(Protocol1_13To1_13_1.class);
             Chunk chunk = wrapper.passthrough(ChunkType1_13.forEnvironment(clientWorld.getEnvironment()));
 
-            blockRewriter.handleChunk(chunk);
+            protocol.getBlockRewriter().handleChunk(chunk);
         });
 
-        blockRewriter.registerBlockEvent(ClientboundPackets1_13.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_13.BLOCK_UPDATE);
-        blockRewriter.registerChunkBlocksUpdate(ClientboundPackets1_13.CHUNK_BLOCKS_UPDATE);
-
-        protocol.registerClientbound(ClientboundPackets1_13.LEVEL_EVENT, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_13.LEVEL_EVENT, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.INT); // Effect Id

common/src/main/java/com/viaversion/viaversion/protocols/v1_14_4to1_15/Protocol1_14_4To1_15.java

@@ -32,9 +32,8 @@ import com.viaversion.viaversion.protocols.v1_14_4to1_15.packet.ClientboundPacke
 import com.viaversion.viaversion.protocols.v1_14_4to1_15.rewriter.EntityPacketRewriter1_15;
 import com.viaversion.viaversion.protocols.v1_14_4to1_15.rewriter.ItemPacketRewriter1_15;
 import com.viaversion.viaversion.protocols.v1_14_4to1_15.rewriter.WorldPacketRewriter1_15;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 
 public class Protocol1_14_4To1_15 extends AbstractProtocol<ClientboundPackets1_14_4, ClientboundPackets1_15, ServerboundPackets1_14, ServerboundPackets1_14> {
@@ -44,6 +43,7 @@ public class Protocol1_14_4To1_15 extends AbstractProtocol<ClientboundPackets1_1
     private final ItemPacketRewriter1_15 itemRewriter = new ItemPacketRewriter1_15(this);
     private final ParticleRewriter<ClientboundPackets1_14_4> particleRewriter = new ParticleRewriter<>(this);
     private final TagRewriter<ClientboundPackets1_14_4> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_14_4> blockRewriter = BlockRewriter.for1_14(this);
 
     public Protocol1_14_4To1_15() {
         super(ClientboundPackets1_14_4.class, ClientboundPackets1_15.class, ServerboundPackets1_14.class, ServerboundPackets1_14.class);
@@ -55,12 +55,6 @@ public class Protocol1_14_4To1_15 extends AbstractProtocol<ClientboundPackets1_1
 
         WorldPacketRewriter1_15.register(this);
 
-        SoundRewriter<ClientboundPackets1_14_4> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound(ClientboundPackets1_14_4.SOUND_ENTITY); // Entity Sound Effect (added somewhere in 1.14)
-        soundRewriter.registerSound(ClientboundPackets1_14_4.SOUND);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_14_4.AWARD_STATS);
-
         registerServerbound(ServerboundPackets1_14.EDIT_BOOK, wrapper -> itemRewriter.handleItemToServer(wrapper.user(), wrapper.passthrough(Types.ITEM1_13_2)));
 
         tagRewriter.register(ClientboundPackets1_14_4.UPDATE_TAGS, RegistryType.ENTITY);
@@ -99,6 +93,11 @@ public class Protocol1_14_4To1_15 extends AbstractProtocol<ClientboundPackets1_1
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_14_4> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_14_4> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_14_4to1_15/rewriter/EntityPacketRewriter1_15.java

@@ -40,9 +40,7 @@ public class EntityPacketRewriter1_15 extends EntityRewriter<ClientboundPackets1
 
     @Override
     protected void registerPackets() {
-        registerTrackerWithData(ClientboundPackets1_14_4.ADD_ENTITY, EntityTypes1_15.FALLING_BLOCK);
-
-        protocol.registerClientbound(ClientboundPackets1_14_4.ADD_MOB, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_14_4.ADD_MOB, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.VAR_INT); // 0 - Entity ID
@@ -123,7 +121,6 @@ public class EntityPacketRewriter1_15 extends EntityRewriter<ClientboundPackets1
         });
 
         registerSetEntityData(ClientboundPackets1_14_4.SET_ENTITY_DATA, Types1_14.ENTITY_DATA_LIST);
-        registerRemoveEntities(ClientboundPackets1_14_4.REMOVE_ENTITIES);
     }
 
     @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_14_4to1_15/rewriter/ItemPacketRewriter1_15.java

@@ -32,16 +32,6 @@ public class ItemPacketRewriter1_15 extends ItemRewriter<ClientboundPackets1_14_
 
     @Override
     public void registerPackets() {
-        registerCooldown(ClientboundPackets1_14_4.COOLDOWN);
-        registerSetContent(ClientboundPackets1_14_4.CONTAINER_SET_CONTENT);
-        registerMerchantOffers(ClientboundPackets1_14_4.MERCHANT_OFFERS);
-        registerSetSlot(ClientboundPackets1_14_4.CONTAINER_SET_SLOT);
-        registerSetEquippedItem(ClientboundPackets1_14_4.SET_EQUIPPED_ITEM);
-        registerAdvancements(ClientboundPackets1_14_4.UPDATE_ADVANCEMENTS);
-
         new RecipeRewriter<>(protocol).register(ClientboundPackets1_14_4.UPDATE_RECIPES);
-
-        registerContainerClick(ServerboundPackets1_14.CONTAINER_CLICK);
-        registerSetCreativeModeSlot(ServerboundPackets1_14.SET_CREATIVE_MODE_SLOT);
     }
 }

common/src/main/java/com/viaversion/viaversion/protocols/v1_14_4to1_15/rewriter/WorldPacketRewriter1_15.java

@@ -23,18 +23,11 @@ import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_14;
 import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_15;
 import com.viaversion.viaversion.protocols.v1_14_3to1_14_4.packet.ClientboundPackets1_14_4;
 import com.viaversion.viaversion.protocols.v1_14_4to1_15.Protocol1_14_4To1_15;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 
 public final class WorldPacketRewriter1_15 {
 
     public static void register(Protocol1_14_4To1_15 protocol) {
-        BlockRewriter<ClientboundPackets1_14_4> blockRewriter = BlockRewriter.for1_14(protocol);
-
-        blockRewriter.registerBlockEvent(ClientboundPackets1_14_4.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_14_4.BLOCK_UPDATE);
-        blockRewriter.registerChunkBlocksUpdate(ClientboundPackets1_14_4.CHUNK_BLOCKS_UPDATE);
-        blockRewriter.registerBlockBreakAck(ClientboundPackets1_14_4.BLOCK_BREAK_ACK);
-        blockRewriter.registerLevelChunk(ClientboundPackets1_14_4.LEVEL_CHUNK, ChunkType1_14.TYPE, ChunkType1_15.TYPE, (connection, chunk) -> {
+        protocol.getBlockRewriter().registerLevelChunk(ClientboundPackets1_14_4.LEVEL_CHUNK, ChunkType1_14.TYPE, ChunkType1_15.TYPE, (connection, chunk) -> {
             if (chunk.isFullChunk()) {
                 int[] biomeData = chunk.getBiomeData();
                 int[] newBiomeData = new int[1024];
@@ -58,8 +51,7 @@ public final class WorldPacketRewriter1_15 {
             }
         });
 
-        blockRewriter.registerLevelEvent(ClientboundPackets1_14_4.LEVEL_EVENT, 1010, 2001);
-        protocol.registerClientbound(ClientboundPackets1_14_4.LEVEL_PARTICLES, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_14_4.LEVEL_PARTICLES, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.INT); // 0 - Particle ID

common/src/main/java/com/viaversion/viaversion/protocols/v1_14to1_14_1/rewriter/EntityPacketRewriter1_14_1.java

@@ -55,8 +55,6 @@ public class EntityPacketRewriter1_14_1 extends EntityRewriter<ClientboundPacket
             }
         });
 
-        registerRemoveEntities(ClientboundPackets1_14.REMOVE_ENTITIES);
-
         protocol.registerClientbound(ClientboundPackets1_14.ADD_PLAYER, new PacketHandlers() {
             @Override
             public void register() {

common/src/main/java/com/viaversion/viaversion/protocols/v1_15_2to1_16/Protocol1_15_2To1_16.java

@@ -47,9 +47,8 @@ import com.viaversion.viaversion.protocols.v1_15_2to1_16.rewriter.EntityPacketRe
 import com.viaversion.viaversion.protocols.v1_15_2to1_16.rewriter.ItemPacketRewriter1_16;
 import com.viaversion.viaversion.protocols.v1_15_2to1_16.rewriter.WorldPacketRewriter1_16;
 import com.viaversion.viaversion.protocols.v1_15_2to1_16.storage.InventoryTracker1_16;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.util.GsonUtil;
 import com.viaversion.viaversion.util.Key;
@@ -67,6 +66,7 @@ public class Protocol1_15_2To1_16 extends AbstractProtocol<ClientboundPackets1_1
     private final ParticleRewriter<ClientboundPackets1_15> particleRewriter = new ParticleRewriter<>(this);
     private final ComponentRewriter1_16 componentRewriter = new ComponentRewriter1_16(this);
     private final TagRewriter<ClientboundPackets1_15> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_15> blockRewriter = BlockRewriter.for1_14(this);
 
     public Protocol1_15_2To1_16() {
         super(ClientboundPackets1_15.class, ClientboundPackets1_16.class, ServerboundPackets1_14.class, ServerboundPackets1_16.class);
@@ -79,10 +79,6 @@ public class Protocol1_15_2To1_16 extends AbstractProtocol<ClientboundPackets1_1
         WorldPacketRewriter1_16.register(this);
 
         tagRewriter.register(ClientboundPackets1_15.UPDATE_TAGS, RegistryType.ENTITY);
-        particleRewriter.registerLevelParticles1_13(ClientboundPackets1_15.LEVEL_PARTICLES, Types.DOUBLE);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_15.AWARD_STATS);
-
         // Login Success
         registerClientbound(State.LOGIN, ClientboundLoginPackets.LOGIN_FINISHED, wrapper -> {
             // Transform string to a uuid
@@ -126,7 +122,7 @@ public class Protocol1_15_2To1_16 extends AbstractProtocol<ClientboundPackets1_1
         });
 
         // Handle (relevant) component cases for translatable and score changes
-        registerClientbound(ClientboundPackets1_15.CHAT, new PacketHandlers() {
+        replaceClientbound(ClientboundPackets1_15.CHAT, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.COMPONENT);
@@ -137,13 +133,6 @@ public class Protocol1_15_2To1_16 extends AbstractProtocol<ClientboundPackets1_1
                 });
             }
         });
-        componentRewriter.registerBossEvent(ClientboundPackets1_15.BOSS_EVENT);
-        componentRewriter.registerTitle(ClientboundPackets1_15.SET_TITLES);
-        componentRewriter.registerPlayerCombat(ClientboundPackets1_15.PLAYER_COMBAT);
-
-        SoundRewriter<ClientboundPackets1_15> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound(ClientboundPackets1_15.SOUND);
-        soundRewriter.registerSound(ClientboundPackets1_15.SOUND_ENTITY);
 
         registerServerbound(ServerboundPackets1_16.INTERACT, wrapper -> {
             wrapper.passthrough(Types.VAR_INT); // Entity Id
@@ -258,6 +247,11 @@ public class Protocol1_15_2To1_16 extends AbstractProtocol<ClientboundPackets1_1
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_15> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_15> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_15_2to1_16/rewriter/EntityPacketRewriter1_16.java

@@ -107,11 +107,8 @@ public class EntityPacketRewriter1_16 extends EntityRewriter<ClientboundPackets1
             wrapper.write(Types.SHORT, (short) 0); // velocity
         });
 
-        registerTrackerWithData(ClientboundPackets1_15.ADD_ENTITY, EntityTypes1_16.FALLING_BLOCK);
-        registerTracker(ClientboundPackets1_15.ADD_MOB);
         registerTracker(ClientboundPackets1_15.ADD_PLAYER, EntityTypes1_16.PLAYER);
         registerSetEntityData(ClientboundPackets1_15.SET_ENTITY_DATA, Types1_14.ENTITY_DATA_LIST, Types1_16.ENTITY_DATA_LIST);
-        registerRemoveEntities(ClientboundPackets1_15.REMOVE_ENTITIES);
 
         protocol.registerClientbound(ClientboundPackets1_15.RESPAWN, new PacketHandlers() {
             @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_15_2to1_16/rewriter/ItemPacketRewriter1_16.java

@@ -57,7 +57,7 @@ public class ItemPacketRewriter1_16 extends ItemRewriter<ClientboundPackets1_15,
             clearPacket.send(Protocol1_15_2To1_16.class);
         };
 
-        protocol.registerClientbound(ClientboundPackets1_15.OPEN_SCREEN, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_15.OPEN_SCREEN, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.VAR_INT); // Window Id
@@ -106,12 +106,6 @@ public class ItemPacketRewriter1_16 extends ItemRewriter<ClientboundPackets1_15,
             }
         });
 
-        registerCooldown(ClientboundPackets1_15.COOLDOWN);
-        registerSetContent(ClientboundPackets1_15.CONTAINER_SET_CONTENT);
-        registerMerchantOffers(ClientboundPackets1_15.MERCHANT_OFFERS);
-        registerSetSlot(ClientboundPackets1_15.CONTAINER_SET_SLOT);
-        registerAdvancements(ClientboundPackets1_15.UPDATE_ADVANCEMENTS);
-
         protocol.registerClientbound(ClientboundPackets1_15.SET_EQUIPPED_ITEM, ClientboundPackets1_16.SET_EQUIPMENT, new PacketHandlers() {
             @Override
             public void register() {
@@ -127,9 +121,6 @@ public class ItemPacketRewriter1_16 extends ItemRewriter<ClientboundPackets1_15,
 
         new RecipeRewriter<>(protocol).register(ClientboundPackets1_15.UPDATE_RECIPES);
 
-        registerContainerClick(ServerboundPackets1_16.CONTAINER_CLICK);
-        registerSetCreativeModeSlot(ServerboundPackets1_16.SET_CREATIVE_MODE_SLOT);
-
         protocol.registerServerbound(ServerboundPackets1_16.CONTAINER_CLOSE, wrapper -> {
             InventoryTracker1_16 inventoryTracker = wrapper.user().get(InventoryTracker1_16.class);
             inventoryTracker.setInventoryOpen(false);

common/src/main/java/com/viaversion/viaversion/protocols/v1_15_2to1_16/rewriter/WorldPacketRewriter1_16.java

@@ -30,7 +30,6 @@ import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_15;
 import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_16;
 import com.viaversion.viaversion.protocols.v1_14_4to1_15.packet.ClientboundPackets1_15;
 import com.viaversion.viaversion.protocols.v1_15_2to1_16.Protocol1_15_2To1_16;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.util.CompactArrayUtil;
 import com.viaversion.viaversion.util.Key;
 import com.viaversion.viaversion.util.UUIDUtil;
@@ -40,13 +39,7 @@ import java.util.UUID;
 public class WorldPacketRewriter1_16 {
 
     public static void register(Protocol1_15_2To1_16 protocol) {
-        BlockRewriter<ClientboundPackets1_15> blockRewriter = BlockRewriter.for1_14(protocol);
-
-        blockRewriter.registerBlockEvent(ClientboundPackets1_15.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_15.BLOCK_UPDATE);
-        blockRewriter.registerChunkBlocksUpdate(ClientboundPackets1_15.CHUNK_BLOCKS_UPDATE);
-        blockRewriter.registerBlockBreakAck(ClientboundPackets1_15.BLOCK_BREAK_ACK);
-        blockRewriter.registerLevelChunk(ClientboundPackets1_15.LEVEL_CHUNK, ChunkType1_15.TYPE, ChunkType1_16.TYPE, (connection, chunk) -> {
+        protocol.getBlockRewriter().registerLevelChunk(ClientboundPackets1_15.LEVEL_CHUNK, ChunkType1_15.TYPE, ChunkType1_16.TYPE, (connection, chunk) -> {
             chunk.setIgnoreOldLightData(chunk.isFullChunk());
 
             CompoundTag heightMaps = chunk.getHeightMap();
@@ -78,8 +71,6 @@ public class WorldPacketRewriter1_16 {
             CompoundTag tag = wrapper.passthrough(Types.NAMED_COMPOUND_TAG);
             handleBlockEntity(protocol, wrapper.user(), tag);
         });
-
-        blockRewriter.registerLevelEvent(ClientboundPackets1_15.LEVEL_EVENT, 1010, 2001);
     }
 
     private static void handleBlockEntity(Protocol1_15_2To1_16 protocol, UserConnection connection, CompoundTag compoundTag) {

common/src/main/java/com/viaversion/viaversion/protocols/v1_16_1to1_16_2/Protocol1_16_1To1_16_2.java

@@ -31,9 +31,8 @@ import com.viaversion.viaversion.protocols.v1_16_1to1_16_2.packet.ServerboundPac
 import com.viaversion.viaversion.protocols.v1_16_1to1_16_2.rewriter.EntityPacketRewriter1_16_2;
 import com.viaversion.viaversion.protocols.v1_16_1to1_16_2.rewriter.ItemPacketRewriter1_16_2;
 import com.viaversion.viaversion.protocols.v1_16_1to1_16_2.rewriter.WorldPacketRewriter1_16_2;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 
 public class Protocol1_16_1To1_16_2 extends AbstractProtocol<ClientboundPackets1_16, ClientboundPackets1_16_2, ServerboundPackets1_16, ServerboundPackets1_16_2> {
@@ -43,6 +42,7 @@ public class Protocol1_16_1To1_16_2 extends AbstractProtocol<ClientboundPackets1
     private final ItemPacketRewriter1_16_2 itemRewriter = new ItemPacketRewriter1_16_2(this);
     private final ParticleRewriter<ClientboundPackets1_16> particleRewriter = new ParticleRewriter<>(this);
     private final TagRewriter<ClientboundPackets1_16> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_16> blockRewriter = BlockRewriter.for1_14(this);
 
     public Protocol1_16_1To1_16_2() {
         super(ClientboundPackets1_16.class, ClientboundPackets1_16_2.class, ServerboundPackets1_16.class, ServerboundPackets1_16_2.class);
@@ -55,13 +55,6 @@ public class Protocol1_16_1To1_16_2 extends AbstractProtocol<ClientboundPackets1
         WorldPacketRewriter1_16_2.register(this);
 
         tagRewriter.register(ClientboundPackets1_16.UPDATE_TAGS, RegistryType.ENTITY);
-        particleRewriter.registerLevelParticles1_13(ClientboundPackets1_16.LEVEL_PARTICLES, Types.DOUBLE);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_16.AWARD_STATS);
-
-        SoundRewriter<ClientboundPackets1_16> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound(ClientboundPackets1_16.SOUND);
-        soundRewriter.registerSound(ClientboundPackets1_16.SOUND_ENTITY);
 
         // Recipe book data has been split into 2 separate packets
         registerServerbound(ServerboundPackets1_16_2.RECIPE_BOOK_CHANGE_SETTINGS, ServerboundPackets1_16.RECIPE_BOOK_UPDATE, wrapper -> {
@@ -114,6 +107,11 @@ public class Protocol1_16_1To1_16_2 extends AbstractProtocol<ClientboundPackets1
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_16> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_16> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_16_1to1_16_2/rewriter/EntityPacketRewriter1_16_2.java

@@ -35,11 +35,8 @@ public class EntityPacketRewriter1_16_2 extends EntityRewriter<ClientboundPacket
 
     @Override
     protected void registerPackets() {
-        registerTrackerWithData(ClientboundPackets1_16.ADD_ENTITY, EntityTypes1_16_2.FALLING_BLOCK);
-        registerTracker(ClientboundPackets1_16.ADD_MOB);
         registerTracker(ClientboundPackets1_16.ADD_PLAYER, EntityTypes1_16_2.PLAYER);
         registerSetEntityData(ClientboundPackets1_16.SET_ENTITY_DATA, Types1_16.ENTITY_DATA_LIST);
-        registerRemoveEntities(ClientboundPackets1_16.REMOVE_ENTITIES);
 
         protocol.registerClientbound(ClientboundPackets1_16.LOGIN, new PacketHandlers() {
             @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_16_1to1_16_2/rewriter/ItemPacketRewriter1_16_2.java

@@ -32,13 +32,6 @@ public class ItemPacketRewriter1_16_2 extends ItemRewriter<ClientboundPackets1_1
 
     @Override
     public void registerPackets() {
-        registerCooldown(ClientboundPackets1_16.COOLDOWN);
-        registerSetContent(ClientboundPackets1_16.CONTAINER_SET_CONTENT);
-        registerMerchantOffers(ClientboundPackets1_16.MERCHANT_OFFERS);
-        registerSetSlot(ClientboundPackets1_16.CONTAINER_SET_SLOT);
-        registerSetEquipment(ClientboundPackets1_16.SET_EQUIPMENT);
-        registerAdvancements(ClientboundPackets1_16.UPDATE_ADVANCEMENTS);
-
         protocol.registerClientbound(ClientboundPackets1_16.RECIPE, wrapper -> {
             wrapper.passthrough(Types.VAR_INT);
             wrapper.passthrough(Types.BOOLEAN); // Open
@@ -54,8 +47,6 @@ public class ItemPacketRewriter1_16_2 extends ItemRewriter<ClientboundPackets1_1
 
         new RecipeRewriter<>(protocol).register(ClientboundPackets1_16.UPDATE_RECIPES);
 
-        registerContainerClick(ServerboundPackets1_16_2.CONTAINER_CLICK);
-        registerSetCreativeModeSlot(ServerboundPackets1_16_2.SET_CREATIVE_MODE_SLOT);
         protocol.registerServerbound(ServerboundPackets1_16_2.EDIT_BOOK, wrapper -> handleItemToServer(wrapper.user(), wrapper.passthrough(Types.ITEM1_13_2)));
     }
 }

common/src/main/java/com/viaversion/viaversion/protocols/v1_16_1to1_16_2/rewriter/WorldPacketRewriter1_16_2.java

@@ -35,12 +35,7 @@ public class WorldPacketRewriter1_16_2 {
     private static final BlockChangeRecord[] EMPTY_RECORDS = new BlockChangeRecord[0];
 
     public static void register(Protocol1_16_1To1_16_2 protocol) {
-        BlockRewriter<ClientboundPackets1_16> blockRewriter = BlockRewriter.for1_14(protocol);
-
-        blockRewriter.registerBlockEvent(ClientboundPackets1_16.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_16.BLOCK_UPDATE);
-        blockRewriter.registerBlockBreakAck(ClientboundPackets1_16.BLOCK_BREAK_ACK);
-        blockRewriter.registerLevelChunk(ClientboundPackets1_16.LEVEL_CHUNK, ChunkType1_16.TYPE, ChunkType1_16_2.TYPE);
+        protocol.getBlockRewriter().registerLevelChunk(ClientboundPackets1_16.LEVEL_CHUNK, ChunkType1_16.TYPE, ChunkType1_16_2.TYPE);
 
         protocol.registerClientbound(ClientboundPackets1_16.CHUNK_BLOCKS_UPDATE, ClientboundPackets1_16_2.SECTION_BLOCKS_UPDATE, wrapper -> {
             wrapper.cancel();
@@ -78,7 +73,5 @@ public class WorldPacketRewriter1_16_2 {
                 newPacket.send(Protocol1_16_1To1_16_2.class);
             }
         });
-
-        blockRewriter.registerLevelEvent(ClientboundPackets1_16.LEVEL_EVENT, 1010, 2001);
     }
 }

common/src/main/java/com/viaversion/viaversion/protocols/v1_16_4to1_17/Protocol1_16_4To1_17.java

@@ -38,11 +38,9 @@ import com.viaversion.viaversion.protocols.v1_16_4to1_17.rewriter.ComponentRewri
 import com.viaversion.viaversion.protocols.v1_16_4to1_17.rewriter.EntityPacketRewriter1_17;
 import com.viaversion.viaversion.protocols.v1_16_4to1_17.rewriter.ItemPacketRewriter1_17;
 import com.viaversion.viaversion.protocols.v1_16_4to1_17.rewriter.WorldPacketRewriter1_17;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
-import org.checkerframework.checker.nullness.qual.Nullable;
 
 public final class Protocol1_16_4To1_17 extends AbstractProtocol<ClientboundPackets1_16_2, ClientboundPackets1_17, ServerboundPackets1_16_2, ServerboundPackets1_17> {
 
@@ -52,6 +50,7 @@ public final class Protocol1_16_4To1_17 extends AbstractProtocol<ClientboundPack
     private final ParticleRewriter<ClientboundPackets1_16_2> particleRewriter = new ParticleRewriter<>(this);
     private final ComponentRewriter1_17 componentRewriter = new ComponentRewriter1_17(this);
     private final TagRewriter<ClientboundPackets1_16_2> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_16_2> blockRewriter = BlockRewriter.for1_14(this);
 
     public Protocol1_16_4To1_17() {
         super(ClientboundPackets1_16_2.class, ClientboundPackets1_17.class, ServerboundPackets1_16_2.class, ServerboundPackets1_17.class);
@@ -85,23 +84,6 @@ public final class Protocol1_16_4To1_17 extends AbstractProtocol<ClientboundPack
             tagRewriter.appendNewTags(wrapper, RegistryType.GAME_EVENT);
         });
 
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_16_2.AWARD_STATS);
-
-        componentRewriter.registerComponentPacket(ClientboundPackets1_16_2.CHAT);
-        componentRewriter.registerBossEvent(ClientboundPackets1_16_2.BOSS_EVENT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_16_2.DISCONNECT);
-        componentRewriter.registerTabList(ClientboundPackets1_16_2.TAB_LIST);
-        componentRewriter.registerOpenScreen1_14(ClientboundPackets1_16_2.OPEN_SCREEN);
-        componentRewriter.registerSetPlayerTeam1_13(ClientboundPackets1_16_2.SET_PLAYER_TEAM);
-        componentRewriter.registerSetObjective(ClientboundPackets1_16_2.SET_OBJECTIVE);
-        componentRewriter.registerPing();
-
-        SoundRewriter<ClientboundPackets1_16_2> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound(ClientboundPackets1_16_2.SOUND);
-        soundRewriter.registerSound(ClientboundPackets1_16_2.SOUND_ENTITY);
-
-        particleRewriter.registerLevelParticles1_13(ClientboundPackets1_16_2.LEVEL_PARTICLES, Types.DOUBLE);
-
         registerClientbound(ClientboundPackets1_16_2.RESOURCE_PACK, wrapper -> {
             wrapper.passthrough(Types.STRING);
             wrapper.passthrough(Types.STRING);
@@ -227,13 +209,18 @@ public final class Protocol1_16_4To1_17 extends AbstractProtocol<ClientboundPack
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_16_2> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_16_2> getParticleRewriter() {
         return particleRewriter;
     }
 
     @Override
-    public @Nullable ComponentRewriter1_17 getComponentRewriter() {
+    public ComponentRewriter1_17 getComponentRewriter() {
         return componentRewriter;
     }
 

common/src/main/java/com/viaversion/viaversion/protocols/v1_16_4to1_17/rewriter/EntityPacketRewriter1_17.java

@@ -43,8 +43,6 @@ public final class EntityPacketRewriter1_17 extends EntityRewriter<ClientboundPa
 
     @Override
     public void registerPackets() {
-        registerTrackerWithData(ClientboundPackets1_16_2.ADD_ENTITY, EntityTypes1_17.FALLING_BLOCK);
-        registerTracker(ClientboundPackets1_16_2.ADD_MOB);
         registerTracker(ClientboundPackets1_16_2.ADD_PLAYER, EntityTypes1_17.PLAYER);
         registerSetEntityData(ClientboundPackets1_16_2.SET_ENTITY_DATA, Types1_16.ENTITY_DATA_LIST, Types1_17.ENTITY_DATA_LIST);
 

common/src/main/java/com/viaversion/viaversion/protocols/v1_16_4to1_17/rewriter/ItemPacketRewriter1_17.java

@@ -40,20 +40,11 @@ public final class ItemPacketRewriter1_17 extends ItemRewriter<ClientboundPacket
 
     @Override
     public void registerPackets() {
-        registerCooldown(ClientboundPackets1_16_2.COOLDOWN);
-        registerSetContent(ClientboundPackets1_16_2.CONTAINER_SET_CONTENT);
-        registerMerchantOffers(ClientboundPackets1_16_2.MERCHANT_OFFERS);
-        registerSetSlot(ClientboundPackets1_16_2.CONTAINER_SET_SLOT);
-        registerAdvancements(ClientboundPackets1_16_2.UPDATE_ADVANCEMENTS);
-        registerSetEquipment(ClientboundPackets1_16_2.SET_EQUIPMENT);
-
         new RecipeRewriter<>(protocol).register(ClientboundPackets1_16_2.UPDATE_RECIPES);
 
-        registerSetCreativeModeSlot(ServerboundPackets1_17.SET_CREATIVE_MODE_SLOT);
-
         protocol.registerServerbound(ServerboundPackets1_17.EDIT_BOOK, wrapper -> handleItemToServer(wrapper.user(), wrapper.passthrough(Types.ITEM1_13_2)));
 
-        protocol.registerServerbound(ServerboundPackets1_17.CONTAINER_CLICK, new PacketHandlers() {
+        protocol.replaceServerbound(ServerboundPackets1_17.CONTAINER_CLICK, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.BYTE); // Window Id

common/src/main/java/com/viaversion/viaversion/protocols/v1_16_4to1_17/rewriter/WorldPacketRewriter1_17.java

@@ -32,7 +32,6 @@ import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_17;
 import com.viaversion.viaversion.protocols.v1_16_1to1_16_2.packet.ClientboundPackets1_16_2;
 import com.viaversion.viaversion.protocols.v1_16_4to1_17.Protocol1_16_4To1_17;
 import com.viaversion.viaversion.protocols.v1_16_4to1_17.packet.ClientboundPackets1_17;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 import java.util.ArrayList;
 import java.util.BitSet;
 import java.util.List;
@@ -40,13 +39,6 @@ import java.util.List;
 public final class WorldPacketRewriter1_17 {
 
     public static void register(Protocol1_16_4To1_17 protocol) {
-        BlockRewriter<ClientboundPackets1_16_2> blockRewriter = BlockRewriter.for1_14(protocol);
-
-        blockRewriter.registerBlockEvent(ClientboundPackets1_16_2.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_16_2.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate(ClientboundPackets1_16_2.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerBlockBreakAck(ClientboundPackets1_16_2.BLOCK_BREAK_ACK);
-
         protocol.registerClientbound(ClientboundPackets1_16_2.SET_BORDER, null, wrapper -> {
             // Border packet actions have been split into individual packets (the content hasn't changed)
             int type = wrapper.read(Types.VAR_INT);
@@ -126,10 +118,8 @@ public final class WorldPacketRewriter1_17 {
             chunk.setChunkMask(BitSet.valueOf(new long[]{chunk.getBitmask()}));
 
             // Rewrite block state ids
-            blockRewriter.handleChunk(chunk);
+            protocol.getBlockRewriter().handleChunk(chunk);
         });
-
-        blockRewriter.registerLevelEvent(ClientboundPackets1_16_2.LEVEL_EVENT, 1010, 2001);
     }
 
     private static void writeMultiBlockChangePacket(PacketWrapper wrapper, Chunk chunk) {

common/src/main/java/com/viaversion/viaversion/protocols/v1_17_1to1_18/Protocol1_17_1To1_18.java

@@ -37,8 +37,6 @@ import com.viaversion.viaversion.protocols.v1_17_1to1_18.rewriter.WorldPacketRew
 import com.viaversion.viaversion.protocols.v1_17_1to1_18.storage.ChunkLightStorage;
 import com.viaversion.viaversion.protocols.v1_17to1_17_1.packet.ClientboundPackets1_17_1;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.util.ProtocolLogger;
 
@@ -62,27 +60,6 @@ public final class Protocol1_17_1To1_18 extends AbstractProtocol<ClientboundPack
         itemRewriter.register();
         WorldPacketRewriter1_18.register(this);
 
-        final SoundRewriter<ClientboundPackets1_17_1> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound(ClientboundPackets1_17_1.SOUND);
-        soundRewriter.registerSound(ClientboundPackets1_17_1.SOUND_ENTITY);
-
-        tagRewriter.registerGeneric(ClientboundPackets1_17_1.UPDATE_TAGS);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_17_1.AWARD_STATS);
-
-        componentRewriter.registerComponentPacket(ClientboundPackets1_17_1.CHAT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_17_1.SET_ACTION_BAR_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_17_1.SET_TITLE_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_17_1.SET_SUBTITLE_TEXT);
-        componentRewriter.registerBossEvent(ClientboundPackets1_17_1.BOSS_EVENT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_17_1.DISCONNECT);
-        componentRewriter.registerTabList(ClientboundPackets1_17_1.TAB_LIST);
-        componentRewriter.registerOpenScreen1_14(ClientboundPackets1_17_1.OPEN_SCREEN);
-        componentRewriter.registerPlayerCombatKill(ClientboundPackets1_17_1.PLAYER_COMBAT_KILL);
-        componentRewriter.registerSetPlayerTeam1_13(ClientboundPackets1_17_1.SET_PLAYER_TEAM);
-        componentRewriter.registerSetObjective(ClientboundPackets1_17_1.SET_OBJECTIVE);
-        componentRewriter.registerPing();
-
         registerServerbound(ServerboundPackets1_17.CLIENT_INFORMATION, new PacketHandlers() {
             @Override
             public void register() {

common/src/main/java/com/viaversion/viaversion/protocols/v1_17_1to1_18/rewriter/ItemPacketRewriter1_18.java

@@ -34,30 +34,7 @@ public final class ItemPacketRewriter1_18 extends ItemRewriter<ClientboundPacket
 
     @Override
     public void registerPackets() {
-        registerCooldown(ClientboundPackets1_17_1.COOLDOWN);
-        registerSetContent1_17_1(ClientboundPackets1_17_1.CONTAINER_SET_CONTENT);
-        registerMerchantOffers(ClientboundPackets1_17_1.MERCHANT_OFFERS);
-        registerSetSlot1_17_1(ClientboundPackets1_17_1.CONTAINER_SET_SLOT);
-        registerAdvancements(ClientboundPackets1_17_1.UPDATE_ADVANCEMENTS);
-        registerSetEquipment(ClientboundPackets1_17_1.SET_EQUIPMENT);
-
-        protocol.registerClientbound(ClientboundPackets1_17_1.LEVEL_EVENT, new PacketHandlers() {
-            @Override
-            public void register() {
-                map(Types.INT); // Effect id
-                map(Types.BLOCK_POSITION1_14); // Location
-                map(Types.INT); // Data
-                handler(wrapper -> {
-                    int id = wrapper.get(Types.INT, 0);
-                    int data = wrapper.get(Types.INT, 1);
-                    if (id == 1010) { // Play record
-                        wrapper.set(Types.INT, 1, protocol.getMappingData().getNewItemId(data));
-                    }
-                });
-            }
-        });
-
-        protocol.registerClientbound(ClientboundPackets1_17_1.LEVEL_PARTICLES, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_17_1.LEVEL_PARTICLES, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.INT); // Particle id
@@ -98,8 +75,5 @@ public final class ItemPacketRewriter1_18 extends ItemRewriter<ClientboundPacket
         });
 
         new RecipeRewriter<>(protocol).register(ClientboundPackets1_17_1.UPDATE_RECIPES);
-
-        registerContainerClick1_17_1(ServerboundPackets1_17.CONTAINER_CLICK);
-        registerSetCreativeModeSlot(ServerboundPackets1_17.SET_CREATIVE_MODE_SLOT);
     }
 }

common/src/main/java/com/viaversion/viaversion/protocols/v1_17to1_17_1/rewriter/ItemPacketRewriter1_17_1.java

@@ -42,22 +42,16 @@ public final class ItemPacketRewriter1_17_1 extends ItemRewriter<ClientboundPack
 
     @Override
     public void registerPackets() {
-        registerMerchantOffers(ClientboundPackets1_17.MERCHANT_OFFERS);
-        registerSetEquipment(ClientboundPackets1_17.SET_EQUIPMENT);
-        registerAdvancements(ClientboundPackets1_17.UPDATE_ADVANCEMENTS);
-
         new RecipeRewriter<>(protocol).register(ClientboundPackets1_17.UPDATE_RECIPES);
 
-        registerSetCreativeModeSlot(ServerboundPackets1_17.SET_CREATIVE_MODE_SLOT);
-
-        protocol.registerClientbound(ClientboundPackets1_17.CONTAINER_SET_SLOT, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_17.CONTAINER_SET_SLOT, wrapper -> {
             wrapper.passthrough(Types.BYTE); // Container id
             wrapper.write(Types.VAR_INT, 0); // Add arbitrary state id
             wrapper.passthrough(Types.SHORT); // Slot id
             passthroughClientboundItem(wrapper);
         });
 
-        protocol.registerClientbound(ClientboundPackets1_17.CONTAINER_SET_CONTENT, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_17.CONTAINER_SET_CONTENT, wrapper -> {
             wrapper.passthrough(Types.UNSIGNED_BYTE); // Container id
             wrapper.write(Types.VAR_INT, 0); // Add arbitrary state id
             // Length encoded as var int now
@@ -70,7 +64,7 @@ public final class ItemPacketRewriter1_17_1 extends ItemRewriter<ClientboundPack
             wrapper.write(Types.ITEM1_13_2, null);
         });
 
-        protocol.registerServerbound(ServerboundPackets1_17.CONTAINER_CLICK, wrapper -> {
+        protocol.replaceServerbound(ServerboundPackets1_17.CONTAINER_CLICK, wrapper -> {
             wrapper.passthrough(Types.BYTE); // Container id
             wrapper.read(Types.VAR_INT); // Remove state id
             wrapper.passthrough(Types.SHORT); // Slot

common/src/main/java/com/viaversion/viaversion/protocols/v1_18_2to1_19/Protocol1_18_2To1_19.java

@@ -28,6 +28,7 @@ import com.viaversion.viaversion.api.protocol.packet.State;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandler;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
 import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_18;
 import com.viaversion.viaversion.api.type.types.misc.ParticleType;
 import com.viaversion.viaversion.api.type.types.version.Types1_19;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
@@ -46,10 +47,10 @@ import com.viaversion.viaversion.protocols.v1_18_2to1_19.rewriter.WorldPacketRew
 import com.viaversion.viaversion.protocols.v1_18_2to1_19.storage.DimensionRegistryStorage;
 import com.viaversion.viaversion.protocols.v1_18_2to1_19.storage.NonceStorage1_19;
 import com.viaversion.viaversion.protocols.v1_18_2to1_19.storage.SequenceStorage;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.CommandRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
 import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.util.CipherUtil;
 import com.viaversion.viaversion.util.ComponentUtil;
@@ -63,6 +64,7 @@ public final class Protocol1_18_2To1_19 extends AbstractProtocol<ClientboundPack
     private final ParticleRewriter<ClientboundPackets1_18> particleRewriter = new ParticleRewriter<>(this);
     private final ComponentRewriter1_19 componentRewriter = new ComponentRewriter1_19(this);
     private final TagRewriter<ClientboundPackets1_18> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_18> blockRewriter = BlockRewriter.for1_18(this, ChunkType1_18::new);
 
     public Protocol1_18_2To1_19() {
         super(ClientboundPackets1_18.class, ClientboundPackets1_19.class, ServerboundPackets1_17.class, ServerboundPackets1_19.class);
@@ -70,16 +72,13 @@ public final class Protocol1_18_2To1_19 extends AbstractProtocol<ClientboundPack
 
     @Override
     protected void registerPackets() {
-        tagRewriter.registerGeneric(ClientboundPackets1_18.UPDATE_TAGS);
-
-        entityRewriter.register();
-        itemRewriter.register();
+        super.registerPackets();
         WorldPacketRewriter1_19.register(this);
 
         cancelClientbound(ClientboundPackets1_18.ADD_VIBRATION_SIGNAL);
 
         final SoundRewriter<ClientboundPackets1_18> soundRewriter = new SoundRewriter<>(this);
-        registerClientbound(ClientboundPackets1_18.SOUND, new PacketHandlers() {
+        replaceClientbound(ClientboundPackets1_18.SOUND, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.VAR_INT); // Sound id
@@ -93,7 +92,7 @@ public final class Protocol1_18_2To1_19 extends AbstractProtocol<ClientboundPack
                 handler(soundRewriter.getSoundHandler());
             }
         });
-        registerClientbound(ClientboundPackets1_18.SOUND_ENTITY, new PacketHandlers() {
+        replaceClientbound(ClientboundPackets1_18.SOUND_ENTITY, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.VAR_INT); // Sound id
@@ -119,8 +118,6 @@ public final class Protocol1_18_2To1_19 extends AbstractProtocol<ClientboundPack
             }
         });
 
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_18.AWARD_STATS);
-
         final PacketHandler singleNullTextComponentMapper = wrapper -> wrapper.write(Types.COMPONENT, mapTextComponentIfNull(wrapper.user(), wrapper.read(Types.COMPONENT)));
         registerClientbound(ClientboundPackets1_18.SET_TITLE_TEXT, singleNullTextComponentMapper);
         registerClientbound(ClientboundPackets1_18.SET_SUBTITLE_TEXT, singleNullTextComponentMapper);
@@ -146,13 +143,6 @@ public final class Protocol1_18_2To1_19 extends AbstractProtocol<ClientboundPack
             }
         });
 
-        componentRewriter.registerBossEvent(ClientboundPackets1_18.BOSS_EVENT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_18.DISCONNECT);
-        componentRewriter.registerTabList(ClientboundPackets1_18.TAB_LIST);
-        componentRewriter.registerOpenScreen1_14(ClientboundPackets1_18.OPEN_SCREEN);
-        componentRewriter.registerPlayerCombatKill(ClientboundPackets1_18.PLAYER_COMBAT_KILL);
-        componentRewriter.registerPing();
-
         registerClientbound(ClientboundPackets1_18.PLAYER_INFO, wrapper -> {
             final int action = wrapper.passthrough(Types.VAR_INT);
             final int entries = wrapper.passthrough(Types.VAR_INT);
@@ -392,6 +382,11 @@ public final class Protocol1_18_2To1_19 extends AbstractProtocol<ClientboundPack
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_18> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_18> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_18_2to1_19/rewriter/EntityPacketRewriter1_19.java

@@ -60,9 +60,8 @@ public final class EntityPacketRewriter1_19 extends EntityRewriter<ClientboundPa
     public void registerPackets() {
         registerTracker(ClientboundPackets1_18.ADD_PLAYER, EntityTypes1_19.PLAYER);
         registerSetEntityData(ClientboundPackets1_18.SET_ENTITY_DATA, Types1_18.ENTITY_DATA_LIST, Types1_19.ENTITY_DATA_LIST);
-        registerRemoveEntities(ClientboundPackets1_18.REMOVE_ENTITIES);
 
-        protocol.registerClientbound(ClientboundPackets1_18.ADD_ENTITY, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_18.ADD_ENTITY, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.VAR_INT); // Entity id

common/src/main/java/com/viaversion/viaversion/protocols/v1_18_2to1_19/rewriter/ItemPacketRewriter1_19.java

@@ -38,12 +38,7 @@ public final class ItemPacketRewriter1_19 extends ItemRewriter<ClientboundPacket
 
     @Override
     public void registerPackets() {
-        registerCooldown(ClientboundPackets1_18.COOLDOWN);
-        registerSetContent1_17_1(ClientboundPackets1_18.CONTAINER_SET_CONTENT);
-        registerSetSlot1_17_1(ClientboundPackets1_18.CONTAINER_SET_SLOT);
-        registerAdvancements(ClientboundPackets1_18.UPDATE_ADVANCEMENTS);
-        registerSetEquipment(ClientboundPackets1_18.SET_EQUIPMENT);
-        protocol.registerClientbound(ClientboundPackets1_18.LEVEL_PARTICLES, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_18.LEVEL_PARTICLES, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.INT, Types.VAR_INT); // 0 - Particle ID
@@ -73,12 +68,7 @@ public final class ItemPacketRewriter1_19 extends ItemRewriter<ClientboundPacket
             }
         });
 
-        registerContainerClick1_17_1(ServerboundPackets1_19.CONTAINER_CLICK);
-        registerSetCreativeModeSlot(ServerboundPackets1_19.SET_CREATIVE_MODE_SLOT);
-
-        registerContainerSetData(ClientboundPackets1_18.CONTAINER_SET_DATA);
-
-        protocol.registerClientbound(ClientboundPackets1_18.MERCHANT_OFFERS, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_18.MERCHANT_OFFERS, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.VAR_INT); // Container id

common/src/main/java/com/viaversion/viaversion/protocols/v1_18_2to1_19/rewriter/WorldPacketRewriter1_19.java

@@ -18,22 +18,13 @@
 package com.viaversion.viaversion.protocols.v1_18_2to1_19.rewriter;
 
 import com.viaversion.viaversion.api.type.Types;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_18;
 import com.viaversion.viaversion.protocols.v1_17_1to1_18.packet.ClientboundPackets1_18;
 import com.viaversion.viaversion.protocols.v1_18_2to1_19.Protocol1_18_2To1_19;
 import com.viaversion.viaversion.protocols.v1_18_2to1_19.packet.ServerboundPackets1_19;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 
 public final class WorldPacketRewriter1_19 {
 
     public static void register(final Protocol1_18_2To1_19 protocol) {
-        final BlockRewriter<ClientboundPackets1_18> blockRewriter = BlockRewriter.for1_14(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets1_18.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_18.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate(ClientboundPackets1_18.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerLevelEvent(ClientboundPackets1_18.LEVEL_EVENT, 1010, 2001);
-        blockRewriter.registerLevelChunk1_19(ClientboundPackets1_18.LEVEL_CHUNK_WITH_LIGHT, ChunkType1_18::new);
-
         protocol.cancelClientbound(ClientboundPackets1_18.BLOCK_BREAK_ACK);
 
         protocol.registerServerbound(ServerboundPackets1_19.SET_BEACON, wrapper -> {

common/src/main/java/com/viaversion/viaversion/protocols/v1_19_1to1_19_3/Protocol1_19_1To1_19_3.java

@@ -38,6 +38,7 @@ import com.viaversion.viaversion.api.protocol.packet.State;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandler;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
 import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_18;
 import com.viaversion.viaversion.api.type.types.misc.ParticleType;
 import com.viaversion.viaversion.api.type.types.version.Types1_19_3;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
@@ -52,9 +53,9 @@ import com.viaversion.viaversion.protocols.v1_19_1to1_19_3.storage.NonceStorage1
 import com.viaversion.viaversion.protocols.v1_19_1to1_19_3.storage.ReceivedMessagesStorage;
 import com.viaversion.viaversion.protocols.v1_19to1_19_1.packet.ClientboundPackets1_19_1;
 import com.viaversion.viaversion.protocols.v1_19to1_19_1.packet.ServerboundPackets1_19_1;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.CommandRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.util.ComponentUtil;
 import com.viaversion.viaversion.util.Pair;
@@ -73,6 +74,7 @@ public final class Protocol1_19_1To1_19_3 extends AbstractProtocol<ClientboundPa
     private final ParticleRewriter<ClientboundPackets1_19_1> particleRewriter = new ParticleRewriter<>(this);
     private final ComponentRewriter1_19_3 componentRewriter = new ComponentRewriter1_19_3(this);
     private final TagRewriter<ClientboundPackets1_19_1> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_19_1> blockRewriter = BlockRewriter.for1_18(this, ChunkType1_18::new);
 
     public Protocol1_19_1To1_19_3() {
         super(ClientboundPackets1_19_1.class, ClientboundPackets1_19_3.class, ServerboundPackets1_19_1.class, ServerboundPackets1_19_3.class);
@@ -80,12 +82,7 @@ public final class Protocol1_19_1To1_19_3 extends AbstractProtocol<ClientboundPa
 
     @Override
     protected void registerPackets() {
-        tagRewriter.registerGeneric(ClientboundPackets1_19_1.UPDATE_TAGS);
-
-        particleRewriter.registerLevelParticles1_19(ClientboundPackets1_19_1.LEVEL_PARTICLES);
-
-        entityRewriter.register();
-        itemRewriter.register();
+        super.registerPackets();
 
         // Rewrite sounds as holders
         final PacketHandler soundHandler = wrapper -> {
@@ -98,28 +95,13 @@ public final class Protocol1_19_1To1_19_3 extends AbstractProtocol<ClientboundPa
 
             wrapper.write(Types.SOUND_EVENT, Holder.of(soundId));
         };
-        registerClientbound(ClientboundPackets1_19_1.SOUND_ENTITY, soundHandler);
-        registerClientbound(ClientboundPackets1_19_1.SOUND, soundHandler);
+        replaceClientbound(ClientboundPackets1_19_1.SOUND_ENTITY, soundHandler);
+        replaceClientbound(ClientboundPackets1_19_1.SOUND, soundHandler);
         registerClientbound(ClientboundPackets1_19_1.CUSTOM_SOUND, ClientboundPackets1_19_3.SOUND, wrapper -> {
             final String soundIdentifier = wrapper.read(Types.STRING);
             wrapper.write(Types.SOUND_EVENT, Holder.of(new SoundEvent(soundIdentifier, null)));
         });
 
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_19_1.AWARD_STATS);
-
-        componentRewriter.registerComponentPacket(ClientboundPackets1_19_1.SYSTEM_CHAT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_19_1.SET_ACTION_BAR_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_19_1.SET_TITLE_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_19_1.SET_SUBTITLE_TEXT);
-        componentRewriter.registerBossEvent(ClientboundPackets1_19_1.BOSS_EVENT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_19_1.DISCONNECT);
-        componentRewriter.registerTabList(ClientboundPackets1_19_1.TAB_LIST);
-        componentRewriter.registerOpenScreen1_14(ClientboundPackets1_19_1.OPEN_SCREEN);
-        componentRewriter.registerPlayerCombatKill(ClientboundPackets1_19_1.PLAYER_COMBAT_KILL);
-        componentRewriter.registerSetPlayerTeam1_13(ClientboundPackets1_19_1.SET_PLAYER_TEAM);
-        componentRewriter.registerSetObjective(ClientboundPackets1_19_1.SET_OBJECTIVE);
-        componentRewriter.registerPing();
-
         final CommandRewriter<ClientboundPackets1_19_1> commandRewriter = new CommandRewriter<>(this) {
             @Override
             public void handleArgument(final PacketWrapper wrapper, final String argumentType) {
@@ -131,9 +113,9 @@ public final class Protocol1_19_1To1_19_3 extends AbstractProtocol<ClientboundPa
                 }
             }
         };
-        commandRewriter.registerDeclareCommands1_19(ClientboundPackets1_19_1.COMMANDS);
+        replaceClientbound(ClientboundPackets1_19_1.COMMANDS, commandRewriter::handle1_19);
 
-        registerClientbound(ClientboundPackets1_19_1.SERVER_DATA, new PacketHandlers() {
+        replaceClientbound(ClientboundPackets1_19_1.SERVER_DATA, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.OPTIONAL_COMPONENT); // Motd
@@ -388,6 +370,11 @@ public final class Protocol1_19_1To1_19_3 extends AbstractProtocol<ClientboundPa
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_19_1> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_19_1> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_19_1to1_19_3/rewriter/EntityPacketRewriter1_19_3.java

@@ -41,11 +41,9 @@ public final class EntityPacketRewriter1_19_3 extends EntityRewriter<Clientbound
 
     @Override
     public void registerPackets() {
-        registerTrackerWithData1_19(ClientboundPackets1_19_1.ADD_ENTITY, EntityTypes1_19_3.FALLING_BLOCK);
         registerTracker(ClientboundPackets1_19_1.ADD_EXPERIENCE_ORB, EntityTypes1_19_3.EXPERIENCE_ORB);
         registerTracker(ClientboundPackets1_19_1.ADD_PLAYER, EntityTypes1_19_3.PLAYER);
         registerSetEntityData(ClientboundPackets1_19_1.SET_ENTITY_DATA, Types1_19.ENTITY_DATA_LIST, Types1_19_3.ENTITY_DATA_LIST);
-        registerRemoveEntities(ClientboundPackets1_19_1.REMOVE_ENTITIES);
 
         protocol.registerClientbound(ClientboundPackets1_19_1.LOGIN, new PacketHandlers() {
             @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_19_1to1_19_3/rewriter/ItemPacketRewriter1_19_3.java

@@ -20,11 +20,9 @@ package com.viaversion.viaversion.protocols.v1_19_1to1_19_3.rewriter;
 import com.viaversion.viaversion.api.minecraft.item.Item;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
 import com.viaversion.viaversion.api.type.Types;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_18;
 import com.viaversion.viaversion.protocols.v1_19_1to1_19_3.Protocol1_19_1To1_19_3;
 import com.viaversion.viaversion.protocols.v1_19_1to1_19_3.packet.ServerboundPackets1_19_3;
 import com.viaversion.viaversion.protocols.v1_19to1_19_1.packet.ClientboundPackets1_19_1;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ItemRewriter;
 import com.viaversion.viaversion.rewriter.RecipeRewriter;
 import com.viaversion.viaversion.util.Key;
@@ -39,24 +37,6 @@ public final class ItemPacketRewriter1_19_3 extends ItemRewriter<ClientboundPack
 
     @Override
     public void registerPackets() {
-        final BlockRewriter<ClientboundPackets1_19_1> blockRewriter = BlockRewriter.for1_14(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets1_19_1.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_19_1.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate(ClientboundPackets1_19_1.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerLevelEvent(ClientboundPackets1_19_1.LEVEL_EVENT, 1010, 2001);
-        blockRewriter.registerLevelChunk1_19(ClientboundPackets1_19_1.LEVEL_CHUNK_WITH_LIGHT, ChunkType1_18::new);
-        blockRewriter.registerBlockEntityData(ClientboundPackets1_19_1.BLOCK_ENTITY_DATA);
-
-        registerCooldown(ClientboundPackets1_19_1.COOLDOWN);
-        registerSetContent1_17_1(ClientboundPackets1_19_1.CONTAINER_SET_CONTENT);
-        registerSetSlot1_17_1(ClientboundPackets1_19_1.CONTAINER_SET_SLOT);
-        registerAdvancements(ClientboundPackets1_19_1.UPDATE_ADVANCEMENTS);
-        registerSetEquipment(ClientboundPackets1_19_1.SET_EQUIPMENT);
-        registerContainerClick1_17_1(ServerboundPackets1_19_3.CONTAINER_CLICK);
-        registerMerchantOffers1_19(ClientboundPackets1_19_1.MERCHANT_OFFERS);
-        registerSetCreativeModeSlot(ServerboundPackets1_19_3.SET_CREATIVE_MODE_SLOT);
-        registerContainerSetData(ClientboundPackets1_19_1.CONTAINER_SET_DATA);
-
         final RecipeRewriter<ClientboundPackets1_19_1> recipeRewriter = new RecipeRewriter<>(protocol);
         protocol.registerClientbound(ClientboundPackets1_19_1.UPDATE_RECIPES, wrapper -> {
             final int size = wrapper.passthrough(Types.VAR_INT);
@@ -99,9 +79,12 @@ public final class ItemPacketRewriter1_19_3 extends ItemRewriter<ClientboundPack
                         wrapper.passthrough(Types.FLOAT); // EXP
                         wrapper.passthrough(Types.VAR_INT); // Cooking time
                     }
-                    case "crafting_special_armordye", "crafting_special_bookcloning", "crafting_special_mapcloning", "crafting_special_mapextending",
-                         "crafting_special_firework_rocket", "crafting_special_firework_star", "crafting_special_firework_star_fade", "crafting_special_tippedarrow",
-                         "crafting_special_bannerduplicate", "crafting_special_shielddecoration", "crafting_special_shulkerboxcoloring", "crafting_special_suspiciousstew",
+                    case "crafting_special_armordye", "crafting_special_bookcloning", "crafting_special_mapcloning",
+                         "crafting_special_mapextending",
+                         "crafting_special_firework_rocket", "crafting_special_firework_star",
+                         "crafting_special_firework_star_fade", "crafting_special_tippedarrow",
+                         "crafting_special_bannerduplicate", "crafting_special_shielddecoration",
+                         "crafting_special_shulkerboxcoloring", "crafting_special_suspiciousstew",
                          "crafting_special_repairitem" -> wrapper.write(Types.VAR_INT, MISC_CRAFTING_BOOK_CATEGORY);
                     default -> recipeRewriter.handleRecipeType(wrapper, type);
                 }

common/src/main/java/com/viaversion/viaversion/protocols/v1_19_3to1_19_4/Protocol1_19_3To1_19_4.java

@@ -23,6 +23,7 @@ import com.viaversion.viaversion.api.minecraft.entities.EntityTypes1_19_4;
 import com.viaversion.viaversion.api.protocol.AbstractProtocol;
 import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
 import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_18;
 import com.viaversion.viaversion.api.type.types.misc.ParticleType;
 import com.viaversion.viaversion.api.type.types.version.Types1_19_4;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
@@ -34,10 +35,9 @@ import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ServerboundPac
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.rewriter.EntityPacketRewriter1_19_4;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.rewriter.ItemPacketRewriter1_19_4;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.storage.PlayerVehicleTracker;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.CommandRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.util.ComponentUtil;
 import java.nio.charset.StandardCharsets;
@@ -50,6 +50,7 @@ public final class Protocol1_19_3To1_19_4 extends AbstractProtocol<ClientboundPa
     private final ItemPacketRewriter1_19_4 itemRewriter = new ItemPacketRewriter1_19_4(this);
     private final ParticleRewriter<ClientboundPackets1_19_3> particleRewriter = new ParticleRewriter<>(this);
     private final TagRewriter<ClientboundPackets1_19_3> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_19_3> blockRewriter = BlockRewriter.for1_18(this, ChunkType1_18::new);
 
     public Protocol1_19_3To1_19_4() {
         super(ClientboundPackets1_19_3.class, ClientboundPackets1_19_4.class, ServerboundPackets1_19_3.class, ServerboundPackets1_19_4.class);
@@ -59,16 +60,7 @@ public final class Protocol1_19_3To1_19_4 extends AbstractProtocol<ClientboundPa
     protected void registerPackets() {
         super.registerPackets();
 
-        tagRewriter.registerGeneric(ClientboundPackets1_19_3.UPDATE_TAGS);
-        particleRewriter.registerLevelParticles1_19(ClientboundPackets1_19_3.LEVEL_PARTICLES);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_19_3.AWARD_STATS);
-
-        final SoundRewriter<ClientboundPackets1_19_3> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_19_3.SOUND_ENTITY);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_19_3.SOUND);
-
-        new CommandRewriter<>(this) {
+        final CommandRewriter<ClientboundPackets1_19_3> commandRewriter = new CommandRewriter<>(this) {
             @Override
             public void handleArgument(final PacketWrapper wrapper, final String argumentType) {
                 if (argumentType.equals("minecraft:time")) {
@@ -78,7 +70,8 @@ public final class Protocol1_19_3To1_19_4 extends AbstractProtocol<ClientboundPa
                     super.handleArgument(wrapper, argumentType);
                 }
             }
-        }.registerDeclareCommands1_19(ClientboundPackets1_19_3.COMMANDS);
+        };
+        replaceClientbound(ClientboundPackets1_19_3.COMMANDS, commandRewriter::handle1_19);
 
         registerClientbound(ClientboundPackets1_19_3.SERVER_DATA, wrapper -> {
             JsonElement element = wrapper.read(Types.OPTIONAL_COMPONENT);
@@ -136,6 +129,11 @@ public final class Protocol1_19_3To1_19_4 extends AbstractProtocol<ClientboundPa
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_19_3> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_19_3> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_19_3to1_19_4/rewriter/EntityPacketRewriter1_19_4.java

@@ -206,8 +206,6 @@ public final class EntityPacketRewriter1_19_4 extends EntityRewriter<Clientbound
             wrapper.write(Types.BYTE, event);
         });
 
-        registerTrackerWithData1_19(ClientboundPackets1_19_3.ADD_ENTITY, EntityTypes1_19_4.FALLING_BLOCK);
-        registerRemoveEntities(ClientboundPackets1_19_3.REMOVE_ENTITIES);
         registerSetEntityData(ClientboundPackets1_19_3.SET_ENTITY_DATA, Types1_19_3.ENTITY_DATA_LIST, Types1_19_4.ENTITY_DATA_LIST);
     }
 

common/src/main/java/com/viaversion/viaversion/protocols/v1_19_3to1_19_4/rewriter/ItemPacketRewriter1_19_4.java

@@ -20,12 +20,10 @@ package com.viaversion.viaversion.protocols.v1_19_3to1_19_4.rewriter;
 import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
 import com.viaversion.viaversion.api.type.Types;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_18;
 import com.viaversion.viaversion.protocols.v1_19_1to1_19_3.packet.ClientboundPackets1_19_3;
 import com.viaversion.viaversion.protocols.v1_19_1to1_19_3.rewriter.RecipeRewriter1_19_3;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.Protocol1_19_3To1_19_4;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ServerboundPackets1_19_4;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ItemRewriter;
 
 public final class ItemPacketRewriter1_19_4 extends ItemRewriter<ClientboundPackets1_19_3, ServerboundPackets1_19_4, Protocol1_19_3To1_19_4> {
@@ -36,14 +34,7 @@ public final class ItemPacketRewriter1_19_4 extends ItemRewriter<ClientboundPack
 
     @Override
     public void registerPackets() {
-        final BlockRewriter<ClientboundPackets1_19_3> blockRewriter = BlockRewriter.for1_14(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets1_19_3.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_19_3.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate(ClientboundPackets1_19_3.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerLevelChunk1_19(ClientboundPackets1_19_3.LEVEL_CHUNK_WITH_LIGHT, ChunkType1_18::new);
-        blockRewriter.registerBlockEntityData(ClientboundPackets1_19_3.BLOCK_ENTITY_DATA);
-
-        protocol.registerClientbound(ClientboundPackets1_19_3.LEVEL_EVENT, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_19_3.LEVEL_EVENT, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.INT); // Effect Id
@@ -83,16 +74,6 @@ public final class ItemPacketRewriter1_19_4 extends ItemRewriter<ClientboundPack
             }
         });
 
-        registerCooldown(ClientboundPackets1_19_3.COOLDOWN);
-        registerSetContent1_17_1(ClientboundPackets1_19_3.CONTAINER_SET_CONTENT);
-        registerSetSlot1_17_1(ClientboundPackets1_19_3.CONTAINER_SET_SLOT);
-        registerAdvancements(ClientboundPackets1_19_3.UPDATE_ADVANCEMENTS);
-        registerSetEquipment(ClientboundPackets1_19_3.SET_EQUIPMENT);
-        registerMerchantOffers1_19(ClientboundPackets1_19_3.MERCHANT_OFFERS);
-        registerContainerSetData(ClientboundPackets1_19_3.CONTAINER_SET_DATA);
-        registerSetCreativeModeSlot(ServerboundPackets1_19_4.SET_CREATIVE_MODE_SLOT);
-        registerContainerClick1_17_1(ServerboundPackets1_19_4.CONTAINER_CLICK);
-
         new RecipeRewriter1_19_3<>(protocol) {
             @Override
             public void handleCraftingShaped(final PacketWrapper wrapper) {

common/src/main/java/com/viaversion/viaversion/protocols/v1_19_4to1_20/Protocol1_19_4To1_20.java

@@ -29,11 +29,11 @@ import com.viaversion.viaversion.api.type.types.version.Types1_20;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ClientboundPackets1_19_4;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ServerboundPackets1_19_4;
+import com.viaversion.viaversion.protocols.v1_19_4to1_20.rewriter.BlockPacketRewriter1_20;
 import com.viaversion.viaversion.protocols.v1_19_4to1_20.rewriter.EntityPacketRewriter1_20;
 import com.viaversion.viaversion.protocols.v1_19_4to1_20.rewriter.ItemPacketRewriter1_20;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 
 public final class Protocol1_19_4To1_20 extends AbstractProtocol<ClientboundPackets1_19_4, ClientboundPackets1_19_4, ServerboundPackets1_19_4, ServerboundPackets1_19_4> {
@@ -43,6 +43,7 @@ public final class Protocol1_19_4To1_20 extends AbstractProtocol<ClientboundPack
     private final ItemPacketRewriter1_20 itemRewriter = new ItemPacketRewriter1_20(this);
     private final ParticleRewriter<ClientboundPackets1_19_4> particleRewriter = new ParticleRewriter<>(this);
     private final TagRewriter<ClientboundPackets1_19_4> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_19_4> blockRewriter = new BlockPacketRewriter1_20(this);
 
     public Protocol1_19_4To1_20() {
         super(ClientboundPackets1_19_4.class, ClientboundPackets1_19_4.class, ServerboundPackets1_19_4.class, ServerboundPackets1_19_4.class);
@@ -52,15 +53,6 @@ public final class Protocol1_19_4To1_20 extends AbstractProtocol<ClientboundPack
     protected void registerPackets() {
         super.registerPackets();
 
-        tagRewriter.registerGeneric(ClientboundPackets1_19_4.UPDATE_TAGS);
-        particleRewriter.registerLevelParticles1_19(ClientboundPackets1_19_4.LEVEL_PARTICLES);
-
-        final SoundRewriter<ClientboundPackets1_19_4> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_19_4.SOUND);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_19_4.SOUND_ENTITY);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_19_4.AWARD_STATS);
-
         registerClientbound(ClientboundPackets1_19_4.PLAYER_COMBAT_END, wrapper -> {
             wrapper.passthrough(Types.VAR_INT); // Duration
             wrapper.read(Types.INT); // Killer ID
@@ -111,6 +103,11 @@ public final class Protocol1_19_4To1_20 extends AbstractProtocol<ClientboundPack
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_19_4> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_19_4> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_19_4to1_20/rewriter/BlockPacketRewriter1_20.java

@@ -24,6 +24,7 @@ import com.viaversion.nbt.tag.Tag;
 import com.viaversion.viaversion.api.connection.UserConnection;
 import com.viaversion.viaversion.api.minecraft.blockentity.BlockEntity;
 import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_18;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ClientboundPackets1_19_4;
 import com.viaversion.viaversion.protocols.v1_19_4to1_20.Protocol1_19_4To1_20;
 import com.viaversion.viaversion.rewriter.BlockRewriter;
@@ -32,7 +33,7 @@ import com.viaversion.viaversion.util.ComponentUtil;
 public final class BlockPacketRewriter1_20 extends BlockRewriter<ClientboundPackets1_19_4> {
 
     public BlockPacketRewriter1_20(final Protocol1_19_4To1_20 protocol) {
-        super(protocol, Types.BLOCK_POSITION1_14, Types.NAMED_COMPOUND_TAG);
+        super(protocol, Types.BLOCK_POSITION1_14, Types.NAMED_COMPOUND_TAG, ChunkType1_18::new, null);
     }
 
     @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_19_4to1_20/rewriter/EntityPacketRewriter1_20.java

@@ -46,9 +46,7 @@ public final class EntityPacketRewriter1_20 extends EntityRewriter<ClientboundPa
 
     @Override
     public void registerPackets() {
-        registerTrackerWithData1_19(ClientboundPackets1_19_4.ADD_ENTITY, EntityTypes1_19_4.FALLING_BLOCK);
         registerSetEntityData(ClientboundPackets1_19_4.SET_ENTITY_DATA, Types1_19_4.ENTITY_DATA_LIST, Types1_20.ENTITY_DATA_LIST);
-        registerRemoveEntities(ClientboundPackets1_19_4.REMOVE_ENTITIES);
 
         protocol.registerClientbound(ClientboundPackets1_19_4.LOGIN, new PacketHandlers() {
             @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_19_4to1_20/rewriter/ItemPacketRewriter1_20.java

@@ -21,12 +21,10 @@ import com.viaversion.viaversion.api.minecraft.BlockChangeRecord;
 import com.viaversion.viaversion.api.minecraft.chunks.Chunk;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
 import com.viaversion.viaversion.api.type.Types;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_18;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ClientboundPackets1_19_4;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ServerboundPackets1_19_4;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.rewriter.RecipeRewriter1_19_4;
 import com.viaversion.viaversion.protocols.v1_19_4to1_20.Protocol1_19_4To1_20;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ItemRewriter;
 import com.viaversion.viaversion.rewriter.RecipeRewriter;
 import com.viaversion.viaversion.util.Key;
@@ -39,23 +37,7 @@ public final class ItemPacketRewriter1_20 extends ItemRewriter<ClientboundPacket
 
     @Override
     public void registerPackets() {
-        final BlockRewriter<ClientboundPackets1_19_4> blockRewriter = new BlockPacketRewriter1_20(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets1_19_4.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_19_4.BLOCK_UPDATE);
-        blockRewriter.registerLevelEvent(ClientboundPackets1_19_4.LEVEL_EVENT, 1010, 2001);
-        blockRewriter.registerBlockEntityData(ClientboundPackets1_19_4.BLOCK_ENTITY_DATA);
-
-        registerOpenScreen(ClientboundPackets1_19_4.OPEN_SCREEN);
-        registerCooldown(ClientboundPackets1_19_4.COOLDOWN);
-        registerSetContent1_17_1(ClientboundPackets1_19_4.CONTAINER_SET_CONTENT);
-        registerSetSlot1_17_1(ClientboundPackets1_19_4.CONTAINER_SET_SLOT);
-        registerSetEquipment(ClientboundPackets1_19_4.SET_EQUIPMENT);
-        registerContainerClick1_17_1(ServerboundPackets1_19_4.CONTAINER_CLICK);
-        registerMerchantOffers1_19(ClientboundPackets1_19_4.MERCHANT_OFFERS);
-        registerSetCreativeModeSlot(ServerboundPackets1_19_4.SET_CREATIVE_MODE_SLOT);
-        registerContainerSetData(ClientboundPackets1_19_4.CONTAINER_SET_DATA);
-
-        protocol.registerClientbound(ClientboundPackets1_19_4.UPDATE_ADVANCEMENTS, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_19_4.UPDATE_ADVANCEMENTS, wrapper -> {
             wrapper.passthrough(Types.BOOLEAN); // Reset/clear
             int size = wrapper.passthrough(Types.VAR_INT); // Mapping size
             for (int i = 0; i < size; i++) {
@@ -99,12 +81,12 @@ public final class ItemPacketRewriter1_20 extends ItemRewriter<ClientboundPacket
             }
         });
 
-        protocol.registerClientbound(ClientboundPackets1_19_4.LEVEL_CHUNK_WITH_LIGHT, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_19_4.LEVEL_CHUNK_WITH_LIGHT, new PacketHandlers() {
             @Override
             protected void register() {
                 handler(wrapper -> {
-                    final Chunk chunk = blockRewriter.handleChunk1_19(wrapper, ChunkType1_18::new);
-                    blockRewriter.handleBlockEntities(chunk, wrapper.user());
+                    final Chunk chunk = protocol.getBlockRewriter().handleChunk1_18(wrapper);
+                    protocol.getBlockRewriter().handleBlockEntities(chunk, wrapper.user());
                 });
                 read(Types.BOOLEAN); // Trust edges
             }
@@ -116,7 +98,7 @@ public final class ItemPacketRewriter1_20 extends ItemRewriter<ClientboundPacket
             wrapper.read(Types.BOOLEAN); // Trust edges
         });
 
-        protocol.registerClientbound(ClientboundPackets1_19_4.SECTION_BLOCKS_UPDATE, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_19_4.SECTION_BLOCKS_UPDATE, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.LONG); // Chunk position

common/src/main/java/com/viaversion/viaversion/protocols/v1_20_2to1_20_3/Protocol1_20_2To1_20_3.java

@@ -30,10 +30,10 @@ import com.viaversion.viaversion.api.protocol.packet.provider.SimplePacketTypesP
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandler;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
 import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_20_2;
 import com.viaversion.viaversion.api.type.types.misc.ParticleType;
 import com.viaversion.viaversion.api.type.types.version.Types1_20_3;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
-import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.rewriter.CommandRewriter1_19_4;
 import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ClientboundConfigurationPackets1_20_3;
 import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ClientboundPacket1_20_3;
 import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ClientboundPackets1_20_3;
@@ -47,9 +47,8 @@ import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ClientboundPacke
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ServerboundConfigurationPackets1_20_2;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ServerboundPacket1_20_2;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ServerboundPackets1_20_2;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.util.ComponentUtil;
 import java.nio.charset.StandardCharsets;
@@ -65,6 +64,7 @@ public final class Protocol1_20_2To1_20_3 extends AbstractProtocol<ClientboundPa
     private final ParticleRewriter<ClientboundPacket1_20_2> particleRewriter = new ParticleRewriter<>(this);
     private final EntityPacketRewriter1_20_3 entityRewriter = new EntityPacketRewriter1_20_3(this);
     private final TagRewriter<ClientboundPacket1_20_2> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPacket1_20_2> blockRewriter = BlockRewriter.for1_20_2(this, ChunkType1_20_2::new);
 
     public Protocol1_20_2To1_20_3() {
         super(ClientboundPacket1_20_2.class, ClientboundPacket1_20_3.class, ServerboundPacket1_20_2.class, ServerboundPacket1_20_3.class);
@@ -76,16 +76,6 @@ public final class Protocol1_20_2To1_20_3 extends AbstractProtocol<ClientboundPa
 
         cancelServerbound(ServerboundPackets1_20_3.CONTAINER_SLOT_STATE_CHANGED);
 
-        tagRewriter.registerGeneric(ClientboundPackets1_20_2.UPDATE_TAGS);
-        tagRewriter.registerGeneric(ClientboundConfigurationPackets1_20_2.UPDATE_TAGS);
-
-        final SoundRewriter<ClientboundPacket1_20_2> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_20_2.SOUND);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_20_2.SOUND_ENTITY);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_20_2.AWARD_STATS);
-        new CommandRewriter1_19_4<>(this).registerDeclareCommands1_19(ClientboundPackets1_20_2.COMMANDS);
-
         registerClientbound(ClientboundPackets1_20_2.SET_SCORE, wrapper -> {
             wrapper.passthrough(Types.STRING); // Owner
 
@@ -132,7 +122,7 @@ public final class Protocol1_20_2To1_20_3 extends AbstractProtocol<ClientboundPa
         });
 
         // Components are now (mostly) written as nbt instead of json strings
-        registerClientbound(ClientboundPackets1_20_2.UPDATE_ADVANCEMENTS, wrapper -> {
+        replaceClientbound(ClientboundPackets1_20_2.UPDATE_ADVANCEMENTS, wrapper -> {
             wrapper.passthrough(Types.BOOLEAN); // Reset/clear
             final int size = wrapper.passthrough(Types.VAR_INT); // Mapping size
             for (int i = 0; i < size; i++) {
@@ -250,7 +240,7 @@ public final class Protocol1_20_2To1_20_3 extends AbstractProtocol<ClientboundPa
             convertOptionalComponent(wrapper); // Target name
         });
         registerClientbound(ClientboundPackets1_20_2.SYSTEM_CHAT, this::convertComponent);
-        registerClientbound(ClientboundPackets1_20_2.OPEN_SCREEN, wrapper -> {
+        replaceClientbound(ClientboundPackets1_20_2.OPEN_SCREEN, wrapper -> {
             wrapper.passthrough(Types.VAR_INT); // Container id
 
             final int containerTypeId = wrapper.read(Types.VAR_INT);
@@ -377,6 +367,11 @@ public final class Protocol1_20_2To1_20_3 extends AbstractProtocol<ClientboundPa
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPacket1_20_2> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPacket1_20_2> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_20_2to1_20_3/rewriter/BlockItemPacketRewriter1_20_3.java

@@ -29,15 +29,12 @@ import com.viaversion.viaversion.api.minecraft.item.Item;
 import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
 import com.viaversion.viaversion.api.type.Types;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_20_2;
 import com.viaversion.viaversion.api.type.types.version.Types1_20_3;
 import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.Protocol1_20_2To1_20_3;
 import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ServerboundPacket1_20_3;
-import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ServerboundPackets1_20_3;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ClientboundPacket1_20_2;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ClientboundPackets1_20_2;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.rewriter.RecipeRewriter1_20_2;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ItemRewriter;
 import com.viaversion.viaversion.util.ComponentUtil;
 import com.viaversion.viaversion.util.Key;
@@ -54,24 +51,7 @@ public final class BlockItemPacketRewriter1_20_3 extends ItemRewriter<Clientboun
 
     @Override
     public void registerPackets() {
-        final BlockRewriter<ClientboundPacket1_20_2> blockRewriter = BlockRewriter.for1_20_2(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets1_20_2.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_20_2.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate1_20(ClientboundPackets1_20_2.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerLevelEvent(ClientboundPackets1_20_2.LEVEL_EVENT, 1010, 2001);
-        blockRewriter.registerLevelChunk1_19(ClientboundPackets1_20_2.LEVEL_CHUNK_WITH_LIGHT, ChunkType1_20_2::new);
-        blockRewriter.registerBlockEntityData(ClientboundPackets1_20_2.BLOCK_ENTITY_DATA);
-
-        registerCooldown(ClientboundPackets1_20_2.COOLDOWN);
-        registerSetContent1_17_1(ClientboundPackets1_20_2.CONTAINER_SET_CONTENT);
-        registerSetSlot1_17_1(ClientboundPackets1_20_2.CONTAINER_SET_SLOT);
-        registerSetEquipment(ClientboundPackets1_20_2.SET_EQUIPMENT);
-        registerContainerClick1_17_1(ServerboundPackets1_20_3.CONTAINER_CLICK);
-        registerMerchantOffers1_19(ClientboundPackets1_20_2.MERCHANT_OFFERS);
-        registerSetCreativeModeSlot(ServerboundPackets1_20_3.SET_CREATIVE_MODE_SLOT);
-        registerContainerSetData(ClientboundPackets1_20_2.CONTAINER_SET_DATA);
-
-        protocol.registerClientbound(ClientboundPackets1_20_2.LEVEL_PARTICLES, new PacketHandlers() {
+        protocol.replaceClientbound(ClientboundPackets1_20_2.LEVEL_PARTICLES, new PacketHandlers() {
             @Override
             public void register() {
                 map(Types.VAR_INT); // 0 - Particle ID

common/src/main/java/com/viaversion/viaversion/protocols/v1_20_2to1_20_3/rewriter/EntityPacketRewriter1_20_3.java

@@ -44,9 +44,7 @@ public final class EntityPacketRewriter1_20_3 extends EntityRewriter<Clientbound
 
     @Override
     public void registerPackets() {
-        registerTrackerWithData1_19(ClientboundPackets1_20_2.ADD_ENTITY, EntityTypes1_20_3.FALLING_BLOCK);
         registerSetEntityData(ClientboundPackets1_20_2.SET_ENTITY_DATA, Types1_20_2.ENTITY_DATA_LIST, Types1_20_3.ENTITY_DATA_LIST);
-        registerRemoveEntities(ClientboundPackets1_20_2.REMOVE_ENTITIES);
 
         protocol.registerClientbound(ClientboundConfigurationPackets1_20_2.REGISTRY_DATA, new PacketHandlers() {
             @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_20_3to1_20_5/Protocol1_20_3To1_20_5.java

@@ -28,12 +28,12 @@ import com.viaversion.viaversion.api.protocol.packet.State;
 import com.viaversion.viaversion.api.protocol.packet.provider.PacketTypesProvider;
 import com.viaversion.viaversion.api.protocol.packet.provider.SimplePacketTypesProvider;
 import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_20_2;
 import com.viaversion.viaversion.api.type.types.misc.ParticleType;
 import com.viaversion.viaversion.api.type.types.version.VersionedTypes;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
 import com.viaversion.viaversion.protocols.base.ClientboundLoginPackets;
 import com.viaversion.viaversion.protocols.base.ServerboundLoginPackets;
-import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.rewriter.CommandRewriter1_19_4;
 import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ClientboundConfigurationPackets1_20_3;
 import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ClientboundPacket1_20_3;
 import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ClientboundPackets1_20_3;
@@ -55,8 +55,7 @@ import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.storage.ArmorTrimStor
 import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.storage.ScoreboardTeamStorage;
 import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.storage.TagKeys;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ServerboundConfigurationPackets1_20_2;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.rewriter.text.JsonNBTComponentRewriter;
 import com.viaversion.viaversion.util.ProtocolLogger;
@@ -80,6 +79,7 @@ public final class Protocol1_20_3To1_20_5 extends AbstractProtocol<ClientboundPa
     private final ParticleRewriter1_20_5 particleRewriter = new ParticleRewriter1_20_5(this);
     private final TagRewriter<ClientboundPacket1_20_3> tagRewriter = new TagRewriter<>(this);
     private final ComponentRewriter1_20_5<ClientboundPacket1_20_3> componentRewriter = new ComponentRewriter1_20_5<>(this, VersionedTypes.V1_20_5.structuredData);
+    private final BlockRewriter<ClientboundPacket1_20_3> blockRewriter = BlockRewriter.for1_20_2(this, ChunkType1_20_2::new);
 
     public Protocol1_20_3To1_20_5() {
         super(ClientboundPacket1_20_3.class, ClientboundPacket1_20_5.class, ServerboundPacket1_20_3.class, ServerboundPacket1_20_5.class);
@@ -89,34 +89,6 @@ public final class Protocol1_20_3To1_20_5 extends AbstractProtocol<ClientboundPa
     protected void registerPackets() {
         super.registerPackets();
 
-        registerClientbound(ClientboundPackets1_20_3.UPDATE_TAGS, this::updateTags);
-        registerClientbound(ClientboundConfigurationPackets1_20_3.UPDATE_TAGS, this::updateTags);
-
-        final SoundRewriter<ClientboundPacket1_20_3> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_20_3.SOUND);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_20_3.SOUND_ENTITY);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_20_3.AWARD_STATS);
-
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_3.SYSTEM_CHAT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_3.DISGUISED_CHAT);
-        componentRewriter.registerPlayerChat(ClientboundPackets1_20_3.PLAYER_CHAT, Types.VAR_INT);
-        componentRewriter.registerPlayerCombatKill1_20(ClientboundPackets1_20_3.PLAYER_COMBAT_KILL);
-
-        // People add item hovers to all sorts of weird places...
-        componentRewriter.registerOpenScreen1_14(ClientboundPackets1_20_3.OPEN_SCREEN);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_3.SET_ACTION_BAR_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_3.SET_TITLE_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_3.SET_SUBTITLE_TEXT);
-        componentRewriter.registerBossEvent(ClientboundPackets1_20_3.BOSS_EVENT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_3.DISCONNECT);
-        componentRewriter.registerComponentPacket(ClientboundConfigurationPackets1_20_3.DISCONNECT);
-        componentRewriter.registerTabList(ClientboundPackets1_20_3.TAB_LIST);
-        componentRewriter.registerPlayerInfoUpdate1_20_3(ClientboundPackets1_20_3.PLAYER_INFO_UPDATE);
-        componentRewriter.registerSetObjective(ClientboundPackets1_20_3.SET_OBJECTIVE);
-        componentRewriter.registerSetScore1_20_3(ClientboundPackets1_20_3.SET_SCORE);
-        componentRewriter.registerPing();
-
         registerClientbound(State.LOGIN, ClientboundLoginPackets.HELLO, wrapper -> {
             wrapper.passthrough(Types.STRING); // Server ID
             wrapper.passthrough(Types.BYTE_ARRAY_PRIMITIVE); // Public key
@@ -124,8 +96,8 @@ public final class Protocol1_20_3To1_20_5 extends AbstractProtocol<ClientboundPa
             wrapper.write(Types.BOOLEAN, true); // Authenticate
         });
 
-        registerClientbound(ClientboundPackets1_20_3.SERVER_DATA, wrapper -> {
-            wrapper.passthrough(Types.TRUSTED_TAG); // MOTD
+        replaceClientbound(ClientboundPackets1_20_3.SERVER_DATA, wrapper -> {
+            componentRewriter.passthroughAndProcess(wrapper); // MOTD
             wrapper.passthrough(Types.OPTIONAL_BYTE_ARRAY_PRIMITIVE); // Icon
 
             // Moved to join game
@@ -220,8 +192,6 @@ public final class Protocol1_20_3To1_20_5 extends AbstractProtocol<ClientboundPa
 
         registerClientbound(ClientboundPackets1_20_3.START_CONFIGURATION, wrapper -> wrapper.user().put(new AcknowledgedMessagesStorage()));
 
-        new CommandRewriter1_19_4<>(this).registerDeclareCommands1_19(ClientboundPackets1_20_3.COMMANDS);
-
         registerClientbound(State.LOGIN, ClientboundLoginPackets.LOGIN_FINISHED, wrapper -> {
             wrapper.passthrough(Types.UUID); // UUID
             wrapper.passthrough(Types.STRING); // Name
@@ -229,7 +199,7 @@ public final class Protocol1_20_3To1_20_5 extends AbstractProtocol<ClientboundPa
             wrapper.write(Types.BOOLEAN, strictErrorHandling);
         });
 
-        registerClientbound(ClientboundPackets1_20_3.SET_PLAYER_TEAM, wrapper -> {
+        replaceClientbound(ClientboundPackets1_20_3.SET_PLAYER_TEAM, wrapper -> {
             final ScoreboardTeamStorage storage = wrapper.user().get(ScoreboardTeamStorage.class);
 
             final String teamName = wrapper.passthrough(Types.STRING);
@@ -377,6 +347,11 @@ public final class Protocol1_20_3To1_20_5 extends AbstractProtocol<ClientboundPa
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPacket1_20_3> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter1_20_5 getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_20_3to1_20_5/rewriter/BlockItemPacketRewriter1_20_5.java

@@ -78,7 +78,6 @@ import com.viaversion.viaversion.api.minecraft.item.data.WritableBook;
 import com.viaversion.viaversion.api.minecraft.item.data.WrittenBook;
 import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
 import com.viaversion.viaversion.api.type.Types;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_20_2;
 import com.viaversion.viaversion.api.type.types.version.Types1_20_3;
 import com.viaversion.viaversion.api.type.types.version.VersionedTypes;
 import com.viaversion.viaversion.protocols.v1_20_2to1_20_3.packet.ClientboundPacket1_20_3;
@@ -99,7 +98,6 @@ import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ServerboundPac
 import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.storage.ArmorTrimStorage;
 import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.storage.BannerPatternStorage;
 import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.storage.TagKeys;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ItemRewriter;
 import com.viaversion.viaversion.util.ComponentUtil;
 import com.viaversion.viaversion.util.Either;
@@ -136,13 +134,8 @@ public final class BlockItemPacketRewriter1_20_5 extends ItemRewriter<Clientboun
 
     @Override
     public void registerPackets() {
-        final BlockRewriter<ClientboundPacket1_20_3> blockRewriter = BlockRewriter.for1_20_2(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets1_20_3.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_20_3.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate1_20(ClientboundPackets1_20_3.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerLevelEvent(ClientboundPackets1_20_3.LEVEL_EVENT, 1010, 2001);
-        protocol.registerClientbound(ClientboundPackets1_20_3.LEVEL_CHUNK_WITH_LIGHT, wrapper -> {
-            final Chunk chunk = blockRewriter.handleChunk1_19(wrapper, ChunkType1_20_2::new);
+        protocol.replaceClientbound(ClientboundPackets1_20_3.LEVEL_CHUNK_WITH_LIGHT, wrapper -> {
+            final Chunk chunk = protocol.getBlockRewriter().handleChunk1_18(wrapper);
             for (int i = 0; i < chunk.blockEntities().size(); i++) {
                 final BlockEntity blockEntity = chunk.blockEntities().get(i);
                 if (isUnknownBlockEntity(blockEntity.typeId())) {
@@ -154,7 +147,7 @@ public final class BlockItemPacketRewriter1_20_5 extends ItemRewriter<Clientboun
                 updateBlockEntityTag(wrapper.user(), null, blockEntity.tag());
             }
         });
-        protocol.registerClientbound(ClientboundPackets1_20_3.BLOCK_ENTITY_DATA, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_20_3.BLOCK_ENTITY_DATA, wrapper -> {
             wrapper.passthrough(Types.BLOCK_POSITION1_14); // Position
 
             final int typeId = wrapper.passthrough(Types.VAR_INT);
@@ -173,13 +166,6 @@ public final class BlockItemPacketRewriter1_20_5 extends ItemRewriter<Clientboun
             wrapper.write(Types.TRUSTED_COMPOUND_TAG, tag);
         });
 
-        registerCooldown(ClientboundPackets1_20_3.COOLDOWN);
-        registerSetContent1_17_1(ClientboundPackets1_20_3.CONTAINER_SET_CONTENT);
-        registerSetSlot1_17_1(ClientboundPackets1_20_3.CONTAINER_SET_SLOT);
-        registerContainerClick1_17_1(ServerboundPackets1_20_5.CONTAINER_CLICK);
-        registerContainerSetData(ClientboundPackets1_20_3.CONTAINER_SET_DATA);
-        registerSetCreativeModeSlot(ServerboundPackets1_20_5.SET_CREATIVE_MODE_SLOT);
-
         protocol.registerServerbound(ServerboundPackets1_20_5.CONTAINER_BUTTON_CLICK, wrapper -> {
             final byte containerId = wrapper.read(Types.VAR_INT).byteValue();
             final byte buttonId = wrapper.read(Types.VAR_INT).byteValue();
@@ -187,7 +173,7 @@ public final class BlockItemPacketRewriter1_20_5 extends ItemRewriter<Clientboun
             wrapper.write(Types.BYTE, buttonId);
         });
 
-        protocol.registerClientbound(ClientboundPackets1_20_3.UPDATE_ADVANCEMENTS, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_20_3.UPDATE_ADVANCEMENTS, wrapper -> {
             wrapper.passthrough(Types.BOOLEAN); // Reset/clear
             int size = wrapper.passthrough(Types.VAR_INT); // Mapping size
             for (int i = 0; i < size; i++) {
@@ -220,7 +206,7 @@ public final class BlockItemPacketRewriter1_20_5 extends ItemRewriter<Clientboun
             }
         });
 
-        protocol.registerClientbound(ClientboundPackets1_20_3.LEVEL_PARTICLES, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_20_3.LEVEL_PARTICLES, wrapper -> {
             final int particleId = wrapper.read(Types.VAR_INT);
 
             wrapper.passthrough(Types.BOOLEAN); // Long Distance
@@ -317,7 +303,7 @@ public final class BlockItemPacketRewriter1_20_5 extends ItemRewriter<Clientboun
             wrapper.write(Types.SOUND_EVENT, Holder.of(new SoundEvent(sound, range)));
         });
 
-        protocol.registerClientbound(ClientboundPackets1_20_3.MERCHANT_OFFERS, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_20_3.MERCHANT_OFFERS, wrapper -> {
             wrapper.passthrough(Types.VAR_INT); // Container id
             final int size = wrapper.passthrough(Types.VAR_INT);
             for (int i = 0; i < size; i++) {

common/src/main/java/com/viaversion/viaversion/protocols/v1_20_3to1_20_5/rewriter/EntityPacketRewriter1_20_5.java

@@ -74,11 +74,9 @@ public final class EntityPacketRewriter1_20_5 extends EntityRewriter<Clientbound
 
     @Override
     public void registerPackets() {
-        registerTrackerWithData1_19(ClientboundPackets1_20_3.ADD_ENTITY, EntityTypes1_20_5.FALLING_BLOCK);
         registerSetEntityData(ClientboundPackets1_20_3.SET_ENTITY_DATA, Types1_20_3.ENTITY_DATA_LIST, VersionedTypes.V1_20_5.entityDataList);
-        registerRemoveEntities(ClientboundPackets1_20_3.REMOVE_ENTITIES);
 
-        protocol.registerClientbound(ClientboundPackets1_20_3.SET_EQUIPMENT, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_20_3.SET_EQUIPMENT, wrapper -> {
             final int entityId = wrapper.passthrough(Types.VAR_INT); // Entity id
             final EntityType type = tracker(wrapper.user()).entityType(entityId);
 

common/src/main/java/com/viaversion/viaversion/protocols/v1_20_5to1_21/Protocol1_20_5To1_21.java

@@ -23,14 +23,15 @@ import com.viaversion.viaversion.api.minecraft.RegistryType;
 import com.viaversion.viaversion.api.minecraft.data.StructuredDataKey;
 import com.viaversion.viaversion.api.minecraft.entities.EntityTypes1_20_5;
 import com.viaversion.viaversion.api.minecraft.item.data.ChatType;
-import com.viaversion.viaversion.api.protocol.AbstractProtocol;
 import com.viaversion.viaversion.api.protocol.packet.provider.PacketTypesProvider;
 import com.viaversion.viaversion.api.protocol.packet.provider.SimplePacketTypesProvider;
 import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_20_2;
 import com.viaversion.viaversion.api.type.types.misc.ParticleType;
 import com.viaversion.viaversion.api.type.types.version.VersionedTypes;
 import com.viaversion.viaversion.api.type.types.version.VersionedTypesHolder;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
+import com.viaversion.viaversion.api.protocol.AbstractProtocol;
 import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ClientboundConfigurationPackets1_20_5;
 import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ClientboundPacket1_20_5;
 import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ClientboundPackets1_20_5;
@@ -47,9 +48,8 @@ import com.viaversion.viaversion.protocols.v1_20_5to1_21.rewriter.ComponentRewri
 import com.viaversion.viaversion.protocols.v1_20_5to1_21.rewriter.EntityPacketRewriter1_21;
 import com.viaversion.viaversion.protocols.v1_20_5to1_21.storage.EfficiencyAttributeStorage;
 import com.viaversion.viaversion.protocols.v1_20_5to1_21.storage.PlayerPositionStorage;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.rewriter.text.JsonNBTComponentRewriter;
 import com.viaversion.viaversion.util.Key;
@@ -67,6 +67,7 @@ public final class Protocol1_20_5To1_21 extends AbstractProtocol<ClientboundPack
     private final ParticleRewriter<ClientboundPacket1_20_5> particleRewriter = new ParticleRewriter<>(this);
     private final TagRewriter<ClientboundPacket1_20_5> tagRewriter = new TagRewriter<>(this);
     private final JsonNBTComponentRewriter<ClientboundPacket1_20_5> componentRewriter = new ComponentRewriter1_21(this);
+    private final BlockRewriter<ClientboundPacket1_20_5> blockRewriter = BlockRewriter.for1_20_2(this, ChunkType1_20_2::new);
 
     public Protocol1_20_5To1_21() {
         super(ClientboundPacket1_20_5.class, ClientboundPacket1_21.class, ServerboundPacket1_20_5.class, ServerboundPacket1_20_5.class);
@@ -76,36 +77,14 @@ public final class Protocol1_20_5To1_21 extends AbstractProtocol<ClientboundPack
     protected void registerPackets() {
         super.registerPackets();
 
-        tagRewriter.registerGeneric(ClientboundPackets1_20_5.UPDATE_TAGS);
-        tagRewriter.registerGeneric(ClientboundConfigurationPackets1_20_5.UPDATE_TAGS);
-
-        final SoundRewriter<ClientboundPacket1_20_5> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_20_5.SOUND);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_20_5.SOUND_ENTITY);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_20_5.AWARD_STATS);
-
-        componentRewriter.registerOpenScreen1_14(ClientboundPackets1_20_5.OPEN_SCREEN);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_5.SET_ACTION_BAR_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_5.SET_TITLE_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_5.SET_SUBTITLE_TEXT);
-        componentRewriter.registerBossEvent(ClientboundPackets1_20_5.BOSS_EVENT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_5.DISCONNECT);
-        componentRewriter.registerTabList(ClientboundPackets1_20_5.TAB_LIST);
-        componentRewriter.registerPlayerCombatKill1_20(ClientboundPackets1_20_5.PLAYER_COMBAT_KILL);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_20_5.SYSTEM_CHAT);
-
-        particleRewriter.registerLevelParticles1_20_5(ClientboundPackets1_20_5.LEVEL_PARTICLES);
-        particleRewriter.registerExplode1_20_5(ClientboundPackets1_20_5.EXPLODE); // Rewrites the included sound and particles
-
-        registerClientbound(ClientboundPackets1_20_5.DISGUISED_CHAT, wrapper -> {
+        replaceClientbound(ClientboundPackets1_20_5.DISGUISED_CHAT, wrapper -> {
             componentRewriter.processTag(wrapper.user(), wrapper.passthrough(Types.TRUSTED_TAG)); // Message
 
             // Holder time
             final int chatType = wrapper.read(Types.VAR_INT);
             wrapper.write(ChatType.TYPE, Holder.of(chatType));
         });
-        registerClientbound(ClientboundPackets1_20_5.PLAYER_CHAT, wrapper -> {
+        replaceClientbound(ClientboundPackets1_20_5.PLAYER_CHAT, wrapper -> {
             wrapper.passthrough(Types.UUID); // Sender
             wrapper.passthrough(Types.VAR_INT); // Index
             wrapper.passthrough(Types.OPTIONAL_SIGNATURE_BYTES); // Signature
@@ -254,6 +233,11 @@ public final class Protocol1_20_5To1_21 extends AbstractProtocol<ClientboundPack
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPacket1_20_5> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPacket1_20_5> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_20_5to1_21/rewriter/BlockItemPacketRewriter1_21.java

@@ -62,16 +62,7 @@ public final class BlockItemPacketRewriter1_21 extends StructuredItemRewriter<Cl
 
     @Override
     public void registerPackets() {
-        final BlockRewriter<ClientboundPacket1_20_5> blockRewriter = BlockRewriter.for1_20_2(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets1_20_5.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_20_5.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate1_20(ClientboundPackets1_20_5.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerLevelChunk1_19(ClientboundPackets1_20_5.LEVEL_CHUNK_WITH_LIGHT, ChunkType1_20_2::new);
-        blockRewriter.registerBlockEntityData(ClientboundPackets1_20_5.BLOCK_ENTITY_DATA);
-
-        registerCooldown(ClientboundPackets1_20_5.COOLDOWN);
-        registerSetContent1_17_1(ClientboundPackets1_20_5.CONTAINER_SET_CONTENT);
-        protocol.registerClientbound(ClientboundPackets1_20_5.CONTAINER_SET_SLOT, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_20_5.CONTAINER_SET_SLOT, wrapper -> {
             final byte containerId = wrapper.passthrough(Types.BYTE);
             wrapper.passthrough(Types.VAR_INT); // State id
             final short slotId = wrapper.passthrough(Types.SHORT);
@@ -94,11 +85,6 @@ public final class BlockItemPacketRewriter1_21 extends StructuredItemRewriter<Cl
             };
             storage.setEnchants(-1, wrapper.user(), active);
         });
-        registerAdvancements1_20_3(ClientboundPackets1_20_5.UPDATE_ADVANCEMENTS);
-        registerSetEquipment(ClientboundPackets1_20_5.SET_EQUIPMENT);
-        registerContainerClick1_17_1(ServerboundPackets1_20_5.CONTAINER_CLICK);
-        registerMerchantOffers1_20_5(ClientboundPackets1_20_5.MERCHANT_OFFERS);
-        registerSetCreativeModeSlot(ServerboundPackets1_20_5.SET_CREATIVE_MODE_SLOT);
 
         protocol.registerClientbound(ClientboundPackets1_20_5.HORSE_SCREEN_OPEN, wrapper -> {
             wrapper.passthrough(Types.UNSIGNED_BYTE); // Container id
@@ -108,7 +94,7 @@ public final class BlockItemPacketRewriter1_21 extends StructuredItemRewriter<Cl
             wrapper.write(Types.VAR_INT, Math.max(0, (size - 1) / 3));
         });
 
-        protocol.registerClientbound(ClientboundPackets1_20_5.LEVEL_EVENT, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_20_5.LEVEL_EVENT, wrapper -> {
             final int id = wrapper.passthrough(Types.INT);
             wrapper.passthrough(Types.BLOCK_POSITION1_14);
 

common/src/main/java/com/viaversion/viaversion/protocols/v1_20_5to1_21/rewriter/EntityPacketRewriter1_21.java

@@ -52,10 +52,6 @@ public final class EntityPacketRewriter1_21 extends EntityRewriter<ClientboundPa
 
     @Override
     public void registerPackets() {
-        registerTrackerWithData1_19(ClientboundPackets1_20_5.ADD_ENTITY, EntityTypes1_20_5.FALLING_BLOCK);
-        registerSetEntityData(ClientboundPackets1_20_5.SET_ENTITY_DATA);
-        registerRemoveEntities(ClientboundPackets1_20_5.REMOVE_ENTITIES);
-
         final RegistryDataRewriter registryDataRewriter = new RegistryDataRewriter(protocol);
         final CompoundTag campfireDamageType = new CompoundTag();
         campfireDamageType.putString("scaling", "when_caused_by_living_non_player");
@@ -109,16 +105,11 @@ public final class EntityPacketRewriter1_21 extends EntityRewriter<ClientboundPa
             }
         });
 
-        registerLogin1_20_5(ClientboundPackets1_20_5.LOGIN);
         protocol.appendClientbound(ClientboundPackets1_20_5.LOGIN, wrapper -> {
             wrapper.user().get(EfficiencyAttributeStorage.class).onLoginSent(wrapper.get(Types.INT, 0), wrapper.user());
         });
 
-        protocol.registerClientbound(ClientboundPackets1_20_5.RESPAWN, wrapper -> {
-            final int dimensionId = wrapper.passthrough(Types.VAR_INT);
-            final String world = wrapper.passthrough(Types.STRING);
-            trackWorldDataByKey1_20_5(wrapper.user(), dimensionId, world); // Tracks world height and name for chunk data and entity (un)tracking
-
+        protocol.appendClientbound(ClientboundPackets1_20_5.RESPAWN, wrapper -> {
             // Resend attribute modifiers from items
             wrapper.user().get(EfficiencyAttributeStorage.class).onRespawn(wrapper.user());
 

common/src/main/java/com/viaversion/viaversion/protocols/v1_20to1_20_2/Protocol1_20To1_20_2.java

@@ -25,8 +25,6 @@ import com.viaversion.viaversion.api.connection.ProtocolInfo;
 import com.viaversion.viaversion.api.connection.UserConnection;
 import com.viaversion.viaversion.api.data.MappingData;
 import com.viaversion.viaversion.api.data.MappingDataBase;
-import com.viaversion.viaversion.api.minecraft.RegistryType;
-import com.viaversion.viaversion.api.minecraft.TagData;
 import com.viaversion.viaversion.api.minecraft.entities.EntityTypes1_19_4;
 import com.viaversion.viaversion.api.protocol.AbstractProtocol;
 import com.viaversion.viaversion.api.protocol.packet.Direction;
@@ -35,8 +33,6 @@ import com.viaversion.viaversion.api.protocol.packet.State;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandler;
 import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
 import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
-import com.viaversion.viaversion.api.rewriter.EntityRewriter;
-import com.viaversion.viaversion.api.rewriter.ItemRewriter;
 import com.viaversion.viaversion.api.type.Types;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
 import com.viaversion.viaversion.exception.CancelException;
@@ -50,17 +46,16 @@ import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ClientboundPacke
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ServerboundConfigurationPackets1_20_2;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ServerboundPackets1_20_2;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.rewriter.BlockItemPacketRewriter1_20_2;
+import com.viaversion.viaversion.protocols.v1_20to1_20_2.rewriter.BlockRewriter1_20_2;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.rewriter.EntityPacketRewriter1_20_2;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.storage.ConfigurationState;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.storage.ConfigurationState.BridgePhase;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.storage.LastResourcePack;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.storage.LastTags;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.util.Key;
-import java.util.Arrays;
-import java.util.List;
 import java.util.UUID;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
@@ -71,6 +66,7 @@ public final class Protocol1_20To1_20_2 extends AbstractProtocol<ClientboundPack
     private final BlockItemPacketRewriter1_20_2 itemPacketRewriter = new BlockItemPacketRewriter1_20_2(this);
     private final ParticleRewriter<ClientboundPackets1_19_4> particleRewriter = new ParticleRewriter<>(this);
     private final TagRewriter<ClientboundPackets1_19_4> tagRewriter = new TagRewriter<>(this);
+    private final BlockRewriter<ClientboundPackets1_19_4> blockRewriter = new BlockRewriter1_20_2(this);
 
     public Protocol1_20To1_20_2() {
         super(ClientboundPackets1_19_4.class, ClientboundPackets1_20_2.class, ServerboundPackets1_19_4.class, ServerboundPackets1_20_2.class);
@@ -81,12 +77,6 @@ public final class Protocol1_20To1_20_2 extends AbstractProtocol<ClientboundPack
         // Close your eyes and turn around while you still can
         super.registerPackets();
 
-        final SoundRewriter<ClientboundPackets1_19_4> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_19_4.SOUND);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_19_4.SOUND_ENTITY);
-
-        particleRewriter.registerLevelParticles1_19(ClientboundPackets1_19_4.LEVEL_PARTICLES);
-
         registerClientbound(ClientboundPackets1_19_4.CUSTOM_PAYLOAD, new PacketHandlers() {
             @Override
             protected void register() {
@@ -123,7 +113,7 @@ public final class Protocol1_20To1_20_2 extends AbstractProtocol<ClientboundPack
             wrapper.user().put(new LastResourcePack(url, hash, required, prompt));
         });
 
-        registerClientbound(ClientboundPackets1_19_4.UPDATE_TAGS, wrapper -> {
+        replaceClientbound(ClientboundPackets1_19_4.UPDATE_TAGS, wrapper -> {
             tagRewriter.handleGeneric(wrapper);
             wrapper.resetReader();
             wrapper.user().put(new LastTags(wrapper));
@@ -407,15 +397,20 @@ public final class Protocol1_20To1_20_2 extends AbstractProtocol<ClientboundPack
     }
 
     @Override
-    public EntityRewriter<Protocol1_20To1_20_2> getEntityRewriter() {
+    public EntityPacketRewriter1_20_2 getEntityRewriter() {
         return entityPacketRewriter;
     }
 
     @Override
-    public ItemRewriter<Protocol1_20To1_20_2> getItemRewriter() {
+    public BlockItemPacketRewriter1_20_2 getItemRewriter() {
         return itemPacketRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPackets1_19_4> getBlockRewriter() {
+        return blockRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPackets1_19_4> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_20to1_20_2/rewriter/BlockItemPacketRewriter1_20_2.java

@@ -23,27 +23,19 @@ import com.viaversion.nbt.tag.NumberTag;
 import com.viaversion.nbt.tag.StringTag;
 import com.viaversion.nbt.tag.Tag;
 import com.viaversion.viaversion.api.connection.UserConnection;
-import com.viaversion.viaversion.api.data.entity.EntityTracker;
+import com.viaversion.viaversion.api.minecraft.BlockPosition;
 import com.viaversion.viaversion.api.minecraft.ChunkPosition;
 import com.viaversion.viaversion.api.minecraft.blockentity.BlockEntity;
-import com.viaversion.viaversion.api.minecraft.chunks.Chunk;
-import com.viaversion.viaversion.api.minecraft.chunks.ChunkSection;
-import com.viaversion.viaversion.api.minecraft.chunks.DataPalette;
-import com.viaversion.viaversion.api.minecraft.chunks.PaletteType;
+import com.viaversion.viaversion.api.minecraft.blockentity.BlockEntityImpl;
 import com.viaversion.viaversion.api.minecraft.item.Item;
-import com.viaversion.viaversion.api.protocol.remapper.PacketHandlers;
 import com.viaversion.viaversion.api.type.Type;
 import com.viaversion.viaversion.api.type.Types;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_18;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_20_2;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ClientboundPackets1_19_4;
 import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.rewriter.RecipeRewriter1_19_4;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.Protocol1_20To1_20_2;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.data.PotionEffects1_20_2;
 import com.viaversion.viaversion.protocols.v1_20to1_20_2.packet.ServerboundPackets1_20_2;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ItemRewriter;
-import com.viaversion.viaversion.util.MathUtil;
 import org.checkerframework.checker.nullness.qual.Nullable;
 
 public final class BlockItemPacketRewriter1_20_2 extends ItemRewriter<ClientboundPackets1_19_4, ServerboundPackets1_20_2, Protocol1_20To1_20_2> {
@@ -54,18 +46,6 @@ public final class BlockItemPacketRewriter1_20_2 extends ItemRewriter<Clientboun
 
     @Override
     public void registerPackets() {
-        final BlockRewriter<ClientboundPackets1_19_4> blockRewriter = BlockRewriter.for1_14(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets1_19_4.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_19_4.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate1_20(ClientboundPackets1_19_4.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerLevelEvent(ClientboundPackets1_19_4.LEVEL_EVENT, 1010, 2001);
-
-        registerSetContent1_17_1(ClientboundPackets1_19_4.CONTAINER_SET_CONTENT);
-        registerSetSlot1_17_1(ClientboundPackets1_19_4.CONTAINER_SET_SLOT);
-        registerContainerClick1_17_1(ServerboundPackets1_20_2.CONTAINER_CLICK);
-        registerMerchantOffers1_19(ClientboundPackets1_19_4.MERCHANT_OFFERS);
-        registerSetCreativeModeSlot(ServerboundPackets1_20_2.SET_CREATIVE_MODE_SLOT);
-
         protocol.registerServerbound(ServerboundPackets1_20_2.SET_BEACON, wrapper -> {
             // Effects start at 1 before 1.20.2
             if (wrapper.passthrough(Types.BOOLEAN)) { // Primary effect
@@ -87,38 +67,17 @@ public final class BlockItemPacketRewriter1_20_2 extends ItemRewriter<Clientboun
             wrapper.write(Types.COMPOUND_TAG, wrapper.read(Types.NAMED_COMPOUND_TAG));
         });
 
-        protocol.registerClientbound(ClientboundPackets1_19_4.BLOCK_ENTITY_DATA, wrapper -> {
-            wrapper.passthrough(Types.BLOCK_POSITION1_14); // Position
-            wrapper.passthrough(Types.VAR_INT); // Type
-            wrapper.write(Types.TRUSTED_COMPOUND_TAG, handleBlockEntity(wrapper.read(Types.NAMED_COMPOUND_TAG)));
+        protocol.replaceClientbound(ClientboundPackets1_19_4.BLOCK_ENTITY_DATA, wrapper -> {
+            final BlockPosition position = wrapper.passthrough(Types.BLOCK_POSITION1_14);
+            final int typeId = wrapper.passthrough(Types.VAR_INT);
+
+            final CompoundTag tag = wrapper.read(Types.NAMED_COMPOUND_TAG);
+            final BlockEntity blockEntity = new BlockEntityImpl(BlockEntity.pack(position.x(), position.z()), (short) position.y(), typeId, tag);
+            protocol.getBlockRewriter().handleBlockEntity(wrapper.user(), blockEntity);
+            wrapper.write(Types.TRUSTED_COMPOUND_TAG, blockEntity.tag());
         });
 
-        protocol.registerClientbound(ClientboundPackets1_19_4.LEVEL_CHUNK_WITH_LIGHT, wrapper -> {
-            final EntityTracker tracker = protocol.getEntityRewriter().tracker(wrapper.user());
-            final Type<Chunk> chunkType = new ChunkType1_18(tracker.currentWorldSectionHeight(),
-                MathUtil.ceilLog2(protocol.getMappingData().getBlockStateMappings().size()),
-                MathUtil.ceilLog2(tracker.biomesSent()));
-            final Chunk chunk = wrapper.read(chunkType);
-
-            final Type<Chunk> newChunkType = new ChunkType1_20_2(tracker.currentWorldSectionHeight(),
-                MathUtil.ceilLog2(protocol.getMappingData().getBlockStateMappings().mappedSize()),
-                MathUtil.ceilLog2(tracker.biomesSent()));
-            wrapper.write(newChunkType, chunk);
-
-            for (final ChunkSection section : chunk.getSections()) {
-                final DataPalette blockPalette = section.palette(PaletteType.BLOCKS);
-                for (int i = 0; i < blockPalette.size(); i++) {
-                    final int id = blockPalette.idByIndex(i);
-                    blockPalette.setIdByIndex(i, protocol.getMappingData().getNewBlockStateId(id));
-                }
-            }
-
-            for (final BlockEntity blockEntity : chunk.blockEntities()) {
-                handleBlockEntity(blockEntity.tag());
-            }
-        });
-
-        protocol.registerClientbound(ClientboundPackets1_19_4.UPDATE_ADVANCEMENTS, wrapper -> {
+        protocol.replaceClientbound(ClientboundPackets1_19_4.UPDATE_ADVANCEMENTS, wrapper -> {
             wrapper.passthrough(Types.BOOLEAN); // Reset/clear
             final int size = wrapper.passthrough(Types.VAR_INT); // Mapping size
             for (int i = 0; i < size; i++) {
@@ -150,19 +109,6 @@ public final class BlockItemPacketRewriter1_20_2 extends ItemRewriter<Clientboun
                 wrapper.passthrough(Types.BOOLEAN); // Send telemetry
             }
         });
-        protocol.registerClientbound(ClientboundPackets1_19_4.SET_EQUIPMENT, new PacketHandlers() {
-            @Override
-            public void register() {
-                map(Types.VAR_INT); // 0 - Entity ID
-                handler(wrapper -> {
-                    byte slot;
-                    do {
-                        slot = wrapper.passthrough(Types.BYTE);
-                        wrapper.write(Types.ITEM1_20_2, handleItemToClient(wrapper.user(), wrapper.read(Types.ITEM1_13_2)));
-                    } while ((slot & 0xFFFFFF80) != 0);
-                });
-            }
-        });
 
         new RecipeRewriter1_19_4<>(protocol) {
             @Override
@@ -266,21 +212,4 @@ public final class BlockItemPacketRewriter1_20_2 extends ItemRewriter<Clientboun
             tag.put(toEntryName, entry);
         }
     }
-
-    private @Nullable CompoundTag handleBlockEntity(@Nullable final CompoundTag tag) {
-        if (tag == null) {
-            return null;
-        }
-
-        final Tag primaryEffect = tag.remove("Primary");
-        if (primaryEffect instanceof NumberTag && ((NumberTag) primaryEffect).asInt() != 0) {
-            tag.put("primary_effect", new StringTag(PotionEffects1_20_2.idToKeyOrLuck(((NumberTag) primaryEffect).asInt() - 1)));
-        }
-
-        final Tag secondaryEffect = tag.remove("Secondary");
-        if (secondaryEffect instanceof NumberTag && ((NumberTag) secondaryEffect).asInt() != 0) {
-            tag.put("secondary_effect", new StringTag(PotionEffects1_20_2.idToKeyOrLuck(((NumberTag) secondaryEffect).asInt() - 1)));
-        }
-        return tag;
-    }
 }

common/src/main/java/com/viaversion/viaversion/protocols/v1_20to1_20_2/rewriter/BlockRewriter1_20_2.java

@@ -0,0 +1,53 @@
+/*
+ * This file is part of ViaVersion - https://github.com/ViaVersion/ViaVersion
+ * Copyright (C) 2016-2026 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.protocols.v1_20to1_20_2.rewriter;
+
+import com.viaversion.nbt.tag.CompoundTag;
+import com.viaversion.nbt.tag.NumberTag;
+import com.viaversion.nbt.tag.StringTag;
+import com.viaversion.nbt.tag.Tag;
+import com.viaversion.viaversion.api.connection.UserConnection;
+import com.viaversion.viaversion.api.minecraft.blockentity.BlockEntity;
+import com.viaversion.viaversion.api.protocol.Protocol;
+import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_18;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_20_2;
+import com.viaversion.viaversion.protocols.v1_19_3to1_19_4.packet.ClientboundPackets1_19_4;
+import com.viaversion.viaversion.protocols.v1_20to1_20_2.data.PotionEffects1_20_2;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
+
+public final class BlockRewriter1_20_2 extends BlockRewriter<ClientboundPackets1_19_4> {
+
+    public BlockRewriter1_20_2(final Protocol<ClientboundPackets1_19_4, ?, ?, ?> protocol) {
+        super(protocol, Types.BLOCK_POSITION1_14, Types.NAMED_COMPOUND_TAG, ChunkType1_18::new, ChunkType1_20_2::new);
+    }
+
+    @Override
+    public void handleBlockEntity(final UserConnection connection, final BlockEntity blockEntity) {
+        final CompoundTag tag = blockEntity.tag();
+        final Tag primaryEffect = tag.remove("Primary");
+        if (primaryEffect instanceof NumberTag && ((NumberTag) primaryEffect).asInt() != 0) {
+            tag.put("primary_effect", new StringTag(PotionEffects1_20_2.idToKeyOrLuck(((NumberTag) primaryEffect).asInt() - 1)));
+        }
+
+        final Tag secondaryEffect = tag.remove("Secondary");
+        if (secondaryEffect instanceof NumberTag && ((NumberTag) secondaryEffect).asInt() != 0) {
+            tag.put("secondary_effect", new StringTag(PotionEffects1_20_2.idToKeyOrLuck(((NumberTag) secondaryEffect).asInt() - 1)));
+        }
+    }
+}

common/src/main/java/com/viaversion/viaversion/protocols/v1_20to1_20_2/rewriter/EntityPacketRewriter1_20_2.java

@@ -39,9 +39,7 @@ public final class EntityPacketRewriter1_20_2 extends EntityRewriter<Clientbound
 
     @Override
     public void registerPackets() {
-        registerTrackerWithData1_19(ClientboundPackets1_19_4.ADD_ENTITY, EntityTypes1_19_4.FALLING_BLOCK);
         registerSetEntityData(ClientboundPackets1_19_4.SET_ENTITY_DATA, Types1_20.ENTITY_DATA_LIST, Types1_20_2.ENTITY_DATA_LIST);
-        registerRemoveEntities(ClientboundPackets1_19_4.REMOVE_ENTITIES);
 
         protocol.registerClientbound(ClientboundPackets1_19_4.ADD_PLAYER, ClientboundPackets1_20_2.ADD_ENTITY, wrapper -> {
             wrapper.passthrough(Types.VAR_INT); // Entity id

common/src/main/java/com/viaversion/viaversion/protocols/v1_21_11to26_1/Protocol1_21_11To26_1.java

@@ -34,6 +34,8 @@ import com.viaversion.viaversion.api.protocol.packet.PacketWrapper;
 import com.viaversion.viaversion.api.protocol.packet.provider.PacketTypesProvider;
 import com.viaversion.viaversion.api.protocol.packet.provider.SimplePacketTypesProvider;
 import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_21_5;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType26_1;
 import com.viaversion.viaversion.api.type.types.misc.ParticleType;
 import com.viaversion.viaversion.api.type.types.version.Types1_20_5;
 import com.viaversion.viaversion.api.type.types.version.VersionedTypes;
@@ -48,18 +50,19 @@ import com.viaversion.viaversion.protocols.v1_21_11to26_1.rewriter.BlockItemPack
 import com.viaversion.viaversion.protocols.v1_21_11to26_1.rewriter.ComponentRewriter26_1;
 import com.viaversion.viaversion.protocols.v1_21_11to26_1.rewriter.EntityPacketRewriter26_1;
 import com.viaversion.viaversion.protocols.v1_21_11to26_1.storage.TagsSent;
+import com.viaversion.viaversion.protocols.v1_21_4to1_21_5.rewriter.RecipeDisplayRewriter1_21_5;
 import com.viaversion.viaversion.protocols.v1_21_5to1_21_6.packet.ServerboundPackets1_21_6;
 import com.viaversion.viaversion.protocols.v1_21_7to1_21_9.packet.ClientboundConfigurationPackets1_21_9;
 import com.viaversion.viaversion.protocols.v1_21_7to1_21_9.packet.ServerboundConfigurationPackets1_21_9;
 import com.viaversion.viaversion.protocols.v1_21_7to1_21_9.packet.ServerboundPacket1_21_9;
 import com.viaversion.viaversion.protocols.v1_21_9to1_21_11.packet.ClientboundPacket1_21_11;
 import com.viaversion.viaversion.protocols.v1_21_9to1_21_11.packet.ClientboundPackets1_21_11;
-import com.viaversion.viaversion.rewriter.AttributeRewriter;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
+import com.viaversion.viaversion.rewriter.RecipeDisplayRewriter;
 import com.viaversion.viaversion.rewriter.RegistryDataRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
+import com.viaversion.viaversion.rewriter.block.BlockRewriter1_21_5;
 import com.viaversion.viaversion.rewriter.text.NBTComponentRewriter;
 import com.viaversion.viaversion.util.Key;
 import java.util.Map;
@@ -75,6 +78,8 @@ public final class Protocol1_21_11To26_1 extends AbstractProtocol<ClientboundPac
     private final TagRewriter<ClientboundPacket1_21_11> tagRewriter = new TagRewriter<>(this);
     private final NBTComponentRewriter<ClientboundPacket1_21_11> componentRewriter = new ComponentRewriter26_1(this);
     private final RegistryDataRewriter registryDataRewriter = new RegistryDataRewriter(this);
+    private final RecipeDisplayRewriter<ClientboundPacket1_21_11> recipeRewriter = new RecipeDisplayRewriter1_21_5<>(this);
+    private final BlockRewriter<ClientboundPacket1_21_11> blockRewriter = new BlockRewriter1_21_5<>(this, ChunkType1_21_5::new, ChunkType26_1::new);
 
     public Protocol1_21_11To26_1() {
         super(ClientboundPacket1_21_11.class, ClientboundPacket26_1.class, ServerboundPacket1_21_9.class, ServerboundPacket26_1.class);
@@ -142,36 +147,6 @@ public final class Protocol1_21_11To26_1 extends AbstractProtocol<ClientboundPac
                 attributes.putInt("visual/ambient_light_color", ambientLightColor);
             }
         });
-        registerClientbound(ClientboundConfigurationPackets1_21_9.REGISTRY_DATA, registryDataRewriter::handle);
-
-        registerClientbound(ClientboundPackets1_21_11.UPDATE_TAGS, this::handleTags);
-        registerClientbound(ClientboundConfigurationPackets1_21_9.UPDATE_TAGS, this::handleTags);
-
-        componentRewriter.registerOpenScreen1_14(ClientboundPackets1_21_11.OPEN_SCREEN);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_21_11.SET_ACTION_BAR_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_21_11.SET_TITLE_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_21_11.SET_SUBTITLE_TEXT);
-        componentRewriter.registerBossEvent(ClientboundPackets1_21_11.BOSS_EVENT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_21_11.DISCONNECT);
-        componentRewriter.registerTabList(ClientboundPackets1_21_11.TAB_LIST);
-        componentRewriter.registerSetPlayerTeam1_21_5(ClientboundPackets1_21_11.SET_PLAYER_TEAM);
-        componentRewriter.registerPlayerCombatKill1_20(ClientboundPackets1_21_11.PLAYER_COMBAT_KILL);
-        componentRewriter.registerPlayerInfoUpdate1_21_4(ClientboundPackets1_21_11.PLAYER_INFO_UPDATE);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_21_11.SYSTEM_CHAT);
-        componentRewriter.registerDisguisedChat(ClientboundPackets1_21_11.DISGUISED_CHAT);
-        componentRewriter.registerPlayerChat1_21_5(ClientboundPackets1_21_11.PLAYER_CHAT);
-        componentRewriter.registerPing();
-
-        particleRewriter.registerLevelParticles1_21_4(ClientboundPackets1_21_11.LEVEL_PARTICLES);
-        particleRewriter.registerExplode1_21_9(ClientboundPackets1_21_11.EXPLODE);
-
-        final SoundRewriter<ClientboundPacket1_21_11> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_21_11.SOUND);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_21_11.SOUND_ENTITY);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_21_11.AWARD_STATS);
-        new AttributeRewriter<>(this).register1_21(ClientboundPackets1_21_11.UPDATE_ATTRIBUTES);
-
         registerClientbound(ClientboundPackets1_21_11.SET_TIME, wrapper -> {
             wrapper.passthrough(Types.LONG); // Game time
 
@@ -185,6 +160,9 @@ public final class Protocol1_21_11To26_1 extends AbstractProtocol<ClientboundPac
             wrapper.write(Types.FLOAT, tickDayTime ? 1F : 0F); // Tick rate
         });
         cancelServerbound(ServerboundPackets26_1.SET_GAME_RULE);
+
+        replaceClientbound(ClientboundPackets1_21_11.UPDATE_TAGS, this::handleTags);
+        replaceClientbound(ClientboundConfigurationPackets1_21_9.UPDATE_TAGS, this::handleTags);
     }
 
     private void handleTags(final PacketWrapper wrapper) {
@@ -365,6 +343,16 @@ public final class Protocol1_21_11To26_1 extends AbstractProtocol<ClientboundPac
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPacket1_21_11> getBlockRewriter() {
+        return blockRewriter;
+    }
+
+    @Override
+    public RecipeDisplayRewriter<ClientboundPacket1_21_11> getRecipeRewriter() {
+        return recipeRewriter;
+    }
+
     @Override
     public RegistryDataRewriter getRegistryDataRewriter() {
         return registryDataRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_21_11to26_1/rewriter/BlockItemPacketRewriter26_1.java

@@ -37,19 +37,11 @@ import com.viaversion.viaversion.api.minecraft.item.data.JukeboxPlayable;
 import com.viaversion.viaversion.api.minecraft.item.data.ProvidesBannerPatterns;
 import com.viaversion.viaversion.api.minecraft.item.data.ProvidesTrimMaterial;
 import com.viaversion.viaversion.api.protocol.Protocol;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_21_5;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType26_1;
 import com.viaversion.viaversion.protocols.v1_21_11to26_1.Protocol1_21_11To26_1;
 import com.viaversion.viaversion.protocols.v1_21_11to26_1.packet.ServerboundPacket26_1;
-import com.viaversion.viaversion.protocols.v1_21_11to26_1.packet.ServerboundPackets26_1;
-import com.viaversion.viaversion.protocols.v1_21_4to1_21_5.rewriter.RecipeDisplayRewriter1_21_5;
-import com.viaversion.viaversion.protocols.v1_21_7to1_21_9.packet.ClientboundConfigurationPackets1_21_9;
 import com.viaversion.viaversion.protocols.v1_21_9to1_21_11.packet.ClientboundPacket1_21_11;
 import com.viaversion.viaversion.protocols.v1_21_9to1_21_11.packet.ClientboundPackets1_21_11;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
-import com.viaversion.viaversion.rewriter.RecipeDisplayRewriter;
 import com.viaversion.viaversion.rewriter.StructuredItemRewriter;
-import com.viaversion.viaversion.rewriter.block.BlockRewriter1_21_5;
 import com.viaversion.viaversion.util.Either;
 import com.viaversion.viaversion.util.Key;
 import org.checkerframework.checker.nullness.qual.Nullable;
@@ -62,14 +54,8 @@ public final class BlockItemPacketRewriter26_1 extends StructuredItemRewriter<Cl
 
     @Override
     public void registerPackets() {
-        final BlockRewriter<ClientboundPacket1_21_11> blockRewriter = new BlockRewriter1_21_5<>(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets1_21_11.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_21_11.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate1_20(ClientboundPackets1_21_11.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerLevelEvent1_21(ClientboundPackets1_21_11.LEVEL_EVENT, 2001);
-        blockRewriter.registerBlockEntityData(ClientboundPackets1_21_11.BLOCK_ENTITY_DATA);
-        protocol.registerClientbound(ClientboundPackets1_21_11.LEVEL_CHUNK_WITH_LIGHT, wrapper -> {
-            final Chunk chunk = blockRewriter.handleChunk1_19(wrapper, ChunkType1_21_5::new, ChunkType26_1::new);
+        protocol.replaceClientbound(ClientboundPackets1_21_11.LEVEL_CHUNK_WITH_LIGHT, wrapper -> {
+            final Chunk chunk = protocol.getBlockRewriter().handleChunk1_18(wrapper);
             for (final ChunkSection section : chunk.getSections()) {
                 final DataPalette blockPalette = section.palette(PaletteType.BLOCKS);
                 for (int i = 0; i < blockPalette.size(); i++) {
@@ -80,26 +66,8 @@ public final class BlockItemPacketRewriter26_1 extends StructuredItemRewriter<Cl
                     }
                 }
             }
-            blockRewriter.handleBlockEntities(chunk, wrapper.user());
+            protocol.getBlockRewriter().handleBlockEntities(chunk, wrapper.user());
         });
-
-        registerSetCursorItem(ClientboundPackets1_21_11.SET_CURSOR_ITEM);
-        registerSetPlayerInventory(ClientboundPackets1_21_11.SET_PLAYER_INVENTORY);
-        registerCooldown1_21_2(ClientboundPackets1_21_11.COOLDOWN);
-        registerSetContent1_21_2(ClientboundPackets1_21_11.CONTAINER_SET_CONTENT);
-        registerSetSlot1_21_2(ClientboundPackets1_21_11.CONTAINER_SET_SLOT);
-        registerAdvancements1_20_3(ClientboundPackets1_21_11.UPDATE_ADVANCEMENTS);
-        registerSetEquipment(ClientboundPackets1_21_11.SET_EQUIPMENT);
-        registerMerchantOffers1_20_5(ClientboundPackets1_21_11.MERCHANT_OFFERS);
-        registerContainerClick1_21_5(ServerboundPackets26_1.CONTAINER_CLICK);
-        registerSetCreativeModeSlot1_21_5(ServerboundPackets26_1.SET_CREATIVE_MODE_SLOT);
-        registerShowDialog(ClientboundPackets1_21_11.SHOW_DIALOG);
-        registerShowDialogDirect(ClientboundConfigurationPackets1_21_9.SHOW_DIALOG);
-
-        final RecipeDisplayRewriter<ClientboundPacket1_21_11> recipeRewriter = new RecipeDisplayRewriter1_21_5<>(protocol);
-        recipeRewriter.registerUpdateRecipes(ClientboundPackets1_21_11.UPDATE_RECIPES);
-        recipeRewriter.registerRecipeBookAdd(ClientboundPackets1_21_11.RECIPE_BOOK_ADD);
-        recipeRewriter.registerPlaceGhostRecipe(ClientboundPackets1_21_11.PLACE_GHOST_RECIPE);
     }
 
     @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_21_11to26_1/rewriter/EntityPacketRewriter26_1.java

@@ -38,14 +38,6 @@ public final class EntityPacketRewriter26_1 extends EntityRewriter<ClientboundPa
 
     @Override
     public void registerPackets() {
-        registerTrackerWithData1_21_9(ClientboundPackets1_21_11.ADD_ENTITY, EntityTypes1_21_11.FALLING_BLOCK);
-        registerSetEntityData(ClientboundPackets1_21_11.SET_ENTITY_DATA);
-        registerRemoveEntities(ClientboundPackets1_21_11.REMOVE_ENTITIES);
-        registerPlayerAbilities(ClientboundPackets1_21_11.PLAYER_ABILITIES);
-        registerGameEvent(ClientboundPackets1_21_11.GAME_EVENT);
-        registerLogin1_20_5(ClientboundPackets1_21_11.LOGIN);
-        registerRespawn1_20_5(ClientboundPackets1_21_11.RESPAWN);
-
         protocol.registerServerbound(ServerboundPackets26_1.INTERACT, wrapper -> {
             final int entityId = wrapper.passthrough(Types.VAR_INT);
             wrapper.write(Types.VAR_INT, 0); // Interact

common/src/main/java/com/viaversion/viaversion/protocols/v1_21_2to1_21_4/Protocol1_21_2To1_21_4.java

@@ -23,9 +23,7 @@ import com.viaversion.viaversion.api.data.MappingDataBase;
 import com.viaversion.viaversion.api.minecraft.Particle;
 import com.viaversion.viaversion.api.minecraft.data.StructuredDataKey;
 import com.viaversion.viaversion.api.minecraft.entities.EntityTypes1_21_4;
-import com.viaversion.viaversion.api.minecraft.item.data.ChatType;
 import com.viaversion.viaversion.api.platform.providers.ViaProviders;
-import com.viaversion.viaversion.api.protocol.AbstractProtocol;
 import com.viaversion.viaversion.api.protocol.packet.provider.PacketTypesProvider;
 import com.viaversion.viaversion.api.protocol.packet.provider.SimplePacketTypesProvider;
 import com.viaversion.viaversion.api.type.Types;
@@ -33,12 +31,14 @@ import com.viaversion.viaversion.api.type.types.misc.ParticleType;
 import com.viaversion.viaversion.api.type.types.version.VersionedTypes;
 import com.viaversion.viaversion.api.type.types.version.VersionedTypesHolder;
 import com.viaversion.viaversion.data.entity.EntityTrackerBase;
+import com.viaversion.viaversion.api.protocol.AbstractProtocol;
 import com.viaversion.viaversion.protocols.v1_20_3to1_20_5.packet.ServerboundConfigurationPackets1_20_5;
 import com.viaversion.viaversion.protocols.v1_20_5to1_21.packet.ClientboundConfigurationPackets1_21;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.packet.ServerboundPacket1_21_4;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.packet.ServerboundPackets1_21_4;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.provider.PickItemProvider;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.rewriter.BlockItemPacketRewriter1_21_4;
+import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.rewriter.BlockPacketRewriter1_21_4;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.rewriter.ComponentRewriter1_21_4;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.rewriter.EntityPacketRewriter1_21_4;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.rewriter.ParticleRewriter1_21_4;
@@ -46,10 +46,10 @@ import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPacke
 import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPackets1_21_2;
 import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ServerboundPacket1_21_2;
 import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ServerboundPackets1_21_2;
-import com.viaversion.viaversion.rewriter.AttributeRewriter;
+import com.viaversion.viaversion.rewriter.BlockRewriter;
 import com.viaversion.viaversion.rewriter.ParticleRewriter;
-import com.viaversion.viaversion.rewriter.SoundRewriter;
-import com.viaversion.viaversion.rewriter.StatisticsRewriter;
+import com.viaversion.viaversion.rewriter.RecipeDisplayRewriter;
+import com.viaversion.viaversion.rewriter.RegistryDataRewriter;
 import com.viaversion.viaversion.rewriter.TagRewriter;
 import com.viaversion.viaversion.rewriter.text.JsonNBTComponentRewriter;
 import java.util.BitSet;
@@ -64,6 +64,9 @@ public final class Protocol1_21_2To1_21_4 extends AbstractProtocol<ClientboundPa
     private final ParticleRewriter<ClientboundPacket1_21_2> particleRewriter = new ParticleRewriter1_21_4(this);
     private final TagRewriter<ClientboundPacket1_21_2> tagRewriter = new TagRewriter<>(this);
     private final JsonNBTComponentRewriter<ClientboundPacket1_21_2> componentRewriter = new ComponentRewriter1_21_4(this);
+    private final BlockRewriter<ClientboundPacket1_21_2> blockRewriter = new BlockPacketRewriter1_21_4(this);
+    private final RecipeDisplayRewriter<ClientboundPacket1_21_2> recipeRewriter = new RecipeDisplayRewriter<>(this);
+    private final RegistryDataRewriter registryDataRewriter = new RegistryDataRewriter(this);
 
     public Protocol1_21_2To1_21_4() {
         super(ClientboundPacket1_21_2.class, ClientboundPacket1_21_2.class, ServerboundPacket1_21_2.class, ServerboundPacket1_21_4.class);
@@ -73,28 +76,7 @@ public final class Protocol1_21_2To1_21_4 extends AbstractProtocol<ClientboundPa
     protected void registerPackets() {
         super.registerPackets();
 
-        tagRewriter.registerGeneric(ClientboundPackets1_21_2.UPDATE_TAGS);
-        tagRewriter.registerGeneric(ClientboundConfigurationPackets1_21.UPDATE_TAGS);
-
-        componentRewriter.registerOpenScreen1_14(ClientboundPackets1_21_2.OPEN_SCREEN);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_21_2.SET_ACTION_BAR_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_21_2.SET_TITLE_TEXT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_21_2.SET_SUBTITLE_TEXT);
-        componentRewriter.registerBossEvent(ClientboundPackets1_21_2.BOSS_EVENT);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_21_2.DISCONNECT);
-        componentRewriter.registerComponentPacket(ClientboundConfigurationPackets1_21.DISCONNECT);
-        componentRewriter.registerTabList(ClientboundPackets1_21_2.TAB_LIST);
-        componentRewriter.registerPlayerCombatKill1_20(ClientboundPackets1_21_2.PLAYER_COMBAT_KILL);
-        componentRewriter.registerComponentPacket(ClientboundPackets1_21_2.SYSTEM_CHAT);
-        componentRewriter.registerDisguisedChat(ClientboundPackets1_21_2.DISGUISED_CHAT);
-        componentRewriter.registerPlayerChat(ClientboundPackets1_21_2.PLAYER_CHAT, ChatType.TYPE);
-        componentRewriter.registerSetPlayerTeam1_13(ClientboundPackets1_21_2.SET_PLAYER_TEAM);
-        componentRewriter.registerSetObjective(ClientboundPackets1_21_2.SET_OBJECTIVE);
-        componentRewriter.registerSetScore1_20_3(ClientboundPackets1_21_2.SET_SCORE);
-        componentRewriter.registerPing();
-
-        particleRewriter.registerExplode1_21_2(ClientboundPackets1_21_2.EXPLODE);
-        registerClientbound(ClientboundPackets1_21_2.LEVEL_PARTICLES, wrapper -> {
+        replaceClientbound(ClientboundPackets1_21_2.LEVEL_PARTICLES, wrapper -> {
             wrapper.passthrough(Types.BOOLEAN); // Override limiter
             wrapper.write(Types.BOOLEAN, false); // Always show
             wrapper.passthrough(Types.DOUBLE); // X
@@ -110,14 +92,7 @@ public final class Protocol1_21_2To1_21_4 extends AbstractProtocol<ClientboundPa
             particleRewriter.rewriteParticle(wrapper.user(), particle);
         });
 
-        final SoundRewriter<ClientboundPacket1_21_2> soundRewriter = new SoundRewriter<>(this);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_21_2.SOUND);
-        soundRewriter.registerSound1_19_3(ClientboundPackets1_21_2.SOUND_ENTITY);
-
-        new StatisticsRewriter<>(this).register(ClientboundPackets1_21_2.AWARD_STATS);
-        new AttributeRewriter<>(this).register1_21(ClientboundPackets1_21_2.UPDATE_ATTRIBUTES);
-
-        registerClientbound(ClientboundPackets1_21_2.PLAYER_INFO_UPDATE, wrapper -> {
+        replaceClientbound(ClientboundPackets1_21_2.PLAYER_INFO_UPDATE, wrapper -> {
             // Added "show hat" - true by default, keep it like that
             final BitSet actions = wrapper.passthroughAndMap(Types.PROFILE_ACTIONS_ENUM1_21_2, Types.PROFILE_ACTIONS_ENUM1_21_4);
             if (!actions.get(5)) { // Update display name
@@ -215,6 +190,21 @@ public final class Protocol1_21_2To1_21_4 extends AbstractProtocol<ClientboundPa
         return itemRewriter;
     }
 
+    @Override
+    public BlockRewriter<ClientboundPacket1_21_2> getBlockRewriter() {
+        return blockRewriter;
+    }
+
+    @Override
+    public RecipeDisplayRewriter<ClientboundPacket1_21_2> getRecipeRewriter() {
+        return recipeRewriter;
+    }
+
+    @Override
+    public RegistryDataRewriter getRegistryDataRewriter() {
+        return registryDataRewriter;
+    }
+
     @Override
     public ParticleRewriter<ClientboundPacket1_21_2> getParticleRewriter() {
         return particleRewriter;

common/src/main/java/com/viaversion/viaversion/protocols/v1_21_2to1_21_4/rewriter/BlockItemPacketRewriter1_21_4.java

@@ -31,15 +31,12 @@ import com.viaversion.viaversion.api.minecraft.item.data.Consumable1_21_2;
 import com.viaversion.viaversion.api.minecraft.item.data.CustomModelData1_21_4;
 import com.viaversion.viaversion.api.protocol.version.ProtocolVersion;
 import com.viaversion.viaversion.api.type.Types;
-import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_20_2;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.Protocol1_21_2To1_21_4;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.packet.ServerboundPacket1_21_4;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.packet.ServerboundPackets1_21_4;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.provider.PickItemProvider;
 import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPacket1_21_2;
 import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPackets1_21_2;
-import com.viaversion.viaversion.rewriter.BlockRewriter;
-import com.viaversion.viaversion.rewriter.RecipeDisplayRewriter;
 import com.viaversion.viaversion.rewriter.StructuredItemRewriter;
 
 public final class BlockItemPacketRewriter1_21_4 extends StructuredItemRewriter<ClientboundPacket1_21_2, ServerboundPacket1_21_4, Protocol1_21_2To1_21_4> {
@@ -50,14 +47,6 @@ public final class BlockItemPacketRewriter1_21_4 extends StructuredItemRewriter<
 
     @Override
     public void registerPackets() {
-        final BlockRewriter<ClientboundPacket1_21_2> blockRewriter = new BlockPacketRewriter1_21_4(protocol);
-        blockRewriter.registerBlockEvent(ClientboundPackets1_21_2.BLOCK_EVENT);
-        blockRewriter.registerBlockUpdate(ClientboundPackets1_21_2.BLOCK_UPDATE);
-        blockRewriter.registerSectionBlocksUpdate1_20(ClientboundPackets1_21_2.SECTION_BLOCKS_UPDATE);
-        blockRewriter.registerLevelEvent1_21(ClientboundPackets1_21_2.LEVEL_EVENT, 2001);
-        blockRewriter.registerLevelChunk1_19(ClientboundPackets1_21_2.LEVEL_CHUNK_WITH_LIGHT, ChunkType1_20_2::new);
-        blockRewriter.registerBlockEntityData(ClientboundPackets1_21_2.BLOCK_ENTITY_DATA);
-
         protocol.registerClientbound(ClientboundPackets1_21_2.SET_HELD_SLOT, wrapper -> {
             final byte slot = wrapper.read(Types.BYTE);
             wrapper.write(Types.VAR_INT, (int) slot);
@@ -75,22 +64,6 @@ public final class BlockItemPacketRewriter1_21_4 extends StructuredItemRewriter<
             Via.getManager().getProviders().get(PickItemProvider.class).pickItemFromEntity(wrapper.user(), entityId, includeData);
             wrapper.cancel();
         });
-
-        protocol.registerClientbound(ClientboundPackets1_21_2.SET_CURSOR_ITEM, this::passthroughClientboundItem);
-        registerSetPlayerInventory(ClientboundPackets1_21_2.SET_PLAYER_INVENTORY);
-        registerCooldown1_21_2(ClientboundPackets1_21_2.COOLDOWN);
-        registerSetContent1_21_2(ClientboundPackets1_21_2.CONTAINER_SET_CONTENT);
-        registerSetSlot1_21_2(ClientboundPackets1_21_2.CONTAINER_SET_SLOT);
-        registerAdvancements1_20_3(ClientboundPackets1_21_2.UPDATE_ADVANCEMENTS);
-        registerSetEquipment(ClientboundPackets1_21_2.SET_EQUIPMENT);
-        registerContainerClick1_21_2(ServerboundPackets1_21_4.CONTAINER_CLICK);
-        registerMerchantOffers1_20_5(ClientboundPackets1_21_2.MERCHANT_OFFERS);
-        registerSetCreativeModeSlot(ServerboundPackets1_21_4.SET_CREATIVE_MODE_SLOT);
-
-        final RecipeDisplayRewriter<ClientboundPacket1_21_2> recipeRewriter = new RecipeDisplayRewriter<>(protocol);
-        recipeRewriter.registerUpdateRecipes(ClientboundPackets1_21_2.UPDATE_RECIPES);
-        recipeRewriter.registerRecipeBookAdd(ClientboundPackets1_21_2.RECIPE_BOOK_ADD);
-        recipeRewriter.registerPlaceGhostRecipe(ClientboundPackets1_21_2.PLACE_GHOST_RECIPE);
     }
 
     @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_21_2to1_21_4/rewriter/BlockPacketRewriter1_21_4.java

@@ -24,6 +24,7 @@ import com.viaversion.nbt.tag.NumberTag;
 import com.viaversion.viaversion.api.connection.UserConnection;
 import com.viaversion.viaversion.api.minecraft.blockentity.BlockEntity;
 import com.viaversion.viaversion.api.type.Types;
+import com.viaversion.viaversion.api.type.types.chunk.ChunkType1_20_2;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.Protocol1_21_2To1_21_4;
 import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPacket1_21_2;
 import com.viaversion.viaversion.rewriter.BlockRewriter;
@@ -32,7 +33,7 @@ import com.viaversion.viaversion.util.TagUtil;
 public final class BlockPacketRewriter1_21_4 extends BlockRewriter<ClientboundPacket1_21_2> {
 
     public BlockPacketRewriter1_21_4(final Protocol1_21_2To1_21_4 protocol) {
-        super(protocol, Types.BLOCK_POSITION1_14, Types.COMPOUND_TAG);
+        super(protocol, Types.BLOCK_POSITION1_14, Types.COMPOUND_TAG, ChunkType1_20_2::new, null);
     }
 
     @Override

common/src/main/java/com/viaversion/viaversion/protocols/v1_21_2to1_21_4/rewriter/EntityPacketRewriter1_21_4.java

@@ -27,7 +27,6 @@ import com.viaversion.viaversion.protocols.v1_20_5to1_21.packet.ClientboundConfi
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.Protocol1_21_2To1_21_4;
 import com.viaversion.viaversion.protocols.v1_21_2to1_21_4.packet.ServerboundPackets1_21_4;
 import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPacket1_21_2;
-import com.viaversion.viaversion.protocols.v1_21to1_21_2.packet.ClientboundPackets1_21_2;
 import com.viaversion.viaversion.rewriter.EntityRewriter;
 import com.viaversion.viaversion.rewriter.RegistryDataRewriter;
 
@@ -39,12 +38,7 @@ public final class EntityPacketRewriter1_21_4 extends EntityRewriter<Clientbound
 
     @Override
     public void registerPackets() {
-        registerTrackerWithData1_19(ClientboundPackets1_21_2.ADD_ENTITY, EntityTypes1_21_4.FALLING_BLOCK);
-        registerSetEntityData(ClientboundPackets1_21_2.SET_ENTITY_DATA);
-        registerRemoveEntities(ClientboundPackets1_21_2.REMOVE_ENTITIES);
-
-        final RegistryDataRewriter registryDataRewriter = new RegistryDataRewriter(protocol);
-        registryDataRewriter.addHandler("worldgen/biome", (key, biome) -> {
+        protocol.getRegistryDataRewriter().addHandler("worldgen/biome", (key, biome) -> {
             final CompoundTag effectsTag = biome.getCompoundTag("effects");
             final CompoundTag musicTag = effectsTag.getCompoundTag("music");
             if (musicTag == null) {
@@ -59,10 +53,6 @@ public final class EntityPacketRewriter1_21_4 extends EntityRewriter<Clientbound
             weightedMusicTags.add(weightedMusicTag);
             effectsTag.put("music", weightedMusicTags);
         });
-        protocol.registerClientbound(ClientboundConfigurationPackets1_21.REGISTRY_DATA, registryDataRewriter::handle);
-
-        registerLogin1_20_5(ClientboundPackets1_21_2.LOGIN);
-        registerRespawn1_20_5(ClientboundPackets1_21_2.RESPAWN);
 
         protocol.registerServerbound(ServerboundPackets1_21_4.MOVE_VEHICLE, wrapper -> {
             wrapper.passthrough(Types.DOUBLE); // X