pending interactions fixes / improvements

Author: beanbag44

common/src/main/kotlin/com/lambda/config/groups/BreakSettings.kt

@@ -32,14 +32,14 @@ class BreakSettings(
     override val doubleBreak by c.setting("Double Break", false, "Allows breaking two blocks at once") { vis() }
     override val breakDelay by c.setting("Break Delay", 5, 0..5, 1, "The delay between breaking blocks", " ticks") { vis() }
     override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand") { vis() }
-    override val swingType by c.setting("Break Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() }
+    override val swingType by c.setting("Break Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing != SwingMode.None }
     override val sounds by c.setting("Break Sounds", true, "Plays the breaking sounds") { vis() }
     override val particles by c.setting("Particles", true, "Renders the breaking particles") { vis() }
     override val breakingTexture by c.setting("Breaking Overlay", true, "Overlays the breaking texture at its different stages") { vis() }
     override val rotateForBreak by c.setting("Rotate For Break", true, "Rotate towards block while breaking") { vis() }
     override val ignoredBlocks by c.setting("Ignored Blocks", allSigns, "Blocks that wont be broken") { vis() }
     override val breakConfirmation by c.setting("Break Confirmation", BreakConfirmationMode.BreakThenAwait, "The style of confirmation used when breaking") { vis() }
-    override val maxPendingBreaks by c.setting("Max Pending Breaks", 2, 0..5, 1, "The maximum amount of pending breaks") { vis() }
+    override val maxPendingBreaks by c.setting("Max Pending Breaks", 5, 1..30, 1, "The maximum amount of pending breaks") { vis() }
     override val breaksPerTick by c.setting("Instant Breaks Per Tick", 5, 1..30, 1, "Maximum instant block breaks per tick") { vis() }
     override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)") { vis() }
     override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { vis() }

common/src/main/kotlin/com/lambda/config/groups/PlaceSettings.kt

@@ -29,9 +29,9 @@ class PlaceSettings(
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() }
     override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces") { vis() }
     override val placeConfirmationMode by c.setting("Place Confirmation", PlaceConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation") { vis() }
-    override val maxPendingPlacements by c.setting("Max Pending Placements", 2, 0..5, 1, "The maximum amount of pending placements") { vis() }
+    override val maxPendingPlacements by c.setting("Max Pending Placements", 5, 0..30, 1, "The maximum amount of pending placements") { vis() }
     override val placementsPerTick by c.setting("Instant Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() }
     override val swing by c.setting("Swing", true, "Swings the players hand when placing") { vis() }
-    override val swingType by c.setting("Place Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() }
+    override val swingType by c.setting("Place Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing }
     override val sounds by c.setting("Place Sounds", true, "Plays the placing sounds") { vis() }
 }

common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakConfig.kt

@@ -57,7 +57,10 @@ abstract class BreakConfig(
         Constant,
         StartAndEnd,
         Start,
-        End
+        End,
+        None;
+
+        fun isEnabled() = this != None
     }
 
     enum class BreakConfirmationMode {

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

@@ -27,6 +27,7 @@ import com.lambda.event.events.UpdateManagerEvent
 import com.lambda.event.events.WorldEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.interaction.construction.context.BreakContext
+import com.lambda.interaction.construction.context.BuildContext
 import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.request.PositionBlocking
 import com.lambda.interaction.request.Priority
@@ -77,6 +78,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
     ) {
         info("${it::class.simpleName} at ${it.context.expectedPos.toShortString()} timed out")
         mc.world?.setBlockState(it.context.expectedPos, it.context.checkedState)
+        it.pendingInteractionsList.remove(it.context)
     }
 
     override val blockedPositions
@@ -121,7 +123,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
                         handleRequestContext(
                             ctx,
                             buildConfig, rotationConfig, hotbarConfig,
-                            onBreak, onItemDrop
+                            pendingInteractionsList, onBreak, onItemDrop
                         )
                     } ?: return@request
                     if (!breakInfo.requestHotbarSwap()) return@forEach
@@ -156,6 +158,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
             currentRequest?.let request@ { request ->
                 val breakConfig = request.buildConfig.breakSettings
                 val takeCount = breakConfig.maxPendingBreaks - (breakingInfos.count { it != null } + pendingBreaks.size)
+                if (takeCount <= 0) return@request
                 val validContexts = request.contexts
                     .filter { ctx -> canAccept(ctx) }
                     .sortedBy { it.instantBreak }
@@ -174,7 +177,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
                             handleRequestContext(
                                 ctx,
                                 buildConfig, rotationConfig, hotbarConfig,
-                                onBreak, onItemDrop
+                                pendingInteractionsList, onBreak, onItemDrop
                             )
                         }
                         if (breakInfo == null) return@request
@@ -199,7 +202,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
 
                     // return if the block's not broken
                     if (!matchesTargetState(event.pos, pending.context.targetState, event.newState)) {
-                        pendingBreaks.remove(pending)
+                        removePendingBreak(pending)
                         return@listen
                     }
 
@@ -208,7 +211,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
                     }
                     pending.internalOnBreak()
                     if (pending.callbacksCompleted) {
-                        pendingBreaks.remove(pending)
+                        removePendingBreak(pending)
                     }
                     return@listen
                 }
@@ -225,10 +228,10 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
                     }
                     destroyBlock(info)
                     info.internalOnBreak()
-                    info.nullify()
                     if (!info.callbacksCompleted) {
-                        pendingBreaks.add(info)
+                        addPendingBreak(info)
                     }
+                    info.nullify()
                 }
         }
 
