SeedMapper Fork on J23

Author: cev-api

README.md

@@ -1,106 +1,98 @@
-**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.18.x (MC1.21.11) - 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`
+## Compiling & Running
 
-Sometimes it may be necessary to click the option for skipping the Java compatibility check.
+Follow original instructions.
 
-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.
+### Zoom
+Zoom further out on the SeedMap. Limited to approx 30,000x30,000. I suggest enabling the clear cache setting below.
 
-## Features
-Before using any of these commands, make sure the seed has been configured using `/sm:config Seed set <seed>`.
+![Zoomies](https://i.imgur.com/utIgDkp.png)
 
-### Seed map
-Usage: `/sm:seedmap`
+### Directional Arrow
+Around your player icon in the SeedMap there will be a little arrow showing you which direction you're facing. This is toggleable with ```/sm:config ShowPlayerDirectionArrow```.
 
-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!
+![Arrow](https://i.imgur.com/pkodE8d.png)
 
-### Biome locating
-Usage: `/sm:locate biome <biome>`.
+### World Presets
 
-Locates a given biome closest to the player. All biomes in all dimensions are supported.
+If the server you're on uses anything other than the default world preset (Amplified, Superflat, Large Biomes, Single Biome) this will greatly change the world generation. Change the preset to match the server in order to produce an accurate seedmap.
 
-### Structure locating
-Usage: `/sm:locate feature <structure>[<pieces>]{<variants>}`.
+- /sm:preset list — show available presets  
+- /sm:preset set <id> — set SeedMapper’s preset 
 
-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]`.
+### Seed Map Minimap
 
-### Ore vein locating
-Usage: `/sm:locate orevein (copper|iron)`.
+- Run ``` /sm:minimap ``` to open a live SeedMap minimap in the top-left corner of the HUD.  
+  - Use ``` /sm:minimap on/off ``` or  to explicitly control whether it is shown.
 
-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.
+- The minimap:
+  - Renders the same features you selected on the main map.
+  - Tracks your current position in real time.
+  - Ideal for overlaying over Xaeros Minimap (Default settings suits size 152).
 
-### Loot locating
-Usage: `/sm:locate loot <amount> <item> [<enchantment conditions>]`.
+- Position & size:
+  - Move it horizontally with ``` /sm:config SeedMapMinimapOffsetX ```
+  - Move it vertically with ``` /sm:config SeedMapMinimapOffsetY ```
+  - Change width with ``` /sm:config SeedMapMinimapWidth ```
+  - Change height with ``` /sm:config SeedMapMinimapHeight ```
 
-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`.
+- Display options:
+  - Rotate the map with the player’s facing using ``` /sm:config SeedMapMinimapRotateWithPlayer ```
+  - Adjust zoom independently from the main map via ``` /sm:config SeedMapMinimapPixelsPerBiome ```
+  - Scale feature icons with ``` /sm:config SeedMapMinimapIconScale ```
+  - Fine tune the background opacity with ``` /sm:config SeedMapMinimapOpacity ``` without affecting icon readability.
 
-### Ore highlighting
-Usage: `/sm:highlight block <block> [chunks]`.
+![Map1](https://i.imgur.com/w5U6Aux.png) ![Map2](https://i.imgur.com/MXqXY5n.png)
 
-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.
+### Memory Handling
+Added a config option ```/sm:config ClearSeedMapCachesOnClose``` to clear tiles, per‑world locations and any other relevant caches. When enabled, this prevents FPS dips from garbage collection on large caches after zooming out far and then closing the map. Opening the map again will result it in being loaded like its the first time, at smaller zoom levels this isn't a problem.
 
-### Ore vein highlighting
-Usage: `/sm:highlight orevein [chunks]`.
+### Icon Text
+When hovering over location icons in the SeedMap it will display text telling you what the locations are.
 
-Highlights ore veins in the world. Raw ore blocks that generate as part of the ore vein are highlighted distinctly. Filler blocks are ignored.
+![Text](https://i.imgur.com/A5gCXgP.png)
 
-### Slime chunk locating
-Usage: `/sm:locate slimechunk`.
+### 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~~
 
-Locates a slime chunk closest to the player. This will always be accurate.
+This has now been implemented by upstream. They have unified both End City Ships and End Cities together. I have accepted this change but altered it to retain my Elytra icon, this allows you to explicitly look only for Elytras. The command ```/sm:locate feature end_city_ship``` also still applies.
 
-### Source mutation
-Usage: `/sm:source (run)|(as <entity>)|(positioned <position>)|(rotated <rotation>)|(in <dimension>)|(versioned <version>)|(seeded <seed>)`.
+![Elytra](https://i.imgur.com/fFxoFX4.png)
 
-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!
+### Export SeedMap
+- Added **Export JSON** button on the top right of the SeedMap screen which will export all selected locations to a JSON in the folder ```SeedMapper/exports/<Server IP>_<Seed>-<Date/Time>.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.
 
