Fixes and Generation units

- generate command now accepts a unit parameter
- fixed the skipping of not generated chunks

src/main/kotlin/net/trivernis/chunkmaster/commands/CmdGenerate.kt

@@ -7,6 +7,7 @@ import net.trivernis.chunkmaster.lib.Subcommand
 import org.bukkit.command.Command
 import org.bukkit.command.CommandSender
 import org.bukkit.entity.Player
+import kotlin.math.pow
 
 class CmdGenerate(private val chunkmaster: Chunkmaster): Subcommand {
     override val name = "generate"
@@ -23,9 +24,19 @@ class CmdGenerate(private val chunkmaster: Chunkmaster): Subcommand {
         if (args.size == 1) {
             return sender.server.worlds.filter { it.name.indexOf(args[0]) == 0 }
                 .map {it.name}.toMutableList()
+        } else if (args.size == 2) {
+            if (args[0].toIntOrNull() != null) {
+                return units.filter {it.indexOf(args[1]) == 0}.toMutableList()
+            }
+        } else if (args.size > 2) {
+            if (args[1].toIntOrNull() != null) {
+                return units.filter {it.indexOf(args[2]) == 0}.toMutableList()
+            }
         }
         return emptyList<String>().toMutableList()
     }
+    val units = listOf("blockradius", "radius", "diameter")
+
 
     /**
      * Creates a new generation task for the world and chunk count.
@@ -41,8 +52,24 @@ class CmdGenerate(private val chunkmaster: Chunkmaster): Subcommand {
                 } else {
                     worldName = args[0]
                 }
-                if (args.size > 1 && args[1].toIntOrNull() != null) {
+                if (args.size > 1) {
-                    stopAfter = args[1].toInt()
+                    if (args[1].toIntOrNull() != null) {
+                        stopAfter = args[1].toInt()
+                    } else if (args[1] in units) {
+                        when (args[1]) {
+                            "radius" -> {
+                                stopAfter = ((stopAfter * 2)+1).toDouble().pow(2.0).toInt()
+                            }
+                            "diameter" -> {
+                                stopAfter = stopAfter.toDouble().pow(2.0).toInt()
+                            }
+                            "blockradius" -> {
+                                stopAfter = ((stopAfter*32)+1).toDouble().pow(2.0).toInt()
+                            }
+                        }
+                    } else {
+                        worldName = args[1]
+                    }
                 }
             } else {
                 worldName = sender.world.name

src/main/kotlin/net/trivernis/chunkmaster/lib/generation/GenerationManager.kt

@@ -28,7 +28,7 @@ class GenerationManager(private val chunkmaster: Chunkmaster, private val server
     fun addTask(world: World, stopAfter: Int = -1): Int {
         val foundTask = allTasks.find { it.generationTask.world == world }
         if (foundTask == null) {
-            val centerChunk = world.getChunkAt(world.spawnLocation)
+            val centerChunk = ChunkCoordinates(world.spawnLocation.chunk.x, world.spawnLocation.chunk.z)
             val generationTask = createGenerationTask(world, centerChunk, centerChunk, stopAfter)
 
             val insertStatement = chunkmaster.sqliteConnection.prepareStatement(
@@ -59,7 +59,7 @@ class GenerationManager(private val chunkmaster: Chunkmaster, private val server
             getIdStatement.close()
 
             generationTask.onEndReached {
-                server.consoleSender.sendMessage("Task #${id} finished after ${generationTask.count} chunks.")
+                chunkmaster.logger.info("Task #${id} finished after ${generationTask.count} chunks.")
                 removeTask(id)
             }
 
@@ -82,7 +82,13 @@ class GenerationManager(private val chunkmaster: Chunkmaster, private val server
     /**
      * Resumes a generation task
      */
-    private fun resumeTask(world: World, center: Chunk, last: Chunk, id: Int, stopAfter: Int = -1) {
+    private fun resumeTask(
+        world: World,
+        center: ChunkCoordinates,
+        last: ChunkCoordinates,
+        id: Int,
+        stopAfter: Int = -1
+    ) {
         if (!paused) {
             chunkmaster.logger.info("Resuming chunk generation task for world \"${world.name}\"")
             val generationTask = createGenerationTask(world, center, last, stopAfter)
@@ -92,7 +98,7 @@ class GenerationManager(private val chunkmaster: Chunkmaster, private val server
             )
             tasks.add(RunningTaskEntry(id, task, generationTask))
             generationTask.onEndReached {
-                server.consoleSender.sendMessage("Task #${id} finished after ${generationTask.count} chunks.")
+                chunkmaster.logger.info("Task #${id} finished after ${generationTask.count} chunks.")
                 removeTask(id)
             }
         }
@@ -143,7 +149,7 @@ class GenerationManager(private val chunkmaster: Chunkmaster, private val server
             if (server.onlinePlayers.isEmpty()) {
                 startAll()     // run startAll after 10 seconds if empty
             }
-        }, 200)
+        }, 600)
     }
 
     /**
@@ -174,14 +180,14 @@ class GenerationManager(private val chunkmaster: Chunkmaster, private val server
             try {
                 val id = res.getInt("id")
                 val world = server.getWorld(res.getString("world"))
-                val center = world!!.getChunkAt(res.getInt("center_x"), res.getInt("center_z"))
+                val center = ChunkCoordinates(res.getInt("center_x"), res.getInt("center_z"))
-                val last = world.getChunkAt(res.getInt("last_x"), res.getInt("last_z"))
+                val last = ChunkCoordinates(res.getInt("last_x"), res.getInt("last_z"))
                 val stopAfter = res.getInt("stop_after")
                 if (this.tasks.find { it.id == id } == null) {
-                    resumeTask(world, center, last, id, stopAfter)
+                    resumeTask(world!!, center, last, id, stopAfter)
                 }
             } catch (error: NullPointerException) {
-                server.consoleSender.sendMessage("Failed to load Task ${res.getInt("id")}.")
+                chunkmaster.logger.severe("Failed to load Task ${res.getInt("id")}.")
             }
         }
         savedTasksStatement.close()
@@ -217,7 +223,7 @@ class GenerationManager(private val chunkmaster: Chunkmaster, private val server
         for (task in tasks) {
             try {
                 val genTask = task.generationTask
-                server.consoleSender.sendMessage(
+                chunkmaster.logger.info(
                     """Task #${task.id} running for "${genTask.world.name}".
                     |Progress ${task.generationTask.count} chunks
                     |${if (task.generationTask.stopAfter > 0) "(${(task.generationTask.count.toDouble() /
@@ -236,7 +242,7 @@ class GenerationManager(private val chunkmaster: Chunkmaster, private val server
                 updateStatement.execute()
                 updateStatement.close()
             } catch (error: Exception) {
-                server.consoleSender.sendMessage("Exception when saving task progress ${error.message}")
+                chunkmaster.logger.warning("Exception when saving task progress ${error.message}")
             }
         }
     }
@@ -245,7 +251,12 @@ class GenerationManager(private val chunkmaster: Chunkmaster, private val server
      * Creates a new generation task. This method is used to create a task depending
      * on the server type (Paper/Spigot).
      */
