Fix Datapack Structures

Author: cev-api

common/src/main/java/com/mamiyaotaru/voxelmap/gui/GuiSeedMapperDatapackOptions.java

@@ -14,7 +14,7 @@
 import java.util.Random;
 
 public class GuiSeedMapperDatapackOptions extends GuiScreenMinimap {
-    private static final List<String> COLOR_SCHEMES = List.of("Random", "HSV", "Bright HSV");
+    private static final List<String> COLOR_SCHEMES = List.of("Palette Random", "Highly Saturated", "Vibrant");
     private static final List<String> ICON_STYLES = List.of("Default", "Large", "Potion");
     private static final int[] COLOR_COUNTS = {32, 64, 128, 256};
 
@@ -62,12 +62,20 @@ public void init() {
         y += 24;
         randomColorsButton = addRenderableWidget(new Button.Builder(Component.empty(), button -> {
             cycleRandomColorCount();
+            settings.datapackRandomColorCycle = 0;
+            settings.datapackColorScheme = 1;
             refreshLabels();
             MapSettingsManager.instance.saveAll();
         }).bounds(left, y, 150, 20).build());
 
         regenerateColorsButton = addRenderableWidget(new Button.Builder(Component.literal("Regenerate Colors"), button -> {
-            regenerateColors(settings.getDatapackRandomColors().size());
+            if (settings.getDatapackRandomColors().isEmpty()) {
+                regenerateColors(COLOR_COUNTS[0]);
+                settings.datapackRandomColorCycle = 0;
+            } else {
+                settings.cycleDatapackRandomColors();
+            }
+            settings.datapackColorScheme = 1;
             refreshLabels();
             MapSettingsManager.instance.saveAll();
         }).bounds(right, y, 150, 20).build());
@@ -97,14 +105,20 @@ private void refreshLabels() {
         colorSchemeButton.setMessage(Component.literal("Color Scheme: " + COLOR_SCHEMES.get(Math.max(0, Math.min(COLOR_SCHEMES.size() - 1, settings.datapackColorScheme - 1)))));
         iconStyleButton.setMessage(Component.literal("Icon Style: " + ICON_STYLES.get(Math.max(0, Math.min(ICON_STYLES.size() - 1, settings.datapackIconStyle - 1)))));
         randomColorsButton.setMessage(Component.literal("Random Colors: " + settings.getDatapackRandomColors().size()));
-        structureDisabledButton.setMessage(Component.literal("Structure Disabled: " + countDisabledStructures()));
+        structureDisabledButton.setMessage(Component.literal("Datapack Structures: " + countEnabledStructures() + " shown"));
         savedUrlsButton.setMessage(Component.literal("Saved URLs"));
         savedCachePathsButton.setMessage(Component.literal("Saved Cache Paths"));
     }
 
-    private int countDisabledStructures() {
+    private int countEnabledStructures() {
         String worldKey = currentWorldKey();
-        return settings.getDisabledDatapackStructures(worldKey).size();
+        long seed = Long.MIN_VALUE;
+        try {
+            seed = settings.resolveSeed(VoxelConstants.getVoxelMapInstance().getWorldSeed());
+        } catch (IllegalArgumentException ignored) {
+        }
+        int total = SeedMapperDatapackManager.readImportedStructureIds(settings.datapackCachePath, seed).size();
+        return Math.max(0, total - settings.getDisabledDatapackStructures(worldKey).size());
     }
 
     private void cycleRandomColorCount() {

common/src/main/java/com/mamiyaotaru/voxelmap/gui/GuiSeedMapperDatapackStructures.java

@@ -45,7 +45,12 @@ public void init() {
 
     private void reloadEntries() {
         structureIds.clear();
-        structureIds.addAll(SeedMapperDatapackManager.readImportedStructureIds(settings.datapackCachePath));
+        long seed = Long.MIN_VALUE;
+        try {
+            seed = settings.resolveSeed(VoxelConstants.getVoxelMapInstance().getWorldSeed());
+        } catch (IllegalArgumentException ignored) {
+        }
+        structureIds.addAll(SeedMapperDatapackManager.readImportedStructureIds(settings.datapackCachePath, seed));
         structureIds.sort(Comparator.comparing(s -> s, String.CASE_INSENSITIVE_ORDER));
         clampScroll();
         refreshButtons();

common/src/main/java/com/mamiyaotaru/voxelmap/persistent/GuiPersistentMap.java

@@ -1856,13 +1856,21 @@ private void drawSeedMapperFeatureStrip(GuiGraphicsExtractor graphics, int mouse
         int x = startX + titleWidth + stripPad + 8;
         int contentEnd = this.width - this.sideMargin - 6;
         int perPage = Math.max(1, (contentEnd - x) / (iconSize + gap));
-        List<SeedMapperFeature> visibleFeatures = new ArrayList<>();
+        List<LegendEntry> visibleEntries = new ArrayList<>();
         for (SeedMapperFeature feature : SeedMapperFeature.values()) {
+            if (feature == SeedMapperFeature.DATAPACK_STRUCTURE) {
+                continue;
+            }
             if (featureMatchesDimension(feature, currentDimension) && isSeedMapperFeatureVisible(feature)) {
-                visibleFeatures.add(feature);
+                visibleEntries.add(LegendEntry.feature(feature));
+            }
+        }
+        if (seedMapperOptions.datapackEnabled && seedMapperOptions.isFeatureEnabled(SeedMapperFeature.DATAPACK_STRUCTURE)) {
+            for (String structureId : visibleDatapackLegendStructureIds()) {
+                visibleEntries.add(LegendEntry.datapack(structureId));
             }
         }
-        SeedMapperFeature[] all = visibleFeatures.toArray(SeedMapperFeature[]::new);
+        LegendEntry[] all = visibleEntries.toArray(LegendEntry[]::new);
         seedMapperLegendMaxPage = Math.max(0, (all.length - 1) / perPage);
         if (seedMapperLegendPage > seedMapperLegendMaxPage) {
             seedMapperLegendPage = seedMapperLegendMaxPage;
@@ -1871,8 +1879,8 @@ private void drawSeedMapperFeatureStrip(GuiGraphicsExtractor graphics, int mouse
         int startIndex = seedMapperLegendPage * perPage;
         int endIndex = Math.min(all.length, startIndex + perPage);
         for (int i = startIndex; i < endIndex; i++) {
-            SeedMapperFeature feature = all[i];
-            seedMapperIconHitboxes.add(new FeatureIconHitbox(feature, x, y + (barHeight - iconSize) / 2, iconSize));
+            LegendEntry entry = all[i];
+            seedMapperIconHitboxes.add(new FeatureIconHitbox(entry.feature(), entry.datapackStructureId(), x, y + (barHeight - iconSize) / 2, iconSize));
             x += iconSize + gap;
         }
 
@@ -1918,13 +1926,19 @@ private void drawSeedMapperFeatureStrip(GuiGraphicsExtractor graphics, int mouse
         if (!seedMapperIconHitboxes.isEmpty()) {
             for (FeatureIconHitbox hitbox : seedMapperIconHitboxes) {
                 SeedMapperFeature feature = hitbox.feature();
-                boolean enabled = isFeatureEnabledInPanel(feature);
+                boolean datapackStructure = hitbox.datapackStructureId() != null;
+                boolean enabled = datapackStructure || isFeatureEnabledInPanel(feature);
                 int color = enabled ? 0xFFFFFFFF : 0x55FFFFFF;
-                VoxelMapGuiGraphics.blitFloat(graphics, RenderPipelines.GUI_TEXTURED, feature.icon(), hitbox.x(), hitbox.y(), iconSize, iconSize, 0, 1, 0, 1, color);
+                if (datapackStructure) {
+                    drawDatapackLegendIcon(graphics, hitbox.datapackStructureId(), hitbox.x(), hitbox.y(), iconSize);
+                } else {
+                    VoxelMapGuiGraphics.blitFloat(graphics, RenderPipelines.GUI_TEXTURED, feature.icon(), hitbox.x(), hitbox.y(), iconSize, iconSize, 0, 1, 0, 1, color);
+                }
                 if (mouseX >= hitbox.x() && mouseX <= hitbox.x() + iconSize && mouseY >= hitbox.y() && mouseY <= hitbox.y() + iconSize) {
                     graphics.requestCursor(CursorTypes.CROSSHAIR);
-                    Component tooltip = Component.translatable(feature.translationKey())
-                            .append(Component.literal(enabled ? " (ON)" : " (OFF)"));
+                    Component tooltip = datapackStructure
+                            ? Component.literal(hitbox.datapackStructureId() + " (ON)")
+                            : Component.translatable(feature.translationKey()).append(Component.literal(enabled ? " (ON)" : " (OFF)"));
                     renderTooltip(graphics, tooltip, mouseX, mouseY);
                 }
             }
@@ -1961,6 +1975,13 @@ private boolean handleSeedMapperIconClick(int mouseX, int mouseY) {
         }
         for (FeatureIconHitbox hitbox : seedMapperIconHitboxes) {
             if (hitbox.contains(mouseX, mouseY)) {
+                if (hitbox.datapackStructureId() != null) {
+                    seedMapperOptions.setDatapackStructureEnabled(currentSeedMapperWorldKey(), hitbox.datapackStructureId(), false);
+                    seedMapperSavedToggles = null;
+                    seedMapperIsolatedFeature = null;
+                    MapSettingsManager.instance.saveAll();
+                    return true;
+                }
                 boolean ctrlDown = isCtrlDown();
                 SeedMapperFeature clicked = hitbox.feature();
                 if (isPortalFeature(clicked)) {
@@ -2027,6 +2048,37 @@ private boolean isSeedMapperFeatureVisible(SeedMapperFeature feature) {
         return true;
     }
 
+    private List<String> visibleDatapackLegendStructureIds() {
+        long seed;
+        try {
+            seed = seedMapperOptions.resolveSeed(VoxelConstants.getVoxelMapInstance().getWorldSeed());
+        } catch (IllegalArgumentException ignored) {
+            return List.of();
+        }
+        String worldKey = currentSeedMapperWorldKey();
+        Set<String> disabled = seedMapperOptions.getDisabledDatapackStructures(worldKey);
+        ArrayList<String> ids = new ArrayList<>();
+        for (String id : SeedMapperImportedDatapackManager.importedStructureIds(seedMapperOptions.datapackCachePath, seed)) {
+            if (!disabled.contains(id)) {
+                ids.add(id);
+            }
+        }
+        return ids;
+    }
+
+    private void drawDatapackLegendIcon(GuiGraphicsExtractor graphics, String structureId, int x, int y, int iconSize) {
+        int color = SeedMapperImportedDatapackManager.colorForStructureId(structureId);
+        if (SeedMapperImportedDatapackManager.usesPotionIcon()) {
+            Identifier potion = SeedMapperImportedDatapackManager.iconForStructureId(structureId);
+            Identifier overlay = SeedMapperImportedDatapackManager.iconOverlayForStructureId(structureId);
+            VoxelMapGuiGraphics.blitFloat(graphics, RenderPipelines.GUI_TEXTURED, potion, x, y, iconSize, iconSize, 0, 1, 0, 1, 0xFFFFFFFF);
+            VoxelMapGuiGraphics.blitFloat(graphics, RenderPipelines.GUI_TEXTURED, overlay, x, y, iconSize, iconSize, 0, 1, 0, 1, color);
+            return;
+        }
+        graphics.fill(x - 1, y - 1, x + iconSize + 1, y + iconSize + 1, 0xFF000000);
+        graphics.fill(x, y, x + iconSize, y + iconSize, color);
+    }
+
     private boolean isPortalFeature(SeedMapperFeature feature) {
         return feature == SeedMapperFeature.NETHER_PORTAL
                 || feature == SeedMapperFeature.END_PORTAL
@@ -2685,7 +2737,17 @@ private void centerOnWorldSpawn() {
         }
     }
 
-    private record FeatureIconHitbox(SeedMapperFeature feature, int x, int y, int size) {
+    private record LegendEntry(SeedMapperFeature feature, String datapackStructureId) {
+        private static LegendEntry feature(SeedMapperFeature feature) {
+            return new LegendEntry(feature, null);
+        }
+
+        private static LegendEntry datapack(String structureId) {
+            return new LegendEntry(SeedMapperFeature.DATAPACK_STRUCTURE, structureId);
+        }
+    }
+
+    private record FeatureIconHitbox(SeedMapperFeature feature, String datapackStructureId, int x, int y, int size) {
         private boolean contains(int mouseX, int mouseY) {
             return mouseX >= x && mouseX <= x + size && mouseY >= y && mouseY <= y + size;
         }

common/src/main/java/com/mamiyaotaru/voxelmap/seedmapper/SeedMapperDatapackManager.java

@@ -55,9 +55,19 @@ public static ImportResult importFromUrl(String urlString) throws IOException {
     }
 
     public static List<String> readImportedStructureIds(String datapackRootPath) {
+        return readImportedStructureIds(datapackRootPath, Long.MIN_VALUE);
+    }
+
+    public static List<String> readImportedStructureIds(String datapackRootPath, long seed) {
         if (datapackRootPath == null || datapackRootPath.isBlank()) {
             return List.of();
         }
+        if (seed != Long.MIN_VALUE) {
+            List<String> worldgenIds = SeedMapperImportedDatapackManager.importedStructureIds(datapackRootPath, seed);
+            if (!worldgenIds.isEmpty()) {
+                return worldgenIds;
+            }
+        }
         Path root = Path.of(datapackRootPath);
         if (!Files.isDirectory(root)) {
             return List.of();