From f83984402946549ccd8230825c83dec9e468e926 Mon Sep 17 00:00:00 2001
From: Joe <burtonjae@hotmail.co.uk>
Date: Sun, 29 Dec 2024 22:08:52 +0000
Subject: [PATCH] Wip client gametests

---
 .gitignore                                    |   1 +
 build.gradle                                  |  46 ++-
 gradle.properties                             |   2 +-
 .../gametest/BannedActionGametest.java        | 356 ++++++++++++++++++
 src/clientGametest/resources/fabric.mod.json  |  14 +
 .../mixin/rngevents/LivingEntityMixin.java    |   2 +-
 .../util/MultiVersionCompat.java              |  32 ++
 7 files changed, 450 insertions(+), 3 deletions(-)
 create mode 100644 src/clientGametest/java/net/earthcomputer/clientcommands/gametest/BannedActionGametest.java
 create mode 100644 src/clientGametest/resources/fabric.mod.json

diff --git a/.gitignore b/.gitignore
index a51657876..9fdceaf90 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,6 +23,7 @@ bin/
 # fabric
 
 run/
+runGametest/
 logs/
 
 /changelog.txt
diff --git a/build.gradle b/build.gradle
index 0b57d410e..985285b5b 100644
--- a/build.gradle
+++ b/build.gradle
@@ -14,7 +14,15 @@ base {
 }
 
 sourceSets {
-	codeGen
+	clientGametest {
+		compileClasspath += main.compileClasspath
+		runtimeClasspath += main.runtimeClasspath
+	}
+
+	codeGen {
+		compileClasspath += main.compileClasspath
+		runtimeClasspath += main.runtimeClasspath
+	}
 }
 
 configurations {
@@ -42,6 +50,22 @@ repositories {
 
 loom {
 	accessWidenerPath = file('src/main/resources/clientcommands.aw')
+
+	runs {
+		clientGametest {
+			client()
+			ideConfigGenerated true
+			name 'Client Gametest'
+			property 'fabric.client.gametest'
+			programArgs '--username', 'GametestUser'
+			runDir 'runGametest'
+			source sourceSets.clientGametest
+		}
+	}
+
+	mods.register('clientcommands-gametest') {
+		sourceSet sourceSets.clientGametest
+	}
 }
 
 dependencies {
@@ -74,6 +98,7 @@ dependencies {
 
 	include api('net.fabricmc:mapping-io:0.5.1')
 
+	clientGametestImplementation sourceSets.main.output
 	codeGenImplementation sourceSets.main.output
 
 	testImplementation "net.fabricmc:fabric-loader-junit:${project.loader_version}"
@@ -125,6 +150,25 @@ tasks.register('sourcesJar', Jar) {
 	from sourceSets.main.allSource
 }
 
+tasks.register('cleanGametestRunDir', Delete) {
+	delete 'runGametest'
+	doLast {
+		mkdir('runGametest')
+	}
+}
+
+// hack to make sure run directory is cleaned before the gametests are run
+ideaSyncTask.doLast {
+	def gametestXml = file('.idea/runConfigurations/Client_Gametest.xml').readLines()
+	def index = gametestXml.findIndexOf { it.endsWith '<method v="2">' }
+	assert index >= 0
+	def endIndex = gametestXml.findIndexOf(index) { it.endsWith('</method>') }
+	gametestXml.add(endIndex, '<option enabled="true" externalProjectPath="$PROJECT_DIR$" name="Gradle.BeforeRunTask" scriptParameters="" tasks="cleanGametestRunDir" vmOptions=""/>')
+	file('.idea/runConfigurations/Client_Gametest.xml').write(gametestXml.join('\n'))
+}
+
+runClientGametest.dependsOn cleanGametestRunDir
+
 tasks.register('codeGen', JavaExec) {
 	mainClass = 'net.earthcomputer.clientcommands.codegen.CodeGenerator'
 	classpath = sourceSets.codeGen.runtimeClasspath
diff --git a/gradle.properties b/gradle.properties
index abb104790..d285311c7 100644
--- a/gradle.properties
+++ b/gradle.properties
@@ -19,7 +19,7 @@ org.gradle.jvmargs=-Xmx2G
 
 # Dependencies
 	# also check this on https://fabricmc.net/develop/
-	fabric_version=0.110.5+1.21.4
+	fabric_version=0.113.0+1.21.4
 	clientarguments_version=1.10.1
 	betterconfig_version=2.1.2
 	seedfinding_core_version=1.200.1
diff --git a/src/clientGametest/java/net/earthcomputer/clientcommands/gametest/BannedActionGametest.java b/src/clientGametest/java/net/earthcomputer/clientcommands/gametest/BannedActionGametest.java
new file mode 100644
index 000000000..eda96a592
--- /dev/null
+++ b/src/clientGametest/java/net/earthcomputer/clientcommands/gametest/BannedActionGametest.java
@@ -0,0 +1,356 @@
+package net.earthcomputer.clientcommands.gametest;
+
+import com.mojang.blaze3d.platform.InputConstants;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import net.earthcomputer.clientcommands.Configs;
+import net.earthcomputer.clientcommands.features.PlayerRandCracker;
+import net.earthcomputer.clientcommands.util.MultiVersionCompat;
+import net.fabricmc.fabric.api.client.command.v2.ClientCommandManager;
+import net.fabricmc.fabric.api.client.command.v2.FabricClientCommandSource;
+import net.fabricmc.fabric.api.client.gametest.v1.ClientGameTestContext;
+import net.fabricmc.fabric.api.client.gametest.v1.FabricClientGameTest;
+import net.fabricmc.fabric.api.client.gametest.v1.TestSingleplayerContext;
+import net.minecraft.client.multiplayer.ClientPacketListener;
+import net.minecraft.core.BlockPos;
+import net.minecraft.core.Registry;
+import net.minecraft.core.registries.Registries;
+import net.minecraft.server.MinecraftServer;
+import net.minecraft.server.level.ServerPlayer;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.EntitySpawnReason;
+import net.minecraft.world.entity.EntityType;
+import net.minecraft.world.entity.monster.Spider;
+import net.minecraft.world.inventory.ClickType;
+import net.minecraft.world.item.ItemStack;
+import net.minecraft.world.item.Items;
+import net.minecraft.world.item.alchemy.PotionContents;
+import net.minecraft.world.item.alchemy.Potions;
+import net.minecraft.world.item.enchantment.Enchantment;
+import net.minecraft.world.item.enchantment.EnchantmentHelper;
+import net.minecraft.world.item.enchantment.Enchantments;
+import net.minecraft.world.level.block.Blocks;
+import net.minecraft.world.level.levelgen.LegacyRandomSource;
+import net.minecraft.world.phys.Vec3;
+
+import java.util.Objects;
+
+@SuppressWarnings("UnstableApiUsage")
+public final class BannedActionGametest implements FabricClientGameTest {
+    @Override
+    public void runTest(ClientGameTestContext context) {
+        try (TestSingleplayerContext singleplayer = context.worldBuilder().adjustSettings(settings -> settings.setAllowCommands(true)).create()) {
+            singleplayer.getServer().runOnServer(server -> setInventoryItem(server, 0, new ItemStack(Items.COBBLESTONE, 64)));
+            context.waitTick();
+
+            runClientCommand(context, "cconfig clientcommands playerRNGMaintenance set false");
+            runClientCommand(context, "ccrackrng");
+            context.waitFor(client -> Configs.playerCrackState.knowsSeed());
+
+            long playerSeed = getPlayerSeed(singleplayer);
+            if (playerSeed != PlayerRandCracker.getSeed()) {
+                throw new AssertionError("Seed found by ccrackrng (%012x) does not match actual seed (%012x)".formatted(PlayerRandCracker.getSeed(), playerSeed));
+            }
+
+            context.waitTicks(100);
+
+            if (getPlayerSeed(singleplayer) != playerSeed) {
+                throw new AssertionError("Player seed has changed after doing nothing, something is very wrong!");
+            }
+
+            testAmethystChime(context, singleplayer);
+            testAnvil(context, singleplayer);
+            testBaneOfArthropods(context, singleplayer);
+            testCrossbow(context, singleplayer);
+            testDrink(context, singleplayer);
+            testDropItem(context);
+            testEnterWater(context, singleplayer);
+            testEquipItem(context, singleplayer);
+            testFallFlying(context, singleplayer);
+            testFood(context, singleplayer);
+            testFrostWalker(context, singleplayer);
+            testGiveCommand(context);
+            testItemBreak(context, singleplayer);
+
+            context.waitTicks(100);
+        }
+    }
+
+    private static void testAmethystChime(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        BlockPos pos = getPlayerPos(context);
+        singleplayer.getServer().runOnServer(server -> {
+            for (int i = 1; i <= 2; i++) {
+                server.overworld().setBlockAndUpdate(pos.south(i).below(), Blocks.AMETHYST_BLOCK.defaultBlockState());
+            }
+        });
+        context.getInput().holdKey(options -> options.keyUp);
+        context.waitFor(client -> client.player.blockPosition().getZ() >= pos.getZ() + 3);
+        context.getInput().releaseKey(options -> options.keyUp);
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger amethyst chime detection");
+        }
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+    }
+
+    private static void testAnvil(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        singleplayer.getServer().runCommand("xp set GametestUser 1 levels");
+        BlockPos pos = getPlayerPos(context);
+        singleplayer.getServer().runOnServer(server -> server.overworld().setBlockAndUpdate(pos.south(), Blocks.ANVIL.defaultBlockState()));
+        context.waitTick();
+        runClientCommand(context, "clook block %d %d %d".formatted(pos.getX(), pos.getY(), pos.getZ() + 1));
+        context.getInput().pressKey(options -> options.keyUse);
+        context.waitTicks(2);
+        context.runOnClient(client -> client.gameMode.handleInventoryMouseClick(client.player.containerMenu.containerId, 30, 0, ClickType.QUICK_MOVE, client.player));
+        context.getInput().holdControl();
+        context.getInput().pressKey(InputConstants.KEY_A);
+        context.getInput().releaseControl();
+        context.getInput().typeChars("test");
+        context.runOnClient(client -> client.gameMode.handleInventoryMouseClick(client.player.containerMenu.containerId, 2, 0, ClickType.QUICK_MOVE, client.player));
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger anvil detection");
+        }
+        context.getInput().pressKey(InputConstants.KEY_ESCAPE);
+        singleplayer.getServer().runOnServer(server -> server.overworld().removeBlock(pos.south(), false));
+        context.waitTick();
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+    }
+
+    private static void testBaneOfArthropods(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        MultiVersionCompat.setProtocolVersion(MultiVersionCompat.V1_20_6, "1.20.6");
+
+        BlockPos pos = getPlayerPos(context);
+
+        Spider spider = singleplayer.getServer().computeOnServer(server -> {
+            ItemStack baneOfArthropodsSword = new ItemStack(Items.DIAMOND_SWORD);
+            EnchantmentHelper.updateEnchantments(baneOfArthropodsSword, enchantments -> {
+                Registry<Enchantment> enchantmentRegistry = server.registryAccess().lookupOrThrow(Registries.ENCHANTMENT);
+                enchantments.set(enchantmentRegistry.getOrThrow(Enchantments.BANE_OF_ARTHROPODS), 1);
+            });
+            setInventoryItem(server, 0, baneOfArthropodsSword);
+
+            Spider spider1 = EntityType.SPIDER.create(server.overworld(), EntitySpawnReason.COMMAND);
+            spider1.setNoAi(true);
+            spider1.moveTo(Vec3.atCenterOf(pos.south()));
+            server.overworld().addFreshEntity(spider1);
+            return spider1;
+        });
+
+        context.waitTick();
+        context.getInput().pressKey(options -> options.keyAttack);
+        context.waitTicks(2);
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger bane of arthropods detection");
+        }
+
+        singleplayer.getServer().runOnServer(server -> spider.remove(Entity.RemovalReason.DISCARDED));
+
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+        MultiVersionCompat.setLatestProtocol();
+    }
+
+    private static void testCrossbow(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        singleplayer.getServer().runOnServer(server -> {
+            setInventoryItem(server, 0, new ItemStack(Items.CROSSBOW));
+            setInventoryItem(server, 1, new ItemStack(Items.ARROW));
+        });
+
+        context.waitTick();
+        useItemUntilCompleted(context, singleplayer);
+        context.waitTick();
+        context.getInput().pressKey(options -> options.keyUse);
+        context.waitTick();
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger crossbow detection");
+        }
+
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+    }
+
+    private static void testDrink(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        singleplayer.getServer().runOnServer(server -> setInventoryItem(server, 0, PotionContents.createItemStack(Items.POTION, Potions.WATER)));
+        context.waitTick();
+        useItemUntilCompleted(context, singleplayer);
+        context.waitTick();
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger drink detection");
+        }
+
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+    }
+
+    private static void testDropItem(ClientGameTestContext context) {
+        context.getInput().pressKey(options -> options.keyDrop);
+        context.waitTick();
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger drop detection");
+        }
+
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+    }
+
+    private static void testEnterWater(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        BlockPos pos = getPlayerPos(context);
+        singleplayer.getServer().runOnServer(server -> server.overworld().setBlockAndUpdate(pos, Blocks.WATER.defaultBlockState()));
+        context.waitTicks(2);
+        singleplayer.getServer().runOnServer(server -> server.overworld().setBlockAndUpdate(pos, Blocks.AIR.defaultBlockState()));
+        context.waitTick();
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger enter water detection");
+        }
+
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+    }
+
+    private static void testEquipItem(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        singleplayer.getServer().runOnServer(server -> setInventoryItem(server, 0, new ItemStack(Items.DIAMOND_CHESTPLATE)));
+        context.waitTick();
+        context.getInput().pressKey(options -> options.keyUse);
+        context.waitTicks(2);
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger equip detection");
+        }
+
+        singleplayer.getServer().runOnServer(server -> setInventoryItem(server, 38, ItemStack.EMPTY));
+        context.waitTick();
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+    }
+
+    private static void testFallFlying(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        singleplayer.getServer().runOnServer(server -> {
+            setInventoryItem(server, 38, new ItemStack(Items.ELYTRA));
+            getServerPlayer(server).teleportRelative(0, 2, 0);
+        });
+        context.waitTicks(2);
+        context.getInput().holdKeyFor(options -> options.keyJump, 1);
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger fall flying detection");
+        }
+
+        singleplayer.getServer().runOnServer(server -> setInventoryItem(server, 38, ItemStack.EMPTY));
+        context.waitFor(client -> client.player.onGround());
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+    }
+
+    private static void testFood(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        singleplayer.getServer().runOnServer(server -> setInventoryItem(server, 0, new ItemStack(Items.GOLDEN_APPLE)));
+        context.waitTick();
+        context.getInput().holdKeyFor(options -> options.keyUse, 10);
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger eat detection");
+        }
+
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+    }
+
+    private static void testFrostWalker(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        MultiVersionCompat.setProtocolVersion(MultiVersionCompat.V1_20_6, "1.20.6");
+        BlockPos pos = getPlayerPos(context);
+        singleplayer.getServer().runOnServer(server -> {
+            ItemStack frostWalkerBoots = new ItemStack(Items.DIAMOND_BOOTS);
+            EnchantmentHelper.updateEnchantments(frostWalkerBoots, enchantments -> {
+                Registry<Enchantment> enchantmentRegistry = server.registryAccess().lookupOrThrow(Registries.ENCHANTMENT);
+                enchantments.set(enchantmentRegistry.getOrThrow(Enchantments.FROST_WALKER), 1);
+            });
+            setInventoryItem(server, 36, frostWalkerBoots);
+            server.overworld().setBlockAndUpdate(pos.south().below(), Blocks.WATER.defaultBlockState());
+        });
+
+        context.getInput().holdKey(options -> options.keyUp);
+        context.waitFor(client -> !client.player.blockPosition().equals(pos));
+        context.waitTick();
+        context.getInput().releaseKey(options -> options.keyUp);
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger frost walker detection");
+        }
+
+        singleplayer.getServer().runOnServer(server -> {
+            setInventoryItem(server, 36, ItemStack.EMPTY);
+            server.overworld().setBlockAndUpdate(pos.south().below(), Blocks.GRASS_BLOCK.defaultBlockState());
+        });
+        context.waitTick();
+
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+        MultiVersionCompat.setLatestProtocol();
+    }
+
+    private static void testGiveCommand(ClientGameTestContext context) {
+        context.getInput().pressKey(options -> options.keyChat);
+        context.waitTick();
+        context.getInput().typeChars("/give @s cobblestone");
+        context.getInput().pressKey(InputConstants.KEY_RETURN);
+        context.waitTicks(2);
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger give command detection");
+        }
+
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+    }
+
+    private static void testItemBreak(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        MultiVersionCompat.setProtocolVersion(MultiVersionCompat.V1_13, "1.13");
+
+        singleplayer.getServer().runOnServer(server -> {
+            ItemStack almostBrokenShovel = new ItemStack(Items.DIAMOND_SHOVEL);
+            almostBrokenShovel.setDamageValue(almostBrokenShovel.getMaxDamage() - 1);
+            setInventoryItem(server, 0, almostBrokenShovel);
+        });
+
+        runClientCommand(context, "clook cardinal down");
+        context.waitTick();
+        context.getInput().pressKey(options -> options.keyUse);
+
+        if (Configs.playerCrackState.knowsSeed()) {
+            throw new AssertionError("Didn't trigger item break detection");
+        }
+
+        Configs.playerCrackState = PlayerRandCracker.CrackState.CRACKED;
+        MultiVersionCompat.setLatestProtocol();
+    }
+
+    private static void runClientCommand(ClientGameTestContext context, String command) {
+        try {
+            context.runOnClient(client -> {
+                var dispatcher = Objects.requireNonNull(ClientCommandManager.getActiveDispatcher());
+                ClientPacketListener connection = Objects.requireNonNull(client.getConnection());
+                dispatcher.execute(command, (FabricClientCommandSource) connection.getSuggestionsProvider());
+            });
+        } catch (CommandSyntaxException e) {
+            throw new RuntimeException("Exception while running command", e);
+        }
+    }
+
+    private static long getPlayerSeed(TestSingleplayerContext singleplayer) {
+        return singleplayer.getServer().computeOnServer(server -> ((LegacyRandomSource) getServerPlayer(server).getRandom()).seed.get());
+    }
+
+    private static ServerPlayer getServerPlayer(MinecraftServer server) {
+        return Objects.requireNonNull(server.getPlayerList().getPlayerByName("GametestUser"), "Couldn't find player in server");
+    }
+
+    private static void setInventoryItem(MinecraftServer server, int slot, ItemStack stack) {
+        ServerPlayer player = getServerPlayer(server);
+        player.getInventory().setItem(slot, stack);
+        player.containerMenu.broadcastChanges();
+    }
+
+    private static void useItemUntilCompleted(ClientGameTestContext context, TestSingleplayerContext singleplayer) {
+        context.getInput().holdKey(options -> options.keyUse);
+        context.waitTick();
+        context.waitTicks(singleplayer.getServer().computeOnServer(server -> getServerPlayer(server).getUseItemRemainingTicks()));
+        context.waitTick(); // TODO: this is sometimes needed and sometimes not, fix this inconsistency in FAPI
+        context.getInput().releaseKey(options -> options.keyUse);
+    }
+
+    private static BlockPos getPlayerPos(ClientGameTestContext context) {
+        return context.computeOnClient(client -> client.player.blockPosition());
+    }
+}
diff --git a/src/clientGametest/resources/fabric.mod.json b/src/clientGametest/resources/fabric.mod.json
new file mode 100644
index 000000000..ec29bb09a
--- /dev/null
+++ b/src/clientGametest/resources/fabric.mod.json
@@ -0,0 +1,14 @@
+{
+  "schemaVersion": 1,
+  "id": "clientcommands-gametest",
+  "name": "Client Commands Gametest",
+  "description": "Gametest for clientcommands",
+  "version": "1.0",
+  "environment": "client",
+  "license": "LGPL-3.0-or-later",
+  "entrypoints": {
+    "fabric-client-gametest": [
+      "net.earthcomputer.clientcommands.gametest.BannedActionGametest"
+    ]
+  }
+}
diff --git a/src/main/java/net/earthcomputer/clientcommands/mixin/rngevents/LivingEntityMixin.java b/src/main/java/net/earthcomputer/clientcommands/mixin/rngevents/LivingEntityMixin.java
index df9ff7f97..798a173da 100644
--- a/src/main/java/net/earthcomputer/clientcommands/mixin/rngevents/LivingEntityMixin.java
+++ b/src/main/java/net/earthcomputer/clientcommands/mixin/rngevents/LivingEntityMixin.java
@@ -106,7 +106,7 @@ private void testFrostWalker(CallbackInfo ci) {
                         for (BlockPos offsetPos : BlockPos.betweenClosed(pos.offset(-radius, -1, -radius), pos.offset(radius, -1, radius))) {
                             if (offsetPos.closerToCenterThan(position(), radius)) {
                                 BlockState offsetState = level().getBlockState(offsetPos);
-                                if (offsetState == FrostedIceBlock.meltsInto() && level().isUnobstructed(frostedIce, offsetPos, CollisionContext.empty())) {
+                                if ((offsetState.is(Blocks.FROSTED_ICE) || offsetState == FrostedIceBlock.meltsInto()) && level().isUnobstructed(frostedIce, offsetPos, CollisionContext.empty())) {
                                     if (level().isEmptyBlock(offsetPos.above())) {
                                         PlayerRandCracker.onFrostWalker();
                                     }
diff --git a/src/main/java/net/earthcomputer/clientcommands/util/MultiVersionCompat.java b/src/main/java/net/earthcomputer/clientcommands/util/MultiVersionCompat.java
index b10c62391..e095495ad 100644
--- a/src/main/java/net/earthcomputer/clientcommands/util/MultiVersionCompat.java
+++ b/src/main/java/net/earthcomputer/clientcommands/util/MultiVersionCompat.java
@@ -11,6 +11,7 @@
 import net.minecraft.client.multiplayer.ClientPacketListener;
 import net.minecraft.network.Connection;
 import net.minecraft.world.item.Item;
+import org.jetbrains.annotations.VisibleForTesting;
 import org.slf4j.Logger;
 
 import java.lang.reflect.Field;
@@ -50,6 +51,10 @@ public boolean doesItemExist(Item item) {
 
     public static final MultiVersionCompat INSTANCE = Util.make(() -> {
         try {
+            if (System.getProperty("fabric.client.gametest") != null) {
+                return new Gametest();
+            }
+
             FabricLoader loader = FabricLoader.getInstance();
             if (loader.isModLoaded("viafabric")) {
                 return new ViaFabric();
@@ -64,6 +69,18 @@ public boolean doesItemExist(Item item) {
         }
     });
 
+    @VisibleForTesting
+    public static void setProtocolVersion(int protocolVersion, String protocolName) {
+        Gametest gametestInstance = (Gametest) INSTANCE;
+        gametestInstance.protocolVersion = protocolVersion;
+        gametestInstance.protocolName = protocolName;
+    }
+
+    @VisibleForTesting
+    public static void setLatestProtocol() {
+        setProtocolVersion(SharedConstants.getProtocolVersion(), SharedConstants.getCurrentVersion().getName());
+    }
+
     private static final class None extends MultiVersionCompat {
         @Override
         public int getProtocolVersion() {
@@ -76,6 +93,21 @@ public String getProtocolName() {
         }
     }
 
+    private static final class Gametest extends MultiVersionCompat {
+        private int protocolVersion = SharedConstants.getProtocolVersion();
+        private String protocolName = SharedConstants.getCurrentVersion().getName();
+
+        @Override
+        public int getProtocolVersion() {
+            return protocolVersion;
+        }
+
+        @Override
+        public String getProtocolName() {
+            return protocolName;
+        }
+    }
+
     private static abstract sealed class AbstractViaVersion extends MultiVersionCompat {
         protected final Class<?> protocolVersion;
         private final Method getVersion;