-    private fun createGenerationTask(world: World, center: Chunk, start: Chunk, stopAfter: Int): GenerationTask {
+    private fun createGenerationTask(
+        world: World,
+        center: ChunkCoordinates,
+        start: ChunkCoordinates,
+        stopAfter: Int
+    ): GenerationTask {
         return if (PaperLib.isPaper()) {
             GenerationTaskPaper(chunkmaster, world, center, start, stopAfter)
         } else {

src/main/kotlin/net/trivernis/chunkmaster/lib/generation/GenerationTask.kt

@@ -8,7 +8,8 @@ import org.bukkit.World
 /**
  * Interface for generation tasks.
  */
-abstract class GenerationTask(plugin: Chunkmaster, centerChunk: Chunk, startChunk: Chunk) : Runnable {
+abstract class GenerationTask(plugin: Chunkmaster, centerChunk: ChunkCoordinates, startChunk: ChunkCoordinates) :
+    Runnable {
 
     abstract val stopAfter: Int
     abstract val world: World
@@ -35,11 +36,12 @@ abstract class GenerationTask(plugin: Chunkmaster, centerChunk: Chunk, startChun
             val nextChunkCoords = spiral.next()
             return ChunkCoordinates(nextChunkCoords.first, nextChunkCoords.second)
         }
-    var lastChunk: Chunk = startChunk
+
+    val lastChunk: Chunk
         get() {
             return world.getChunkAt(lastChunkCoords.x, lastChunkCoords.z)
         }
-        private set
+
     val nextChunk: Chunk
         get() {
             val next = nextChunkCoordinates

src/main/kotlin/net/trivernis/chunkmaster/lib/generation/GenerationTaskPaper.kt

@@ -8,7 +8,7 @@ import io.papermc.lib.PaperLib
 
 class GenerationTaskPaper(
     private val plugin: Chunkmaster, override val world: World,
-    centerChunk: Chunk, private val startChunk: Chunk,
+    centerChunk: ChunkCoordinates, private val startChunk: ChunkCoordinates,
     override val stopAfter: Int = -1
 ) : GenerationTask(plugin, centerChunk, startChunk) {
 
@@ -52,12 +52,15 @@ class GenerationTaskPaper(
                 }
 
                 if (!PaperLib.isChunkGenerated(world, chunk.x, chunk.z)) {
-                    for (i in 0 until chunksPerStep) {
+                    for (i in 0 until minOf(chunksPerStep, (stopAfter - count) - 1)) {
                         if (!PaperLib.isChunkGenerated(world, chunk.x, chunk.z)) {
                             pendingChunks.add(PaperLib.getChunkAtAsync(world, chunk.x, chunk.z, true))
                         }
                         chunk = nextChunkCoordinates
                     }
+                    if (!PaperLib.isChunkGenerated(world, chunk.x, chunk.z)) {
+                        pendingChunks.add(PaperLib.getChunkAtAsync(world, chunk.x, chunk.z, true))
+                    }
                 }
                 lastChunkCoords = chunk
                 count = spiral.count // set the count to the more accurate spiral count

src/main/kotlin/net/trivernis/chunkmaster/lib/generation/GenerationTaskSpigot.kt

@@ -6,7 +6,7 @@ import org.bukkit.World
 
 class GenerationTaskSpigot(
     private val plugin: Chunkmaster, override val world: World,
-    centerChunk: Chunk, private val startChunk: Chunk,
+    centerChunk: ChunkCoordinates, private val startChunk: ChunkCoordinates,
     override val stopAfter: Int = -1
 ) : GenerationTask(plugin, centerChunk, startChunk) {
 
@@ -37,14 +37,14 @@ class GenerationTaskSpigot(
                     return
                 }
 
-                var chunk = nextChunkCoordinates
+                var chunk = lastChunkCoords
 
                 if (!world.isChunkGenerated(chunk.x, chunk.z)) {
-                    for (i in 0 until chunksPerStep) {
+                    for (i in 0 until minOf(chunksPerStep, (stopAfter - count) - 1)) {
+                        chunk = nextChunkCoordinates
                         val chunkInstance = world.getChunkAt(chunk.x, chunk.z)
                         chunkInstance.load(true)
                         loadedChunks.add(chunkInstance)
-                        chunk = nextChunkCoordinates
                     }
                 }
                 lastChunkCoords = chunk