new pr because fixing merge conflict would take too long

4 files changed, 1341 insertions, 0 deletions

diff --git a/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/DungeonMapUtils.java b/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/DungeonMapUtils.java
new file mode 100644
index 00000000..259cc3f3
--- /dev/null
+++ b/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/DungeonMapUtils.java
@@ -0,0 +1,275 @@
+package de.hysky.skyblocker.skyblock.dungeon.secrets;
+
+import com.google.gson.JsonObject;
+import it.unimi.dsi.fastutil.ints.IntSortedSet;
+import it.unimi.dsi.fastutil.objects.ObjectIntPair;
+import net.minecraft.block.MapColor;
+import net.minecraft.item.map.MapIcon;
+import net.minecraft.item.map.MapState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.util.math.Vec3i;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.joml.RoundingMode;
+import org.joml.Vector2i;
+import org.joml.Vector2ic;
+
+import java.util.*;
+
+public class DungeonMapUtils {
+    public static final byte BLACK_COLOR = MapColor.BLACK.getRenderColorByte(MapColor.Brightness.LOWEST);
+    public static final byte WHITE_COLOR = MapColor.WHITE.getRenderColorByte(MapColor.Brightness.HIGH);
+
+    public static byte getColor(MapState map, @Nullable Vector2ic pos) {
+        return pos == null ? -1 : getColor(map, pos.x(), pos.y());
+    }
+
+    public static byte getColor(MapState map, int x, int z) {
+        if (x < 0 || z < 0 || x >= 128 || z >= 128) {
+            return -1;
+        }
+        return map.colors[x + (z << 7)];
+    }
+
+    public static boolean isEntranceColor(MapState map, int x, int z) {
+        return getColor(map, x, z) == Room.Type.ENTRANCE.color;
+    }
+
+    public static boolean isEntranceColor(MapState map, @Nullable Vector2ic pos) {
+        return getColor(map, pos) == Room.Type.ENTRANCE.color;
+    }
+
+    @Nullable
+    private static Vector2i getMapPlayerPos(MapState map) {
+        for (MapIcon icon : map.getIcons()) {
+            if (icon.type() == MapIcon.Type.FRAME) {
+                return new Vector2i((icon.x() >> 1) + 64, (icon.z() >> 1) + 64);
+            }
+        }
+        return null;
+    }
+
+    @Nullable
+    public static ObjectIntPair<Vector2ic> getMapEntrancePosAndRoomSize(@NotNull MapState map) {
+        Vector2ic mapPos = getMapPlayerPos(map);
+        if (mapPos == null) {
+            return null;
+        }
+        Queue<Vector2ic> posToCheck = new ArrayDeque<>();
+        Set<Vector2ic> checked = new HashSet<>();
+        posToCheck.add(mapPos);
+        checked.add(mapPos);
+        while ((mapPos = posToCheck.poll()) != null) {
+            if (isEntranceColor(map, mapPos)) {
+                ObjectIntPair<Vector2ic> mapEntranceAndRoomSizePos = getMapEntrancePosAndRoomSizeAt(map, mapPos);
+                if (mapEntranceAndRoomSizePos.rightInt() > 0) {
+                    return mapEntranceAndRoomSizePos;
+                }
+            }
+            Vector2ic pos = new Vector2i(mapPos).sub(10, 0);
+            if (checked.add(pos)) {
+                posToCheck.add(pos);
+            }
+            pos = new Vector2i(mapPos).sub(0, 10);
+            if (checked.add(pos)) {
+                posToCheck.add(pos);
+            }
+            pos = new Vector2i(mapPos).add(10, 0);
+            if (checked.add(pos)) {
+                posToCheck.add(pos);
+            }
+            pos = new Vector2i(mapPos).add(0, 10);
+            if (checked.add(pos)) {
+                posToCheck.add(pos);
+            }
+        }
+        return null;
+    }
+
+    private static ObjectIntPair<Vector2ic> getMapEntrancePosAndRoomSizeAt(MapState map, Vector2ic mapPosImmutable) {
+        Vector2i mapPos = new Vector2i(mapPosImmutable);
+        // noinspection StatementWithEmptyBody
+        while (isEntranceColor(map, mapPos.sub(1, 0))) {
+        }
+        mapPos.add(1, 0);
+        //noinspection StatementWithEmptyBody
+        while (isEntranceColor(map, mapPos.sub(0, 1))) {
+        }
+        return ObjectIntPair.of(mapPos.add(0, 1), getMapRoomSize(map, mapPos));
+    }
+
+    public static int getMapRoomSize(MapState map, Vector2ic mapEntrancePos) {
+        int i = -1;
+        //noinspection StatementWithEmptyBody
+        while (isEntranceColor(map, mapEntrancePos.x() + ++i, mapEntrancePos.y())) {
+        }
+        return i > 5 ? i : 0;
+    }
+
+    /**
+     * Gets the map position of the top left corner of the room the player is in.
+     *
+     * @param map            the map
+     * @param mapEntrancePos the map position of the top left corner of the entrance
+     * @param mapRoomSize    the size of a room on the map
+     * @return the map position of the top left corner of the room the player is in
+     * @implNote {@code mapPos} is shifted by 2 so room borders are evenly split.
+     * {@code mapPos} is then shifted by {@code offset} to align the top left most room at (0, 0)
+     * so subtracting the modulo will give the top left corner of the room shifted by {@code offset}.
+     * Finally, {@code mapPos} is shifted back by {@code offset} to its intended position.
+     */
+    @Nullable
+    public static Vector2ic getMapRoomPos(MapState map, Vector2ic mapEntrancePos, int mapRoomSize) {
+        int mapRoomSizeWithGap = mapRoomSize + 4;
+        Vector2i mapPos = getMapPlayerPos(map);
+        if (mapPos == null) {
+            return null;
+        }
+        Vector2ic offset = new Vector2i(mapEntrancePos.x() % mapRoomSizeWithGap, mapEntrancePos.y() % mapRoomSizeWithGap);
+        return mapPos.add(2, 2).sub(offset).sub(mapPos.x() % mapRoomSizeWithGap, mapPos.y() % mapRoomSizeWithGap).add(offset);
+    }
+
+    /**
+     * Gets the map position of the top left corner of the room corresponding to the physical position of the northwest corner of a room.
+     *
+     * @param physicalEntrancePos the physical position of the northwest corner of the entrance room
+     * @param mapEntrancePos      the map position of the top left corner of the entrance room
+     * @param mapRoomSize         the size of a room on the map
+     * @param physicalPos         the physical position of the northwest corner of the room
+     * @return the map position of the top left corner of the room corresponding to the physical position of the northwest corner of a room
+     */
+    public static Vector2ic getMapPosFromPhysical(Vector2ic physicalEntrancePos, Vector2ic mapEntrancePos, int mapRoomSize, Vector2ic physicalPos) {
+        return new Vector2i(physicalPos).sub(physicalEntrancePos).div(32).mul(mapRoomSize + 4).add(mapEntrancePos);
+    }
+
+    /**
+     * @see #getPhysicalRoomPos(double, double)
+     */
+    @NotNull
+    public static Vector2ic getPhysicalRoomPos(@NotNull Vec3d pos) {
+        return getPhysicalRoomPos(pos.getX(), pos.getZ());
+    }
+
+    /**
+     * @see #getPhysicalRoomPos(double, double)
+     */
+    @NotNull
+    public static Vector2ic getPhysicalRoomPos(@NotNull Vec3i pos) {
+        return getPhysicalRoomPos(pos.getX(), pos.getZ());
+    }
+
+    /**
+     * Gets the physical position of the northwest corner of the room the given coordinate is in. Hypixel Skyblock Dungeons are aligned to a 32 by 32 blocks grid, allowing corners to be calculated through math.
+     *
+     * @param x the x position of the coordinate to calculate
+     * @param z the z position of the coordinate to calculate
+     * @return the physical position of the northwest corner of the room the player is in
+     * @implNote {@code physicalPos} is shifted by 0.5 so room borders are evenly split.
+     * {@code physicalPos} is further shifted by 8 because Hypixel offset dungeons by 8 blocks in Skyblock 0.12.3.
+     * Subtracting the modulo gives the northwest corner of the room shifted by 8. Finally, {@code physicalPos} is shifted back by 8 to its intended position.
+     */
+    @NotNull
+    public static Vector2ic getPhysicalRoomPos(double x, double z) {
+        Vector2i physicalPos = new Vector2i(x + 8.5, z + 8.5, RoundingMode.TRUNCATE);
+        return physicalPos.sub(MathHelper.floorMod(physicalPos.x(), 32), MathHelper.floorMod(physicalPos.y(), 32)).sub(8, 8);
+    }
+
+    public static Vector2ic[] getPhysicalPosFromMap(Vector2ic mapEntrancePos, int mapRoomSize, Vector2ic physicalEntrancePos, Vector2ic... mapPositions) {
+        for (int i = 0; i < mapPositions.length; i++) {
+            mapPositions[i] = getPhysicalPosFromMap(mapEntrancePos, mapRoomSize, physicalEntrancePos, mapPositions[i]);
+        }
+        return mapPositions;
+    }
+
+    /**
+     * Gets the physical position of the northwest corner of the room corresponding to the map position of the top left corner of a room.
+     *
+     * @param mapEntrancePos      the map position of the top left corner of the entrance room
+     * @param mapRoomSize         the size of a room on the map
+     * @param physicalEntrancePos the physical position of the northwest corner of the entrance room
+     * @param mapPos              the map position of the top left corner of the room
+     * @return the physical position of the northwest corner of the room corresponding to the map position of the top left corner of a room
+     */
+    public static Vector2ic getPhysicalPosFromMap(Vector2ic mapEntrancePos, int mapRoomSize, Vector2ic physicalEntrancePos, Vector2ic mapPos) {
+        return new Vector2i(mapPos).sub(mapEntrancePos).div(mapRoomSize + 4).mul(32).add(physicalEntrancePos);
+    }
+
+    public static Vector2ic getPhysicalCornerPos(Room.Direction direction, IntSortedSet segmentsX, IntSortedSet segmentsY) {
+        return switch (direction) {
+            case NW -> new Vector2i(segmentsX.firstInt(), segmentsY.firstInt());
+            case NE -> new Vector2i(segmentsX.lastInt() + 30, segmentsY.firstInt());
+            case SW -> new Vector2i(segmentsX.firstInt(), segmentsY.lastInt() + 30);
+            case SE -> new Vector2i(segmentsX.lastInt() + 30, segmentsY.lastInt() + 30);
+        };
+    }
+
+    public static BlockPos actualToRelative(Room.Direction direction, Vector2ic physicalCornerPos, BlockPos pos) {
+        return switch (direction) {
+            case NW -> new BlockPos(pos.getX() - physicalCornerPos.x(), pos.getY(), pos.getZ() - physicalCornerPos.y());
+            case NE -> new BlockPos(pos.getZ() - physicalCornerPos.y(), pos.getY(), -pos.getX() + physicalCornerPos.x());
+            case SW -> new BlockPos(-pos.getZ() + physicalCornerPos.y(), pos.getY(), pos.getX() - physicalCornerPos.x());
+            case SE -> new BlockPos(-pos.getX() + physicalCornerPos.x(), pos.getY(), -pos.getZ() + physicalCornerPos.y());
+        };
+    }
+
+    public static BlockPos relativeToActual(Room.Direction direction, Vector2ic physicalCornerPos, JsonObject posJson) {
+        return relativeToActual(direction, physicalCornerPos, new BlockPos(posJson.get("x").getAsInt(), posJson.get("y").getAsInt(), posJson.get("z").getAsInt()));
+    }
+
+    public static BlockPos relativeToActual(Room.Direction direction, Vector2ic physicalCornerPos, BlockPos pos) {
+        return switch (direction) {
+            case NW -> new BlockPos(pos.getX() + physicalCornerPos.x(), pos.getY(), pos.getZ() + physicalCornerPos.y());
+            case NE -> new BlockPos(-pos.getZ() + physicalCornerPos.x(), pos.getY(), pos.getX() + physicalCornerPos.y());
+            case SW -> new BlockPos(pos.getZ() + physicalCornerPos.x(), pos.getY(), -pos.getX() + physicalCornerPos.y());
+            case SE -> new BlockPos(-pos.getX() + physicalCornerPos.x(), pos.getY(), -pos.getZ() + physicalCornerPos.y());
+        };
+    }
+
+    public static Room.Type getRoomType(MapState map, Vector2ic mapPos) {
+        return switch (getColor(map, mapPos)) {
+            case 30 -> Room.Type.ENTRANCE;
+            case 63 -> Room.Type.ROOM;
+            case 66 -> Room.Type.PUZZLE;
+            case 62 -> Room.Type.TRAP;
+            case 74 -> Room.Type.MINIBOSS;
+            case 82 -> Room.Type.FAIRY;
+            case 18 -> Room.Type.BLOOD;
+            case 85 -> Room.Type.UNKNOWN;
+            default -> null;
+        };
+    }
+
+    public static Vector2ic[] getRoomSegments(MapState map, Vector2ic mapPos, int mapRoomSize, byte color) {
+        Set<Vector2ic> segments = new HashSet<>();
+        Queue<Vector2ic> queue = new ArrayDeque<>();
+        segments.add(mapPos);
+        queue.add(mapPos);
+        while (!queue.isEmpty()) {
+            Vector2ic curMapPos = queue.poll();
+            Vector2i newMapPos = new Vector2i();
+            if (getColor(map, newMapPos.set(curMapPos).sub(1, 0)) == color && !segments.contains(newMapPos.sub(mapRoomSize + 3, 0))) {
+                segments.add(newMapPos);
+                queue.add(newMapPos);
+                newMapPos = new Vector2i();
+            }
+            if (getColor(map, newMapPos.set(curMapPos).sub(0, 1)) == color && !segments.contains(newMapPos.sub(0, mapRoomSize + 3))) {
+                segments.add(newMapPos);
+                queue.add(newMapPos);
+                newMapPos = new Vector2i();
+            }
+            if (getColor(map, newMapPos.set(curMapPos).add(mapRoomSize, 0)) == color && !segments.contains(newMapPos.add(4, 0))) {
+                segments.add(newMapPos);
+                queue.add(newMapPos);
+                newMapPos = new Vector2i();
+            }
+            if (getColor(map, newMapPos.set(curMapPos).add(0, mapRoomSize)) == color && !segments.contains(newMapPos.add(0, 4))) {
+                segments.add(newMapPos);
+                queue.add(newMapPos);
+            }
+        }
+        DungeonSecrets.LOGGER.debug("[Skyblocker] Found dungeon room segments: {}", Arrays.toString(segments.toArray()));
+        return segments.toArray(Vector2ic[]::new);
+    }
+}
diff --git a/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/DungeonSecrets.java b/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/DungeonSecrets.java
new file mode 100644
index 00000000..7d20644a
--- /dev/null
+++ b/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/DungeonSecrets.java
@@ -0,0 +1,451 @@
+package de.hysky.skyblocker.skyblock.dungeon.secrets;
+
+import com.google.gson.JsonArray;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import com.mojang.brigadier.Command;
+import com.mojang.brigadier.arguments.IntegerArgumentType;
+import com.mojang.brigadier.builder.ArgumentBuilder;
+import com.mojang.brigadier.builder.RequiredArgumentBuilder;
+import it.unimi.dsi.fastutil.objects.Object2ByteMap;
+import it.unimi.dsi.fastutil.objects.Object2ByteOpenHashMap;
+import it.unimi.dsi.fastutil.objects.ObjectIntPair;
+import de.hysky.skyblocker.SkyblockerMod;
+import de.hysky.skyblocker.config.SkyblockerConfigManager;
+import de.hysky.skyblocker.utils.Utils;
+import de.hysky.skyblocker.utils.scheduler.Scheduler;
+import net.fabricmc.fabric.api.client.command.v2.ClientCommandRegistrationCallback;
+import net.fabricmc.fabric.api.client.command.v2.FabricClientCommandSource;
+import net.fabricmc.fabric.api.client.message.v1.ClientReceiveMessageEvents;
+import net.fabricmc.fabric.api.client.networking.v1.ClientPlayConnectionEvents;
+import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderContext;
+import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderEvents;
+import net.fabricmc.fabric.api.event.player.UseBlockCallback;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.entity.ItemEntity;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.mob.AmbientEntity;
+import net.minecraft.entity.passive.BatEntity;
+import net.minecraft.item.FilledMapItem;
+import net.minecraft.item.ItemStack;
+import net.minecraft.item.Items;
+import net.minecraft.item.map.MapState;
+import net.minecraft.resource.Resource;
+import net.minecraft.text.Text;
+import net.minecraft.util.ActionResult;
+import net.minecraft.util.Identifier;
+import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.math.Vec3d;
+import net.minecraft.world.World;
+import org.jetbrains.annotations.Contract;
+import org.jetbrains.annotations.NotNull;
+import org.jetbrains.annotations.Nullable;
+import org.joml.Vector2ic;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.ObjectInputStream;
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.zip.InflaterInputStream;
+
+import static net.fabricmc.fabric.api.client.command.v2.ClientCommandManager.argument;
+import static net.fabricmc.fabric.api.client.command.v2.ClientCommandManager.literal;
+
+public class DungeonSecrets {
+    protected static final Logger LOGGER = LoggerFactory.getLogger(DungeonSecrets.class);
+    private static final String DUNGEONS_PATH = "dungeons";
+    /**
+     * Maps the block identifier string to a custom numeric block id used in dungeon rooms data.
+     *
+     * @implNote Not using {@link net.minecraft.registry.Registry#getId(Object) Registry#getId(Block)} and {@link net.minecraft.block.Blocks Blocks} since this is also used by {@link de.hysky.skyblocker.skyblock.dungeon.secrets.DungeonRoomsDFU DungeonRoomsDFU}, which runs outside of Minecraft.
+     */
+    @SuppressWarnings("JavadocReference")
+    protected static final Object2ByteMap<String> NUMERIC_ID = new Object2ByteOpenHashMap<>(Map.ofEntries(
+            Map.entry("minecraft:stone", (byte) 1),
+            Map.entry("minecraft:diorite", (byte) 2),
+            Map.entry("minecraft:polished_diorite", (byte) 3),
+            Map.entry("minecraft:andesite", (byte) 4),
+            Map.entry("minecraft:polished_andesite", (byte) 5),
+            Map.entry("minecraft:grass_block", (byte) 6),
+            Map.entry("minecraft:dirt", (byte) 7),
+            Map.entry("minecraft:coarse_dirt", (byte) 8),
+            Map.entry("minecraft:cobblestone", (byte) 9),
+            Map.entry("minecraft:bedrock", (byte) 10),
+            Map.entry("minecraft:oak_leaves", (byte) 11),
+            Map.entry("minecraft:gray_wool", (byte) 12),
+            Map.entry("minecraft:double_stone_slab", (byte) 13),
+            Map.entry("minecraft:mossy_cobblestone", (byte) 14),
+            Map.entry("minecraft:clay", (byte) 15),
+            Map.entry("minecraft:stone_bricks", (byte) 16),
+            Map.entry("minecraft:mossy_stone_bricks", (byte) 17),
+            Map.entry("minecraft:chiseled_stone_bricks", (byte) 18),
+            Map.entry("minecraft:gray_terracotta", (byte) 19),
+            Map.entry("minecraft:cyan_terracotta", (byte) 20),
+            Map.entry("minecraft:black_terracotta", (byte) 21)
+    ));
+    /**
+     * Block data for dungeon rooms. See {@link de.hysky.skyblocker.skyblock.dungeon.secrets.DungeonRoomsDFU DungeonRoomsDFU} for format details and how it's generated.
+     * All access to this map must check {@link #isRoomsLoaded()} to prevent concurrent modification.
+     */
+    @SuppressWarnings("JavadocReference")
+    protected static final HashMap<String, Map<String, Map<String, int[]>>> ROOMS_DATA = new HashMap<>();
+    @NotNull
+    private static final Map<Vector2ic, Room> rooms = new HashMap<>();
+    private static final Map<String, JsonElement> roomsJson = new HashMap<>();
+    private static final Map<String, JsonElement> waypointsJson = new HashMap<>();
+    @Nullable
+    private static CompletableFuture<Void> roomsLoaded;
+    /**
+     * The map position of the top left corner of the entrance room.
+     */
+    @Nullable
+    private static Vector2ic mapEntrancePos;
+    /**
+     * The size of a room on the map.
+     */
+    private static int mapRoomSize;
+    /**
+     * The physical position of the northwest corner of the entrance room.
+     */
+    @Nullable
+    private static Vector2ic physicalEntrancePos;
+    private static Room currentRoom;
+
+    public static boolean isRoomsLoaded() {
+        return roomsLoaded != null && roomsLoaded.isDone();
+    }
+
+    @SuppressWarnings("unused")
+    public static JsonObject getRoomMetadata(String room) {
+        return roomsJson.get(room).getAsJsonObject();
+    }
+
+    public static JsonArray getRoomWaypoints(String room) {
+        return waypointsJson.get(room).getAsJsonArray();
+    }
+
+    /**
+     * Loads the dungeon secrets asynchronously from {@code /assets/skyblocker/dungeons}.
+     * Use {@link #isRoomsLoaded()} to check for completion of loading.
+     */
+    public static void init() {
+        if (SkyblockerConfigManager.get().locations.dungeons.secretWaypoints.noInitSecretWaypoints) {
+            return;
+        }
+        // Execute with MinecraftClient as executor since we need to wait for MinecraftClient#resourceManager to be set
+        CompletableFuture.runAsync(DungeonSecrets::load, MinecraftClient.getInstance()).exceptionally(e -> {
+            LOGGER.error("[Skyblocker] Failed to load dungeon secrets", e);
+            return null;
+        });
+        Scheduler.INSTANCE.scheduleCyclic(DungeonSecrets::update, 10);
+        WorldRenderEvents.AFTER_TRANSLUCENT.register(DungeonSecrets::render);
+        ClientReceiveMessageEvents.GAME.register(DungeonSecrets::onChatMessage);
+        ClientReceiveMessageEvents.GAME_CANCELED.register(DungeonSecrets::onChatMessage);
+        UseBlockCallback.EVENT.register((player, world, hand, hitResult) -> onUseBlock(world, hitResult));
+        ClientCommandRegistrationCallback.EVENT.register((dispatcher, registryAccess) -> dispatcher.register(literal(SkyblockerMod.NAMESPACE).then(literal("dungeons").then(literal("secrets")
+                .then(literal("markAsFound").then(markSecretsCommand(true)))
+                .then(literal("markAsMissing").then(markSecretsCommand(false)))))));
+        ClientPlayConnectionEvents.JOIN.register(((handler, sender, client) -> reset()));
+    }
+
+    private static void load() {
+        long startTime = System.currentTimeMillis();
+        List<CompletableFuture<Void>> dungeonFutures = new ArrayList<>();
+        for (Map.Entry<Identifier, Resource> resourceEntry : MinecraftClient.getInstance().getResourceManager().findResources(DUNGEONS_PATH, id -> id.getPath().endsWith(".skeleton")).entrySet()) {
+            String[] path = resourceEntry.getKey().getPath().split("/");
+            if (path.length != 4) {
+                LOGGER.error("[Skyblocker] Failed to load dungeon secrets, invalid resource identifier {}", resourceEntry.getKey());
+                break;
+            }
+            String dungeon = path[1];
+            String roomShape = path[2];
+            String room = path[3].substring(0, path[3].length() - ".skeleton".length());
+            ROOMS_DATA.computeIfAbsent(dungeon, dungeonKey -> new HashMap<>());
+            ROOMS_DATA.get(dungeon).computeIfAbsent(roomShape, roomShapeKey -> new HashMap<>());
+            dungeonFutures.add(CompletableFuture.supplyAsync(() -> readRoom(resourceEntry.getValue())).thenAcceptAsync(rooms -> {
+                Map<String, int[]> roomsMap = ROOMS_DATA.get(dungeon).get(roomShape);
+                synchronized (roomsMap) {
+                    roomsMap.put(room, rooms);
+                }
+                LOGGER.debug("[Skyblocker] Loaded dungeon secrets dungeon {} room shape {} room {}", dungeon, roomShape, room);
+            }).exceptionally(e -> {
+                LOGGER.error("[Skyblocker] Failed to load dungeon secrets dungeon {} room shape {} room {}", dungeon, roomShape, room, e);
+                return null;
+            }));
+        }
+        dungeonFutures.add(CompletableFuture.runAsync(() -> {
+            try (BufferedReader roomsReader = MinecraftClient.getInstance().getResourceManager().openAsReader(new Identifier(SkyblockerMod.NAMESPACE, "dungeons/dungeonrooms.json")); BufferedReader waypointsReader = MinecraftClient.getInstance().getResourceManager().openAsReader(new Identifier(SkyblockerMod.NAMESPACE, "dungeons/secretlocations.json"))) {
+                loadJson(roomsReader, roomsJson);
+                loadJson(waypointsReader, waypointsJson);
+                LOGGER.debug("[Skyblocker] Loaded dungeon secrets json");
+            } catch (Exception e) {
+                LOGGER.error("[Skyblocker] Failed to load dungeon secrets json", e);
+            }
+        }));
+        roomsLoaded = CompletableFuture.allOf(dungeonFutures.toArray(CompletableFuture[]::new)).thenRun(() -> LOGGER.info("[Skyblocker] Loaded dungeon secrets for {} dungeon(s), {} room shapes, and {} rooms total in {} ms", ROOMS_DATA.size(), ROOMS_DATA.values().stream().mapToInt(Map::size).sum(), ROOMS_DATA.values().stream().map(Map::values).flatMap(Collection::stream).mapToInt(Map::size).sum(), System.currentTimeMillis() - startTime)).exceptionally(e -> {
+            LOGGER.error("[Skyblocker] Failed to load dungeon secrets", e);
+            return null;
+        });
+        LOGGER.info("[Skyblocker] Started loading dungeon secrets in (blocked main thread for) {} ms", System.currentTimeMillis() - startTime);
+    }
+
+    private static int[] readRoom(Resource resource) throws RuntimeException {
+        try (ObjectInputStream in = new ObjectInputStream(new InflaterInputStream(resource.getInputStream()))) {
+            return (int[]) in.readObject();
+        } catch (IOException | ClassNotFoundException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    /**
+     * Loads the json from the given {@link BufferedReader} into the given {@link Map}.
+     * @param reader the reader to read the json from
+     * @param map the map to load into
+     */
+    private static void loadJson(BufferedReader reader, Map<String, JsonElement> map) {
+        SkyblockerMod.GSON.fromJson(reader, JsonObject.class).asMap().forEach((room, jsonElement) -> map.put(room.toLowerCase().replaceAll(" ", "-"), jsonElement));
+    }
+
+    private static ArgumentBuilder<FabricClientCommandSource, RequiredArgumentBuilder<FabricClientCommandSource, Integer>> markSecretsCommand(boolean found) {
+        return argument("secret", IntegerArgumentType.integer()).executes(context -> {
+            int secretIndex = IntegerArgumentType.getInteger(context, "secret");
+            if (markSecrets(secretIndex, found)) {
+                context.getSource().sendFeedback(Text.translatable(found ? "skyblocker.dungeons.secrets.markSecretFound" : "skyblocker.dungeons.secrets.markSecretMissing", secretIndex));
+            } else {
+                context.getSource().sendError(Text.translatable(found ? "skyblocker.dungeons.secrets.markSecretFoundUnable" : "skyblocker.dungeons.secrets.markSecretMissingUnable", secretIndex));
+            }
+            return Command.SINGLE_SUCCESS;
+        });
+    }
+
+    /**
+     * Updates the dungeon. The general idea is similar to the Dungeon Rooms Mod.
+     * <p></p>
+     * When entering a new dungeon, this method:
+     * <ul>
+     *     <li> Gets the physical northwest corner position of the entrance room and saves it in {@link #physicalEntrancePos}. </li>
+     *     <li> Do nothing until the dungeon map exists. </li>
+     *     <li> Gets the upper left corner of entrance room on the map and saves it in {@link #mapEntrancePos}. </li>
+     *     <li> Gets the size of a room on the map in pixels and saves it in {@link #mapRoomSize}. </li>
+     *     <li> Creates a new {@link Room} with {@link Room.Type} {@link Room.Type.ENTRANCE ENTRANCE} and sets {@link #currentRoom}. </li>
+     * </ul>
+     * When processing an existing dungeon, this method:
+     * <ul>
+     *     <li> Calculates the physical northwest corner and upper left corner on the map of the room the player is currently in. </li>
+     *     <li> Gets the room type based on the map color. </li>
+     *     <li> If the room has not been created (when the physical northwest corner is not in {@link #rooms}):</li>
+     *     <ul>
+     *         <li> If the room type is {@link Room.Type.ROOM}, gets the northwest corner of all connected room segments with {@link DungeonMapUtils#getRoomSegments(MapState, Vector2ic, int, byte)}.  (For example, a 1x2 room has two room segments.) </li>
+     *         <li> Create a new room. </li>
+     *     </ul>
+     *     <li> Sets {@link #currentRoom} to the current room, either created from the previous step or from {@link #rooms}. </li>
+     *     <li> Calls {@link Room#update()} on {@link #currentRoom}. </li>
+     * </ul>
+     */
+    @SuppressWarnings("JavadocReference")
+    private static void update() {
+        if (!SkyblockerConfigManager.get().locations.dungeons.secretWaypoints.enableSecretWaypoints) {
+            return;
+        }
+        if (!Utils.isInDungeons()) {
+            if (mapEntrancePos != null) {
+                reset();
+            }
+            return;
+        }
+        MinecraftClient client = MinecraftClient.getInstance();
+        ClientPlayerEntity player = client.player;
+        if (player == null || client.world == null) {
+            return;
+        }
+        if (physicalEntrancePos == null) {
+            Vec3d playerPos = player.getPos();
+            physicalEntrancePos = DungeonMapUtils.getPhysicalRoomPos(playerPos);
+            currentRoom = newRoom(Room.Type.ENTRANCE, physicalEntrancePos);
+        }
+        ItemStack stack = player.getInventory().main.get(8);
+        if (!stack.isOf(Items.FILLED_MAP)) {
+            return;
+        }
+        MapState map = FilledMapItem.getMapState(FilledMapItem.getMapId(stack), client.world);
+        if (map == null) {
+            return;
+        }
+        if (mapEntrancePos == null || mapRoomSize == 0) {
+            ObjectIntPair<Vector2ic> mapEntrancePosAndSize = DungeonMapUtils.getMapEntrancePosAndRoomSize(map);
+            if (mapEntrancePosAndSize == null) {
+                return;
+            }
+            mapEntrancePos = mapEntrancePosAndSize.left();
+            mapRoomSize = mapEntrancePosAndSize.rightInt();
+            LOGGER.info("[Skyblocker] Started dungeon with map room size {}, map entrance pos {}, player pos {}, and physical entrance pos {}", mapRoomSize, mapEntrancePos, client.player.getPos(), physicalEntrancePos);
+        }
+
+        Vector2ic physicalPos = DungeonMapUtils.getPhysicalRoomPos(client.player.getPos());
+        Vector2ic mapPos = DungeonMapUtils.getMapPosFromPhysical(physicalEntrancePos, mapEntrancePos, mapRoomSize, physicalPos);
+        Room room = rooms.get(physicalPos);
+        if (room == null) {
+            Room.Type type = DungeonMapUtils.getRoomType(map, mapPos);
+            if (type == null || type == Room.Type.UNKNOWN) {
+                return;
+            }
+            switch (type) {
+                case ENTRANCE, PUZZLE, TRAP, MINIBOSS, FAIRY, BLOOD -> room = newRoom(type, physicalPos);
+                case ROOM -> room = newRoom(type, DungeonMapUtils.getPhysicalPosFromMap(mapEntrancePos, mapRoomSize, physicalEntrancePos, DungeonMapUtils.getRoomSegments(map, mapPos, mapRoomSize, type.color)));
+            }
+        }
+        if (room != null && currentRoom != room) {
+            currentRoom = room;
+        }
+        currentRoom.update();
+    }
+
+    /**
+     * Creates a new room with the given type and physical positions,
+     * adds the room to {@link #rooms}, and sets {@link #currentRoom} to the new room.
+     *
+     * @param type              the type of room to create
+     * @param physicalPositions the physical positions of the room
+     */
+    @Nullable
+    private static Room newRoom(Room.Type type, Vector2ic... physicalPositions) {
+        try {
+            Room newRoom = new Room(type, physicalPositions);
+            for (Vector2ic physicalPos : physicalPositions) {
+                rooms.put(physicalPos, newRoom);
+            }
+            return newRoom;
+        } catch (IllegalArgumentException e) {
+            LOGGER.error("[Skyblocker] Failed to create room", e);
+        }
+        return null;
+    }
+
+    /**
+     * Renders the secret waypoints in {@link #currentRoom} if {@link #isCurrentRoomMatched()}.
+     */
+    private static void render(WorldRenderContext context) {
+        if (isCurrentRoomMatched()) {
+            currentRoom.render(context);
+        }
+    }
+
+    /**
+     * Calls {@link Room#onChatMessage(String)} on {@link #currentRoom} if the message is an overlay message and {@link #isCurrentRoomMatched()}.
+     * Used to detect when all secrets in a room are found.
+     */
+    private static void onChatMessage(Text text, boolean overlay) {
+        if (overlay && isCurrentRoomMatched()) {
+            currentRoom.onChatMessage(text.getString());
+        }
+    }
+
+    /**
+     * Calls {@link Room#onUseBlock(World, BlockHitResult)} on {@link #currentRoom} if {@link #isCurrentRoomMatched()}.
+     * Used to detect finding {@link SecretWaypoint.Category.CHEST} and {@link SecretWaypoint.Category.WITHER} secrets.
+     *
+     * @return {@link ActionResult#PASS}
+     */
+    @SuppressWarnings("JavadocReference")
+    private static ActionResult onUseBlock(World world, BlockHitResult hitResult) {
+        if (isCurrentRoomMatched()) {
+            currentRoom.onUseBlock(world, hitResult);
+        }
+        return ActionResult.PASS;
+    }
+
+    /**
+     * Calls {@link Room#onItemPickup(ItemEntity, LivingEntity)} on the room the {@code collector} is in if that room {@link #isRoomMatched(Room)}.
+     * Used to detect finding {@link SecretWaypoint.Category.ITEM} secrets.
+     * If the collector is the player, {@link #currentRoom} is used as an optimization.
+     */
+    @SuppressWarnings("JavadocReference")
+    public static void onItemPickup(ItemEntity itemEntity, LivingEntity collector, boolean isPlayer) {
+        if (isPlayer) {
+            if (isCurrentRoomMatched()) {
+                currentRoom.onItemPickup(itemEntity, collector);
+            }
+        } else {
+            Room room = getRoomAtPhysical(collector.getPos());
+            if (isRoomMatched(room)) {
+                room.onItemPickup(itemEntity, collector);
+            }
+        }
+    }
+
+    /**
+     * Calls {@link Room#onBatRemoved(BatEntity)} on the room the {@code bat} is in if that room {@link #isRoomMatched(Room)}.
+     * Used to detect finding {@link SecretWaypoint.Category.BAT} secrets.
+     */
+    @SuppressWarnings("JavadocReference")
+    public static void onBatRemoved(AmbientEntity bat) {
+        Room room = getRoomAtPhysical(bat.getPos());
+        if (isRoomMatched(room)) {
+            room.onBatRemoved(bat);
+        }
+    }
+
+    public static boolean markSecrets(int secretIndex, boolean found) {
+        if (isCurrentRoomMatched()) {
+            return currentRoom.markSecrets(secretIndex, found);
+        }
+        return false;
+    }
+
+    /**
+     * Gets the room at the given physical position.
+     *
+     * @param pos the physical position
+     * @return the room at the given physical position, or null if there is no room at the given physical position
+     * @see #rooms
+     * @see DungeonMapUtils#getPhysicalRoomPos(Vec3d)
+     */
+    @Nullable
+    private static Room getRoomAtPhysical(Vec3d pos) {
+        return rooms.get(DungeonMapUtils.getPhysicalRoomPos(pos));
+    }
+
+    /**
+     * Calls {@link #isRoomMatched(Room)} on {@link #currentRoom}.
+     *
+     * @return {@code true} if {@link #currentRoom} is not null and {@link #isRoomMatched(Room)}
+     */
+    private static boolean isCurrentRoomMatched() {
+        return isRoomMatched(currentRoom);
+    }
+
+    /**
+     * Calls {@link #shouldProcess()} and {@link Room#isMatched()} on the given room.
+     *
+     * @param room the room to check
+     * @return {@code true} if {@link #shouldProcess()}, the given room is not null, and {@link Room#isMatched()} on the given room
+     */
+    @Contract("null -> false")
+    private static boolean isRoomMatched(@Nullable Room room) {
+        return shouldProcess() && room != null && room.isMatched();
+    }
+
+    /**
+     * Checks if the player is in a dungeon and {@link SkyblockerConfigManager.Dungeons#secretWaypoints Secret Waypoints} is enabled.
+     *
+     * @return whether dungeon secrets should be processed
+     */
+    private static boolean shouldProcess() {
+        return SkyblockerConfigManager.get().locations.dungeons.secretWaypoints.enableSecretWaypoints && Utils.isInDungeons();
+    }
+
+    /**
+     * Resets fields when leaving a dungeon.
+     */
+    private static void reset() {
+        mapEntrancePos = null;
+        mapRoomSize = 0;
+        physicalEntrancePos = null;
+        rooms.clear();
+        currentRoom = null;
+    }
+}
diff --git a/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/Room.java b/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/Room.java
new file mode 100644
index 00000000..dd7dc91e
--- /dev/null
+++ b/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/Room.java
@@ -0,0 +1,473 @@
+package de.hysky.skyblocker.skyblock.dungeon.secrets;
+
+import com.google.common.collect.HashBasedTable;
+import com.google.common.collect.ImmutableTable;
+import com.google.common.collect.Table;
+import com.google.gson.JsonElement;
+import com.google.gson.JsonObject;
+import it.unimi.dsi.fastutil.ints.IntRBTreeSet;
+import it.unimi.dsi.fastutil.ints.IntSortedSet;
+import it.unimi.dsi.fastutil.ints.IntSortedSets;
+import de.hysky.skyblocker.utils.scheduler.Scheduler;
+import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderContext;
+import net.fabricmc.fabric.api.util.TriState;
+import net.minecraft.block.BlockState;
+import net.minecraft.block.Blocks;
+import net.minecraft.block.MapColor;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.client.network.ClientPlayerEntity;
+import net.minecraft.client.world.ClientWorld;
+import net.minecraft.entity.ItemEntity;
+import net.minecraft.entity.LivingEntity;
+import net.minecraft.entity.mob.AmbientEntity;
+import net.minecraft.registry.Registries;
+import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.MathHelper;
+import net.minecraft.world.World;
+import org.apache.commons.lang3.tuple.MutableTriple;
+import org.apache.commons.lang3.tuple.Triple;
+import org.jetbrains.annotations.NotNull;
+import org.joml.Vector2i;
+import org.joml.Vector2ic;
+
+import java.util.*;
+import java.util.concurrent.CompletableFuture;
+import java.util.regex.Matcher;
+import java.util.regex.Pattern;
+
+public class Room {
+    private static final Pattern SECRETS = Pattern.compile("§7(\\d{1,2})/(\\d{1,2}) Secrets");
+    @NotNull
+    private final Type type;
+    @NotNull
+    private final Set<Vector2ic> segments;
+    /**
+     * The shape of the room. See {@link #getShape(IntSortedSet, IntSortedSet)}.
+     */
+    @NotNull
+    private final Shape shape;
+    /**
+     * The room data containing all rooms for a specific dungeon and {@link #shape}.
+     */
+    private Map<String, int[]> roomsData;
+    /**
+     * Contains all possible dungeon rooms for this room. The list is gradually shrunk by checking blocks until only one room is left.
+     */
+    private List<MutableTriple<Direction, Vector2ic, List<String>>> possibleRooms;
+    /**
+     * Contains all blocks that have been checked to prevent checking the same block multiple times.
+     */
+    private Set<BlockPos> checkedBlocks = new HashSet<>();
+    /**
+     * The task that is used to check blocks. This is used to ensure only one such task can run at a time.
+     */
+    private CompletableFuture<Void> findRoom;
+    private int doubleCheckBlocks;
+    /**
+     * Represents the matching state of the room with the following possible values:
+     * <li>{@link TriState#DEFAULT} means that the room has not been checked, is being processed, or does not {@link Type#needsScanning() need to be processed}.
+     * <li>{@link TriState#FALSE} means that the room has been checked and there is no match.
+     * <li>{@link TriState#TRUE} means that the room has been checked and there is a match.
+     */
+    private TriState matched = TriState.DEFAULT;
+    private Table<Integer, BlockPos, SecretWaypoint> secretWaypoints;
+
+    public Room(@NotNull Type type, @NotNull Vector2ic... physicalPositions) {
+        this.type = type;
+        segments = Set.of(physicalPositions);
+        IntSortedSet segmentsX = IntSortedSets.unmodifiable(new IntRBTreeSet(segments.stream().mapToInt(Vector2ic::x).toArray()));
+        IntSortedSet segmentsY = IntSortedSets.unmodifiable(new IntRBTreeSet(segments.stream().mapToInt(Vector2ic::y).toArray()));
+        shape = getShape(segmentsX, segmentsY);
+        roomsData = DungeonSecrets.ROOMS_DATA.getOrDefault("catacombs", Collections.emptyMap()).getOrDefault(shape.shape.toLowerCase(), Collections.emptyMap());
+        possibleRooms = getPossibleRooms(segmentsX, segmentsY);
+    }
+
+    @NotNull
+    public Type getType() {
+        return type;
+    }
+
+    public boolean isMatched() {
+        return matched == TriState.TRUE;
+    }
+
+    @Override
+    public String toString() {
+        return "Room{type=" + type + ", shape=" + shape + ", matched=" + matched + ", segments=" + Arrays.toString(segments.toArray()) + "}";
+    }
+
+    @NotNull
+    private Shape getShape(IntSortedSet segmentsX, IntSortedSet segmentsY) {
+        return switch (segments.size()) {
+            case 1 -> Shape.ONE_BY_ONE;
+            case 2 -> Shape.ONE_BY_TWO;
+            case 3 -> segmentsX.size() == 2 && segmentsY.size() == 2 ? Shape.L_SHAPE : Shape.ONE_BY_THREE;
+            case 4 -> segmentsX.size() == 2 && segmentsY.size() == 2 ? Shape.TWO_BY_TWO : Shape.ONE_BY_FOUR;
+            default -> throw new IllegalArgumentException("There are no matching room shapes with this set of physical positions: " + Arrays.toString(segments.toArray()));
+        };
+    }
+
+    private List<MutableTriple<Direction, Vector2ic, List<String>>> getPossibleRooms(IntSortedSet segmentsX, IntSortedSet segmentsY) {
+        List<String> possibleDirectionRooms = new ArrayList<>(roomsData.keySet());
+        List<MutableTriple<Direction, Vector2ic, List<String>>> possibleRooms = new ArrayList<>();
+        for (Direction direction : getPossibleDirections(segmentsX, segmentsY)) {
+            possibleRooms.add(MutableTriple.of(direction, DungeonMapUtils.getPhysicalCornerPos(direction, segmentsX, segmentsY), possibleDirectionRooms));
+        }
+        return possibleRooms;
+    }
+
+    @NotNull
+    private Direction[] getPossibleDirections(IntSortedSet segmentsX, IntSortedSet segmentsY) {
+        return switch (shape) {
+            case ONE_BY_ONE, TWO_BY_TWO -> Direction.values();
+            case ONE_BY_TWO, ONE_BY_THREE, ONE_BY_FOUR -> {
+                if (segmentsX.size() > 1 && segmentsY.size() == 1) {
+                    yield new Direction[]{Direction.NW, Direction.SE};
+                } else if (segmentsX.size() == 1 && segmentsY.size() > 1) {
+                    yield new Direction[]{Direction.NE, Direction.SW};
+                }
+                throw new IllegalArgumentException("Shape " + shape.shape + " does not match segments: " + Arrays.toString(segments.toArray()));
+            }
+            case L_SHAPE -> {
+                if (!segments.contains(new Vector2i(segmentsX.firstInt(), segmentsY.firstInt()))) {
+                    yield new Direction[]{Direction.SW};
+                } else if (!segments.contains(new Vector2i(segmentsX.firstInt(), segmentsY.lastInt()))) {
+                    yield new Direction[]{Direction.SE};
+                } else if (!segments.contains(new Vector2i(segmentsX.lastInt(), segmentsY.firstInt()))) {
+                    yield new Direction[]{Direction.NW};
+                } else if (!segments.contains(new Vector2i(segmentsX.lastInt(), segmentsY.lastInt()))) {
+                    yield new Direction[]{Direction.NE};
+                }
+                throw new IllegalArgumentException("Shape " + shape.shape + " does not match segments: " + Arrays.toString(segments.toArray()));
+            }
+        };
+    }
+
+    /**
+     * Updates the room.
+     * <p></p>
+     * This method returns immediately if any of the following conditions are met:
+     * <ul>
+     *     <li> The room does not need to be scanned and matched. (When the room is not of type {@link Type.ROOM}, {@link Type.PUZZLE}, or {@link Type.TRAP}. See {@link Type#needsScanning()}) </li>
+     *     <li> The room has been matched or failed to match and is on cooldown. See {@link #matched}. </li>
+     *     <li> {@link #findRoom The previous update} has not completed. </li>
+     * </ul>
+     * Then this method tries to match this room through:
+     * <ul>
+     *     <li> Iterate over a 11 by 11 by 11 box around the player. </li>
+     *     <li> Check it the block is part of this room and not part of a doorway. See {@link #segments} and {@link #notInDoorway(BlockPos)}. </li>
+     *     <li> Checks if the position has been checked and adds it to {@link #checkedBlocks}. </li>
+     *     <li> Calls {@link #checkBlock(ClientWorld, BlockPos)} </li>
+     * </ul>
+     */
+    @SuppressWarnings("JavadocReference")
+    protected void update() {
+        // Logical AND has higher precedence than logical OR
+        if (!type.needsScanning() || matched != TriState.DEFAULT || !DungeonSecrets.isRoomsLoaded() || findRoom != null && !findRoom.isDone()) {
+            return;
+        }
+        MinecraftClient client = MinecraftClient.getInstance();
+        ClientPlayerEntity player = client.player;
+        ClientWorld world = client.world;
+        if (player == null || world == null) {
+            return;
+        }
+        findRoom = CompletableFuture.runAsync(() -> {
+            for (BlockPos pos : BlockPos.iterate(player.getBlockPos().add(-5, -5, -5), player.getBlockPos().add(5, 5, 5))) {
+                if (segments.contains(DungeonMapUtils.getPhysicalRoomPos(pos)) && notInDoorway(pos) && checkedBlocks.add(pos) && checkBlock(world, pos)) {
+                    break;
+                }
+            }
+        });
+    }
+
+    private static boolean notInDoorway(BlockPos pos) {
+        if (pos.getY() < 66 || pos.getY() > 73) {
+            return true;
+        }
+        int x = MathHelper.floorMod(pos.getX() - 8, 32);
+        int z = MathHelper.floorMod(pos.getZ() - 8, 32);
+        return (x < 13 || x > 17 || z > 2 && z < 28) && (z < 13 || z > 17 || x > 2 && x < 28);
+    }
+
+    /**
+     * Filters out dungeon rooms which does not contain the block at the given position.
+     * <p></p>
+     * This method:
+     * <ul>
+     *     <li> Checks if the block type is included in the dungeon rooms data. See {@link DungeonSecrets#NUMERIC_ID}. </li>
+     *     <li> For each possible direction: </li>
+     *     <ul>
+     *         <li> Rotate and convert the position to a relative position. See {@link DungeonMapUtils#actualToRelative(Direction, Vector2ic, BlockPos)}. </li>
+     *         <li> Encode the block based on the relative position and the custom numeric block id. See {@link #posIdToInt(BlockPos, byte)}. </li>
+     *         <li> For each possible room in the current direction: </li>
+     *         <ul>
+     *             <li> Check if {@link #roomsData} contains the encoded block. </li>
+     *             <li> If so, add the room to the new list of possible rooms for this direction. </li>
+     *         </ul>
+     *         <li> Replace the old possible room list for the current direction with the new one. </li>
+     *     </ul>
+     *     <li> If there are no matching rooms left: </li>
+     *     <ul>
+     *         <li> Terminate matching by setting {@link #matched} to {@link TriState#FALSE}. </li>
+     *         <li> Schedule another matching attempt in 50 ticks (2.5 seconds). </li>
+     *         <li> Reset {@link #possibleRooms} and {@link #checkedBlocks} with {@link #reset()}. </li>
+     *         <li> Return {@code true} </li>
+     *     </ul>
+     *     <li> If there are exactly one room matching: </li>
+     *     <ul>
+     *         <li> Call {@link #roomMatched(String, Direction, Vector2ic)}. </li>
+     *         <li> Discard the no longer needed fields to save memory. </li>
+     *         <li> Return {@code true} </li>
+     *     </ul>
+     *     <li> Return {@code false} </li>
+     * </ul>
+     *
+     * @param world the world to get the block from
+     * @param pos   the position of the block to check
+     * @return whether room matching should end. Either a match is found or there are no valid rooms left
+     */
+    private boolean checkBlock(ClientWorld world, BlockPos pos) {
+        byte id = DungeonSecrets.NUMERIC_ID.getByte(Registries.BLOCK.getId(world.getBlockState(pos).getBlock()).toString());
+        if (id == 0) {
+            return false;
+        }
+        for (MutableTriple<Direction, Vector2ic, List<String>> directionRooms : possibleRooms) {
+            int block = posIdToInt(DungeonMapUtils.actualToRelative(directionRooms.getLeft(), directionRooms.getMiddle(), pos), id);
+            List<String> possibleDirectionRooms = new ArrayList<>();
+            for (String room : directionRooms.getRight()) {
+                if (Arrays.binarySearch(roomsData.get(room), block) >= 0) {
+                    possibleDirectionRooms.add(room);
+                }
+            }
+            directionRooms.setRight(possibleDirectionRooms);
+        }
+
+        int matchingRoomsSize = possibleRooms.stream().map(Triple::getRight).mapToInt(Collection::size).sum();
+        if (matchingRoomsSize == 0) {
+            // If no rooms match, reset the fields and scan again after 50 ticks.
+            matched = TriState.FALSE;
+            DungeonSecrets.LOGGER.warn("[Skyblocker] No dungeon room matches after checking {} block(s)", checkedBlocks.size());
+            Scheduler.INSTANCE.schedule(() -> matched = TriState.DEFAULT, 50);
+            reset();
+            return true;
+        } else if (matchingRoomsSize == 1 && ++doubleCheckBlocks >= 10) {
+            // If one room matches, load the secrets for that room and discard the no longer needed fields.
+            for (Triple<Direction, Vector2ic, List<String>> directionRooms : possibleRooms) {
+                if (directionRooms.getRight().size() == 1) {
+                    roomMatched(directionRooms.getRight().get(0), directionRooms.getLeft(), directionRooms.getMiddle());
+                    discard();
+                    return true;
+                }
+            }
+            return false; // This should never happen, we just checked that there is one possible room, and the return true in the loop should activate
+        } else {
+            DungeonSecrets.LOGGER.debug("[Skyblocker] {} room(s) remaining after checking {} block(s)", matchingRoomsSize, checkedBlocks.size());
+            return false;
+        }
+    }
+
+    /**
+     * Encodes a {@link BlockPos} and the custom numeric block id into an integer.
+     *
+     * @param pos the position of the block
+     * @param id  the custom numeric block id
+     * @return the encoded integer
+     */
+    private int posIdToInt(BlockPos pos, byte id) {
+        return pos.getX() << 24 | pos.getY() << 16 | pos.getZ() << 8 | id;
+    }
+
+    /**
+     * Loads the secret waypoints for the room from {@link DungeonSecrets#waypointsJson} once it has been matched
+     * and sets {@link #matched} to {@link TriState#TRUE}.
+     *
+     * @param directionRooms the direction, position, and name of the room
+     */
+    @SuppressWarnings("JavadocReference")
+    private void roomMatched(String name, Direction direction, Vector2ic physicalCornerPos) {
+        Table<Integer, BlockPos, SecretWaypoint> secretWaypointsMutable = HashBasedTable.create();
+        for (JsonElement waypointElement : DungeonSecrets.getRoomWaypoints(name)) {
+            JsonObject waypoint = waypointElement.getAsJsonObject();
+            String secretName = waypoint.get("secretName").getAsString();
+            int secretIndex = Integer.parseInt(secretName.substring(0, Character.isDigit(secretName.charAt(1)) ? 2 : 1));
+            BlockPos pos = DungeonMapUtils.relativeToActual(direction, physicalCornerPos, waypoint);
+            secretWaypointsMutable.put(secretIndex, pos, new SecretWaypoint(secretIndex, waypoint, secretName, pos));
+        }
+        secretWaypoints = ImmutableTable.copyOf(secretWaypointsMutable);
+        matched = TriState.TRUE;
+        DungeonSecrets.LOGGER.info("[Skyblocker] Room {} matched after checking {} block(s)", name, checkedBlocks.size());
+    }
+
+    /**
+     * Resets fields for another round of matching after room matching fails.
+     */
+    private void reset() {
+        IntSortedSet segmentsX = IntSortedSets.unmodifiable(new IntRBTreeSet(segments.stream().mapToInt(Vector2ic::x).toArray()));
+        IntSortedSet segmentsY = IntSortedSets.unmodifiable(new IntRBTreeSet(segments.stream().mapToInt(Vector2ic::y).toArray()));
+        possibleRooms = getPossibleRooms(segmentsX, segmentsY);
+        checkedBlocks = new HashSet<>();
+        doubleCheckBlocks = 0;
+    }
+
+    /**
+     * Discards fields after room matching completes when a room is found.
+     * These fields are no longer needed and are discarded to save memory.
+     */
+    private void discard() {
+        roomsData = null;
+        possibleRooms = null;
+        checkedBlocks = null;
+        doubleCheckBlocks = 0;
+    }
+
+    /**
+     * Calls {@link SecretWaypoint#render(WorldRenderContext)} on {@link #secretWaypoints all secret waypoints}.
+     */
+    protected void render(WorldRenderContext context) {
+        for (SecretWaypoint secretWaypoint : secretWaypoints.values()) {
+            if (secretWaypoint.shouldRender()) {
+                secretWaypoint.render(context);
+            }
+        }
+    }
+
+    /**
+     * Sets all secrets as found if {@link #isAllSecretsFound(String)}.
+     */
+    protected void onChatMessage(String message) {
+        if (isAllSecretsFound(message)) {
+            secretWaypoints.values().forEach(SecretWaypoint::setFound);
+        }
+    }
+
+    /**
+     * Checks if the number of found secrets is equals or greater than the total number of secrets in the room.
+     *
+     * @param message the message to check in
+     * @return whether the number of found secrets is equals or greater than the total number of secrets in the room
+     */
+    protected static boolean isAllSecretsFound(String message) {
+        Matcher matcher = SECRETS.matcher(message);
+        if (matcher.find()) {
+            return Integer.parseInt(matcher.group(1)) >= Integer.parseInt(matcher.group(2));
+        }
+        return false;
+    }
+
+    /**
+     * Marks the secret at the interaction position as found when the player interacts with a chest or a player head,
+     * if there is a secret at the interaction position.
+     *
+     * @param world     the world to get the block from
+     * @param hitResult the block being interacted with
+     * @see #onSecretFound(SecretWaypoint, String, Object...)
+     */
+    protected void onUseBlock(World world, BlockHitResult hitResult) {
+        BlockState state = world.getBlockState(hitResult.getBlockPos());
+        if (state.isOf(Blocks.CHEST) || state.isOf(Blocks.PLAYER_HEAD) || state.isOf(Blocks.PLAYER_WALL_HEAD)) {
+            secretWaypoints.column(hitResult.getBlockPos()).values().stream().filter(SecretWaypoint::needsInteraction).findAny()
+                    .ifPresent(secretWaypoint -> onSecretFound(secretWaypoint, "[Skyblocker] Detected {} interaction, setting secret #{} as found", secretWaypoint.category, secretWaypoint.secretIndex));
+        } else if (state.isOf(Blocks.LEVER)) {
+            secretWaypoints.column(hitResult.getBlockPos()).values().stream().filter(SecretWaypoint::isLever).forEach(SecretWaypoint::setFound);
+        }
+    }
+
+    /**
+     * Marks the closest secret that requires item pickup no greater than 6 blocks away as found when the player picks up a secret item.
+     *
+     * @param itemEntity the item entity being picked up
+     * @param collector  the collector of the item
+     * @see #onSecretFound(SecretWaypoint, String, Object...)
+     */
+    protected void onItemPickup(ItemEntity itemEntity, LivingEntity collector) {
+        if (SecretWaypoint.SECRET_ITEMS.stream().noneMatch(itemEntity.getStack().getName().getString()::contains)) {
+            return;
+        }
+        secretWaypoints.values().stream().filter(SecretWaypoint::needsItemPickup).min(Comparator.comparingDouble(SecretWaypoint.getSquaredDistanceToFunction(collector))).filter(SecretWaypoint.getRangePredicate(collector))
+                .ifPresent(secretWaypoint -> onSecretFound(secretWaypoint, "[Skyblocker] Detected {} picked up a {} from a {} secret, setting secret #{} as found", collector.getName().getString(), itemEntity.getName().getString(), secretWaypoint.category, secretWaypoint.secretIndex));
+    }
+
+    /**
+     * Marks the closest bat secret as found when a bat is killed.
+     *
+     * @param bat the bat being killed
+     * @see #onSecretFound(SecretWaypoint, String, Object...)
+     */
+    protected void onBatRemoved(AmbientEntity bat) {
+        secretWaypoints.values().stream().filter(SecretWaypoint::isBat).min(Comparator.comparingDouble(SecretWaypoint.getSquaredDistanceToFunction(bat)))
+                .ifPresent(secretWaypoint -> onSecretFound(secretWaypoint, "[Skyblocker] Detected {} killed for a {} secret, setting secret #{} as found", bat.getName().getString(), secretWaypoint.category, secretWaypoint.secretIndex));
+    }
+
+    /**
+     * Marks all secret waypoints with the same index as the given {@link SecretWaypoint} as found.
+     *
+     * @param secretWaypoint the secret waypoint to read the index from.
+     * @param msg            the message to log
+     * @param args           the args for the {@link org.slf4j.Logger#info(String, Object...) Logger#info(String, Object...)} call
+     */
+    private void onSecretFound(SecretWaypoint secretWaypoint, String msg, Object... args) {
+        secretWaypoints.row(secretWaypoint.secretIndex).values().forEach(SecretWaypoint::setFound);
+        DungeonSecrets.LOGGER.info(msg, args);
+    }
+
+    protected boolean markSecrets(int secretIndex, boolean found) {
+        Map<BlockPos, SecretWaypoint> secret = secretWaypoints.row(secretIndex);
+        if (secret.isEmpty()) {
+            return false;
+        } else {
+            secret.values().forEach(found ? SecretWaypoint::setFound : SecretWaypoint::setMissing);
+            return true;
+        }
+    }
+
+    public enum Type {
+        ENTRANCE(MapColor.DARK_GREEN.getRenderColorByte(MapColor.Brightness.HIGH)),
+        ROOM(MapColor.ORANGE.getRenderColorByte(MapColor.Brightness.LOWEST)),
+        PUZZLE(MapColor.MAGENTA.getRenderColorByte(MapColor.Brightness.HIGH)),
+        TRAP(MapColor.ORANGE.getRenderColorByte(MapColor.Brightness.HIGH)),
+        MINIBOSS(MapColor.YELLOW.getRenderColorByte(MapColor.Brightness.HIGH)),
+        FAIRY(MapColor.PINK.getRenderColorByte(MapColor.Brightness.HIGH)),
+        BLOOD(MapColor.BRIGHT_RED.getRenderColorByte(MapColor.Brightness.HIGH)),
+        UNKNOWN(MapColor.GRAY.getRenderColorByte(MapColor.Brightness.NORMAL));
+        final byte color;
+
+        Type(byte color) {
+            this.color = color;
+        }
+
+        /**
+         * @return whether this room type has secrets and needs to be scanned and matched.
+         */
+        private boolean needsScanning() {
+            return switch (this) {
+                case ROOM, PUZZLE, TRAP -> true;
+                default -> false;
+            };
+        }
+    }
+
+    private enum Shape {
+        ONE_BY_ONE("1x1"),
+        ONE_BY_TWO("1x2"),
+        ONE_BY_THREE("1x3"),
+        ONE_BY_FOUR("1x4"),
+        L_SHAPE("L-shape"),
+        TWO_BY_TWO("2x2");
+        final String shape;
+
+        Shape(String shape) {
+            this.shape = shape;
+        }
+
+        @Override
+        public String toString() {
+            return shape;
+        }
+    }
+
+    public enum Direction {
+        NW, NE, SW, SE
+    }
+}
diff --git a/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/SecretWaypoint.java b/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/SecretWaypoint.java
new file mode 100644
index 00000000..d2a31ea3
--- /dev/null
+++ b/src/main/java/de/hysky/skyblocker/skyblock/dungeon/secrets/SecretWaypoint.java
@@ -0,0 +1,142 @@
+package de.hysky.skyblocker.skyblock.dungeon.secrets;
+
+import com.google.gson.JsonObject;
+
+import de.hysky.skyblocker.config.SkyblockerConfig;
+import de.hysky.skyblocker.config.SkyblockerConfigManager;
+import de.hysky.skyblocker.utils.render.RenderHelper;
+import net.fabricmc.fabric.api.client.rendering.v1.WorldRenderContext;
+import net.minecraft.client.MinecraftClient;
+import net.minecraft.entity.Entity;
+import net.minecraft.text.Text;
+import net.minecraft.util.Formatting;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.util.math.Vec3d;
+
+import java.util.List;
+import java.util.function.Predicate;
+import java.util.function.ToDoubleFunction;
+
+public class SecretWaypoint {
+    static final List<String> SECRET_ITEMS = List.of("Decoy", "Defuse Kit", "Dungeon Chest Key", "Healing VIII", "Inflatable Jerry", "Spirit Leap", "Training Weights", "Trap", "Treasure Talisman");
+    final int secretIndex;
+    final Category category;
+    private final Text name;
+    private final BlockPos pos;
+    private final Vec3d centerPos;
+    private boolean missing;
+
+    SecretWaypoint(int secretIndex, JsonObject waypoint, String name, BlockPos pos) {
+        this.secretIndex = secretIndex;
+        this.category = Category.get(waypoint);
+        this.name = Text.of(name);
+        this.pos = pos;
+        this.centerPos = pos.toCenterPos();
+        this.missing = true;
+    }
+
+    static ToDoubleFunction<SecretWaypoint> getSquaredDistanceToFunction(Entity entity) {
+        return secretWaypoint -> entity.squaredDistanceTo(secretWaypoint.centerPos);
+    }
+
+    static Predicate<SecretWaypoint> getRangePredicate(Entity entity) {
+        return secretWaypoint -> entity.squaredDistanceTo(secretWaypoint.centerPos) <= 36D;
+    }
+
+    boolean shouldRender() {
+        return category.isEnabled() && missing;
+    }
+
+    boolean needsInteraction() {
+        return category.needsInteraction();
+    }
+
+    boolean isLever() {
+        return category.isLever();
+    }
+
+    boolean needsItemPickup() {
+        return category.needsItemPickup();
+    }
+
+    boolean isBat() {
+        return category.isBat();
+    }
+
+    void setFound() {
+        this.missing = false;
+    }
+
+    void setMissing() {
+        this.missing = true;
+    }
+
+    /**
+     * Renders the secret waypoint, including a filled cube, a beacon beam, the name, and the distance from the player.
+     */
+    void render(WorldRenderContext context) {
+        RenderHelper.renderFilledThroughWallsWithBeaconBeam(context, pos, category.colorComponents, 0.5F);
+        Vec3d posUp = centerPos.add(0, 1, 0);
+        RenderHelper.renderText(context, name, posUp, true);
+        double distance = context.camera().getPos().distanceTo(centerPos);
+        RenderHelper.renderText(context, Text.literal(Math.round(distance) + "m").formatted(Formatting.YELLOW), posUp, 1, MinecraftClient.getInstance().textRenderer.fontHeight + 1, true);
+    }
+
+    enum Category {
+        ENTRANCE(secretWaypoints -> secretWaypoints.enableEntranceWaypoints, 0, 255, 0),
+        SUPERBOOM(secretWaypoints -> secretWaypoints.enableSuperboomWaypoints, 255, 0, 0),
+        CHEST(secretWaypoints -> secretWaypoints.enableChestWaypoints, 2, 213, 250),
+        ITEM(secretWaypoints -> secretWaypoints.enableItemWaypoints, 2, 64, 250),
+        BAT(secretWaypoints -> secretWaypoints.enableBatWaypoints, 142, 66, 0),
+        WITHER(secretWaypoints -> secretWaypoints.enableWitherWaypoints, 30, 30, 30),
+        LEVER(secretWaypoints -> secretWaypoints.enableLeverWaypoints, 250, 217, 2),
+        FAIRYSOUL(secretWaypoints -> secretWaypoints.enableFairySoulWaypoints, 255, 85, 255),
+        STONK(secretWaypoints -> secretWaypoints.enableStonkWaypoints, 146, 52, 235),
+        DEFAULT(secretWaypoints -> secretWaypoints.enableDefaultWaypoints, 190, 255, 252);
+        private final Predicate<SkyblockerConfig.SecretWaypoints> enabledPredicate;
+        private final float[] colorComponents;
+
+        Category(Predicate<SkyblockerConfig.SecretWaypoints> enabledPredicate, int... intColorComponents) {
+            this.enabledPredicate = enabledPredicate;
+            colorComponents = new float[intColorComponents.length];
+            for (int i = 0; i < intColorComponents.length; i++) {
+                colorComponents[i] = intColorComponents[i] / 255F;
+            }
+        }
+
+        private static Category get(JsonObject categoryJson) {
+            return switch (categoryJson.get("category").getAsString()) {
+                case "entrance" -> Category.ENTRANCE;
+                case "superboom" -> Category.SUPERBOOM;
+                case "chest" -> Category.CHEST;
+                case "item" -> Category.ITEM;
+                case "bat" -> Category.BAT;
+                case "wither" -> Category.WITHER;
+                case "lever" -> Category.LEVER;
+                case "fairysoul" -> Category.FAIRYSOUL;
+                case "stonk" -> Category.STONK;
+                default -> Category.DEFAULT;
+            };
+        }
+
+        boolean needsInteraction() {
+            return this == CHEST || this == WITHER;
+        }
+
+        boolean isLever() {
+            return this == LEVER;
+        }
+
+        boolean needsItemPickup() {
+            return this == ITEM;
+        }
+
+        boolean isBat() {
+            return this == BAT;
+        }
+
+        boolean isEnabled() {
+            return enabledPredicate.test(SkyblockerConfigManager.get().locations.dungeons.secretWaypoints);
+        }
+    }
+}