Merge branch 'fix-bucket-reuse' into '1.8.0'

Fixed multi-spawns in a single pass using the same bucket for all of them See merge request cable-mc/cobblemon!2104
2026-01-22 13:21:39 +00:00
parent fe35a63769 0752ab3cac
commit f450d9d2d6
5 changed files with 170 additions and 122 deletions
@@ -0,0 +1,19 @@
+# Changelog
+## [1.8.0 (MONTH Xth, 2026)](#1-8-0)
+
+### Additions
+
+### Changes
+
+### Fixes
+- Fixed rare Pokémon being far too likely to spawn multiple times in a single spawn cycle. The dev told me that the exact bug is too complicated to explain.
+
+### Developer
+- Tweaked the spawning selector interface to take a bucket function rather than a bucket directly.
+
+### Molang & Datapacks
+
+### Particles
+
+### Localization
+- Updated translations for:
@@ -44,7 +44,7 @@ import kotlin.random.Random
 * @since July 10th, 2022
 */
 open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelectionData> {
-    class SelectingSpawnInformation {
+    class SelectingSpawnInformation(val spawnDetail: SpawnDetail) {
        val spawnablePositions = mutableMapOf<SpawnablePosition, Float>()
        var highestWeight = 0F

@@ -58,61 +58,81 @@ open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelecti
        fun chooseSpawnablePosition() = spawnablePositions.entries.weightedSelection { it.value }!!.key
    }

-    class SpawnablePositionSelectionData(
-        val spawnToSpawnablePosition: MutableMap<SpawnDetail, SelectingSpawnInformation>,
-        var percentSum: Float
-    ): SpawnSelectionData {
-        val size: Int
-            get() = spawnToSpawnablePosition.size
+    class SpawnablePositionBucketSelectionData(
+        val selectingSpawnInformation: MutableList<SelectingSpawnInformation>
+    ) {
+        var percentSum: Float = 0F
+        val seenSpawns = mutableListOf<SpawnDetail>()

+        fun add(spawnDetail: SpawnDetail, spawnablePosition: SpawnablePosition) {
+            // Only add to percentSum if this is the first time we've seen this SpawnDetail, otherwise
+            // the percentage will get amplified for every spawnable position the thing was possible, completely
+            // ruining the point of this pre-selection percentage.
+            if (spawnDetail.percentage > 0 && spawnDetail !in seenSpawns) {
+                seenSpawns.add(spawnDetail)
+                percentSum += spawnDetail.percentage
+            }
+            val spawnInformation = selectingSpawnInformation.find { it.spawnDetail == spawnDetail }
+                ?: SelectingSpawnInformation(spawnDetail).also { selectingSpawnInformation.add(it) }
+            spawnInformation.add(spawnablePosition, spawnablePosition.getWeight(spawnDetail))
+        }
+
+        fun remove(spawnInformation: SelectingSpawnInformation) {
+            selectingSpawnInformation -= spawnInformation
+            if (spawnInformation.spawnDetail.percentage > 0) {
+                percentSum -= spawnInformation.spawnDetail.percentage
+            }
+        }
+    }
+
+    class SpawnablePositionSelectionData(
+        val spawner: Spawner,
+        val spawnablePositions: List<SpawnablePosition>,
+        val selectingSpawnInformation: MutableMap<SpawnBucket, SpawnablePositionBucketSelectionData>,
+    ): SpawnSelectionData {
        override val spawnActions = mutableListOf<SpawnAction<*>>()
        override val context = mutableMapOf<String, Any>()

+        fun getDataForBucket(bucket: SpawnBucket): SpawnablePositionBucketSelectionData {
+            val existing = selectingSpawnInformation[bucket]
+            if (existing != null) {
+                return existing
+            }
+
+            val bucketSpawnInformation = SpawnablePositionBucketSelectionData(mutableListOf())
+            spawnablePositions.forEach { spawnablePosition ->
+                spawner.getMatchingSpawns(bucket, spawnablePosition).forEach {
+                    bucketSpawnInformation.add(it, spawnablePosition)
+                }
+            }
+
+            selectingSpawnInformation[bucket] = bucketSpawnInformation
+            return bucketSpawnInformation
+        }
+
        override fun removeSpawnDetails(shouldRemove: (SpawnDetail) -> Boolean) {
-            val toRemove = spawnToSpawnablePosition.entries.filter { shouldRemove(it.key) }
-            toRemove.forEach { spawnToSpawnablePosition.remove(it.key) }
-            percentSum -= toRemove.sumOf { it.key.percentage.toDouble().takeIf { it > 0 } ?: 0.0 }.toFloat()
+            selectingSpawnInformation.flatMap { it.value.selectingSpawnInformation.filter { shouldRemove(it.spawnDetail) } }
+                .forEach { selectingSpawnInformation[it.spawnDetail.bucket]?.remove(it) }
        }

        override fun removeSpawnablePositions(shouldRemove: (SpawnDetail, SpawnablePosition) -> Boolean) {
-            val toRemove = spawnToSpawnablePosition.entries.filter { (spawnDetail, positionData) ->
-                positionData.spawnablePositions.removeIf { shouldRemove(spawnDetail, it.key) }
+            val toRemove = selectingSpawnInformation.flatMap { it.value.selectingSpawnInformation }.filter { positionData ->
+                positionData.spawnablePositions.removeIf { shouldRemove(positionData.spawnDetail, it.key) }
                positionData.highestWeight = positionData.spawnablePositions.maxOfOrNull { it.value } ?: 0F
                positionData.spawnablePositions.isEmpty()
            }

-            toRemove.forEach { spawnToSpawnablePosition.remove(it.key) }
-
-            percentSum -= toRemove.sumOf { it.key.percentage.toDouble().takeIf { it > 0 } ?: 0.0 }.toFloat()
+            toRemove.forEach { selectingSpawnInformation[it.spawnDetail.bucket]?.remove(it) }
        }
    }

    override fun getSelectionData(
        spawner: Spawner,
-        bucket: SpawnBucket,
        spawnablePositions: List<SpawnablePosition>
    ): SpawnablePositionSelectionData {
-        val spawnToSpawnablePosition: MutableMap<SpawnDetail, SelectingSpawnInformation> = mutableMapOf()
-        var percentSum = 0F
+        val selectingSpawnInformation: MutableMap<SpawnBucket, SpawnablePositionBucketSelectionData> = mutableMapOf()

-        spawnablePositions.forEach { spawnablePosition ->
-            spawner.getMatchingSpawns(bucket, spawnablePosition).forEach {
-                // Only add to percentSum if this is the first time we've seen this SpawnDetail, otherwise
-                // the percentage will get amplified for every spawnable position the thing was possible, completely
-                // ruining the point of this pre-selection percentage.
-                if (it.percentage > 0 && !spawnToSpawnablePosition.containsKey(it)) {
-                    percentSum += it.percentage
-                }
-
-                val selectingSpawnInformation = spawnToSpawnablePosition.getOrPut(
-                    it,
-                    ::SelectingSpawnInformation
-                )
-                selectingSpawnInformation.add(spawnablePosition, spawnablePosition.getWeight(it))
-            }
-        }
-
-        return SpawnablePositionSelectionData(spawnToSpawnablePosition, percentSum)
+        return SpawnablePositionSelectionData(spawner, spawnablePositions, selectingSpawnInformation)
    }

    override fun selectSpawnAction(
@@ -120,8 +140,8 @@ open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelecti
        bucket: SpawnBucket,
        selectionData: SpawnablePositionSelectionData,
    ): SpawnAction<*>? {
-        val spawnToSpawnablePosition = selectionData.spawnToSpawnablePosition
-        var percentSum = selectionData.percentSum
+        val selectingSpawnInformation = selectionData.getDataForBucket(bucket) ?: return null
+        var percentSum = selectingSpawnInformation.percentSum

        // First pass is doing percentage checks.
        if (percentSum > 0) {
@@ -129,7 +149,7 @@ open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelecti
            if (percentSum > 100) {
                Cobblemon.LOGGER.warn(
                    """
-                        A spawn list for ${spawner.name} exceeded 100% on percentage sums...
+                        A spawn list for ${spawner.name} exceeded 100% on percentage sums in bucket ${bucket.name}...
                        This means you don't understand how this option works.
                    """.trimIndent()
                )
@@ -140,13 +160,13 @@ open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelecti
             * It's [0, 1) and I want (0, 1]
             * See half-open intervals here https://en.wikipedia.org/wiki/Interval_(mathematics)#Terminology
             */
-            val selectedPercentage = 100 - Random.Default.nextFloat() * 100
+            val selectedPercentage = 100 - Random.nextFloat() * 100
            percentSum = 0F
-            for ((spawnDetail, info) in spawnToSpawnablePosition) {
-                if (spawnDetail.percentage > 0) {
-                    percentSum += spawnDetail.percentage
+            for (info in selectingSpawnInformation.selectingSpawnInformation) {
+                if (info.spawnDetail.percentage > 0) {
+                    percentSum += info.spawnDetail.percentage
                    if (percentSum >= selectedPercentage) {
-                        return spawnDetail.choose(
+                        return info.spawnDetail.choose(
                            spawnablePosition = info.chooseSpawnablePosition(),
                            bucket = bucket,
                            selectionData = selectionData
@@ -156,9 +176,9 @@ open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelecti
            }
        }

-        val selectedSpawn = spawnToSpawnablePosition.entries.toList().weightedSelection { it.value.highestWeight }!!
-        return selectedSpawn.key.choose(
-            spawnablePosition = selectedSpawn.value.chooseSpawnablePosition(),
+        val selectedSpawn = selectingSpawnInformation.selectingSpawnInformation.toList().weightedSelection { it.highestWeight }!!
+        return selectedSpawn.spawnDetail.choose(
+            spawnablePosition = selectedSpawn.chooseSpawnablePosition(),
            bucket = bucket,
            selectionData = selectionData
        )
@@ -169,16 +189,16 @@ open class FlatSelector : SpawningSelector<FlatSelector.SpawnablePositionSelecti
        bucket: SpawnBucket,
        spawnablePositions: List<SpawnablePosition>
    ): Map<SpawnDetail, Float> {
-        val selectionData = getSelectionData(spawner, bucket, spawnablePositions)
+        val selectionData = getSelectionData(spawner, spawnablePositions).getDataForBucket(bucket)

-        if (selectionData.size == 0) {
+        if (selectionData.selectingSpawnInformation.isEmpty()) {
            return emptyMap()
        }

        val totalWeights = mutableMapOf<SpawnDetail, Float>()

-        for ((spawnDetail, info) in selectionData.spawnToSpawnablePosition.entries) {
-            totalWeights[spawnDetail] = info.highestWeight
+        for (info in selectionData.selectingSpawnInformation) {
+            totalWeights[info.spawnDetail] = info.highestWeight
        }

        return totalWeights
@@ -18,7 +18,6 @@ import com.cobblemon.mod.common.api.spawning.spawner.Spawner
 import com.cobblemon.mod.common.util.removeIf
 import com.cobblemon.mod.common.util.weightedSelection
 import kotlin.random.Random
-import kotlin.reflect.full.createInstance

 /**
 * A spawning selector that compiles a distinct list of all spawn details that
@@ -33,9 +32,9 @@ import kotlin.reflect.full.createInstance
 * of an entire spawnable position type to favour whichever are the more populous.
 *
 * The weight for a spawn when doing primary selection is whichever spawnable position-influenced
- * weight is highest (as weight multipliers exist per spawnable position) and then the
- * selection of which spawnable position to spawn the primary selected spawn uses the spawnable
- * position-adjusted weight.
+ * weight is highest (as weight multipliers exist per spawnable position). After the spawn has been
+ * chosen, the selection of which spawnable position to spawn it at is selected via another weighted
+ * selection using spawnable position-adjusted weights.
 *
 * At a glance:
 * - Spawn detail selection is flat across spawnable position quantity
@@ -45,7 +44,6 @@ import kotlin.reflect.full.createInstance
 * @since July 10th, 2022
 */
 open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnablePositionWeightedSelector.SeparatedSelectionData> {
-    open fun getWeight(spawnablePositionType: SpawnablePositionType<*>) = spawnablePositionType.getWeight()

    class SelectingSpawnInformation {
        val spawnablePositionWeights = mutableMapOf<SpawnablePosition, Float>()
@@ -62,13 +60,25 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
        fun chooseSpawnablePosition() = spawnablePositionWeights.keys.toList().weightedSelection { spawnablePositionWeights[it]!! }!!
    }

-    class SpawnablePositionSelectionData(
-        val spawnToSpawnablePosition: MutableMap<SpawnDetail, SelectingSpawnInformation>,
-        var percentSum: Float
-    ) {
+    class SpawnablePositionSelectionData {
+        val spawnToSpawnablePosition = mutableMapOf<SpawnDetail, SelectingSpawnInformation>()
+        var percentSum: Float = 0F
+        val seenSpawns = mutableListOf<SpawnDetail>()
        val size: Int
            get() = spawnToSpawnablePosition.size

+        fun add(spawnDetail: SpawnDetail, spawnablePosition: SpawnablePosition) {
+            // Only add to percentSum if this is the first time we've seen this SpawnDetail for this spawnable
+            // position type, otherwise the percentage will get amplified for every spawnable position the thing
+            // was possible, completely ruining the point of this pre-selection percentage.
+            if (spawnDetail.percentage > 0 && spawnDetail !in seenSpawns) {
+                percentSum += spawnDetail.percentage
+                seenSpawns.add(spawnDetail)
+            }
+            val selectingSpawnInformation = spawnToSpawnablePosition.getOrPut(spawnDetail, ::SelectingSpawnInformation)
+            selectingSpawnInformation.add(spawnDetail, spawnablePosition, 1F)
+        }
+
        fun removeSpawnDetails(shouldRemove: (SpawnDetail) -> Boolean) {
            val toRemove = spawnToSpawnablePosition.entries.filter { shouldRemove(it.key) }
            toRemove.forEach { spawnToSpawnablePosition.remove(it.key) }
@@ -89,67 +99,68 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
    }

    class SeparatedSelectionData(
-        val spawnablePositionTypeToSpawns: MutableMap<SpawnablePositionType<*>, SpawnablePositionSelectionData>
-    ): SpawnSelectionData {
+        val spawner: Spawner,
+        val spawnablePositions: List<SpawnablePosition>
+    ) : SpawnSelectionData {
        override val spawnActions = mutableListOf<SpawnAction<*>>()
        override val context = mutableMapOf<String, Any>()

+        val bucketData = mutableMapOf<SpawnBucket, MutableMap<SpawnablePositionType<*>, SpawnablePositionSelectionData>>()
+
        override fun removeSpawnDetails(shouldRemove: (SpawnDetail) -> Boolean) {
-            spawnablePositionTypeToSpawns.values.forEach { it.removeSpawnDetails(shouldRemove) }
-            spawnablePositionTypeToSpawns.removeIf { it.value.size == 0 }
+            bucketData.values.forEach {
+                it.values.forEach { it.removeSpawnDetails(shouldRemove) }
+                it.removeIf { it.value.size == 0 }
+            }
        }

        override fun removeSpawnablePositions(shouldRemove: (SpawnDetail, SpawnablePosition) -> Boolean) {
-            spawnablePositionTypeToSpawns.values.forEach { it.removeSpawnablePositions(shouldRemove) }
-            spawnablePositionTypeToSpawns.removeIf { it.value.size == 0 }
+            bucketData.values.forEach {
+                it.values.forEach { it.removeSpawnablePositions(shouldRemove) }
+                it.removeIf { it.value.size == 0 }
+            }
+        }
+
+        fun getDataForBucket(bucket: SpawnBucket): MutableMap<SpawnablePositionType<*>, SpawnablePositionSelectionData> {
+            bucketData[bucket]?.let { return it }
+
+            val spawnablePositionTypeToSpawns = mutableMapOf<SpawnablePositionType<*>, SpawnablePositionSelectionData>()
+
+            spawnablePositions.forEach { spawnablePosition ->
+                val spawnablePositionType = SpawnablePosition.getByClass(spawnablePosition)!!
+
+                val possible = spawner.getMatchingSpawns(bucket, spawnablePosition)
+                if (possible.isNotEmpty()) {
+                    val spawnablePositionSelectionData = spawnablePositionTypeToSpawns
+                        .getOrPut(spawnablePositionType, ::SpawnablePositionSelectionData)
+                    possible.forEach { spawnablePositionSelectionData.add(it, spawnablePosition) }
+                }
+            }
+
+            bucketData[bucket] = spawnablePositionTypeToSpawns
+            return spawnablePositionTypeToSpawns
        }
    }

    override fun getSelectionData(
        spawner: Spawner,
-        bucket: SpawnBucket,
        spawnablePositions: List<SpawnablePosition>
-    ): SeparatedSelectionData {
-        val spawnablePositionTypeToSpawns = mutableMapOf<SpawnablePositionType<*>, SpawnablePositionSelectionData>()
-
-        spawnablePositions.forEach { spawnablePosition ->
-            val spawnablePositionType = SpawnablePosition.getByClass(spawnablePosition)!!
-
-            val possible = spawner.getMatchingSpawns(bucket, spawnablePosition)
-            if (possible.isNotEmpty()) {
-                val spawnablePositionSelectionData = spawnablePositionTypeToSpawns.getOrPut(spawnablePositionType) { SpawnablePositionSelectionData(mutableMapOf(), 0F) }
-                possible.forEach {
-                    // Only add to percentSum if this is the first time we've seen this SpawnDetail for this spawnable
-                    // position type, otherwise the percentage will get amplified for every spawnable position the thing
-                    // was possible, completely ruining the point of this pre-selection percentage.
-                    if (it.percentage > 0 && !spawnablePositionSelectionData.spawnToSpawnablePosition.containsKey(it)) {
-                        spawnablePositionSelectionData.percentSum += it.percentage
-                    }
-
-                    val selectingSpawnInformation = spawnablePositionSelectionData.spawnToSpawnablePosition.getOrPut(
-                        it,
-                        SelectingSpawnInformation::class::createInstance
-                    )
-                    selectingSpawnInformation.add(it, spawnablePosition, getWeight(spawnablePositionType))
-                }
-            }
-        }
-
-        return SeparatedSelectionData(spawnablePositionTypeToSpawns)
-    }
+    ) = SeparatedSelectionData(spawner, spawnablePositions)

    override fun selectSpawnAction(
        spawner: Spawner,
        bucket: SpawnBucket,
        selectionData: SeparatedSelectionData
    ): SpawnAction<*>? {
-        if (selectionData.spawnablePositionTypeToSpawns.isEmpty()) {
+        val bucketData = selectionData.getDataForBucket(bucket)
+
+        if (bucketData.isEmpty()) {
            return null
        }

        // Which spawnable position type should we use?
-        val spawnablePositionSelectionData = selectionData.spawnablePositionTypeToSpawns.entries.toList()
-            .weightedSelection { getWeight(it.key) * it.value.size }
+        val spawnablePositionSelectionData = bucketData.entries.toList()
+            .weightedSelection { it.key.getWeight() * it.value.size }
            ?.value
            ?: return null

@@ -161,7 +172,7 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
            if (percentSum > 100) {
                LOGGER.warn(
                    """
-                        A spawn list for ${spawner.name} exceeded 100% on percentage sums...
+                        A spawn list for ${spawner.name} exceeded 100% on percentage sums in bucket ${bucket.name}...
                        This means you don't understand how this option works.
                    """.trimIndent()
                )
@@ -173,7 +184,7 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
             * It's [0, 1) and I want (0, 1]
             * See half-open intervals here https://en.wikipedia.org/wiki/Interval_(mathematics)#Terminology
             */
-            val selectedPercentage = 100 - Random.Default.nextFloat() * 100
+            val selectedPercentage = 100 - Random.nextFloat() * 100
            percentSum = 0F
            for ((spawnDetail, info) in spawnToSpawnablePosition) {
                if (spawnDetail.percentage > 0) {
@@ -224,7 +235,8 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
        val percentageWeight = (rescaledTotalWeight - totalWeight) / percentSum

        for ((spawnDetail, info) in spawnToSpawnablePosition.entries) {
-            totalWeights[spawnDetail] = info.highestWeight + if (spawnDetail.percentage > 0) spawnDetail.percentage * percentageWeight else 0F
+            totalWeights[spawnDetail] =
+                info.highestWeight + if (spawnDetail.percentage > 0) spawnDetail.percentage * percentageWeight else 0F
        }

        return totalWeights
@@ -235,18 +247,18 @@ open class FlatSpawnablePositionWeightedSelector : SpawningSelector<FlatSpawnabl
        bucket: SpawnBucket,
        spawnablePositions: List<SpawnablePosition>
    ): Map<SpawnDetail, Float> {
-        val selectionData = getSelectionData(spawner, bucket, spawnablePositions)
+        val selectionData = getSelectionData(spawner, spawnablePositions).getDataForBucket(bucket)

-        if (selectionData.spawnablePositionTypeToSpawns.isEmpty()) {
+        if (selectionData.isEmpty()) {
            return mapOf()
        }

        val totalWeights = mutableMapOf<SpawnDetail, Float>()

-        val totalSpawnablePositionWeight = selectionData.spawnablePositionTypeToSpawns.keys.sumOf { getWeight(it).toDouble() }.toFloat()
+        val totalSpawnablePositionWeight = selectionData.keys.sumOf { it.getWeight().toDouble() }.toFloat()

-        for ((spawnablePositionType, spawnPositionSelectionData) in selectionData.spawnablePositionTypeToSpawns) {
-            val spawnPositionWeightCorrection = getWeight(spawnablePositionType) / totalSpawnablePositionWeight
+        for ((spawnablePositionType, spawnPositionSelectionData) in selectionData) {
+            val spawnPositionWeightCorrection = spawnablePositionType.getWeight() / totalSpawnablePositionWeight
            val spawnPositionProbabilities = getProbabilitiesFromSpawnablePositionType(spawner, spawnPositionSelectionData)

            spawnPositionProbabilities.entries.forEach {
@@ -29,7 +29,7 @@ interface SpawningSelector<T : SpawnSelectionData> {
        val DEFAULT = FlatSpawnablePositionWeightedSelector()
    }

-    fun getSelectionData(spawner: Spawner, bucket: SpawnBucket, spawnablePositions: List<SpawnablePosition>): T
+    fun getSelectionData(spawner: Spawner, spawnablePositions: List<SpawnablePosition>): T

    fun selectSpawnAction(
        spawner: Spawner,
@@ -37,12 +37,18 @@ interface SpawningSelector<T : SpawnSelectionData> {
        selectionData: T
    ): SpawnAction<*>?

-    fun select(spawner: Spawner, bucket: SpawnBucket, spawnablePositions: List<SpawnablePosition>, maxSpawns: Int): List<SpawnAction<*>> {
-        val selectionData = getSelectionData(spawner, bucket, spawnablePositions)
+    fun select(
+        spawner: Spawner,
+        bucketSelector: () -> SpawnBucket,
+        spawnablePositions: List<SpawnablePosition>,
+        maxSpawns: Int
+    ): List<SpawnAction<*>> {
+        val selectionData = getSelectionData(spawner, spawnablePositions)

        val spawnActions = selectionData.spawnActions

        while (spawnActions.size < maxSpawns) {
+            val bucket = bucketSelector()
            val spawnAction = selectSpawnAction(
                spawner = spawner,
                bucket = bucket,
@@ -29,13 +29,6 @@ import com.cobblemon.mod.common.util.isBoxLoaded
 import com.cobblemon.mod.common.util.squeezeWithinBounds
 import com.cobblemon.mod.common.util.toVec3f
 import com.cobblemon.mod.common.util.weightedSelection
-import kotlin.Any
-import kotlin.Boolean
-import kotlin.Float
-import kotlin.Int
-import kotlin.Pair
-import kotlin.String
-import kotlin.collections.plus
 import kotlin.math.max
 import net.minecraft.core.BlockPos
 import net.minecraft.core.SectionPos
@@ -95,10 +88,9 @@ interface Spawner {
    ): SpawnAction<*>? {
        influences.removeIf { it.isExpired() }
        spawnablePosition.influences.addAll(influences)
-        val bucket = chooseBucket(cause, spawnablePosition.influences)
        return selector.select(
            spawner = this,
-            bucket = bucket,
+            bucketSelector = { chooseBucket(cause, spawnablePosition.influences) },
            spawnablePositions = listOf(spawnablePosition),
            maxSpawns = 1
        ).firstOrNull()
@@ -116,9 +108,9 @@ interface Spawner {

        val areaBox = AABB.ofSize(
            Vec3(constrainedArea.getCenter().toVec3f()),
-            ENTITY_LIMIT_CHUNK_RANGE * 16.0 * 2,
+            ENTITY_LIMIT_CHUNK_RANGE * 16.0,
            1000.0,
-            ENTITY_LIMIT_CHUNK_RANGE * 16.0 * 2
+            ENTITY_LIMIT_CHUNK_RANGE * 16.0
        )

        if (!constrainedArea.world.isBoxLoaded(areaBox)) {
@@ -140,11 +132,10 @@ interface Spawner {
        val zone = generator.generate(this, constrainedArea)
        val spawnablePositions = resolver.resolve(this, prioritizedAreaCalculators, zone)
        val influences = influences + zone.unconditionalInfluences
-        val bucket = chooseBucket(zoneInput.cause, influences)

        return selector.select(
            spawner = this,
-            bucket = bucket,
+            bucketSelector = { chooseBucket(zoneInput.cause, influences) },
            spawnablePositions = spawnablePositions,
            maxSpawns = maxSpawns
        )