refactor: replace log usage with pluginLogger across modules and remove unused methods

Author: smartcmd

README.md

@@ -39,14 +39,14 @@ http-port: 8080
 # Recommended: 30-120 seconds depending on server performance
 # Default: 60
 update-interval: 60
-```
-
-### Configuration Options
 
-| Option            | Default | Description                                                                                 |
-|-------------------|---------|---------------------------------------------------------------------------------------------|
-| `http-port`       | 8080    | Port for the web interface. The map will be accessible at `http://localhost:<port>`         |
-| `update-interval` | 60      | Interval in seconds between processing modified chunks. Lower = faster updates but more CPU |
+# Whether to render blocks underwater
+# If disabled (false), water surfaces will show biome water color directly
+# If enabled (true), underwater blocks will be visible with water tint applied
+# Disabling this can improve map readability in ocean/river areas
+# Default: false
+render-underwater-blocks: false
+```
 
 ## Usage
 

img.png

@@ -3,10 +3,8 @@
 import eu.okaeri.configs.ConfigManager;
 import eu.okaeri.configs.yaml.snakeyaml.YamlSnakeYamlConfigurer;
 import lombok.Getter;
-import lombok.extern.slf4j.Slf4j;
 import me.daoge.allaymap.httpd.MapHttpServer;
 import me.daoge.allaymap.listener.WorldEventListener;
-import me.daoge.allaymap.render.MapRenderer;
 import me.daoge.allaymap.render.MapTileManager;
 import org.allaymc.api.plugin.Plugin;
 import org.allaymc.api.server.Server;
@@ -17,39 +15,36 @@
 
 /**
  * AllayMap - A minimalistic and lightweight world map viewer for Allay servers.
- * Uses vanilla map rendering style similar to squaremap.
  *
  * @author daoge_cmd
  */
-@Slf4j
+@Getter
 public class AllayMap extends Plugin {
 
     @Getter
     private static AllayMap instance;
 
-    @Getter
-    private AllayMapConfig config;
+    {
+        instance = this;
+    }
 
-    @Getter
+    private AllayMapConfig config;
     private MapTileManager tileManager;
-
-    @Getter
     private MapHttpServer httpServer;
 
     @Override
     public void onLoad() {
-        instance = this;
-        log.info("AllayMap loading...");
+        this.pluginLogger.info("AllayMap loading...");
 
         // Load configuration
         Path dataDir = getPluginContainer().dataFolder();
         try {
             Files.createDirectories(dataDir);
         } catch (IOException e) {
-            log.error("Failed to create data directory", e);
+            this.pluginLogger.error("Failed to create data directory", e);
         }
 
-        config = ConfigManager.create(AllayMapConfig.class, cfg -> {
+        this.config = ConfigManager.create(AllayMapConfig.class, cfg -> {
             cfg.withConfigurer(new YamlSnakeYamlConfigurer());
             cfg.withBindFile(dataDir.resolve("config.yml"));
             cfg.withRemoveOrphans(true);
@@ -60,48 +55,26 @@ public void onLoad() {
 
     @Override
     public void onEnable() {
-        // Initialize colormap resources
-        MapRenderer.initColormaps();
-
         // Initialize tile manager
-        tileManager = new MapTileManager(getPluginContainer().dataFolder());
+        this.tileManager = new MapTileManager(getPluginContainer().dataFolder());
 
         // Register world event listener for chunk/block changes
-        WorldEventListener eventListener = new WorldEventListener(tileManager.getRenderQueue());
-        Server.getInstance().getEventBus().registerListener(eventListener);
-        log.info("Registered world event listener for map updates");
-
-        // Schedule periodic render task
-        int updateIntervalTicks = config.updateInterval() * 20; // Convert seconds to ticks
-        Server.getInstance().getScheduler().scheduleRepeating(this, () -> {
-            tileManager.processDirtyChunks();
-            return true; // Continue running
-        }, updateIntervalTicks);
-        log.info("Scheduled map render task every {} seconds", config.updateInterval());
+        Server.getInstance().getEventBus().registerListener(new WorldEventListener(this.tileManager.getRenderQueue()));
 
         // Start HTTP server
-        httpServer = new MapHttpServer(this, tileManager, config.httpPort());
+        this.httpServer = new MapHttpServer(this, this.tileManager, this.config.httpPort());
         try {
-            httpServer.start();
-            log.info("AllayMap web interface available at http://localhost:{}", config.httpPort());
+            this.httpServer.start();
+            this.pluginLogger.info("AllayMap web interface available at http://localhost:{}", this.config.httpPort());
         } catch (IOException e) {
-            log.error("Failed to start HTTP server on port {}", config.httpPort(), e);
-            log.info("Try changing the port in config.yml");
-            return;
+            this.pluginLogger.error("Failed to start HTTP server on port {}", this.config.httpPort(), e);
+            this.pluginLogger.info("Try changing the port in config.yml");
         }
 
         // Register commands
         registerCommands();
 
-        log.info("AllayMap enabled successfully!");
-    }
-
-    @Override
-    public void onDisable() {
-        if (httpServer != null) {
-            httpServer.stop();
-        }
-        log.info("AllayMap disabled");
+        this.pluginLogger.info("AllayMap enabled successfully!");
     }
 
     private void registerCommands() {
@@ -110,22 +83,8 @@ private void registerCommands() {
     }
 
     @Override
-    public boolean isReloadable() {
-        return true;
-    }
-
-    @Override
-    public void reload() {
-        log.info("Reloading AllayMap...");
-
-        // Reload config
-        config.load(true);
-
-        // Clear tile cache
-        if (tileManager != null) {
-            tileManager.clearCache();
-        }
-
-        log.info("AllayMap reloaded");
+    public void onDisable() {
+        this.httpServer.stop();
+        this.pluginLogger.info("AllayMap disabled");
     }
 }

src/main/java/me/daoge/allaymap/AllayMap.java

@@ -29,7 +29,6 @@
 /**
  * Embedded HTTP server for serving map tiles and web interface.
  */
-@Slf4j
 public class MapHttpServer {
 
     private static final Map<String, String> MIME_TYPES = new HashMap<>();
@@ -78,7 +77,7 @@ public void start() throws IOException {
         server.setExecutor(Executors.newVirtualThreadPerTaskExecutor());
         server.start();
 
-        log.info("AllayMap web server started on port {}", port);
+        AllayMap.getInstance().getPluginLogger().info("AllayMap web server started on port {}", port);
     }
 
     /**
@@ -87,7 +86,7 @@ public void start() throws IOException {
     public void stop() {
         if (server != null) {
             server.stop(0);
-            log.info("AllayMap web server stopped");
+            AllayMap.getInstance().getPluginLogger().info("AllayMap web server stopped");
         }
     }
 

src/main/java/me/daoge/allaymap/httpd/MapHttpServer.java

@@ -1,23 +1,22 @@
 package me.daoge.allaymap.listener;
 
 import lombok.RequiredArgsConstructor;
-import lombok.extern.slf4j.Slf4j;
 import me.daoge.allaymap.render.RenderQueue;
 import org.allaymc.api.eventbus.EventHandler;
 import org.allaymc.api.eventbus.event.block.BlockPlaceEvent;
 import org.allaymc.api.eventbus.event.world.ChunkLoadEvent;
+import org.allaymc.api.eventbus.event.world.WorldUnloadEvent;
 
 /**
  * Listens for world events and marks affected regions as dirty for re-rendering.
  */
-@Slf4j
 @RequiredArgsConstructor
 public class WorldEventListener {
 
     private final RenderQueue renderQueue;
 
     @EventHandler
-    public void onChunkLoad(ChunkLoadEvent event) {
+    private void onChunkLoad(ChunkLoadEvent event) {
         var chunk = event.getChunk();
         var dimension = event.getDimension();
         // Only mark dirty if this region hasn't been rendered yet
@@ -26,9 +25,17 @@ public void onChunkLoad(ChunkLoadEvent event) {
     }
 
     @EventHandler
-    public void onBlockPlace(BlockPlaceEvent event) {
+    private void onBlockPlace(BlockPlaceEvent event) {
         var pos = event.getBlock().getPosition();
         var dimension = event.getBlock().getDimension();
         renderQueue.markBlockDirty(dimension, pos.x(), pos.z());
     }
+
+    @EventHandler
+    private void onWorldUnload(WorldUnloadEvent event) {
+        var world = event.getWorld();
+        for (var dimension : world.getDimensions().values()) {
+            renderQueue.removeDimension(dimension);
+        }
+    }
 }

src/main/java/me/daoge/allaymap/listener/WorldEventListener.java

@@ -19,18 +19,16 @@
 import java.util.concurrent.CompletableFuture;
 
 /**
- * MapRenderer handles the rendering of chunks to images following vanilla map style.
- * Based on AllayMC's ItemFilledMapBaseComponentImpl rendering algorithm.
+ * MapRenderer handles the rendering of chunks to images.
  */
-@Slf4j
 public class MapRenderer {
 
-    public static final int CHUNK_TILE_SIZE = 16; // 1 pixel per block
-    public static final int CHUNK_SIZE = 16;
-    public static final int SEA_LEVEL = 62;
+    private static final int CHUNK_TILE_SIZE = 16;
+    private static final int CHUNK_SIZE = 16;
+    private static final int SEA_LEVEL = 62;
 
     // Color for unloaded/missing chunks
-    private static final Color UNLOADED_CHUNK_COLOR = new Color(0x1a1a2e); // Dark blue-gray
+    private static final Color UNLOADED_CHUNK_COLOR = new Color(0x1a1a2e);
     private static final Color BIRCH_FOLIAGE = new Color(0x80a755);
     private static final Color EVERGREEN_FOLIAGE = new Color(0x619961);
     private static final Color DRY_FOLIAGE_SPECIAL_A = new Color(0x7b5334);
@@ -50,14 +48,18 @@ public class MapRenderer {
     private static volatile BufferedImage DRY_FOLIAGE_COLORMAP;
     private static volatile BufferedImage GRASS_COLORMAP;
 
+    static {
+        initColormaps();
+    }
+
     /**
      * Initialize colormaps from resources
      */
-    public static void initColormaps() {
+    private static void initColormaps() {
         FOLIAGE_COLORMAP = readColormap("colormap/foliage.png");
         DRY_FOLIAGE_COLORMAP = readColormap("colormap/dry_foliage.png");
         GRASS_COLORMAP = readColormap("colormap/grass.png");
-        log.info("Colormaps loaded successfully");
+        AllayMap.getInstance().getPluginLogger().info("Colormaps loaded successfully");
     }
 
     @SneakyThrows
@@ -109,15 +111,15 @@ public CompletableFuture<BufferedImage> renderChunk(Dimension dimension, int chu
             image.setRGB(0, 0, CHUNK_TILE_SIZE, CHUNK_TILE_SIZE, pixels, 0, CHUNK_TILE_SIZE);
             return image;
         }, Server.getInstance().getVirtualThreadPool()).exceptionally(e -> {
-            log.error("Error rendering chunk ({}, {})", chunkX, chunkZ, e);
+            AllayMap.getInstance().getPluginLogger().error("Error rendering chunk ({}, {})", chunkX, chunkZ, e);
             return createEmptyChunkTile();
         });
     }
 
     /**
      * Create an empty 16x16 tile (for unloaded chunks)
      */
-    public BufferedImage createEmptyChunkTile() {
+    private BufferedImage createEmptyChunkTile() {
         BufferedImage image = new BufferedImage(CHUNK_TILE_SIZE, CHUNK_TILE_SIZE, BufferedImage.TYPE_INT_ARGB);
         int color = UNLOADED_CHUNK_COLOR.getRGB();
         for (int i = 0; i < CHUNK_TILE_SIZE * CHUNK_TILE_SIZE; i++) {