@@ -240,7 +243,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
                 ?.let { pending ->
                     pending.internalOnItemDrop(it.entity)
                     if (pending.callbacksCompleted) {
-                        pendingBreaks.remove(pending)
+                        removePendingBreak(pending)
                     }
                     return@listen
                 }
@@ -279,12 +282,13 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
         buildConfig: BuildConfig,
         rotationConfig: RotationConfig,
         hotbarConfig: HotbarConfig,
+        pendingInteractionsList: MutableCollection<BuildContext>,
         onBreak: () -> Unit,
         onItemDrop: ((ItemEntity) -> Unit)?
     ): BreakInfo? {
         val breakInfo = BreakInfo(requestCtx, BreakType.Primary,
             buildConfig.breakSettings, rotationConfig, hotbarConfig,
-            onBreak, onItemDrop
+            pendingInteractionsList, onBreak, onItemDrop
         )
         primaryBreakingInfo?.let { primaryInfo ->
             if (!primaryInfo.breakConfig.doubleBreak
@@ -312,7 +316,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
     }
 
     private fun setPendingInteractionsLimits(buildConfig: BuildConfig) {
-        pendingBreaks.setMaxSize(buildConfig.maxPendingInteractions)
+        pendingBreaks.setMaxSize(buildConfig.breakSettings.maxPendingBreaks)
         pendingBreaks.setDecayTime(buildConfig.interactionTimeout * 50L)
     }
 
@@ -339,7 +343,10 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
                 info.nullify()
                 return false
             }
-            if (info.breakConfig.swing != BreakConfig.SwingMode.End) swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
+            val swing = info.breakConfig.swing
+            if (swing.isEnabled() && swing != BreakConfig.SwingMode.End) {
+                swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
+            }
             return true
         }
 
@@ -385,15 +392,17 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
             setBreakingTextureStage(info)
         }
 
+        val swing = info.breakConfig.swing
+
         if (progress >= info.getBreakThreshold()) {
             interaction.sendSequencedPacket(world) { sequence ->
                 onBlockBreak(info)
                 PlayerActionC2SPacket(PlayerActionC2SPacket.Action.STOP_DESTROY_BLOCK, ctx.expectedPos, hitResult.side, sequence)
             }
-            if (info.breakConfig.swing != BreakConfig.SwingMode.Start) swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
+            if (swing.isEnabled() && swing != BreakConfig.SwingMode.Start) swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
             setBreakCooldown(info.breakConfig.breakDelay)
         } else {
-            if (info.breakConfig.swing == BreakConfig.SwingMode.Constant) swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
+            if (swing == BreakConfig.SwingMode.Constant) swingHand(info.breakConfig.swingType, Hand.MAIN_HAND)
         }
 
         return true
@@ -461,19 +470,32 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
         when (info.breakConfig.breakConfirmation) {
             BreakConfirmationMode.None -> {
                 destroyBlock(info)
-                info.onBreak()
+                info.internalOnBreak()
+                if (!info.callbacksCompleted) {
+                    addPendingBreak(info)
+                }
             }
             BreakConfirmationMode.BreakThenAwait -> {
                 destroyBlock(info)
-                pendingBreaks.add(info)
+                addPendingBreak(info)
             }
             BreakConfirmationMode.AwaitThenBreak -> {
-                pendingBreaks.add(info)
+                addPendingBreak(info)
             }
         }
         info.nullify()
     }
 
