bump kutil and kotlin

* This fixes some bugs and improves performance

pom.xml

@@ -299,7 +299,7 @@
         <maven.compiler.source>11</maven.compiler.source>
         <maven.compiler.target>${maven.compiler.source}</maven.compiler.target>
         <javafx.version>19</javafx.version>
-        <kotlin.version>1.7.10</kotlin.version>
+        <kotlin.version>1.7.20</kotlin.version>
         <lwjgl.version>3.3.1</lwjgl.version>
         <ikonli.version>12.3.1</ikonli.version>
         <netty.version>4.1.82.Final</netty.version>
@@ -510,7 +510,7 @@
         <dependency>
             <groupId>de.bixilon</groupId>
             <artifactId>kutil</artifactId>
-            <version>1.16</version>
+            <version>1.17</version>
         </dependency>
         <dependency>
             <groupId>io.netty</groupId>

src/main/java/de/bixilon/minosoft/Minosoft.kt

@@ -15,14 +15,14 @@ package de.bixilon.minosoft
 
 import de.bixilon.kutil.concurrent.pool.DefaultThreadPool
 import de.bixilon.kutil.concurrent.pool.ThreadPool
-import de.bixilon.kutil.concurrent.worker.TaskWorker
+import de.bixilon.kutil.concurrent.worker.task.TaskWorker
-import de.bixilon.kutil.concurrent.worker.tasks.Task
+import de.bixilon.kutil.concurrent.worker.task.WorkerTask
 import de.bixilon.kutil.file.watcher.FileWatcherService
 import de.bixilon.kutil.latch.CountUpAndDownLatch
 import de.bixilon.kutil.os.OSTypes
 import de.bixilon.kutil.os.PlatformInfo
 import de.bixilon.kutil.reflection.ReflectionUtil.forceInit
-import de.bixilon.kutil.time.TimeUtil
+import de.bixilon.kutil.time.TimeUtil.nanos
 import de.bixilon.kutil.unit.UnitFormatter.formatNanos
 import de.bixilon.minosoft.assets.file.ResourcesAssetsUtil
 import de.bixilon.minosoft.assets.properties.version.AssetsVersionProperties
