move context collection actions into the managers and improve activity checks from other managers

Author: beanbag44

src/main/kotlin/com/lambda/interaction/request/breaking/BreakManager.kt

@@ -56,7 +56,7 @@ import com.lambda.interaction.request.breaking.BreakManager.breaks
 import com.lambda.interaction.request.breaking.BreakManager.canAccept
 import com.lambda.interaction.request.breaking.BreakManager.checkForCancels
 import com.lambda.interaction.request.breaking.BreakManager.initNewBreak
-import com.lambda.interaction.request.breaking.BreakManager.maxInstantBreaksThisTick
+import com.lambda.interaction.request.breaking.BreakManager.maxBreaksThisTick
 import com.lambda.interaction.request.breaking.BreakManager.processNewBreak
 import com.lambda.interaction.request.breaking.BreakManager.processRequest
 import com.lambda.interaction.request.breaking.BreakManager.simulateAbandoned
@@ -94,6 +94,7 @@ import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Box
 import net.minecraft.world.BlockView
 import kotlin.math.max
+import kotlin.math.min
 
 object BreakManager : RequestHandler<BreakRequest>(
     0,
@@ -150,8 +151,8 @@ object BreakManager : RequestHandler<BreakRequest>(
     private val rotated get() = rotationRequest?.done != false
 
     private var breakCooldown = 0
-    var instantBreaksThisTick = 0
-    private var maxInstantBreaksThisTick = 0
+    var breaksThisTick = 0
+    private var maxBreaksThisTick = 0
 
     private var breaks = mutableListOf<BreakContext>()
 
@@ -178,7 +179,7 @@ object BreakManager : RequestHandler<BreakRequest>(
             }
             activeRequest = null
             breaks = mutableListOf()
-            instantBreaksThisTick = 0
+            breaksThisTick = 0
         }
 
         listen<WorldEvent.BlockUpdate.Server>(priority = Int.MIN_VALUE) { event ->
@@ -292,7 +293,7 @@ object BreakManager : RequestHandler<BreakRequest>(
      * @see processRequest
      */
     override fun SafeContext.handleRequest(request: BreakRequest) {
-        if (activeRequest != null || PlaceManager.activeThisTick || InteractionManager.activeThisTick || request.contexts.isEmpty()) return
+        if (activeRequest != null || request.contexts.isEmpty()) return
 
         activeRequest = request
         processRequest(request)
@@ -309,6 +310,8 @@ object BreakManager : RequestHandler<BreakRequest>(
      * @see updateBreakProgress
      */
     private fun SafeContext.processRequest(breakRequest: BreakRequest?) {
+        if (PlaceManager.activeThisTick || InteractionManager.activeThisTick) return
+
         breakRequest?.let { request ->
             logger.debug("Processing request", breakRequest)
             if (request.fresh) populateFrom(request)
@@ -344,15 +347,15 @@ object BreakManager : RequestHandler<BreakRequest>(
             if (activeRequest != null) logger.debug("Clearing active request", activeRequest)
             activeRequest = null
         }
-        if (instantBreaksThisTick > 0 || activeInfos.isNotEmpty()) {
+        if (breaksThisTick > 0 || activeInfos.isNotEmpty()) {
             activeThisTick = true
         }
     }
 
     /**
      * Filters the requests [BreakContext]s, and iterates over the [breakInfos] collection looking for matches
      * in positions. If a match is found, the [BreakInfo] is updated with the new context. Otherwise, the break is cancelled.
-     * The [instantBreaks] and [breaks] collections are then populated with the new appropriate contexts, and the [maxInstantBreaksThisTick]
+     * The [instantBreaks] and [breaks] collections are then populated with the new appropriate contexts, and the [maxBreaksThisTick]
      * value is set.
      *
      * @see canAccept
@@ -363,39 +366,48 @@ object BreakManager : RequestHandler<BreakRequest>(
         // Sanitize the new breaks
         val newBreaks = request.contexts
             .distinctBy { it.blockPos }
+            .filter { canAccept(it) }
             .toMutableList()
 
         // Update the current break infos
         breakInfos
             .filterNotNull()
             .forEach { info ->
-                newBreaks.find { ctx -> ctx.blockPos == info.context.blockPos && canAccept(ctx) }?.let { ctx ->
-                    if ((!info.updatedThisTick || info.type == RedundantSecondary) || info.abandoned) {
-                        logger.debug("Updating info", info, ctx)
-                        if (info.type == RedundantSecondary)
-                            info.request.onStart?.invoke(info.context.blockPos)
-                        else if (info.abandoned) {
-                            info.abandoned = false
-                            info.request.onStart?.invoke(info.context.blockPos)
-                        } else
-                            info.request.onUpdate?.invoke(info.context.blockPos)
-
-                        info.updateInfo(ctx, request)
+                newBreaks
+                    .find { ctx -> ctx.blockPos == info.context.blockPos }
+                    ?.let { ctx ->
+                        if ((!info.updatedThisTick || info.type == RedundantSecondary) || info.abandoned) {
+                            logger.debug("Updating info", info, ctx)
+                            if (info.type == RedundantSecondary)
+                                info.request.onStart?.invoke(info.context.blockPos)
+                            else if (info.abandoned) {
+                                info.abandoned = false
+                                info.request.onStart?.invoke(info.context.blockPos)
+                            } else
+                                info.request.onUpdate?.invoke(info.context.blockPos)
+
+                            info.updateInfo(ctx, request)
+                        }
+                        newBreaks.remove(ctx)
+                        return@forEach
                     }
-                    newBreaks.remove(ctx)
-                    return@forEach
-                }
             }
 
+        val breakConfig = request.config
+
         breaks = newBreaks
             .sortedByDescending { it.instantBreak }
+            .take(
+                min(
+                    breakConfig.maxPendingBreaks - pendingBreakCount,
+                    request.build.maxPendingInteractions - request.pendingInteractions.size
+                ).coerceAtLeast(0)
+            )
             .toMutableList()
 
         logger.debug("${breaks.size} unprocessed breaks")
 
-        val breakConfig = request.config
-        val pendingLimit = (breakConfig.maxPendingBreaks - pendingBreakCount).coerceAtLeast(0)
-        maxInstantBreaksThisTick = breakConfig.breaksPerTick.coerceAtMost(pendingLimit)
+        maxBreaksThisTick = breakConfig.breaksPerTick
     }
 
     /**
@@ -404,11 +416,6 @@ object BreakManager : RequestHandler<BreakRequest>(
     private fun SafeContext.canAccept(newCtx: BreakContext): Boolean {
         if (activeInfos.none { it.context.blockPos == newCtx.blockPos } && isPosBlocked(newCtx.blockPos)) return false
 
-        if (newCtx.instantBreak && instantBreaksThisTick > maxInstantBreaksThisTick) return false
-
-        if (!currentStackSelection.filterStack(player.inventory.getStack(newCtx.hotbarIndex)))
-            return false
-
         val blockState = blockState(newCtx.blockPos)
         val hardness = newCtx.cachedState.getHardness(world, newCtx.blockPos)
 
@@ -462,7 +469,8 @@ object BreakManager : RequestHandler<BreakRequest>(
      */
     private fun SafeContext.processNewBreak(request: BreakRequest): Boolean {
         breaks.forEach { ctx ->
-            if (!canAccept(ctx)) return@forEach
+            if (breaksThisTick >= maxBreaksThisTick) return false
+            if (!currentStackSelection.filterStack(player.inventory.getStack(ctx.hotbarIndex))) return@forEach
 
             initNewBreak(ctx, request) ?: return false
             breaks.remove(ctx)
@@ -582,7 +590,7 @@ object BreakManager : RequestHandler<BreakRequest>(
                 info.startPending()
             }
         }
-        instantBreaksThisTick++
+        breaksThisTick++
         info.nullify()
     }
 
@@ -808,7 +816,6 @@ object BreakManager : RequestHandler<BreakRequest>(
             info.vanillaInstantBreakable = progress >= 1 && swapped
             onBlockBreak(info)
             if (!info.vanillaInstantBreakable) breakCooldown = info.breakConfig.breakDelay
-            instantBreaksThisTick++
         } else {
             logger.debug("Starting break", info)
             info.apply {

src/main/kotlin/com/lambda/interaction/request/breaking/RebreakHandler.kt

@@ -97,7 +97,7 @@ object RebreakHandler {
                 if (reBreak.breakConfig.swing.isEnabled()) {
                     swingHand(reBreak.breakConfig.swingType, Hand.MAIN_HAND)
                 }
-                BreakManager.instantBreaksThisTick++
+                BreakManager.breaksThisTick++
                 RebreakResult.Rebroke
             } else {
                 RebreakResult.StillBreaking(reBreak)

src/main/kotlin/com/lambda/interaction/request/interacting/InteractionManager.kt

@@ -90,14 +90,16 @@ object InteractionManager : RequestHandler<InteractRequest>(
     }
 
     override fun SafeContext.handleRequest(request: InteractRequest) {
-        if (activeRequest != null || BreakManager.activeThisTick || PlaceManager.activeThisTick) return
+        if (activeRequest != null || request.contexts.isEmpty()) return
 
         activeRequest = request
         processRequest(request)
         if (interactionsThisTick > 0) activeThisTick = true
     }
 
     fun SafeContext.processRequest(request: InteractRequest) {
+        if (BreakManager.activeThisTick || PlaceManager.activeThisTick) return
+
         logger.debug("Processing request", request)
 
         if (request.fresh) populateFrom(request)
@@ -139,13 +141,14 @@ object InteractionManager : RequestHandler<InteractRequest>(
         logger.debug("Populating from request", request)
         setPendingConfigs(request.build)
         potentialInteractions = request.contexts
+            .distinctBy { it.blockPos }
             .filter { !isPosBlocked(it.blockPos) }
+            .take((request.build.maxPendingInteractions - pendingActions.size).coerceAtLeast(0))
             .toMutableList()
 
         logger.debug("${potentialInteractions.size} potential interactions")
 
-        val pendingLimit = (request.build.maxPendingInteractions - pendingActions.size).coerceAtLeast(0)
-        maxInteractionsThisTick = (request.build.interactionsPerTick.coerceAtMost(pendingLimit))
+        maxInteractionsThisTick = request.build.interactionsPerTick
     }
 
     override fun preEvent() = UpdateManagerEvent.Interact.post()

src/main/kotlin/com/lambda/interaction/request/placing/PlaceManager.kt

@@ -65,6 +65,7 @@ import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import net.minecraft.util.math.Direction
 import net.minecraft.world.GameMode
+import kotlin.math.min
 
 object PlaceManager : RequestHandler<PlaceRequest>(
     0,
@@ -124,7 +125,7 @@ object PlaceManager : RequestHandler<PlaceRequest>(
      * @see processRequest
      */
     override fun SafeContext.handleRequest(request: PlaceRequest) {
-        if (activeRequest != null || BreakManager.activeThisTick || InteractionManager.activeThisTick) return
+        if (activeRequest != null || request.contexts.isEmpty()) return
 
         activeRequest = request
         processRequest(request)
@@ -142,6 +143,8 @@ object PlaceManager : RequestHandler<PlaceRequest>(
      * @see placeBlock
      */
     fun SafeContext.processRequest(request: PlaceRequest) {
+        if (BreakManager.activeThisTick || InteractionManager.activeThisTick) return
+
         logger.debug("Processing request", request)
 
         if (request.fresh) populateFrom(request)
@@ -185,12 +188,18 @@ object PlaceManager : RequestHandler<PlaceRequest>(
         logger.debug("Populating from request", request)
         setPendingConfigs(request.build)
         potentialPlacements = request.contexts
+            .distinctBy { it.blockPos }
             .filter { !isPosBlocked(it.blockPos) }
+            .take(
+                min(
+                    request.maxPendingPlacements - pendingActions.size,
+                    request.build.maxPendingInteractions - request.pendingInteractions.size
+                ).coerceAtLeast(0)
+            )
             .toMutableList()
         logger.debug("${potentialPlacements.size} potential placements")
 
-        val pendingLimit = (request.maxPendingPlacements - pendingActions.size).coerceAtLeast(0)
-        maxPlacementsThisTick = (request.placementsPerTick.coerceAtMost(pendingLimit))
+        maxPlacementsThisTick = request.placementsPerTick
     }
 
     /**

src/main/kotlin/com/lambda/task/tasks/BuildTask.kt

@@ -158,8 +158,6 @@ class BuildTask private constructor(
                         is BreakResult.Break -> {
                             val breakResults = resultsNotBlocked
                                 .filterIsInstance<BreakResult.Break>()
-                                .distinctBy { it.blockPos }
-                                .take(emptyPendingInteractionSlots)
                                 .map { it.context }
 
                             breakRequest(
@@ -175,17 +173,13 @@ class BuildTask private constructor(
                         is PlaceResult.Place -> {
                             val placeResults = resultsNotBlocked
                                 .filterIsInstance<PlaceResult.Place>()
-                                .distinctBy { it.blockPos }
-                                .take(emptyPendingInteractionSlots)
                                 .map { it.context }
 
                             PlaceRequest(placeResults, pendingInteractions, build, hotbar, rotation) { placements++ }.submit()
                         }
                         is InteractResult.Interact -> {
                             val interactResults = resultsNotBlocked
                                 .filterIsInstance<InteractResult.Interact>()
-                                .distinctBy { it.blockPos }
-                                .take(emptyPendingInteractionSlots)
                                 .map { it.context }
 
                             InteractRequest(interactResults, null, pendingInteractions, build.interacting, build, hotbar, rotation).submit()