First Commit

Author: cev-api

README.md

@@ -1,106 +1,42 @@
-**Always** use the latest (stable) version of SeedMapper! If you want to play on an older version of Minecraft, use [ViaFabricPlus](https://modrinth.com/mod/viafabricplus). This mod allows you to use the latest features of SeedMapper, while still being able to play on older Minecraft versions.
+# Seedmapper 2.16.x (MC1.21.10)- Modified by CevAPI
 
-# SeedMapper
-In-game Minecraft Fabric mod that allows you to do various things with the world seed. For reference, have a look at the [features](#features) this mod has. Keep in mind though, this mod requires you to have access to the seed. If the seed is not known, you could crack it using [SeedCrackerX](https://github.com/19MisterX98/SeedcrackerX/) by 19MisterX98. For questions and support please head to my [Discord](https://discord.xpple.dev/).
+Original Repo: https://github.com/xpple/SeedMapper/
 
-## Installation
-1. Install the [Fabric Loader](https://fabricmc.net/use/).
-2. Download the [Fabric API](https://minecraft.curseforge.com/projects/fabric/) and move it to your mods folder:
-   - Linux/Windows: `.minecraft/mods`.
-   - Mac: `minecraft/mods`.
-3. Download SeedMapper from the [releases page](https://modrinth.com/mod/seedmapper/versions/) and move it to your mods folder.
+## Relationship to upstream
 
-## IMPORTANT
-You need to have at least Java 23 installed to use this mod. I recommend to get Java 23 (or higher) from [adoptium.net](https://adoptium.net/temurin/releases/?version=23). Next, configure your Minecraft launcher to use this release of Java.
+This project is a friendly, independent fork of Seedmapper. I have not proposed any improvements or features to the upstream but I am welcome to them incorporating my changes. I will sporatically maintain this project and re-base/sync with the upstream project.
 
-- Vanilla launcher: Go to `Installations` -> `Edit` -> `More options` -> `Java executable`.
-- MultiMC: Go to `Edit Instance` -> `Settings` -> `Java` -> `Java Installation`.
-- PrismLauncher: Go to `Settings` -> `Java` -> `Java Runtime` -> `Auto-Detect...`.
-- Modrinth App: Go to `Instance settings` -> `Java and memory` -> `Custom Java installation` -> `Browse`
+## Installation and pre-requisites
 
-Sometimes it may be necessary to click the option for skipping the Java compatibility check.
+See original [repo](https://github.com/xpple/SeedMapper) for the project. A precompiled version of my fork will be made available for download.
 
-If you are on Windows, make sure to select `javaw.exe`, not `java.exe`.
+## Improvements
 
-If you run into issues, contact your launcher's support.
+![Screenshot](https://i.imgur.com/m1lzryd.png)
 
-## Features
-Before using any of these commands, make sure the seed has been configured using `/sm:config Seed set <seed>`.
+### Java 21
+Project now builds against Java 21 LTS, however, Minecraft/Fabric must have the flag ```--enable-preview``` added to the Java arguments. 
 
-### Seed map
-Usage: `/sm:seedmap`
+This tells the JVM to accept preview bytecode and APIs. Functionally nothing else changes in Minecraft, Fabric or any of the other mods you have installed.
 
-Opens an explorable seed map based on the configured seed. You can move the map by dragging the mouse, and zoom in or out by using the scroll wheel. You can toggle what features are visible by clicking the feature toggles at the top of the screen. This command is especially useful in combination with the `/sm:source` command!
+![Flag](https://i.imgur.com/rOsP2H0.png)
 
-### Biome locating
-Usage: `/sm:locate biome <biome>`.
+### Zoom
+Zoom further out on the SeedMap
 
-Locates a given biome closest to the player. All biomes in all dimensions are supported.
+### Added Elytra/End Ship Locations
+Can now find Elytra via locating End Ships with the locate command ```/sm:locate feature end_city_ship``` or simply selecting the Elytra icon in the SeedMap
 
-### Structure locating
-Usage: `/sm:locate feature <structure>[<pieces>]{<variants>}`.
+### Export SeedMap
+- Added **Export JSON** button on the top right of the SeedMap screen which will export all selected locations to a JSON
+- Added **Export Xaero** button on the top right of the SeedMap screen which will export all selected locations into Xaero World Map waypoints for the server you're in. Disconnect from the server you're in and reconnect and the waypoints will appear in Xaero.
 
-Locates a given structure closest to the player. All structures in all dimensions are supported. However, due to limitations in the underlying library, some structures (in particular desert pyramids, jungle temples and woodland mansions) may result in occasional false positives. For more advanced querying you can also use piece and variant data to further restrict the search. For example, the following command will search for end cities with ships: `/sm:locate feature structure end_city[end_ship]`.
+### Improved ESP
 
-### Ore vein locating
-Usage: `/sm:locate orevein (copper|iron)`.
+Configurable ESP settings allowing for custom colors, fill (imperfect) and transparency.
 
-Locates an [ore vein](https://minecraft.wiki/w/Ore_vein) closest to the player. The coordinates of the first ore vein block found will be returned. After this, you can use [`/sm:highlight orevein [chunks]`](#ore-vein-highlighting) to highlight the other ores.
+Example: ```/sm:config blockhighlightesp set outlineColor #ff0000 outlineAlpha 0.5 fillEnabled true fillColor #00ff00 fillAlpha 0.35```
 
-### Loot locating
-Usage: `/sm:locate loot <amount> <item> [<enchantment conditions>]`.
+### Highlight Timeout Setting
 
-Locates chest loot closest to the player. All versions from 1.13 onwards are supported. SeedMapper will search through the chest loot of structures to find loot that matches the item and enchantment conditions. Note that queries for unobtainable loot and illegal enchantment combinations are not prevented by the command. If a search is taking too long, you should probably cancel it using `/sm:stoptask`.
-
-### Ore highlighting
-Usage: `/sm:highlight block <block> [chunks]`.
-
-Highlights the specified block in the world. All versions from 1.13 onwards are supported. Due to high dependence on the [`OCEAN_FLOOR_WG`](https://minecraft.wiki/w/Heightmap#OCEAN_FLOOR_WG) heightmap, coal, copper and emerald ore locations may be off.
-
-### Ore vein highlighting
-Usage: `/sm:highlight orevein [chunks]`.
-
-Highlights ore veins in the world. Raw ore blocks that generate as part of the ore vein are highlighted distinctly. Filler blocks are ignored.
-
-### Slime chunk locating
-Usage: `/sm:locate slimechunk`.
-
-Locates a slime chunk closest to the player. This will always be accurate.
-
-### Source mutation
-Usage: `/sm:source (run)|(as <entity>)|(positioned <position>)|(rotated <rotation>)|(in <dimension>)|(versioned <version>)|(seeded <seed>)`.
-
-Executes a given command from a modified source. For example, modifying the source's position will execute the command as if you were in that position. This command is really powerful, use it!
-
-## Building from source
-This mod internally uses (a fork of) the C library [cubiomes](https://github.com/Cubitect/cubiomes) by Cubitect. Java bindings for this library were created with (also a fork of) [jextract](https://github.com/openjdk/jextract). The bindings use the [Foreign Function & Memory API](https://openjdk.org/jeps/454) from [Project Panama](https://openjdk.org/projects/panama/). See [CreateJavaBindingsTask.java](https://github.com/xpple/SeedMapper/blob/master/buildSrc/src/main/java/dev/xpple/seedmapper/buildscript/CreateJavaBindingsTask.java) for the Gradle task that automates this.
-
-To build the mod locally, follow these steps:
-
-1. Clone the repository:
-   ```shell
-   git clone --recurse-submodules https://github.com/xpple/SeedMapper
-   cd SeedMapper
-   ```
-2. Compile cubiomes to a shared library. MSVC cannot be used to build the project! The following is for Windows:
-   ```shell
-   cd src/main/c/cubiomes
-   cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
-   cmake --build build --config Release
-   cp build/cubiomes.dll ../../resources/cubiomes.dll
-   cd ../../../../
-   ```
-3. Install LLVM (version 13.0.0 is recommended) and set the environment variable `LLVM_HOME` to the directory where LLVM was installed.
-4. Compile jextract. Again, the following is for Windows:
-   ```shell
-   cd jextract
-   ./gradlew --stacktrace -Pjdk_home="$env:JAVA_HOME" -Pllvm_home="$env:LLVM_HOME" clean verify
-   cd ../
-   ```
-5. Build the mod:
-   ```shell
-   ./gradlew build
-   ```
-   You should find the Java bindings in `src/main/java/com/github/cubiomes`.
-
-Lastly, you can also consult the [GitHub Actions workflow file](https://github.com/xpple/SeedMapper/blob/master/.github/workflows/build.yml), which contains complete build instructions for each major OS.
+Can now change the default 5 minute render timeout with ```/sm:config esptimeout```

build.gradle

@@ -15,6 +15,12 @@ base {
 
 loom {
 	accessWidenerPath = file('src/main/resources/seedmapper.aw')
+
+	runs {
+		client {
+			vmArgs '--enable-preview'
+		}
+	}
 }
 
 repositories {
@@ -62,8 +68,39 @@ dependencies {
 	testRuntimeOnly 'org.junit.platform:junit-platform-launcher'
 }
 
-tasks.register('createJavaBindings', CreateJavaBindingsTask) {}
-compileJava.dependsOn('createJavaBindings')
+def regenerateBindings = (project.findProperty("seedmapperRegenerateBindings")
+		?: System.getenv("SEEDMAPPER_REGENERATE_BINDINGS")
+		?: "false").toString().toBoolean()
+
+tasks.register('createJavaBindings', CreateJavaBindingsTask) {
+	onlyIf { regenerateBindings }
+}
+
+tasks.register('postProcessJavaBindings') {
+	onlyIf { regenerateBindings }
+	dependsOn 'createJavaBindings'
+	doLast {
+		def pattern = ~/(?<=\w)\$(?:get|set|slice)/
+		fileTree('src/main/java/com/github/cubiomes').matching { include '**/*.java' }.files.each { file ->
+			def original = file.getText('UTF-8')
+			def updated = original.replaceAll(pattern, '')
+			updated = updated.replaceAll(/(public\s+static\s+[^\s]+\s+)(\w+)\(MemorySegment seg, long index\)/, '$1$2AtIndex(MemorySegment seg, long index)')
+			updated = updated.replaceAll(/(public\s+static\s+void\s+)(\w+)\(MemorySegment seg, long index,/, '$1$2AtIndex(MemorySegment seg, long index,')
+			if (updated.contains('long sizeof()') && !updated.contains('MemorySegment asSlice(MemorySegment seg, long index)')) {
+				def insertion = """
+    public static MemorySegment asSlice(MemorySegment seg, long index) {
+        return seg.asSlice(index*sizeof(), sizeof());
+    }
+"""
+				updated = updated.replaceFirst(/(?s)\n\}\s*$/, insertion + "\n}")
+			}
+			if (updated != original) {
+				file.write(updated, 'UTF-8')
+			}
+		}
+	}
+}
+compileJava.dependsOn('postProcessJavaBindings')
 
 tasks.register('generateBuildInfo', GenerateBuildInfoTask) {
 	outputFile = new File(temporaryDir, "build_info.json")
@@ -73,9 +110,10 @@ tasks.register("prodClient", ClientProductionRunTask) {
 	runDir = file("run")
 
 	jvmArgs.add("-Ddevauth.enabled=true")
+	jvmArgs.add("--enable-preview")
 
 	javaLauncher = javaToolchains.launcherFor {
-		languageVersion = JavaLanguageVersion.of(23)
+		languageVersion = JavaLanguageVersion.of(21)
 	}
 }
 
@@ -102,16 +140,26 @@ processResources {
 }
 
 tasks.withType(JavaCompile).configureEach {
-	it.options.release = 23
+	it.options.compilerArgs += '--enable-preview'
+	it.options.release = 21
 }
 
 java {
-	sourceCompatibility = JavaVersion.VERSION_23
-	targetCompatibility = JavaVersion.VERSION_23
+	sourceCompatibility = JavaVersion.VERSION_21
+	targetCompatibility = JavaVersion.VERSION_21
+
+	toolchain {
+		languageVersion = JavaLanguageVersion.of(21)
+	}
+}
+
+tasks.withType(JavaExec).configureEach {
+	it.jvmArgs '--enable-preview'
 }
 
 test {
 	useJUnitPlatform()
+	jvmArgs '--enable-preview'
 }
 
 publishing {

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

@@ -9,10 +9,10 @@ public abstract class CreateJavaBindingsTask extends Exec {
 
     {
         // always run task
-        this.getOutputs().upToDateWhen(_ -> false);
+        this.getOutputs().upToDateWhen(task -> false);
 
         this.setWorkingDir(this.getProject().getRootDir());
         this.setStandardOutput(System.out);
-        this.commandLine("./jextract/build/jextract/bin/jextract" + EXTENSION, "--include-dir", "src/main/c/cubiomes", "--output", "src/main/java", "--use-system-load-library", "--target-package", "com.github.cubiomes", "--header-class-name", "Cubiomes", "@includes.txt", "biomenoise.h", "biomes.h", "finders.h", "generator.h", "layers.h", "biomenoise.h", "biomes.h", "noise.h", "rng.h", "util.h", "quadbase.h", "xrms.h", "loot/items.h", "loot/logging.h", "loot/loot_functions.h", "loot/loot_table_context.h", "loot/loot_table_parser.h", "loot/loot_tables.h", "loot/mc_loot.h");
+        this.commandLine("./jextract/build/jextract/bin/jextract" + EXTENSION, "--include-dir", "src/main/c/cubiomes", "--output", "src/main/java", "--source", "--target-package", "com.github.cubiomes", "--header-class-name", "Cubiomes", "@includes.txt", "src/main/c/cubiomes/seedmapper_jextract.h");
     }
 }

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

@@ -27,7 +27,7 @@ public abstract class GenerateBuildInfoTask extends DefaultTask {
 
     {
         // never reuse previous outputs
-        this.getOutputs().upToDateWhen(_ -> false);
+        this.getOutputs().upToDateWhen(task -> false);
     }
 
     @TaskAction
@@ -52,10 +52,15 @@ protected void run() {
 
     private String executeCommand(Object... args) {
         ByteArrayOutputStream outputBytes = new ByteArrayOutputStream();
-        this.getExecOperations().exec(execSpec -> {
-            execSpec.setStandardOutput(outputBytes);
-            execSpec.commandLine(args);
-        }).rethrowFailure();
-        return outputBytes.toString(StandardCharsets.UTF_8).trim();
+        try {
+            this.getExecOperations().exec(execSpec -> {
+                execSpec.setStandardOutput(outputBytes);
+                execSpec.setErrorOutput(new ByteArrayOutputStream());
+                execSpec.commandLine(args);
+            }).rethrowFailure();
+            return outputBytes.toString(StandardCharsets.UTF_8).trim();
+        } catch (Exception e) {
+            return "unknown";
+        }
     }
 }

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

@@ -10,6 +10,7 @@
 import dev.xpple.seedmapper.command.commands.ClearCommand;
 import dev.xpple.seedmapper.command.commands.DiscordCommand;
 import dev.xpple.seedmapper.command.commands.HighlightCommand;
+import dev.xpple.seedmapper.command.commands.EspConfigCommand;
 import dev.xpple.seedmapper.command.commands.LocateCommand;
 import dev.xpple.seedmapper.command.commands.SampleCommand;
 import dev.xpple.seedmapper.command.commands.SeedMapCommand;
@@ -69,6 +70,9 @@ public void onInitializeClient() {
                     } catch (IllegalStateException _) {
                     }
                 }
+                if (event.config().equals("EspTimeoutMinutes")) {
+                    RenderManager.setHighlightTimeout(Configs.EspTimeoutMinutes);
+                }
             })
             .build();
 
@@ -93,6 +97,7 @@ private static void registerCommands(CommandDispatcher<FabricClientCommandSource
         CheckSeedCommand.register(dispatcher);
         BuildInfoCommand.register(dispatcher);
         HighlightCommand.register(dispatcher);
+        EspConfigCommand.register(dispatcher);
         ClearCommand.register(dispatcher);
         StopTaskCommand.register(dispatcher);
         SeedMapCommand.register(dispatcher);

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

@@ -407,7 +407,7 @@ private Parser(StringReader reader) {
         private EnchantedItem parse() throws CommandSyntaxException {
             int item = parseItem();
             // Predicate<ItemStack>
-            Predicate<MemorySegment> predicate = _ -> true;
+            Predicate<MemorySegment> predicate = segment -> true;
             if (!reader.canRead()) {
                 return new EnchantedItem(item, predicate);
             }

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

@@ -29,7 +29,7 @@
 
 public class StructurePredicateArgument implements ArgumentType<StructurePredicateArgument.StructureAndPredicate> {
 
-    private static final Collection<String> EXAMPLES = Arrays.asList("village", "end_city[end_ship]", "ruined_portal{giant=true, underground=true}", "fortress[bridge_spawner, corridor_nether_wart]");
+    private static final Collection<String> EXAMPLES = Arrays.asList("village", "end_city_ship", "ruined_portal{giant=true, underground=true}", "fortress[bridge_spawner, corridor_nether_wart]");
 
     //<editor-fold defaultstate="collapsed" desc="private static final Map<String, Integer> STRUCTURES;">
     private static final Map<String, Integer> STRUCTURES = ImmutableMap.<String, Integer>builder()
@@ -54,6 +54,7 @@ public class StructurePredicateArgument implements ArgumentType<StructurePredica
         .put("fortress", Cubiomes.Fortress())
         .put("bastion_remnant", Cubiomes.Bastion())
         .put("end_city", Cubiomes.End_City())
+        .put("end_city_ship", Cubiomes.End_City())
         .put("end_gateway", Cubiomes.End_Gateway())
         .put("end_island", Cubiomes.End_Island())
         .put("trail_ruins", Cubiomes.Trail_Ruins())
@@ -105,6 +106,11 @@ public class StructurePredicateArgument implements ArgumentType<StructurePredica
         .build();
     //</editor-fold>
 
+    private static final int END_CITY_SHIP_PIECE = STRUCTURE_PIECES.get(Cubiomes.End_City()).get("end_ship");
+    private static final PiecesPredicate HAS_END_SHIP = (numPieces, pieces) -> IntStream.range(0, numPieces)
+        .mapToObj(i -> Piece.asSlice(pieces, i))
+        .anyMatch(piece -> Piece.type(piece) == END_CITY_SHIP_PIECE);
+
     //<editor-fold defaultstate="collapsed" desc="private static final Map<String, Pair<Map<String, Integer>, Function<MemorySegment, Integer>>> GENERAL_VARIANTS;">
     private static final Map<String, Pair<Map<String, Integer>, Function<MemorySegment, Integer>>> GENERAL_VARIANTS = ImmutableMap.<String, Pair<Map<String, Integer>, Function<MemorySegment, Integer>>>builder()
         .put("biome", Pair.of(BiomeArgument.BIOMES, m -> (int) StructureVariant.biome(m)))
@@ -257,6 +263,7 @@ private static final class Parser {
 
         private final StringReader reader;
         private Consumer<SuggestionsBuilder> suggestor;
+        private PiecesPredicate defaultPiecesPredicate = (numPieces, pieces) -> true;
 
         private Parser(StringReader reader) {
             this.reader = reader;
@@ -265,7 +272,7 @@ private Parser(StringReader reader) {
         private StructureAndPredicate parse() throws CommandSyntaxException {
             int structure = parseStructure();
 
-            PiecesPredicate piecesPredicate = parsePieces(structure);
+            PiecesPredicate piecesPredicate = this.defaultPiecesPredicate.and(parsePieces(structure));
 
             VariantPredicate variantPredicate = parseVariant(structure);
 
@@ -285,6 +292,11 @@ private int parseStructure() throws CommandSyntaxException {
                 reader.setCursor(cursor);
                 throw CommandExceptions.UNKNOWN_STRUCTURE_EXCEPTION.create(structureString);
             }
+            if ("end_city_ship".equals(structureString)) {
+                this.defaultPiecesPredicate = HAS_END_SHIP;
+            } else {
+                this.defaultPiecesPredicate = (numPieces, pieces) -> true;
+            }
             return structure;
         }
 
@@ -341,7 +353,7 @@ private PiecesPredicate parsePieces(int structure) throws CommandSyntaxException
         }
 
         private VariantPredicate parseVariant(int structure) throws CommandSyntaxException {
-            VariantPredicate variantPredicate = _ -> true;
+            VariantPredicate variantPredicate = variant -> true;
             Map<String, Pair<Map<String, Integer>, Function<MemorySegment, Integer>>> specificVariantKeys = STRUCTURE_VARIANTS.get(structure);
             if (specificVariantKeys == null) {
                 return variantPredicate;