Merge upstream/master with curated conflict resolution

Author: cev-api

buildSrc/src/main/java/dev/xpple/seedmapper/buildscript/CreateJavaBindingsTask.java

@@ -3,6 +3,10 @@
 import org.apache.tools.ant.taskdefs.condition.Os;
 import org.gradle.api.tasks.Exec;
 
+import java.io.File;
+import java.util.Arrays;
+import java.util.stream.Collectors;
+
 public abstract class CreateJavaBindingsTask extends Exec {
 
     private static final String EXTENSION = Os.isFamily(Os.FAMILY_WINDOWS) ? ".bat" : "";
@@ -13,6 +17,20 @@ public abstract class CreateJavaBindingsTask extends Exec {
 
         this.setWorkingDir(this.getProject().getRootDir());
         this.setStandardOutput(System.out);
+        // Avoid inheriting MSYS/MinGW include env vars that conflict with jextract's clang on Windows.
+        this.environment("INCLUDE", "");
+        this.environment("CPATH", "");
+        this.environment("C_INCLUDE_PATH", "");
+        this.environment("CPLUS_INCLUDE_PATH", "");
+        this.environment("LIBRARY_PATH", "");
+        String path = System.getenv("PATH");
+        if (path != null && !path.isBlank()) {
+            String separator = File.pathSeparator;
+            String sanitizedPath = Arrays.stream(path.split(java.util.regex.Pattern.quote(separator)))
+                .filter(entry -> !entry.toLowerCase().contains("msys64"))
+                .collect(Collectors.joining(separator));
+            this.environment("PATH", sanitizedPath);
+        }
         this.commandLine(
             "./jextract/build/jextract/bin/jextract" + EXTENSION,
             "--include-dir", "src/main/c/cubiomes/jextract-compat",

changelog.md

@@ -1,6 +1,7 @@
 ## Changelog
-- Re-enabled Baritone integration.
-- Fixed carver highlighting on 1.17.1 and below.
+- Made block colors configurable (`/sm:config BlockColors`).
+- Added ore debug highlighting (`/sm:highlight ore`).
+- Fixed Pale Garden biome issue for 1.21.5+.
 
 ## Mod compatibility
 |      | Mod JAR | Biomes | Structures | Loot | Ores | Slime chunks |

gradle.properties

@@ -3,8 +3,8 @@ org.gradle.jvmargs=-Xmx1G
 org.gradle.parallel=true
 
 # Mod Properties
-mod_version=2.22.3-CevAPI
-fork_release_version=v0.20
+mod_version=2.23.0-CevAPI
+fork_release_version=v0.21
 maven_group=dev.xpple
 archives_base_name=SeedMapper
 

src/main/c/cubiomes

@@ -4,6 +4,7 @@
 import com.mojang.brigadier.CommandDispatcher;
 import com.mojang.logging.LogUtils;
 import dev.xpple.betterconfig.api.ModConfigBuilder;
+import dev.xpple.seedmapper.command.arguments.ColorWrapperArgument;
 import dev.xpple.seedmapper.command.arguments.DurationArgument;
 import dev.xpple.seedmapper.command.arguments.MapFeatureArgument;
 import dev.xpple.seedmapper.command.arguments.SeedIdentifierArgument;
@@ -21,6 +22,8 @@
 import dev.xpple.seedmapper.command.commands.SourceCommand;
 import dev.xpple.seedmapper.command.commands.StopTaskCommand;
 import dev.xpple.seedmapper.command.commands.DatapackImportCommand;
+import dev.xpple.seedmapper.config.ColorWrapper;
+import dev.xpple.seedmapper.config.ColorWrapperAdapter;
 import dev.xpple.seedmapper.config.Configs;
 import dev.xpple.seedmapper.config.DurationAdapter;
 import dev.xpple.seedmapper.config.MapFeatureAdapter;
@@ -88,6 +91,7 @@ public void onInitializeClient() {
             .registerType(SeedResolutionArgument.SeedResolution.class, new SeedResolutionAdapter(), SeedResolutionArgument::seedResolution)
             .registerTypeHierarchy(MapFeature.class, new MapFeatureAdapter(), MapFeatureArgument::mapFeature)
             .registerType(Duration.class, new DurationAdapter(), DurationArgument::duration)
+            .registerType(ColorWrapper.class, new ColorWrapperAdapter(), ColorWrapperArgument::colorWrapper)
             .registerGlobalChangeHook(event -> {
                 if (event.config().equals("DevMode")) {
                     try {

src/main/java/dev/xpple/seedmapper/SeedMapper.java

@@ -19,7 +19,8 @@ private CommandExceptions() {
     public static final DynamicCommandExceptionType UNKNOWN_STRUCTURE_PIECE_EXCEPTION = new DynamicCommandExceptionType(arg -> Component.translatable("commands.exceptions.unknownStructurePiece", arg));
     public static final DynamicCommandExceptionType UNKNOWN_VARIANT_KEY_EXCEPTION = new DynamicCommandExceptionType(arg -> Component.translatable("commands.exceptions.unknownVariantKey", arg));
     public static final DynamicCommandExceptionType UNKNOWN_VARIANT_VALUE_EXCEPTION = new DynamicCommandExceptionType(arg -> Component.translatable("commands.exceptions.unknownVariantValue", arg));
-    public static final DynamicCommandExceptionType UNKNOWN_BLOCK_EXCEPTION = new DynamicCommandExceptionType(arg -> Component.translatable("commands.exceptions.unknownOre", arg));
+    public static final DynamicCommandExceptionType UNKNOWN_BLOCK_EXCEPTION = new DynamicCommandExceptionType(arg -> Component.translatable("commands.exceptions.unknownBlock", arg));
+    public static final DynamicCommandExceptionType UNKNOWN_ORE_EXCEPTION = new DynamicCommandExceptionType(arg -> Component.translatable("commands.exceptions.unknownOre", arg));
     public static final DynamicCommandExceptionType UNKNOWN_ITEM_EXCEPTION = new DynamicCommandExceptionType(arg -> Component.translatable("commands.exceptions.unknownItem", arg));
     public static final DynamicCommandExceptionType UNKNOWN_ENCHANTMENT_EXCEPTION = new DynamicCommandExceptionType(arg -> Component.translatable("commands.exceptions.unknownEnchantment", arg));
     public static final DynamicCommandExceptionType UNKNOWN_CANYON_CARVER_EXCEPTION = new DynamicCommandExceptionType(arg -> Component.translatable("commands.exceptions.unknownCanyonCarver", arg));

src/main/java/dev/xpple/seedmapper/command/CommandExceptions.java

@@ -0,0 +1,26 @@
+package dev.xpple.seedmapper.command.arguments;
+
+import com.mojang.brigadier.context.CommandContext;
+import dev.xpple.betterconfig.util.WrappedArgumentType;
+import dev.xpple.seedmapper.config.ColorWrapper;
+import net.fabricmc.fabric.api.client.command.v2.FabricClientCommandSource;
+import net.minecraft.commands.arguments.HexColorArgument;
+
+public class ColorWrapperArgument extends WrappedArgumentType.Converted<ColorWrapper, Integer> {
+    private ColorWrapperArgument() {
+        super(HexColorArgument.hexColor());
+    }
+
+    public static ColorWrapperArgument colorWrapper() {
+        return new ColorWrapperArgument();
+    }
+
+    public static ColorWrapper getBlock(CommandContext<FabricClientCommandSource> context, String name) {
+        return context.getArgument(name, ColorWrapper.class);
+    }
+
+    @Override
+    public ColorWrapper convert(Integer nativeType) {
+        return new ColorWrapper(nativeType);
+    }
+}

src/main/java/dev/xpple/seedmapper/command/arguments/ColorWrapperArgument.java

@@ -0,0 +1,58 @@
+package dev.xpple.seedmapper.command.arguments;
+
+import com.github.cubiomes.Cubiomes;
+import com.mojang.brigadier.StringReader;
+import com.mojang.brigadier.arguments.ArgumentType;
+import com.mojang.brigadier.context.CommandContext;
+import com.mojang.brigadier.exceptions.CommandSyntaxException;
+import com.mojang.brigadier.suggestion.Suggestions;
+import com.mojang.brigadier.suggestion.SuggestionsBuilder;
+import dev.xpple.seedmapper.command.CommandExceptions;
+import net.fabricmc.fabric.api.client.command.v2.FabricClientCommandSource;
+import net.minecraft.commands.SharedSuggestionProvider;
+
+import java.util.Collection;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.CompletableFuture;
+import java.util.stream.Collectors;
+import java.util.stream.IntStream;
+
+public class OreArgument implements ArgumentType<Integer> {
+
+    private static final Collection<String> EXAMPLES = List.of("ore_quartz_deltas", "ore_redstone_lower", "ore_tuff");
+
+    public static final Map<String, Integer> ORES = IntStream.range(0, Cubiomes.ORE_NUM())
+        .boxed()
+        .collect(Collectors.toUnmodifiableMap(ore -> Cubiomes.ore2str(ore).getString(0), ore -> ore));
+
+    public static OreArgument ore() {
+        return new OreArgument();
+    }
+
+    public static Integer getOre(CommandContext<FabricClientCommandSource> context, String name) {
+        return context.getArgument(name, Integer.class);
+    }
+
+    @Override
+    public Integer parse(StringReader reader) throws CommandSyntaxException {
+        int cursor = reader.getCursor();
+        String oreString = reader.readUnquotedString();
+        Integer ore = ORES.get(oreString);
+        if (ore == null) {
+            reader.setCursor(cursor);
+            throw CommandExceptions.UNKNOWN_ORE_EXCEPTION.create(oreString);
+        }
+        return ore;
+    }
+
+    @Override
+    public <S> CompletableFuture<Suggestions> listSuggestions(CommandContext<S> context, SuggestionsBuilder builder) {
+        return SharedSuggestionProvider.suggest(ORES.keySet(), builder);
+    }
+
+    @Override
+    public Collection<String> getExamples() {
+        return EXAMPLES;
+    }
+}

src/main/java/dev/xpple/seedmapper/command/arguments/OreArgument.java

@@ -17,8 +17,8 @@
 import dev.xpple.seedmapper.SeedMapper;
 import dev.xpple.seedmapper.command.CommandExceptions;
 import dev.xpple.seedmapper.command.CustomClientCommandSource;
+import dev.xpple.seedmapper.command.arguments.OreArgument;
 import dev.xpple.seedmapper.config.Configs;
-import dev.xpple.seedmapper.feature.OreTypes;
 import dev.xpple.seedmapper.render.RenderManager;
 import dev.xpple.seedmapper.render.esp.EspStyle;
 import dev.xpple.seedmapper.util.BaritoneIntegration;
@@ -45,7 +45,6 @@
 import java.util.HashSet;
 import java.util.List;
 import java.util.Map;
-import java.util.Objects;
 import java.util.Set;
 import java.util.stream.Collectors;
 import java.util.stream.IntStream;
@@ -54,6 +53,7 @@
 import static dev.xpple.seedmapper.command.arguments.BlockArgument.*;
 import static dev.xpple.seedmapper.command.arguments.CanyonCarverArgument.*;
 import static dev.xpple.seedmapper.command.arguments.CaveCarverArgument.*;
+import static dev.xpple.seedmapper.command.arguments.OreArgument.*;
 import static dev.xpple.seedmapper.thread.LocatorThreadHelper.*;
 import static dev.xpple.seedmapper.util.ChatBuilder.*;
 import static net.fabricmc.fabric.api.client.command.v2.ClientCommands.*;
@@ -67,6 +67,12 @@ public static void register(CommandDispatcher<FabricClientCommandSource> dispatc
                     .executes(ctx -> highlightBlock(CustomClientCommandSource.of(ctx.getSource()), getBlock(ctx, "block")))
                     .then(argument("chunks", integer(0, 20))
                         .executes(ctx -> submit(() -> highlightBlock(CustomClientCommandSource.of(ctx.getSource()), getBlock(ctx, "block"), getInteger(ctx, "chunks")))))))
+            .then(literal("ore")
+                .requires(_ -> Configs.DevMode)
+                .then(argument("ore", ore())
+                    .executes(ctx -> highlightOre(CustomClientCommandSource.of(ctx.getSource()), getOre(ctx, "ore").intValue()))
+                    .then(argument("chunks", integer(0, 20))
+                        .executes(ctx -> submit(() -> highlightOre(CustomClientCommandSource.of(ctx.getSource()), getOre(ctx, "ore").intValue(), getInteger(ctx, "chunks")))))))
             .then(literal("orevein")
                 .executes(ctx -> submit(() -> highlightOreVein(CustomClientCommandSource.of(ctx.getSource()))))
                 .then(argument("chunks", integer(0, 20))
@@ -96,6 +102,7 @@ private static int highlightBlock(CustomClientCommandSource source, Pair<Integer
 
     private static int highlightBlock(CustomClientCommandSource source, Pair<Integer, Integer> blockPair, int chunkRange) throws CommandSyntaxException {
         RenderManager.clear();
+        int block = blockPair.getFirst();
         SeedIdentifier seed = source.getSeed().getSecond();
         int version = source.getVersion();
         int dimension = source.getDimension();
@@ -124,7 +131,7 @@ private static int highlightBlock(CustomClientCommandSource source, Pair<Integer
                         .boxed()
                         .toList();
                 }
-                OreTypes.ORE_TYPES.stream()
+                OreArgument.ORES.values().stream()
                     .filter(oreType -> biomes.stream().anyMatch(biome -> Cubiomes.isViableOreBiome(version, oreType, biome) != 0))
                     .<MemorySegment>mapMulti((oreType, consumer) -> {
                         MemorySegment oreConfig = OreConfig.allocate(arena);
@@ -145,10 +152,11 @@ private static int highlightBlock(CustomClientCommandSource source, Pair<Integer
                             for (int i = 0; i < size; i++) {
                                 MemorySegment pos3 = Pos3.asSlice(pos3s, i);
                                 BlockPos pos = new BlockPos(Pos3.x(pos3), Pos3.y(pos3), Pos3.z(pos3));
-                                if (doAirCheck && isAirOrLava(chunk, pos)) {
+                                if (doAirCheck && !chunk.getBlockState(pos).canOcclude()) {
                                     continue;
                                 }
                                 Integer previouslyGeneratedOre = generatedOres.get(pos);
+                                // if there is already an ore at this position, check if this ore can replace it
                                 if (previouslyGeneratedOre != null) {
                                     boolean contains = false;
                                     for (int j = 0; j < numReplaceBlocks; j++) {
@@ -169,15 +177,14 @@ private static int highlightBlock(CustomClientCommandSource source, Pair<Integer
                         }
                     });
 
-                int block = blockPair.getFirst();
-                int colour = blockPair.getSecond();
+                int color = Configs.BlockColors.getOrDefault(block, 0xFFFFFF);
                 List<BlockPos> blockOres = generatedOres.entrySet().stream()
                     .filter(entry -> entry.getValue() == block)
                     .map(Map.Entry::getKey)
                     .toList();
                 count[0] += blockOres.size();
                 source.getClient().schedule(() -> {
-                    RenderManager.drawBoxes(blockOres, Configs.BlockHighlightESP, colour);
+                    RenderManager.drawBoxes(blockOres, color);
                     if (SeedMapper.BARITONE_AVAILABLE && Configs.AutoMine) {
                         BaritoneIntegration.addGoals(blockOres);
                     }
@@ -192,6 +199,70 @@ private static int highlightBlock(CustomClientCommandSource source, Pair<Integer
         }
     }
 
+    private static int highlightOre(CustomClientCommandSource source, int ore) throws CommandSyntaxException {
+        return highlightOre(source, ore, 0);
+    }
+
+    private static int highlightOre(CustomClientCommandSource source, int ore, int chunkRange) throws CommandSyntaxException {
+        SeedIdentifier seed = source.getSeed().getSecond();
+        int version = source.getVersion();
+        int dimension = source.getDimension();
+
+        try (Arena arena = Arena.ofConfined()) {
+            MemorySegment generator = Generator.allocate(arena);
+            Cubiomes.setupGenerator(generator, version, source.getGeneratorFlags());
+            Cubiomes.applySeed(generator, dimension, seed.seed());
+            MemorySegment surfaceNoise = SurfaceNoise.allocate(arena);
+            Cubiomes.initSurfaceNoise(surfaceNoise, dimension, seed.seed());
+
+            ChunkPos center = ChunkPos.containing(BlockPos.containing(source.getPosition()));
+
+            int[] count = {0};
+            SpiralLoop.spiral(center.x(), center.z(), chunkRange, (chunkX, chunkZ) -> {
+                List<Integer> biomes;
+                if (version <= Cubiomes.MC_1_17()) {
+                    biomes = List.of(Cubiomes.getBiomeForOreGen(generator, chunkX, chunkZ, 0));
+                } else {
+                    // check certain Y-coordinates that matter for ore generation
+                    // Minecraft checks _all_ biomes in a 3x3 square of chunks, which is not necessary
+                    biomes = IntStream.of(-30, 64, 120)
+                        .map(y -> Cubiomes.getBiomeForOreGen(generator, chunkX, chunkZ, y))
+                        .boxed()
+                        .toList();
+                }
+
+                if (biomes.stream().noneMatch(biome -> Cubiomes.isViableOreBiome(version, ore, biome) != 0)) {
+                    return false;
+                }
+
+                MemorySegment oreConfig = OreConfig.allocate(arena);
+                // just do biomes.getFirst() because in 1.17 there is only one, and in 1.18 it does not matter
+                if (Cubiomes.getOreConfig(ore, version, biomes.getFirst(), oreConfig) == 0) {
+                    return false;
+                }
+
+                Set<BlockPos> ores = new HashSet<>();
+                MemorySegment pos3List = Cubiomes.generateOres(arena, generator, surfaceNoise, oreConfig, chunkX, chunkZ);
+                try {
+                    MemorySegment pos3s = Pos3List.pos3s(pos3List);
+                    for (int i = 0; i < Pos3List.size(pos3List); i++) {
+                        MemorySegment pos3 = Pos3.asSlice(pos3s, i);
+                        ores.add(new BlockPos(Pos3.x(pos3), Pos3.y(pos3), Pos3.z(pos3)));
+                    }
+                } finally {
+                    Cubiomes.freePos3List(pos3List);
+                }
+                count[0] += ores.size();
+                RenderManager.drawBoxes(ores, Configs.BlockColors.getOrDefault(OreConfig.oreBlock(oreConfig), 0xFFFFFF));
+                source.sendFeedback(Component.translatable("command.highlight.block.chunkSuccess", accent(String.valueOf(ores.size())), ComponentUtils.formatXZ(chunkX, chunkZ)));
+                return false;
+            });
+
+            source.getClient().schedule(() -> source.sendFeedback(Component.translatable("command.highlight.block.success", accent(String.valueOf(count[0])))));
+            return count[0];
+        }
+    }
+
     private static int highlightOreVein(CustomClientCommandSource source) throws CommandSyntaxException {
         return highlightOreVein(source, 0);
     }
@@ -240,8 +311,8 @@ private static int highlightOreVein(CustomClientCommandSource source, int chunkR
                         return;
                     }
                     count[0] += positions.size();
-                    int colour = BLOCKS.values().stream().filter(pair -> Objects.equals(block, pair.getFirst())).findAny().orElseThrow().getSecond();
-                    RenderManager.drawBoxes(positions, Configs.OreVeinESP, colour);
+                    int color = Configs.BlockColors.getOrDefault(block, 0xFFFFFF);
+                    RenderManager.drawBoxes(positions, color);
                     if (SeedMapper.BARITONE_AVAILABLE && Configs.AutoMine) {
                         BaritoneIntegration.addGoals(positions);
                     }