fix neoforge server freeze

makeevrserg · makeevrserg · commit a1bd9b9e4231 · 2025-12-26T20:56:30.000+03:00
diff --git a/gradle.properties b/gradle.properties
@@ -13,7 +13,7 @@ makeevrserg.java.ktarget=21
 # Project
 makeevrserg.project.name=SoulKeeper
 makeevrserg.project.group=ru.astrainteractive.soulkeeper
-makeevrserg.project.version.string=1.2.4
+makeevrserg.project.version.string=1.2.5
 makeevrserg.project.description=Keep your items after death
 makeevrserg.project.developers=makeevrserg|Makeev Roman|makeevrserg@gmail.com
 makeevrserg.project.url=https://github.com/Astra-Interactive/SoulKeeper
diff --git a/instances/neoforge/build.gradle.kts b/instances/neoforge/build.gradle.kts
@@ -83,6 +83,7 @@ val shadowJar by tasks.getting(ShadowJar::class) {
         // Dependencies
         exclude(dependency("org.jetbrains:annotations"))
         // Root
+        exclude("kotlin/**") // use kotlin-neoforge
         exclude("_COROUTINE/**")
         exclude("DebugProbesKt.bin")
         exclude("jetty-dir.css")
diff --git a/modules/dao/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/di/SoulsDaoModule.kt b/modules/dao/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/di/SoulsDaoModule.kt
@@ -4,7 +4,7 @@ import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.GlobalScope
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.SharingStarted
-import kotlinx.coroutines.flow.first
+import kotlinx.coroutines.flow.firstOrNull
 import kotlinx.coroutines.flow.flow
 import kotlinx.coroutines.flow.shareIn
 import kotlinx.coroutines.launch
@@ -55,7 +55,7 @@ interface SoulsDaoModule {
         override val lifecycle: Lifecycle = Lifecycle.Lambda(
             onDisable = {
                 GlobalScope.launch(dispatchers.IO) {
-                    TransactionManager.closeAndUnregister(databaseFlow.first())
+                    databaseFlow.firstOrNull()?.let(TransactionManager::closeAndUnregister)
                 }
             }
         )
diff --git a/modules/service-bukkit/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/di/BukkitPlatformServiceModule.kt b/modules/service-bukkit/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/di/BukkitPlatformServiceModule.kt
@@ -35,6 +35,7 @@ class BukkitPlatformServiceModule(
     override val showArmorStandUseCase: ShowArmorStandUseCase = ShowArmorStandUseCaseFactory(coreModule).create()
     override val pickUpItemsUseCase: PickUpItemsUseCase = BukkitPickUpItemsUseCase(
         collectItemSoundProvider = { coreModule.soulsConfigKrate.cachedValue.sounds.collectItem },
-        soulsDao = soulsDaoModule.soulsDao
+        soulsDao = soulsDaoModule.soulsDao,
+        dispatchers = coreModule.dispatchers
     )
 }
diff --git a/modules/service-bukkit/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/domain/BukkitPickUpItemsUseCase.kt b/modules/service-bukkit/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/domain/BukkitPickUpItemsUseCase.kt
@@ -1,7 +1,9 @@
 package ru.astrainteractive.soulkeeper.module.souls.domain
 
+import kotlinx.coroutines.withContext
 import org.bukkit.Bukkit
 import ru.astrainteractive.astralibs.server.player.OnlineMinecraftPlayer
+import ru.astrainteractive.klibs.mikro.core.dispatchers.KotlinDispatchers
 import ru.astrainteractive.klibs.mikro.core.logging.JUtiltLogger
 import ru.astrainteractive.klibs.mikro.core.logging.Logger
 import ru.astrainteractive.soulkeeper.core.plugin.SoulsConfig
@@ -16,6 +18,7 @@ import ru.astrainteractive.soulkeeper.module.souls.domain.PickUpItemsUseCase.Out
 internal class BukkitPickUpItemsUseCase(
     private val collectItemSoundProvider: () -> SoulsConfig.Sounds.SoundConfig,
     private val soulsDao: SoulsDao,
+    private val dispatchers: KotlinDispatchers
 ) : PickUpItemsUseCase,
     Logger by JUtiltLogger("SoulKeeper-PickUpItemsUseCase") {
 
@@ -27,10 +30,23 @@ internal class BukkitPickUpItemsUseCase(
             .map(StringFormatObject::raw)
             .map(ItemStackSerializer::decodeFromString)
             .mapNotNull { itemStackResult -> itemStackResult.getOrNull() }
-        val notAddedItems = bukkitPlayer.inventory.addItem(*items.toTypedArray()).values.toList()
+        val notAddedItems = withContext(dispatchers.Main) {
+            bukkitPlayer.inventory
+                .addItem(*items.toTypedArray())
+                .values
+                .toList()
+        }
         if (notAddedItems != soul.items) {
-            soul.location.toBukkitLocation().playSoundForPlayer(bukkitPlayer, collectItemSoundProvider.invoke())
+            withContext(dispatchers.Main) {
+                soul.location
+                    .toBukkitLocation()
+                    .playSoundForPlayer(
+                        player = bukkitPlayer,
+                        sound = collectItemSoundProvider.invoke()
+                    )
+            }
         }
+
         soulsDao.updateSoul(
             soul.copy(
                 items = notAddedItems
diff --git a/modules/service-neoforge/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/di/NeoForgePlatformServiceModule.kt b/modules/service-neoforge/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/di/NeoForgePlatformServiceModule.kt
@@ -33,6 +33,7 @@ class NeoForgePlatformServiceModule(
         collectItemSoundProvider = { coreModule.soulsConfigKrate.cachedValue.sounds.collectItem },
         soulsDao = soulsDaoModule.soulsDao,
         effectEmitter = effectEmitter,
-        isDeadPlayerProvider = isDeadPlayerProvider
+        isDeadPlayerProvider = isDeadPlayerProvider,
+        dispatchers = coreModule.dispatchers
     )
 }
diff --git a/modules/service-neoforge/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/domain/NeoForgePickUpItemsUseCase.kt b/modules/service-neoforge/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/domain/NeoForgePickUpItemsUseCase.kt
@@ -1,9 +1,11 @@
 package ru.astrainteractive.soulkeeper.module.souls.domain
 
+import kotlinx.coroutines.withContext
 import net.minecraft.world.item.ItemStack
 import ru.astrainteractive.astralibs.server.player.OnlineMinecraftPlayer
 import ru.astrainteractive.astralibs.server.util.NeoForgeUtil
 import ru.astrainteractive.astralibs.server.util.getOnlinePlayer
+import ru.astrainteractive.klibs.mikro.core.dispatchers.KotlinDispatchers
 import ru.astrainteractive.klibs.mikro.core.logging.JUtiltLogger
 import ru.astrainteractive.klibs.mikro.core.logging.Logger
 import ru.astrainteractive.soulkeeper.core.plugin.SoulsConfig
@@ -19,7 +21,8 @@ internal class NeoForgePickUpItemsUseCase(
     private val collectItemSoundProvider: () -> SoulsConfig.Sounds.SoundConfig,
     private val soulsDao: SoulsDao,
     private val effectEmitter: EffectEmitter,
-    private val isDeadPlayerProvider: IsDeadPlayerProvider
+    private val isDeadPlayerProvider: IsDeadPlayerProvider,
+    private val dispatchers: KotlinDispatchers
 ) : PickUpItemsUseCase,
     Logger by JUtiltLogger("SoulKeeper-PickUpItemsUseCase") {
     /**
@@ -47,14 +50,22 @@ internal class NeoForgePickUpItemsUseCase(
         if (serverPlayer.gameMode.isCreative) return Output.SomeItemsRemain
         if (isDeadPlayerProvider.isDead(player)) return Output.SomeItemsRemain
 
-        val notAddedItems = player.addItems(
-            items = soul.items
-                .map(StringFormatObject::raw)
-                .map(ItemStackSerializer::decodeFromString)
-                .mapNotNull { result -> result.getOrNull() }
-        )
+        val notAddedItems = withContext(dispatchers.Main) {
+            player.addItems(
+                items = soul.items
+                    .map(StringFormatObject::raw)
+                    .map(ItemStackSerializer::decodeFromString)
+                    .mapNotNull { result -> result.getOrNull() }
+            )
+        }
         if (notAddedItems.isEmpty()) {
-            effectEmitter.playSoundForPlayer(soul.location, player, collectItemSoundProvider.invoke())
+            withContext(dispatchers.Main) {
+                effectEmitter.playSoundForPlayer(
+                    location = soul.location,
+                    player = player,
+                    sound = collectItemSoundProvider.invoke()
+                )
+            }
         }
         soulsDao.updateSoul(
             soul.copy(
diff --git a/modules/service/src/main/kotlin/ru/astrainteractive/soulkeeper/core/service/ThrottleTickFlowService.kt b/modules/service/src/main/kotlin/ru/astrainteractive/soulkeeper/core/service/ThrottleTickFlowService.kt
@@ -0,0 +1,61 @@
+package ru.astrainteractive.soulkeeper.core.service
+
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.Job
+import kotlinx.coroutines.cancel
+import kotlinx.coroutines.flow.Flow
+import kotlinx.coroutines.flow.channelFlow
+import kotlinx.coroutines.flow.collectLatest
+import kotlinx.coroutines.flow.combine
+import kotlinx.coroutines.flow.flattenConcat
+import kotlinx.coroutines.flow.flowOf
+import kotlinx.coroutines.flow.launchIn
+import kotlinx.coroutines.launch
+import ru.astrainteractive.astralibs.coroutines.withTimings
+import ru.astrainteractive.astralibs.service.Service
+import ru.astrainteractive.astralibs.service.ServiceExecutor
+import ru.astrainteractive.klibs.mikro.core.coroutines.CoroutineFeature
+import ru.astrainteractive.klibs.mikro.core.coroutines.TickFlow
+import kotlin.coroutines.CoroutineContext
+import kotlin.time.Duration
+
+class ThrottleTickFlowService(
+    coroutineContext: CoroutineContext = Dispatchers.IO,
+    private val delay: Flow<Duration>,
+    private val initialDelay: Flow<Duration> = flowOf(Duration.ZERO),
+    private val executor: ServiceExecutor
+) : Service {
+    private val scope = CoroutineFeature
+        .Default(coroutineContext)
+        .withTimings()
+
+    fun <T, K> Flow<T>.throttleLatest(
+        transform: suspend (T) -> K
+    ): Flow<K> = channelFlow {
+        val scope = this
+        var job: Job? = null
+
+        collectLatest { value ->
+            job?.join()
+            job = scope.launch {
+                send(transform(value))
+            }
+        }
+    }
+
+    private val lazyTickFlow = lazy {
+        combine(delay, initialDelay, ::TickFlow)
+            .flattenConcat()
+            .throttleLatest { executor.doWork() }
+            .launchIn(scope)
+    }
+
+    override fun onCreate() {
+        lazyTickFlow.value
+    }
+
+    override fun onDestroy() {
+        lazyTickFlow.value.cancel()
+        scope.cancel()
+    }
+}
diff --git a/modules/service/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/di/ServiceModule.kt b/modules/service/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/di/ServiceModule.kt
@@ -2,8 +2,8 @@ package ru.astrainteractive.soulkeeper.module.souls.di
 
 import kotlinx.coroutines.flow.flowOf
 import ru.astrainteractive.astralibs.lifecycle.Lifecycle
-import ru.astrainteractive.astralibs.service.TickFlowService
 import ru.astrainteractive.soulkeeper.core.di.CoreModule
+import ru.astrainteractive.soulkeeper.core.service.ThrottleTickFlowService
 import ru.astrainteractive.soulkeeper.module.souls.domain.GetNearestSoulUseCase
 import ru.astrainteractive.soulkeeper.module.souls.domain.PickUpExpUseCase
 import ru.astrainteractive.soulkeeper.module.souls.domain.PickUpSoulUseCase
@@ -39,7 +39,7 @@ class ServiceModule(
         effectEmitter = platformServiceModule.effectEmitter
     )
 
-    private val deleteSoulService = TickFlowService(
+    private val deleteSoulService = ThrottleTickFlowService(
         coroutineContext = coreModule.dispatchers.IO,
         delay = flowOf(60.seconds),
         executor = DeleteSoulWorker(
@@ -48,7 +48,7 @@ class ServiceModule(
         )
     )
 
-    private val freeSoulService = TickFlowService(
+    private val freeSoulService = ThrottleTickFlowService(
         coroutineContext = coreModule.dispatchers.IO,
         delay = flowOf(60.seconds),
         executor = FreeSoulWorker(
@@ -71,9 +71,10 @@ class ServiceModule(
         collectXpSoundProvider = { coreModule.soulsConfigKrate.cachedValue.sounds.collectXp },
         soulsDao = soulsDaoModule.soulsDao,
         effectEmitter = platformServiceModule.effectEmitter,
-        experiencedFactory = platformServiceModule.onlineMinecraftPlayerExperiencedFactory
+        experiencedFactory = platformServiceModule.onlineMinecraftPlayerExperiencedFactory,
+        dispatchers = coreModule.dispatchers
     )
-    private val pickUpSoulService = TickFlowService(
+    private val pickUpSoulService = ThrottleTickFlowService(
         coroutineContext = coreModule.dispatchers.IO,
         delay = flowOf(3.seconds),
         executor = PickUpWorker(
diff --git a/modules/service/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/domain/PickUpExpUseCase.kt b/modules/service/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/domain/PickUpExpUseCase.kt
@@ -1,6 +1,8 @@
 package ru.astrainteractive.soulkeeper.module.souls.domain
 
+import kotlinx.coroutines.withContext
 import ru.astrainteractive.astralibs.server.player.OnlineMinecraftPlayer
+import ru.astrainteractive.klibs.mikro.core.dispatchers.KotlinDispatchers
 import ru.astrainteractive.klibs.mikro.core.logging.JUtiltLogger
 import ru.astrainteractive.klibs.mikro.core.logging.Logger
 import ru.astrainteractive.soulkeeper.core.plugin.SoulsConfig
@@ -13,6 +15,7 @@ class PickUpExpUseCase(
     private val collectXpSoundProvider: () -> SoulsConfig.Sounds.SoundConfig,
     private val soulsDao: SoulsDao,
     private val effectEmitter: EffectEmitter,
+    private val dispatchers: KotlinDispatchers,
     private val experiencedFactory: Experienced.Factory<OnlineMinecraftPlayer>
 ) : Logger by JUtiltLogger("PickUpExpUseCase") {
     sealed interface Output {
@@ -22,12 +25,14 @@ class PickUpExpUseCase(
 
     suspend fun invoke(player: OnlineMinecraftPlayer, soul: ItemDatabaseSoul): Output {
         if (soul.exp <= 0) return Output.NoExpPresent
-        effectEmitter.playSoundForPlayer(
-            location = soul.location,
-            player = player,
-            sound = collectXpSoundProvider.invoke()
-        )
-        experiencedFactory.create(player).giveExperience(soul.exp)
+        withContext(dispatchers.Main) {
+            effectEmitter.playSoundForPlayer(
+                location = soul.location,
+                player = player,
+                sound = collectXpSoundProvider.invoke()
+            )
+            experiencedFactory.create(player).giveExperience(soul.exp)
+        }
         soulsDao.updateSoul(soul = soul.copy(exp = 0))
         return Output.ExpCollected
     }
diff --git a/modules/service/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/domain/PickUpSoulUseCase.kt b/modules/service/src/main/kotlin/ru/astrainteractive/soulkeeper/module/souls/domain/PickUpSoulUseCase.kt
@@ -28,23 +28,23 @@ internal class PickUpSoulUseCase(
     }
 
     suspend fun invoke(player: OnlineMinecraftPlayer, soul: ItemDatabaseSoul): Output {
-        return withContext(dispatchers.Main) {
-            pickUpExpUseCase.invoke(player, soul)
-            val updatedSoul = soul.copy(exp = 0)
+        pickUpExpUseCase.invoke(player, soul)
+        val updatedSoul = soul.copy(exp = 0)
 
-            val pickUpOutput = pickUpItemsUseCase.invoke(
-                player = player,
-                soul = updatedSoul
-            )
+        val pickUpOutput = pickUpItemsUseCase.invoke(
+            player = player,
+            soul = updatedSoul
+        )
 
-            val isAllItemsPickedUp = when (pickUpOutput) {
-                PickUpItemsUseCase.Output.NoItemsPresent,
-                PickUpItemsUseCase.Output.ItemsCollected -> true
+        val isAllItemsPickedUp = when (pickUpOutput) {
+            PickUpItemsUseCase.Output.NoItemsPresent,
+            PickUpItemsUseCase.Output.ItemsCollected -> true
 
-                PickUpItemsUseCase.Output.SomeItemsRemain -> false
-            }
+            PickUpItemsUseCase.Output.SomeItemsRemain -> false
+        }
 
-            if (!isAllItemsPickedUp) {
+        if (!isAllItemsPickedUp) {
+            withContext(dispatchers.Main) {
                 effectEmitter.playSoundForPlayer(
                     location = updatedSoul.location,
                     player = player,
@@ -55,9 +55,11 @@ internal class PickUpSoulUseCase(
                     player = player,
                     config = soulContentLeftParticleProvider.invoke()
                 )
-                return@withContext Output.SomethingRest
             }
-            soulsDao.deleteSoul(updatedSoul.id)
+            return Output.SomethingRest
+        }
+        soulsDao.deleteSoul(updatedSoul.id)
+        withContext(dispatchers.Main) {
             effectEmitter.playSoundForPlayer(
                 location = updatedSoul.location,
                 player = player,
@@ -68,7 +70,7 @@ internal class PickUpSoulUseCase(
                 player = player,
                 config = soulGoneParticleProvider.invoke()
             )
-            return@withContext Output.AllPickedUp
         }
+        return Output.AllPickedUp
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -4,7 +4,7 @@ import kotlinx.coroutines.CoroutineScope`
`4`	`4`	`import kotlinx.coroutines.GlobalScope`
`5`	`5`	`import kotlinx.coroutines.flow.Flow`
`6`	`6`	`import kotlinx.coroutines.flow.SharingStarted`
`7`		`-import kotlinx.coroutines.flow.first`
	`7`	`+import kotlinx.coroutines.flow.firstOrNull`
`8`	`8`	`import kotlinx.coroutines.flow.flow`
`9`	`9`	`import kotlinx.coroutines.flow.shareIn`
`10`	`10`	`import kotlinx.coroutines.launch`
`@@ -55,7 +55,7 @@ interface SoulsDaoModule {`
`55`	`55`	`override val lifecycle: Lifecycle = Lifecycle.Lambda(`
`56`	`56`	`onDisable = {`
`57`	`57`	`GlobalScope.launch(dispatchers.IO) {`
`58`		`- TransactionManager.closeAndUnregister(databaseFlow.first())`
	`58`	`+ databaseFlow.firstOrNull()?.let(TransactionManager::closeAndUnregister)`
`59`	`59`	`}`
`60`	`60`	`}`
`61`	`61`	`)`
Original file line number	Diff line number	Diff line change
`@@ -35,6 +35,7 @@ class BukkitPlatformServiceModule(`
`35`	`35`	`override val showArmorStandUseCase: ShowArmorStandUseCase = ShowArmorStandUseCaseFactory(coreModule).create()`
`36`	`36`	`override val pickUpItemsUseCase: PickUpItemsUseCase = BukkitPickUpItemsUseCase(`
`37`	`37`	`collectItemSoundProvider = { coreModule.soulsConfigKrate.cachedValue.sounds.collectItem },`
`38`		`- soulsDao = soulsDaoModule.soulsDao`
	`38`	`+ soulsDao = soulsDaoModule.soulsDao,`
	`39`	`+ dispatchers = coreModule.dispatchers`
`39`	`40`	`)`
`40`	`41`	`}`
Original file line number	Diff line number	Diff line change
`@@ -33,6 +33,7 @@ class NeoForgePlatformServiceModule(`
`33`	`33`	`collectItemSoundProvider = { coreModule.soulsConfigKrate.cachedValue.sounds.collectItem },`
`34`	`34`	`soulsDao = soulsDaoModule.soulsDao,`
`35`	`35`	`effectEmitter = effectEmitter,`
`36`		`- isDeadPlayerProvider = isDeadPlayerProvider`
	`36`	`+ isDeadPlayerProvider = isDeadPlayerProvider,`
	`37`	`+ dispatchers = coreModule.dispatchers`
`37`	`38`	`)`
`38`	`39`	`}`