Ravengard tutorial, classes, regions and config driven items

clientmod/README.md

@@ -9,7 +9,11 @@ This is a 26.2 mod meant for the developers of this project to easily capture da
 - `/getarmorstandinfos <radius>` Gets the position information of armor stands in the defined radius. (wip)
 - `/getscoreboardinfo` Prints out the scoreboard information in chat.
 - `/copymaptexture [all]` Copy's the texture of a map to the clipboard.
-- `/chunkexporter [start|stop <name>|status]` Exports the chunk data of the player. Will be saved to .minecraft/saves
+- `/chunkexporter start` starts a chunk-only export.
+- `/chunkexporter start block_displays` includes stationary block and item displays.
+- `/chunkexporter start ravengard <name>` starts or resumes a named stitched Ravengard capture. Stop it with
+  `/chunkexporter stop <name>`; checkpoints are stored in `.minecraft/chunkexporter_sessions`.
+- `/chunkexporter status` shows the active capture counts.
 - `/nbsrecord start`, `/nbsrecord stop <name>`, `/nbsrecord status` records inbound server sounds to
   `nbs-recordings/<name>.nbs` and exports custom instrument sounds.
 - `Keybind K` Copies the texture ID of the hovered player head into the clipboard.

clientmod/src/main/java/gg/itzkatze/thehypixelrecreationmod/TheHypixelRecreationMod.java

@@ -3,6 +3,8 @@
 import gg.itzkatze.thehypixelrecreationmod.commands.*;
 import gg.itzkatze.thehypixelrecreationmod.features.KeybindRegistry;
 import gg.itzkatze.thehypixelrecreationmod.features.SpraySchemaRecorder;
+import gg.itzkatze.thehypixelrecreationmod.features.guicapture.GuiCaptureRecorder;
+import gg.itzkatze.thehypixelrecreationmod.features.packetlog.EntityPacketLogger;
 import gg.itzkatze.thehypixelrecreationmod.features.worldexport.ChunkExportRecorder;
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
@@ -42,12 +44,18 @@ private static void registerCommands() {
 		NearbyEntitiesCommand.register();
         CopyTabBossbarCommand.register();
         CopyAdvancementsCommand.register();
+		LogPacketsCommand.register();
+		RavengardSessionCommand.register();
+		HudCaptureCommand.register();
 	}
 
 	private static void registerTickHandlers() {
 		ClientTickEvents.END_CLIENT_TICK.register(_ -> {
 			ChunkExportRecorder.tick();
 			SpraySchemaRecorder.tick();
+			EntityPacketLogger.tick();
+			gg.itzkatze.thehypixelrecreationmod.features.packetlog.RavengardSessionLogger.tick();
+			GuiCaptureRecorder.tick(net.minecraft.client.Minecraft.getInstance());
 		});
 	}
 

clientmod/src/main/java/gg/itzkatze/thehypixelrecreationmod/commands/ChunkExporterCommand.java