@@ -67,7 +67,7 @@ object Minosoft {
 
     @JvmStatic
     fun main(args: Array<String>) {
-        val start = TimeUtil.nanos
+        val start = nanos()
         Log::class.java.forceInit()
         CommandLineArguments.parse(args)
         KUtil.initUtilClasses()
@@ -80,39 +80,39 @@ object Minosoft {
 
         val taskWorker = TaskWorker(criticalErrorHandler = { _, exception -> exception.crash() })
 
-        taskWorker += Task(identifier = BootTasks.CLI, priority = ThreadPool.HIGH, executor = CLI::startThread)
+        taskWorker += WorkerTask(identifier = BootTasks.CLI, priority = ThreadPool.HIGH, executor = CLI::startThread)
 
-        taskWorker += Task(identifier = BootTasks.PACKETS, priority = ThreadPool.HIGH, executor = PacketTypeRegistry::init)
+        taskWorker += WorkerTask(identifier = BootTasks.PACKETS, priority = ThreadPool.HIGH, executor = PacketTypeRegistry::init)
-        taskWorker += Task(identifier = BootTasks.VERSIONS, priority = ThreadPool.HIGH, dependencies = arrayOf(BootTasks.PACKETS), executor = Versions::load)
+        taskWorker += WorkerTask(identifier = BootTasks.VERSIONS, priority = ThreadPool.HIGH, dependencies = arrayOf(BootTasks.PACKETS), executor = Versions::load)
-        taskWorker += Task(identifier = BootTasks.PROFILES, priority = ThreadPool.HIGH, dependencies = arrayOf(BootTasks.VERSIONS), executor = GlobalProfileManager::initialize)
+        taskWorker += WorkerTask(identifier = BootTasks.PROFILES, priority = ThreadPool.HIGH, dependencies = arrayOf(BootTasks.VERSIONS), executor = GlobalProfileManager::initialize)
-        taskWorker += Task(identifier = BootTasks.FILE_WATCHER, priority = ThreadPool.HIGH, optional = true, executor = this::startFileWatcherService)
+        taskWorker += WorkerTask(identifier = BootTasks.FILE_WATCHER, priority = ThreadPool.HIGH, optional = true, executor = this::startFileWatcherService)
 
-        taskWorker += Task(identifier = BootTasks.LANGUAGE_FILES, dependencies = arrayOf(BootTasks.PROFILES), executor = this::loadLanguageFiles)
+        taskWorker += WorkerTask(identifier = BootTasks.LANGUAGE_FILES, dependencies = arrayOf(BootTasks.PROFILES), executor = this::loadLanguageFiles)
-        taskWorker += Task(identifier = BootTasks.ASSETS_PROPERTIES, dependencies = arrayOf(BootTasks.PROFILES), executor = AssetsVersionProperties::load)
+        taskWorker += WorkerTask(identifier = BootTasks.ASSETS_PROPERTIES, dependencies = arrayOf(BootTasks.PROFILES), executor = AssetsVersionProperties::load)
-        taskWorker += Task(identifier = BootTasks.DEFAULT_REGISTRIES, dependencies = arrayOf(BootTasks.PROFILES), executor = DefaultRegistries::load)
+        taskWorker += WorkerTask(identifier = BootTasks.DEFAULT_REGISTRIES, dependencies = arrayOf(BootTasks.PROFILES), executor = DefaultRegistries::load)
 
 
-        taskWorker += Task(identifier = BootTasks.LAN_SERVERS, dependencies = arrayOf(BootTasks.PROFILES), executor = LANServerListener::listen)
+        taskWorker += WorkerTask(identifier = BootTasks.LAN_SERVERS, dependencies = arrayOf(BootTasks.PROFILES), executor = LANServerListener::listen)
 
         if (!RunConfiguration.DISABLE_EROS) {
-            taskWorker += Task(identifier = BootTasks.JAVAFX, executor = { JavaFXInitializer.start() })
+            taskWorker += WorkerTask(identifier = BootTasks.JAVAFX, executor = { JavaFXInitializer.start() })
             DefaultThreadPool += { javafx.scene.text.Font::class.java.forceInit() }
-            taskWorker += Task(identifier = BootTasks.X_START_ON_FIRST_THREAD_WARNING, executor = { XStartOnFirstThreadWarning.show() }, dependencies = arrayOf(BootTasks.LANGUAGE_FILES, BootTasks.JAVAFX))
+            taskWorker += WorkerTask(identifier = BootTasks.X_START_ON_FIRST_THREAD_WARNING, executor = { XStartOnFirstThreadWarning.show() }, dependencies = arrayOf(BootTasks.LANGUAGE_FILES, BootTasks.JAVAFX))
 
-            taskWorker += Task(identifier = BootTasks.STARTUP_PROGRESS, executor = { StartingDialog(BOOT_LATCH).show() }, dependencies = arrayOf(BootTasks.LANGUAGE_FILES, BootTasks.JAVAFX))
+            taskWorker += WorkerTask(identifier = BootTasks.STARTUP_PROGRESS, executor = { StartingDialog(BOOT_LATCH).show() }, dependencies = arrayOf(BootTasks.LANGUAGE_FILES, BootTasks.JAVAFX))
 
             Eros::class.java.forceInit()
         }
-        taskWorker += Task(identifier = BootTasks.YGGDRASIL, executor = { YggdrasilUtil.load() })
+        taskWorker += WorkerTask(identifier = BootTasks.YGGDRASIL, executor = { YggdrasilUtil.load() })
 
-        taskWorker += Task(identifier = BootTasks.ASSETS_OVERRIDE, executor = { OVERRIDE_ASSETS_MANAGER.load(it) })
+        taskWorker += WorkerTask(identifier = BootTasks.ASSETS_OVERRIDE, executor = { OVERRIDE_ASSETS_MANAGER.load(it) })
 
 
         taskWorker.work(BOOT_LATCH)
 
         BOOT_LATCH.dec() // remove initial count
         BOOT_LATCH.await()
-        val end = TimeUtil.nanos
+        val end = nanos()
         Log.log(LogMessageType.OTHER, LogLevels.INFO) { "Minosoft boot sequence finished in ${(end - start).formatNanos()}!" }
         GlobalEventMaster.fireEvent(FinishInitializingEvent())
 

src/main/java/de/bixilon/minosoft/data/registries/registries/Registries.kt

@@ -15,8 +15,8 @@ package de.bixilon.minosoft.data.registries.registries
 import de.bixilon.kutil.array.ArrayUtil.cast
 import de.bixilon.kutil.cast.CastUtil.unsafeCast
 import de.bixilon.kutil.concurrent.pool.DefaultThreadPool
-import de.bixilon.kutil.concurrent.worker.TaskWorker
+import de.bixilon.kutil.concurrent.worker.task.TaskWorker
-import de.bixilon.kutil.concurrent.worker.tasks.Task
+import de.bixilon.kutil.concurrent.worker.task.WorkerTask
 import de.bixilon.kutil.json.JsonObject
 import de.bixilon.kutil.json.JsonUtil.asJsonObject
 import de.bixilon.kutil.json.JsonUtil.toJsonObject
@@ -147,57 +147,57 @@ class Registries {
         val worker = TaskWorker(errorHandler = { _, it -> if (error == null) error = it }, criticalErrorHandler = { _, it -> if (error == null) error = it })
         val stopwatch = Stopwatch()
         // enums
-        worker += Task(this::shapes) { loadShapes(pixlyzerData["shapes"]?.toJsonObject()) }
+        worker += WorkerTask(this::shapes) { loadShapes(pixlyzerData["shapes"]?.toJsonObject()) }
 
-        worker += Task(this::equipmentSlotRegistry) { equipmentSlotRegistry.initialize(pixlyzerData["equipment_slots"]) }
+        worker += WorkerTask(this::equipmentSlotRegistry) { equipmentSlotRegistry.initialize(pixlyzerData["equipment_slots"]) }
-        worker += Task(this::handEquipmentSlotRegistry) { handEquipmentSlotRegistry.initialize(pixlyzerData["hand_equipment_slots"]) }
+        worker += WorkerTask(this::handEquipmentSlotRegistry) { handEquipmentSlotRegistry.initialize(pixlyzerData["hand_equipment_slots"]) }
-        worker += Task(this::armorEquipmentSlotRegistry) { armorEquipmentSlotRegistry.initialize(pixlyzerData["armor_equipment_slots"]) }
+        worker += WorkerTask(this::armorEquipmentSlotRegistry) { armorEquipmentSlotRegistry.initialize(pixlyzerData["armor_equipment_slots"]) }
-        worker += Task(this::armorStandEquipmentSlotRegistry) { armorStandEquipmentSlotRegistry.initialize(pixlyzerData["armor_stand_equipment_slots"]) }
+        worker += WorkerTask(this::armorStandEquipmentSlotRegistry) { armorStandEquipmentSlotRegistry.initialize(pixlyzerData["armor_stand_equipment_slots"]) }
 
-        worker += Task(this::entityDataTypesRegistry) { entityDataTypesRegistry.initialize(pixlyzerData["entity_data_data_types"]) }
+        worker += WorkerTask(this::entityDataTypesRegistry) { entityDataTypesRegistry.initialize(pixlyzerData["entity_data_data_types"]) }
 
-        worker += Task(this::titleActionsRegistry) { titleActionsRegistry.initialize(pixlyzerData["title_actions"]) }
+        worker += WorkerTask(this::titleActionsRegistry) { titleActionsRegistry.initialize(pixlyzerData["title_actions"]) }
-        worker += Task(this::entityAnimationRegistry) { entityAnimationRegistry.initialize(pixlyzerData["entity_animations"]) }
+        worker += WorkerTask(this::entityAnimationRegistry) { entityAnimationRegistry.initialize(pixlyzerData["entity_animations"]) }
-        worker += Task(this::entityActionsRegistry) { entityActionsRegistry.initialize(pixlyzerData["entity_actions"]) }
+        worker += WorkerTask(this::entityActionsRegistry) { entityActionsRegistry.initialize(pixlyzerData["entity_actions"]) }
 
         // id stuff
-        worker += Task(this::biomeCategoryRegistry) { biomeCategoryRegistry.update(pixlyzerData["biome_categories"]?.unsafeCast(), this) }
+        worker += WorkerTask(this::biomeCategoryRegistry) { biomeCategoryRegistry.update(pixlyzerData["biome_categories"]?.unsafeCast(), this) }
-        worker += Task(this::biomePrecipitationRegistry) { biomePrecipitationRegistry.update(pixlyzerData["biome_precipitations"]?.unsafeCast(), this) }
+        worker += WorkerTask(this::biomePrecipitationRegistry) { biomePrecipitationRegistry.update(pixlyzerData["biome_precipitations"]?.unsafeCast(), this) }
 
         // id resource location stuff
-        worker += Task(this::containerTypeRegistry) { containerTypeRegistry.rawUpdate(pixlyzerData["container_types"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::containerTypeRegistry) { containerTypeRegistry.rawUpdate(pixlyzerData["container_types"]?.toJsonObject(), this) }
-        worker += Task(this::gameEventRegistry) { gameEventRegistry.rawUpdate(pixlyzerData["game_events"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::gameEventRegistry) { gameEventRegistry.rawUpdate(pixlyzerData["game_events"]?.toJsonObject(), this) }
-        worker += Task(this::worldEventRegistry) { worldEventRegistry.rawUpdate(pixlyzerData["world_events"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::worldEventRegistry) { worldEventRegistry.rawUpdate(pixlyzerData["world_events"]?.toJsonObject(), this) }
-        worker += Task(this::argumentTypeRegistry) { argumentTypeRegistry.rawUpdate(pixlyzerData["argument_type"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::argumentTypeRegistry) { argumentTypeRegistry.rawUpdate(pixlyzerData["argument_type"]?.toJsonObject(), this) }
 
 
-        worker += Task(this::entityTypeRegistry) { entityTypeRegistry.rawUpdate(pixlyzerData["entities"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::entityTypeRegistry) { entityTypeRegistry.rawUpdate(pixlyzerData["entities"]?.toJsonObject(), this) }
 
-        worker += Task(this::motifRegistry) { motifRegistry.rawUpdate(pixlyzerData["motives"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::motifRegistry) { motifRegistry.rawUpdate(pixlyzerData["motives"]?.toJsonObject(), this) }
-        worker += Task(this::soundEventRegistry) { soundEventRegistry.rawUpdate(pixlyzerData["sound_events"]?.toJsonObject(), null) }
+        worker += WorkerTask(this::soundEventRegistry) { soundEventRegistry.rawUpdate(pixlyzerData["sound_events"]?.toJsonObject(), null) }
-        worker += Task(this::soundGroupRegistry, dependencies = arrayOf(this::soundEventRegistry)) { soundGroupRegistry.update(pixlyzerData["sound_groups"]?.unsafeCast(), this) }
+        worker += WorkerTask(this::soundGroupRegistry, dependencies = arrayOf(this::soundEventRegistry)) { soundGroupRegistry.update(pixlyzerData["sound_groups"]?.unsafeCast(), this) }
-        worker += Task(this::particleTypeRegistry) { particleTypeRegistry.rawUpdate(pixlyzerData["particles"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::particleTypeRegistry) { particleTypeRegistry.rawUpdate(pixlyzerData["particles"]?.toJsonObject(), this) }
-        worker += Task(this::materialRegistry) { materialRegistry.rawUpdate(pixlyzerData["materials"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::materialRegistry) { materialRegistry.rawUpdate(pixlyzerData["materials"]?.toJsonObject(), this) }
-        worker += Task(this::enchantmentRegistry) { enchantmentRegistry.rawUpdate(pixlyzerData["enchantments"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::enchantmentRegistry) { enchantmentRegistry.rawUpdate(pixlyzerData["enchantments"]?.toJsonObject(), this) }
-        worker += Task(this::statusEffectRegistry) { statusEffectRegistry.rawUpdate(pixlyzerData["status_effects"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::statusEffectRegistry) { statusEffectRegistry.rawUpdate(pixlyzerData["status_effects"]?.toJsonObject(), this) }
-        worker += Task(this::biomeRegistry, dependencies = arrayOf(this::biomeCategoryRegistry, this::biomePrecipitationRegistry)) { biomeRegistry.rawUpdate(pixlyzerData["biomes"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::biomeRegistry, dependencies = arrayOf(this::biomeCategoryRegistry, this::biomePrecipitationRegistry)) { biomeRegistry.rawUpdate(pixlyzerData["biomes"]?.toJsonObject(), this) }
-        worker += Task(this::dimensionRegistry) { dimensionRegistry.rawUpdate(pixlyzerData["dimensions"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::dimensionRegistry) { dimensionRegistry.rawUpdate(pixlyzerData["dimensions"]?.toJsonObject(), this) }
-        worker += Task(this::fluidRegistry) { fluidRegistry.rawUpdate(pixlyzerData["fluids"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::fluidRegistry) { fluidRegistry.rawUpdate(pixlyzerData["fluids"]?.toJsonObject(), this) }
-        worker += Task(this::blockRegistry, dependencies = arrayOf(this::fluidRegistry, this::shapes)) { blockRegistry.rawUpdate(pixlyzerData["blocks"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::blockRegistry, dependencies = arrayOf(this::fluidRegistry, this::shapes)) { blockRegistry.rawUpdate(pixlyzerData["blocks"]?.toJsonObject(), this) }
-        worker += Task(this::itemRegistry, dependencies = arrayOf(this::blockRegistry, this::entityTypeRegistry, this::fluidRegistry, this::statusEffectRegistry)) { itemRegistry.rawUpdate(pixlyzerData["items"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::itemRegistry, dependencies = arrayOf(this::blockRegistry, this::entityTypeRegistry, this::fluidRegistry, this::statusEffectRegistry)) { itemRegistry.rawUpdate(pixlyzerData["items"]?.toJsonObject(), this) }
 
-        worker += Task(this::blockEntityTypeRegistry, dependencies = arrayOf(this::blockRegistry)) { blockEntityTypeRegistry.rawUpdate(pixlyzerData["block_entities"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::blockEntityTypeRegistry, dependencies = arrayOf(this::blockRegistry)) { blockEntityTypeRegistry.rawUpdate(pixlyzerData["block_entities"]?.toJsonObject(), this) }
 
-        worker += Task(this::villagerProfessionRegistry) { villagerProfessionRegistry.rawUpdate(pixlyzerData["villager_professions"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::villagerProfessionRegistry) { villagerProfessionRegistry.rawUpdate(pixlyzerData["villager_professions"]?.toJsonObject(), this) }
-        worker += Task(this::villagerTypeRegistry) { villagerTypeRegistry.rawUpdate(pixlyzerData["villager_types"]?.toJsonObject(), null) }
+        worker += WorkerTask(this::villagerTypeRegistry) { villagerTypeRegistry.rawUpdate(pixlyzerData["villager_types"]?.toJsonObject(), null) }
 
 
-        worker += Task(this::blockDataTypeRegistry) { blockDataTypeRegistry.rawUpdate(pixlyzerData["block_data_data_types"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::blockDataTypeRegistry) { blockDataTypeRegistry.rawUpdate(pixlyzerData["block_data_data_types"]?.toJsonObject(), this) }
 
-        worker += Task(this::catVariants) { catVariants.rawUpdate(pixlyzerData["variant/cat"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::catVariants) { catVariants.rawUpdate(pixlyzerData["variant/cat"]?.toJsonObject(), this) }
-        worker += Task(this::frogVariants) { frogVariants.rawUpdate(pixlyzerData["variant/frog"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::frogVariants) { frogVariants.rawUpdate(pixlyzerData["variant/frog"]?.toJsonObject(), this) }
 
-        worker += Task(this::statisticRegistry) { statisticRegistry.rawUpdate(pixlyzerData["statistics"]?.toJsonObject(), this) }
+        worker += WorkerTask(this::statisticRegistry) { statisticRegistry.rawUpdate(pixlyzerData["statistics"]?.toJsonObject(), this) }
 
         val inner = CountUpAndDownLatch(1, latch)
         worker.work(inner)

src/main/java/de/bixilon/minosoft/data/world/World.kt

@@ -18,8 +18,8 @@ import de.bixilon.kutil.array.ArrayUtil.cast
 import de.bixilon.kutil.collections.map.LockMap
 import de.bixilon.kutil.concurrent.lock.simple.SimpleLock
 import de.bixilon.kutil.concurrent.pool.ThreadPool
-import de.bixilon.kutil.concurrent.worker.TaskWorker
+import de.bixilon.kutil.concurrent.worker.unconditional.UnconditionalTask
-import de.bixilon.kutil.concurrent.worker.tasks.Task
+import de.bixilon.kutil.concurrent.worker.unconditional.UnconditionalWorker
 import de.bixilon.kutil.watcher.DataWatcher.Companion.watched
 import de.bixilon.minosoft.data.Difficulties
 import de.bixilon.minosoft.data.entities.block.BlockEntity
@@ -280,13 +280,13 @@ class World(
         val simulationDistance = view.simulationDistance
         val cameraPosition = connection.player.positionInfo.chunkPosition
         chunks.lock.acquire()
-        val worker = TaskWorker()
+        val worker = UnconditionalWorker()
         for ((chunkPosition, chunk) in chunks.unsafe) {
             // ToDo: Cache (improve performance)
             if (!chunkPosition.isInViewDistance(simulationDistance, cameraPosition)) {
                 continue
             }
-            worker += Task(priority = ThreadPool.HIGH) { chunk.tick(connection, chunkPosition) }
+            worker += UnconditionalTask(priority = ThreadPool.HIGH) { chunk.tick(connection, chunkPosition) }
         }
         chunks.lock.release()
         worker.work()
@@ -409,8 +409,8 @@ class World(
     }
 
     fun recalculateLight() {
-        val reset = TaskWorker()
+        val reset = UnconditionalWorker()
-        val calculate = TaskWorker()
+        val calculate = UnconditionalWorker()
         lock.acquire()
         for (chunk in chunks.unsafe.values) {
             reset += { chunk.light.reset() }

src/main/java/de/bixilon/minosoft/data/world/WorldEntities.kt

@@ -16,8 +16,8 @@ package de.bixilon.minosoft.data.world
 import de.bixilon.kotlinglm.vec3.Vec3d
 import de.bixilon.kutil.concurrent.lock.simple.SimpleLock
 import de.bixilon.kutil.concurrent.pool.ThreadPool
-import de.bixilon.kutil.concurrent.worker.TaskWorker
+import de.bixilon.kutil.concurrent.worker.unconditional.UnconditionalTask
-import de.bixilon.kutil.concurrent.worker.tasks.Task
+import de.bixilon.kutil.concurrent.worker.unconditional.UnconditionalWorker
 import de.bixilon.minosoft.data.abilities.Gamemodes
 import de.bixilon.minosoft.data.entities.entities.Entity
 import de.bixilon.minosoft.data.entities.entities.player.PlayerEntity
@@ -184,9 +184,9 @@ class WorldEntities : Iterable<Entity> {
 
     fun tick() {
         lock.acquire()
-        val worker = TaskWorker()
+        val worker = UnconditionalWorker()
         for (entity in entities) {
-            worker += Task(priority = ThreadPool.Priorities.HIGH) { entity.tryTick() }
+            worker += UnconditionalTask(priority = ThreadPool.Priorities.HIGH) { entity.tryTick() }
         }
         lock.release()
         worker.work()

src/main/java/de/bixilon/minosoft/gui/rendering/particle/ParticleRenderer.kt

@@ -19,7 +19,7 @@ import de.bixilon.kutil.concurrent.lock.simple.SimpleLock
 import de.bixilon.kutil.concurrent.time.TimeWorker
 import de.bixilon.kutil.concurrent.time.TimeWorkerTask
 import de.bixilon.kutil.latch.CountUpAndDownLatch
-import de.bixilon.kutil.time.TimeUtil
+import de.bixilon.kutil.time.TimeUtil.millis
 import de.bixilon.kutil.watcher.DataWatcher.Companion.observe
 import de.bixilon.minosoft.config.profile.delegate.watcher.SimpleProfileDelegateWatcher.Companion.profileWatch
 import de.bixilon.minosoft.data.registries.ResourceLocation
@@ -159,7 +159,7 @@ class ParticleRenderer(
 
             particlesLock.acquire()
             try {
-                val time = TimeUtil.millis
+                val time = millis()
                 for (particle in particles) {
                     if (!particle.chunkPosition.isInViewDistance(particleViewDistance, cameraPosition)) { // ToDo: Check fog distance
                         particle.dead = true
@@ -207,7 +207,7 @@ class ParticleRenderer(
             particle.dead = true
             return
         }
-        particle.tryTick(TimeUtil.millis)
+        particle.tryTick(millis())
 
         particleQueueLock.lock()
         particleQueue += particle
@@ -227,7 +227,7 @@ class ParticleRenderer(
 
         particlesLock.acquire()
 
-        val time = TimeUtil.millis
+        val time = millis()
         for (particle in particles) {
             particle.tryTick(time)
             if (particle.dead) {

src/main/java/de/bixilon/minosoft/gui/rendering/renderer/renderer/RendererManager.kt

@@ -16,8 +16,8 @@ package de.bixilon.minosoft.gui.rendering.renderer.renderer
 import de.bixilon.kutil.cast.CastUtil.unsafeCast
 import de.bixilon.kutil.collections.CollectionUtil.synchronizedMapOf
 import de.bixilon.kutil.concurrent.pool.ThreadPool
-import de.bixilon.kutil.concurrent.worker.TaskWorker
+import de.bixilon.kutil.concurrent.worker.unconditional.UnconditionalTask
-import de.bixilon.kutil.concurrent.worker.tasks.Task
+import de.bixilon.kutil.concurrent.worker.unconditional.UnconditionalWorker
 import de.bixilon.kutil.latch.CountUpAndDownLatch
 import de.bixilon.minosoft.config.profile.ConnectionProfiles
 import de.bixilon.minosoft.data.registries.ResourceLocation
@@ -65,7 +65,7 @@ class RendererManager(
 
     fun init(latch: CountUpAndDownLatch) {
         val inner = CountUpAndDownLatch(0, latch)
-        var worker = TaskWorker()
+        var worker = UnconditionalWorker()
         for (renderer in renderers.values) {
             worker += { renderer.preAsyncInit(inner) }
         }
@@ -75,7 +75,7 @@ class RendererManager(
             renderer.init(inner)
         }
 
-        worker = TaskWorker()
+        worker = UnconditionalWorker()
         for (renderer in renderers.values) {
             worker += { renderer.asyncInit(inner) }
         }
@@ -87,7 +87,7 @@ class RendererManager(
             renderer.postInit(latch)
         }
         val inner = CountUpAndDownLatch(0, latch)
-        val worker = TaskWorker()
+        val worker = UnconditionalWorker()
         for (renderer in renderers.values) {
             worker += { renderer.postAsyncInit(inner) }
         }
@@ -120,12 +120,12 @@ class RendererManager(
         }
 
         val latch = CountUpAndDownLatch(0)
-        val worker = TaskWorker()
+        val worker = UnconditionalWorker()
         for (renderer in rendererList) {
             if (renderer !is AsyncRenderer) {
                 continue
             }
-            worker += Task(priority = ThreadPool.HIGHER) { renderer.prepareDrawAsync() }
+            worker += UnconditionalTask(priority = ThreadPool.HIGHER) { renderer.prepareDrawAsync() }
         }
         worker.work(latch)
 

src/main/java/de/bixilon/minosoft/gui/rendering/world/WorldRenderer.kt

@@ -22,7 +22,7 @@ import de.bixilon.kutil.concurrent.pool.ThreadPool.Priorities.HIGH
 import de.bixilon.kutil.concurrent.pool.ThreadPool.Priorities.LOW
 import de.bixilon.kutil.concurrent.pool.ThreadPoolRunnable
 import de.bixilon.kutil.latch.CountUpAndDownLatch
-import de.bixilon.kutil.time.TimeUtil
+import de.bixilon.kutil.time.TimeUtil.millis
 import de.bixilon.kutil.watcher.DataWatcher.Companion.observe
 import de.bixilon.minosoft.config.key.KeyActions
 import de.bixilon.minosoft.config.key.KeyBinding
@@ -649,10 +649,10 @@ class WorldRenderer(
         }
 
         var addedMeshes = 0
-        val start = TimeUtil.millis
+        val start = millis()
         val maxTime = if (connection.player.velocity.empty) 50L else 20L // If the player is still, then we can load more chunks (to not cause lags)
 
-        while (meshesToLoad.isNotEmpty() && (TimeUtil.millis - start < maxTime)) {
+        while (meshesToLoad.isNotEmpty() && (millis() - start < maxTime)) {
             val item = meshesToLoad.removeAt(0)
             meshesToLoadSet.remove(item)
             val mesh = item.mesh ?: continue
@@ -688,10 +688,10 @@ class WorldRenderer(
             return
         }
 
-        val time = TimeUtil.millis
+        val time = millis()
         val maxTime = if (connection.player.velocity.empty) 50L else 20L // If the player is still, then we can load more chunks (to not cause lags)
 
-        while (meshesToUnload.isNotEmpty() && (TimeUtil.millis - time < maxTime)) {
+        while (meshesToUnload.isNotEmpty() && (millis() - time < maxTime)) {
             val mesh = meshesToUnload.removeAt(0)
             visible.removeMesh(mesh)
             mesh.unload()

src/main/java/de/bixilon/minosoft/protocol/network/connection/play/PlayConnection.kt

@@ -15,8 +15,8 @@ package de.bixilon.minosoft.protocol.network.connection.play
 
 import de.bixilon.kutil.collections.CollectionUtil.synchronizedMapOf
 import de.bixilon.kutil.collections.CollectionUtil.synchronizedSetOf
-import de.bixilon.kutil.concurrent.worker.TaskWorker
+import de.bixilon.kutil.concurrent.worker.task.TaskWorker
-import de.bixilon.kutil.concurrent.worker.tasks.Task
+import de.bixilon.kutil.concurrent.worker.task.WorkerTask
 import de.bixilon.kutil.latch.CountUpAndDownLatch
 import de.bixilon.kutil.watcher.DataWatcher.Companion.observe
 import de.bixilon.kutil.watcher.DataWatcher.Companion.watched
@@ -187,8 +187,8 @@ class PlayConnection(
             }
             var privateKey: PlayerPrivateKey? = null
             if (version.requiresSignedChat) {
-                taskWorker += Task(optional = true) {
+                taskWorker += WorkerTask(optional = true) {
-                    val minecraftKey = account.fetchKey(latch) ?: return@Task
+                    val minecraftKey = account.fetchKey(latch) ?: return@WorkerTask
                     minecraftKey.requireSignature()
                     privateKey = PlayerPrivateKey(
                         expiresAt = minecraftKey.expiresAt,

src/main/java/de/bixilon/minosoft/protocol/network/network/client/pipeline/compression/PacketInflater.kt

@@ -38,7 +38,7 @@ class PacketInflater(
             throw PacketTooLongException(uncompressedLength, maxPacketSize)
         }
 
-        val decompressed = rest.decompress() // ToDo: Kutil 1.17: passthrough expected
+        val decompressed = rest.decompress(uncompressedLength)
         if (decompressed.size != uncompressedLength) {
             throw SizeMismatchInflaterException()
         }

src/test/java/de/bixilon/minosoft/data/world/chunk/light/LightBenchmark.kt

@@ -13,12 +13,12 @@
 
 package de.bixilon.minosoft.data.world.chunk.light
 
+import de.bixilon.kutil.benchmark.BenchmarkUtil
 import de.bixilon.kutil.unit.UnitFormatter.formatNanos
 import de.bixilon.minosoft.data.world.chunk.ChunkTestingUtil.createChunkWithNeighbours
 import de.bixilon.minosoft.data.world.chunk.ChunkTestingUtil.createSolidBlock
 import de.bixilon.minosoft.data.world.chunk.ChunkTestingUtil.createSolidLight
 import de.bixilon.minosoft.data.world.chunk.ChunkTestingUtil.fillBottom
-import de.bixilon.minosoft.util.benchmark.BenchmarkUtil
 import org.junit.jupiter.api.Test
 import kotlin.system.measureNanoTime
 

src/test/java/de/bixilon/minosoft/util/benchmark/BenchmarkResult.kt

@@ -1,32 +0,0 @@
-/*
- * Minosoft
- * Copyright (C) 2020-2022 Moritz Zwerger
- *
- * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
- *
- * This software is not affiliated with Mojang AB, the original developer of Minecraft.
- */
-
-package de.bixilon.minosoft.util.benchmark
-
-import de.bixilon.kutil.unit.UnitFormatter.formatNanos
-
-@Deprecated("Kutil 1.17")
-class BenchmarkResult(
-    val runs: Int,
-    val totalNanos: Long,
-    val averageNanos: Long,
-) {
-
-    override fun toString(): String {
-        return "Benchmark@$runs, totaling=${totalNanos.formatNanos()}, avg=${averageNanos.formatNanos()}"
-    }
-
-    fun println() {
-        println(this)
-    }
-}

src/test/java/de/bixilon/minosoft/util/benchmark/BenchmarkUtil.kt

@@ -1,33 +0,0 @@
-/*
- * Minosoft
- * Copyright (C) 2020-2022 Moritz Zwerger
- *
- * This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation, either version 3 of the License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License along with this program. If not, see <https://www.gnu.org/licenses/>.
- *
- * This software is not affiliated with Mojang AB, the original developer of Minecraft.
- */
-
-package de.bixilon.minosoft.util.benchmark
-
-import de.bixilon.kutil.time.TimeUtil
-
-@Deprecated("Kutil 1.17")
-object BenchmarkUtil {
-
-    inline fun benchmark(runs: Int = 100, warm: Boolean = true, block: () -> Unit): BenchmarkResult {
-        if (warm) {
-            block.invoke()
-        }
-        val start = TimeUtil.nanos
-        for (run in 0 until runs) {
-            block.invoke()
-        }
-        val end = TimeUtil.nanos
-        val delta = end - start
-        return BenchmarkResult(runs, delta, delta / runs)
-    }
-}