-## 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.
+### Improved ESP
+Configurable ESP settings allowing for custom colors, fill and transparency.
 
-To build the mod locally, follow these steps:
+Example: ```/sm:config blockhighlightesp set outlineColor #ff0000 outlineAlpha 0.5 fillEnabled true fillColor #00ff00 fillAlpha 0.35```
 
-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`.
+![ESP](https://i.imgur.com/yYrinKW.png)
+
+### Improved Waypoints
+Supports [Wurst7-CevAPI](https://github.com/cev-api/Wurst7-CevAPI) waypoints, Xaero Waypoints and its own waypoint system via right click context menu. 
+
+Can now finally remove SeedMapper waypoints with via a right click context menu.
+
+![Map](https://i.imgur.com/1qDgQw7.png)
+
+### Highlight Timeout Setting
+Can now change the default 5 minute render timeout with ```/sm:config esptimeout```
+
+### Export Loot Table
+Can now export the entire loot table for the map you're viewing by clicking ```Export Loot``` or via commands such as ```/sm:exportLoot <radius> [dimension] [structures/all]```.
+
+This data can later be used in my LootSearch hack for [Wurst7-CevAPI](https://github.com/cev-api/Wurst7-CevAPI) which allows you to search and waypoint specific loot.
+
+Exported data will be located in ```SeedMapper/loot/<Server IP>_<Seed>-<Date/Time>.json```
 
-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.

gradle.properties

@@ -3,7 +3,7 @@ org.gradle.jvmargs=-Xmx1G
 org.gradle.parallel=true
 
 # Mod Properties
-mod_version=2.18.1
+mod_version=2.18.1-CevAPI
 maven_group=dev.xpple
 archives_base_name=seedmapper
 

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

@@ -10,55 +10,47 @@
 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.MinimapCommand;
 import dev.xpple.seedmapper.command.commands.SampleCommand;
 import dev.xpple.seedmapper.command.commands.SeedMapCommand;
 import dev.xpple.seedmapper.command.commands.SourceCommand;
 import dev.xpple.seedmapper.command.commands.StopTaskCommand;
+import dev.xpple.seedmapper.command.commands.WorldPresetCommand;
 import dev.xpple.seedmapper.config.Configs;
 import dev.xpple.seedmapper.config.MapFeatureAdapter;
 import dev.xpple.seedmapper.config.SeedResolutionAdapter;
 import dev.xpple.seedmapper.render.RenderManager;
 import dev.xpple.seedmapper.seedmap.MapFeature;
+import dev.xpple.seedmapper.seedmap.SeedMapMinimapManager;
+import dev.xpple.seedmapper.util.CubiomesNative;
 import dev.xpple.seedmapper.util.SeedDatabaseHelper;
+import dev.xpple.seedmapper.world.WorldPresetManager;
 import dev.xpple.simplewaypoints.api.SimpleWaypointsAPI;
 import net.fabricmc.api.ClientModInitializer;
 import net.fabricmc.fabric.api.client.command.v2.ClientCommandManager;
 import net.fabricmc.fabric.api.client.command.v2.ClientCommandRegistrationCallback;
 import net.fabricmc.fabric.api.client.command.v2.FabricClientCommandSource;
+import dev.xpple.seedmapper.command.CustomClientCommandSource;
 import net.fabricmc.fabric.api.client.event.lifecycle.v1.ClientTickEvents;
 import net.fabricmc.fabric.api.client.keybinding.v1.KeyBindingHelper;
-import net.fabricmc.loader.api.FabricLoader;
-import net.fabricmc.loader.api.ModContainer;
 import net.minecraft.client.KeyMapping;
 import net.minecraft.commands.CommandBuildContext;
+import net.fabricmc.loader.api.FabricLoader;
 
-import java.io.IOException;
-import java.nio.file.Files;
 import java.nio.file.Path;
-import java.nio.file.StandardCopyOption;
 
 public class SeedMapper implements ClientModInitializer {
 
     public static final String MOD_ID = "seedmapper";
 
     public static final Path modConfigPath = FabricLoader.getInstance().getConfigDir().resolve(MOD_ID);
 
-    static {
-        String libraryName = System.mapLibraryName("cubiomes");
-        ModContainer modContainer = FabricLoader.getInstance().getModContainer(MOD_ID).orElseThrow();
-        Path tempFile;
-        try {
-            tempFile = Files.createTempFile(libraryName, "");
-            Files.copy(modContainer.findPath(libraryName).orElseThrow(), tempFile, StandardCopyOption.REPLACE_EXISTING);
-        } catch (IOException e) {
-            throw new RuntimeException(e);
-        }
-        System.load(tempFile.toAbsolutePath().toString());
-    }
-
     @Override
     public void onInitializeClient() {
+        CubiomesNative.ensureLoaded();
+
         new ModConfigBuilder<>(MOD_ID, Configs.class)
             .registerType(SeedResolutionArgument.SeedResolution.class, new SeedResolutionAdapter(), SeedResolutionArgument::seedResolution)
             .registerTypeHierarchy(MapFeature.class, new MapFeatureAdapter(), MapFeatureArgument::mapFeature)
@@ -69,22 +61,32 @@ public void onInitializeClient() {
                     } catch (IllegalStateException _) {
                     }
                 }
+                if (event.config().equals("EspTimeoutMinutes")) {
+                    RenderManager.setHighlightTimeout(Configs.EspTimeoutMinutes);
+                }
             })
             .build();
 
+        WorldPresetManager.init();
+
         SimpleWaypointsAPI.getInstance().registerCommandAlias("sm:waypoint");
 
         SeedDatabaseHelper.fetchSeeds();
 
         KeyMapping keyMapping = KeyBindingHelper.registerKeyBinding(new KeyMapping("key.seedMap", InputConstants.KEY_M, KeyMapping.Category.GAMEPLAY));
+        KeyMapping minimapKeyMapping = KeyBindingHelper.registerKeyBinding(new KeyMapping("key.seedMapMinimap", InputConstants.KEY_COMMA, KeyMapping.Category.GAMEPLAY));
         ClientTickEvents.END_CLIENT_TICK.register(minecraft -> {
             while (keyMapping.consumeClick()) {
                 minecraft.player.connection.sendCommand("sm:seedmap");
             }
+            while (minimapKeyMapping.consumeClick()) {
+                minecraft.player.connection.sendCommand("sm:minimap");
+            }
         });
 
         ClientCommandRegistrationCallback.EVENT.register(SeedMapper::registerCommands);
         RenderManager.registerEvents();
+        SeedMapMinimapManager.registerHud();
     }
 
     private static void registerCommands(CommandDispatcher<FabricClientCommandSource> dispatcher, CommandBuildContext context) {
@@ -93,10 +95,25 @@ private static void registerCommands(CommandDispatcher<FabricClientCommandSource
         CheckSeedCommand.register(dispatcher);
         BuildInfoCommand.register(dispatcher);
         HighlightCommand.register(dispatcher);
+        // ensure a clear subcommand exists for sm:highlight clear
+        dispatcher.register(net.fabricmc.fabric.api.client.command.v2.ClientCommandManager.literal("sm:highlight")
+            .then(net.fabricmc.fabric.api.client.command.v2.ClientCommandManager.literal("clear")
+                .executes(ctx -> {
+                    CustomClientCommandSource source = CustomClientCommandSource.of(ctx.getSource());
+                    source.getClient().schedule(() -> {
+                        RenderManager.clear();
+                        source.sendFeedback(net.minecraft.network.chat.Component.translatable("command.highlight.clear.success"));
+                    });
+                    return 1;
+                })));
+        EspConfigCommand.register(dispatcher);
         ClearCommand.register(dispatcher);
         StopTaskCommand.register(dispatcher);
         SeedMapCommand.register(dispatcher);
+        MinimapCommand.register(dispatcher);
         DiscordCommand.register(dispatcher);
         SampleCommand.register(dispatcher);
+        WorldPresetCommand.register(dispatcher);
+        dev.xpple.seedmapper.command.commands.ExportLootCommand.register(dispatcher);
     }
 }

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

@@ -8,6 +8,8 @@
 import dev.xpple.seedmapper.command.arguments.VersionArgument;
 import dev.xpple.seedmapper.config.Configs;
 import dev.xpple.seedmapper.util.SeedDatabaseHelper;
+import dev.xpple.seedmapper.world.WorldPreset;
+import dev.xpple.seedmapper.world.WorldPresetManager;
 import net.fabricmc.fabric.api.client.command.v2.FabricClientCommandSource;
 import net.minecraft.SharedConstants;
 import net.minecraft.client.Minecraft;
@@ -158,4 +160,15 @@ public int getVersion() throws CommandSyntaxException {
         }
         return VersionArgument.version().parse(new StringReader(SharedConstants.getCurrentVersion().name()));
     }
+
+    public WorldPreset getWorldPreset() {
+        Object presetMeta = this.getMeta("world_preset");
+        if (presetMeta instanceof String presetId) {
+            WorldPreset preset = WorldPresetManager.findPreset(presetId);
+            if (preset != null) {
+                return preset;
+            }
+        }
+        return WorldPresetManager.activePreset();
+    }
 }

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

@@ -35,6 +35,10 @@ public static int getDimension(CommandContext<FabricClientCommandSource> context
         return context.getArgument(name, Integer.class);
     }
 
+    public static Integer resolveDimensionId(String name) {
+        return DIMENSIONS.get(name);
+    }
+
     @Override
     public Integer parse(StringReader reader) throws CommandSyntaxException {
         int cursor = reader.getCursor();