@@ -18,7 +18,11 @@ public static void register() {
                         .then(ClientCommands.literal("start")
                                 .executes(context -> start(context, ChunkExportRecorder.CaptureMode.CHUNKS))
                                 .then(ClientCommands.literal("block_displays")
-                                        .executes(context -> start(context, ChunkExportRecorder.CaptureMode.BLOCK_DISPLAYS))))
+                                        .executes(context -> start(context, ChunkExportRecorder.CaptureMode.BLOCK_DISPLAYS)))
+                                .then(ClientCommands.literal("ravengard")
+                                        .then(ClientCommands.argument("name", StringArgumentType.string())
+                                                .executes(context -> startStitchedRavengard(context,
+                                                        StringArgumentType.getString(context, "name"))))))
                         .then(ClientCommands.literal("stop")
                                 .then(ClientCommands.argument("name", StringArgumentType.string())
                                         .executes(context -> {
@@ -36,7 +40,9 @@ public static void register() {
                                                                 + result.blockEntityCount()
                                                                 + " block entities, and "
                                                                 + result.blockDisplayCount()
-                                                                + " stationary block displays to "
+                                                                + " stationary block displays, and "
+                                                                + result.ravengardObjectCount()
+                                                                + " Ravengard dungeon objects to "
                                                                 + result.path().getFileName()
                                                                 + " and "
                                                                 + result.polarPath().getFileName()
@@ -65,7 +71,9 @@ public static void register() {
                                                     + status.chunkCount()
                                                     + " captured chunks, "
                                                     + status.blockDisplayCount()
-                                                    + " stationary block displays, and "
+                                                    + " stationary block displays, "
+                                                    + status.ravengardObjectCount()
+                                                    + " Ravengard dungeon objects, and "
                                                     + status.movingEntityCount()
                                                     + " moving displays excluded (mode: "
                                                     + status.mode().name().toLowerCase()
@@ -98,4 +106,18 @@ private static int start(
             return 0;
         }
     }
+
+    private static int startStitchedRavengard(CommandContext<FabricClientCommandSource> context, String name) {
+        try {
+            ChunkExportRecorder.StartResult result = ChunkExportRecorder.start(ChunkExportRecorder.CaptureMode.RAVENGARD, name);
+            context.getSource().sendFeedback(Component.literal(
+                    "§aRavengard stitched session '" + name + "' is active with "
+                            + result.initialChunkCount() + " chunks and "
+                            + result.initialBlockDisplayCount() + " static displays. Stop it with the same name."));
+            return 1;
+        } catch (Exception exception) {
+            context.getSource().sendFeedback(Component.literal("§cFailed to start stitched Ravengard session: " + exception.getMessage()));
+            return 0;
+        }
+    }
 }

clientmod/src/main/java/gg/itzkatze/thehypixelrecreationmod/commands/HudCaptureCommand.java

@@ -0,0 +1,66 @@
+package gg.itzkatze.thehypixelrecreationmod.commands;
+
+import com.mojang.brigadier.context.CommandContext;
+import gg.itzkatze.thehypixelrecreationmod.features.hudcapture.GlyphAtlas;
+import gg.itzkatze.thehypixelrecreationmod.features.hudcapture.HudCaptureRecorder;
+import net.fabricmc.fabric.api.client.command.v2.ClientCommandRegistrationCallback;
+import net.fabricmc.fabric.api.client.command.v2.ClientCommands;
+import net.fabricmc.fabric.api.client.command.v2.FabricClientCommandSource;
+import net.minecraft.network.chat.Component;
+
+public final class HudCaptureCommand {
+    private HudCaptureCommand() {
+    }
+
+    public static void register() {
+        ClientCommandRegistrationCallback.EVENT.register((dispatcher, _) ->
+                RecreationCommand.register(dispatcher, ClientCommands.literal("hudcapture")
+                        .then(ClientCommands.literal("start")
+                                .executes(context -> start(context, true))
+                                .then(ClientCommands.literal("all")
+                                        .executes(context -> start(context, false))))
+                        .then(ClientCommands.literal("stop")
+                                .executes(HudCaptureCommand::stop))
+                        .then(ClientCommands.literal("glyphs")
+                                .executes(context -> {
+                                    GlyphAtlas.reload();
+                                    context.getSource().sendFeedback(Component.literal(
+                                            "§aGlyph atlas reloaded: " + GlyphAtlas.size() + " bitmap glyphs"));
+                                    return 1;
+                                }))));
+    }
+
+    private static int start(CommandContext<FabricClientCommandSource> context, boolean dedupe) {
+        try {
+            HudCaptureRecorder.StartResult result = HudCaptureRecorder.start(dedupe);
+            context.getSource().sendFeedback(Component.literal(
+                    "§aHUD capture started ("
+                            + result.glyphCount()
+                            + " glyphs resolved, "
+                            + (dedupe ? "unique payloads only" : "every packet")
+                            + ") → §f"
+                            + result.path()));
+            return 1;
+        } catch (Exception exception) {
+            context.getSource().sendFeedback(Component.literal("§cFailed to start HUD capture: " + exception.getMessage()));
+            return 0;
+        }
+    }
+
+    private static int stop(CommandContext<FabricClientCommandSource> context) {
+        try {
+            HudCaptureRecorder.StopResult result = HudCaptureRecorder.stop();
+            context.getSource().sendFeedback(Component.literal(
+                    "§aHUD capture stopped: "
+                            + result.eventCount()
+                            + " events, "
+                            + result.mapDumpCount()
+                            + " map images → §f"
+                            + result.directory()));
+            return 1;
+        } catch (Exception exception) {
+            context.getSource().sendFeedback(Component.literal("§cFailed to stop HUD capture: " + exception.getMessage()));
+            return 0;
+        }
+    }
+}

clientmod/src/main/java/gg/itzkatze/thehypixelrecreationmod/commands/LogPacketsCommand.java

@@ -0,0 +1,121 @@
+package gg.itzkatze.thehypixelrecreationmod.commands;
+
+import com.mojang.brigadier.context.CommandContext;
+import gg.itzkatze.thehypixelrecreationmod.features.packetlog.EntityPacketLogger;
+import net.fabricmc.fabric.api.client.command.v2.ClientCommandRegistrationCallback;
+import net.fabricmc.fabric.api.client.command.v2.ClientCommands;
+import net.fabricmc.fabric.api.client.command.v2.FabricClientCommandSource;
+import net.minecraft.client.Minecraft;
+import net.minecraft.network.chat.Component;
+import net.minecraft.world.entity.Entity;
+import net.minecraft.world.entity.player.Player;
+import net.minecraft.world.entity.projectile.ProjectileUtil;
+import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.EntityHitResult;
+import net.minecraft.world.phys.Vec3;
+
+import java.io.IOException;
+
+public final class LogPacketsCommand {
+    private static final double TARGET_RANGE = 64.0;
+    private static final double RAY_TOLERANCE = 1.0;
+
+    private LogPacketsCommand() {
+    }
+
+    public static void register() {
+        ClientCommandRegistrationCallback.EVENT.register((dispatcher, _) ->
+                dispatcher.register(ClientCommands.literal("logpackets").executes(LogPacketsCommand::toggle)));
+    }
+
+    private static int toggle(CommandContext<FabricClientCommandSource> context) {
+        Minecraft client = Minecraft.getInstance();
+        Player player = client.player;
+        if (player == null || client.level == null) {
+            context.getSource().sendFeedback(Component.literal("§cNot in a world."));
+            return 0;
+        }
+
+        Entity target = getLookedAtEntity(client, player);
+
+        if (EntityPacketLogger.isActive()) {
+            boolean sameEntity = target == null || EntityPacketLogger.isTracking(target);
+            EntityPacketLogger.StopResult result = EntityPacketLogger.stop();
+            context.getSource().sendFeedback(Component.literal(
+                    "§aStopped logging "
+                            + result.entityName()
+                            + " §a(id "
+                            + result.entityId()
+                            + ") after "
+                            + result.packetCount()
+                            + " packets → §f"
+                            + result.path()
+            ));
+
+            if (sameEntity) {
+                return 1;
+            }
+        }
+
+        if (target == null) {
+            context.getSource().sendFeedback(Component.literal("§cNot looking at any entity."));
+            return 0;
+        }
+
+        try {
+            EntityPacketLogger.StartResult result = EntityPacketLogger.start(target);
+            context.getSource().sendFeedback(Component.literal(
+                    "§aLogging packets for "
+                            + result.entityName()
+                            + " §a(id "
+                            + result.entityId()
+                            + ", "
+                            + result.trackedEntityCount()
+                            + " associated entities) → §f"
+                            + result.path()
+            ));
+            return 1;
+        } catch (IOException | RuntimeException exception) {
+            context.getSource().sendFeedback(Component.literal("§cFailed to start packet log: " + exception.getMessage()));
+            return 0;
+        }
+    }
+
+    private static Entity getLookedAtEntity(Minecraft client, Player player) {
+        Vec3 eyePosition = player.getEyePosition(1.0f);
+        Vec3 lookVector = player.getLookAngle();
+        Vec3 reachVector = eyePosition.add(lookVector.scale(TARGET_RANGE));
+        AABB searchBox = player.getBoundingBox().expandTowards(lookVector.scale(TARGET_RANGE)).inflate(1.0);
+
+        EntityHitResult hitResult = ProjectileUtil.getEntityHitResult(
+                player,
+                eyePosition,
+                reachVector,
+                searchBox,
+                entity -> entity != player,
+                TARGET_RANGE * TARGET_RANGE
+        );
+        if (hitResult != null) {
+            return hitResult.getEntity();
+        }
+
+        Entity closest = null;
+        double closestDistance = Double.MAX_VALUE;
+        for (Entity entity : client.level.getEntities(player, searchBox)) {
+            Vec3 offset = entity.getBoundingBox().getCenter().subtract(eyePosition);
+            double distanceAlongRay = offset.dot(lookVector);
+            if (distanceAlongRay <= 0 || distanceAlongRay > TARGET_RANGE) {
+                continue;
+            }
+
+            double distanceFromRay = offset.subtract(lookVector.scale(distanceAlongRay)).length();
+            if (distanceFromRay > RAY_TOLERANCE || distanceAlongRay >= closestDistance) {
+                continue;
+            }
+
+            closestDistance = distanceAlongRay;
+            closest = entity;
+        }
+        return closest;
+    }
+}

clientmod/src/main/java/gg/itzkatze/thehypixelrecreationmod/commands/RavengardSessionCommand.java

@@ -0,0 +1,52 @@
+package gg.itzkatze.thehypixelrecreationmod.commands;
+
+import com.mojang.brigadier.context.CommandContext;
+import gg.itzkatze.thehypixelrecreationmod.features.packetlog.RavengardSessionLogger;
+import net.fabricmc.fabric.api.client.command.v2.ClientCommandRegistrationCallback;
+import net.fabricmc.fabric.api.client.command.v2.ClientCommands;
+import net.fabricmc.fabric.api.client.command.v2.FabricClientCommandSource;
+import net.minecraft.network.chat.Component;
+
+import java.io.IOException;
+import java.nio.file.Path;
+
+public final class RavengardSessionCommand {
+    private RavengardSessionCommand() {
+    }
+
+    public static void register() {
+        ClientCommandRegistrationCallback.EVENT.register((dispatcher, _) ->
+                dispatcher.register(ClientCommands.literal("ravengard")
+                        .then(ClientCommands.literal("start").executes(RavengardSessionCommand::start))
+                        .then(ClientCommands.literal("stop").executes(RavengardSessionCommand::stop))));
+    }
+
+    private static int start(CommandContext<FabricClientCommandSource> context) {
+        if (RavengardSessionLogger.isActive()) {
+            context.getSource().sendFeedback(Component.literal("§cA ravengard session log is already running."));
+            return 0;
+        }
+        try {
+            Path path = RavengardSessionLogger.start();
+            context.getSource().sendFeedback(Component.literal(
+                    "§aRavengard session log started, auto-tracking every rig → §f" + path.getFileName()));
+            return 1;
+        } catch (IOException | RuntimeException exception) {
+            context.getSource().sendFeedback(Component.literal(
+                    "§cFailed to start ravengard session log: " + exception.getMessage()));
+            return 0;
+        }
+    }
+
+    private static int stop(CommandContext<FabricClientCommandSource> context) {
+        if (!RavengardSessionLogger.isActive()) {
+            context.getSource().sendFeedback(Component.literal("§cNo ravengard session log is running."));
+            return 0;
+        }
+        RavengardSessionLogger.StopResult result = RavengardSessionLogger.stop();
+        context.getSource().sendFeedback(Component.literal(
+                "§aRavengard session log stopped after " + result.packetCount() + " packets across "
+                        + result.rigCount() + " rigs → §f" + result.path()));
+        return 1;
+    }
+}

clientmod/src/main/java/gg/itzkatze/thehypixelrecreationmod/features/KeybindRegistry.java

@@ -1,5 +1,6 @@
 package gg.itzkatze.thehypixelrecreationmod.features;
 
+import gg.itzkatze.thehypixelrecreationmod.features.guicapture.GuiCaptureRecorder;
 import net.fabricmc.fabric.api.client.keymapping.v1.KeyMappingHelper;
 import net.fabricmc.fabric.api.client.screen.v1.ScreenEvents;
 import net.fabricmc.fabric.api.client.screen.v1.ScreenKeyboardEvents;
@@ -58,7 +59,7 @@ public static void register() {
                     return false;
                 }
                 if (copyGuiKey.matches(key)) {
-                    CopyCurrentGui.copyCurrentGui(client);
+                    GuiCaptureRecorder.toggle(client);
                     return false;
                 }
                 return true;