+    private fun addPendingBreak(info: BreakInfo) {
+        pendingBreaks.add(info)
+        info.pendingInteractionsList.add(info.context)
+    }
+
+    private fun removePendingBreak(info: BreakInfo) {
+        pendingBreaks.remove(info)
+        info.pendingInteractionsList.remove(info.context)
+    }
+
     private fun SafeContext.destroyBlock(info: BreakInfo): Boolean {
         val ctx = info.context
 
@@ -517,6 +539,7 @@ object BreakManager : RequestHandler<BreakRequest>(), PositionBlocking {
         val breakConfig: BreakConfig,
         val rotationConfig: RotationConfig,
         val hotbarConfig: HotbarConfig,
+        val pendingInteractionsList: MutableCollection<BuildContext>,
         val onBreak: () -> Unit,
         val onItemDrop: ((ItemEntity) -> Unit)?
     ) {

common/src/main/kotlin/com/lambda/interaction/request/breaking/BreakRequest.kt

@@ -19,6 +19,7 @@ package com.lambda.interaction.request.breaking
 
 import com.lambda.config.groups.BuildConfig
 import com.lambda.interaction.construction.context.BreakContext
+import com.lambda.interaction.construction.context.BuildContext
 import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.Request
 import com.lambda.interaction.request.hotbar.HotbarConfig
@@ -33,6 +34,7 @@ data class BreakRequest(
     val rotationConfig: RotationConfig,
     val hotbarConfig: HotbarConfig,
     val prio: Priority = 0,
+    val pendingInteractionsList: MutableCollection<BuildContext>,
     val onBreak: () -> Unit,
     val onItemDrop: ((ItemEntity) -> Unit)?,
 ) : Request(prio) {

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

@@ -67,6 +67,7 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
     ) {
         info("${it::class.simpleName} at ${it.placeContext.expectedPos.toShortString()} timed out")
         mc.world?.setBlockState(it.placeContext.expectedPos, it.placeContext.checkedState)
+        it.pendingInteractionsList.remove(it.placeContext)
     }
 
     override val blockedPositions
@@ -131,7 +132,7 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
                     request.rotationConfig.request(request.placeContext.rotation)
                 else null
 
-                pendingPlacements.setMaxSize(request.buildConfig.maxPendingInteractions)
+                pendingPlacements.setMaxSize(request.buildConfig.placeSettings.maxPendingPlacements)
                 pendingPlacements.setDecayTime(request.buildConfig.interactionTimeout * 50L)
             }
         }
@@ -149,7 +150,7 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
             pendingPlacements
                 .firstOrNull { it.placeContext.expectedPos == event.pos }
                 ?.let { request ->
-                    pendingPlacements.remove(request)
+                    removePendingPlace(request)
 
                     // return if the block wasn't placed
                     if (!matchesTargetState(event.pos, request.placeContext.targetState, event.newState))
@@ -256,10 +257,9 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
 
         val stackInHand = player.getStackInHand(hand)
         val stackCountPre = stackInHand.count
-        if (request.buildConfig.placeSettings.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.None)
-            request.onPlace()
-        else
-            pendingPlacements.add(request)
+        if (placeConfig.placeConfirmationMode != PlaceConfig.PlaceConfirmationMode.None) {
+            addPendingPlace(request)
+        }
 
         if (request.buildConfig.placeSettings.airPlace == PlaceConfig.AirPlaceMode.Grim) {
             airPlaceOffhandSwap()
@@ -297,6 +297,10 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
         if (placeConfig.sounds) placeSound(item, hitState, blockPos)
         if (!player.abilities.creativeMode) itemStack.decrement(1)
 
+        if (placeConfig.placeConfirmationMode == PlaceConfig.PlaceConfirmationMode.None) {
+            request.onPlace()
+        }
+
         return ActionResult.success(world.isClient)
     }
 
@@ -327,6 +331,16 @@ object PlaceManager : RequestHandler<PlaceRequest>(), PositionBlocking {
         )
     }
 
+    private fun addPendingPlace(request: PlaceRequest) {
+        pendingPlacements.add(request)
+        request.pendingInteractionsList.add(request.placeContext)
+    }
+
+    private fun removePendingPlace(request: PlaceRequest) {
+        pendingPlacements.remove(request)
+        request.pendingInteractionsList.remove(request.placeContext)
+    }
+
     override fun preEvent() = UpdateManagerEvent.Place.Pre().post()
     override fun postEvent() = UpdateManagerEvent.Place.Post().post()
 }

common/src/main/kotlin/com/lambda/interaction/request/placing/PlaceRequest.kt

@@ -19,6 +19,7 @@ package com.lambda.interaction.request.placing
 
 import com.lambda.config.groups.BuildConfig
 import com.lambda.config.groups.InteractionConfig
+import com.lambda.interaction.construction.context.BuildContext
 import com.lambda.interaction.construction.context.PlaceContext
 import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.Request
@@ -33,6 +34,7 @@ data class PlaceRequest(
     val rotationConfig: RotationConfig,
     val hotbarConfig: HotbarConfig,
     val interactionConfig: InteractionConfig,
+    val pendingInteractionsList: MutableCollection<BuildContext>,
     val prio: Priority = 0,
     val onPlace: () -> Unit
 ) : Request(prio) {