improved swap checks

Author: beanbag44

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

@@ -661,23 +661,27 @@ object BreakManager : RequestHandler<BreakRequest>(
      *
      * @see net.minecraft.client.network.ClientPlayerInteractionManager.updateBlockBreakingProgress
      */
-    private fun SafeContext.updateBreakProgress(info: BreakInfo): Boolean {
+    private fun SafeContext.updateBreakProgress(info: BreakInfo) {
         val config = info.breakConfig
         val ctx = info.context
 
         info.progressedThisTick = true
 
+        val swapMode = info.breakConfig.swapMode
+
         if (!info.breaking) {
-            return if (startBreaking(info)) true
-            else {
+            if (swapMode.isEnabled() &&
+                (swapMode != BreakConfig.SwapMode.End ||
+                        info.context.instantBreak ||
+                        info.rebreakPotential.isPossible()) &&
+                !swapped) return
+            if (!startBreaking(info)) {
                 info.nullify()
                 info.request.onCancel?.invoke(ctx.blockPos)
-                false
             }
+            return
         }
 
-        if (config.swapMode == BreakConfig.SwapMode.Constant && !swapped) return true
-
         val hitResult = ctx.result
 
         if (gamemode.isCreative && world.worldBorder.contains(ctx.blockPos)) {
@@ -686,17 +690,19 @@ object BreakManager : RequestHandler<BreakRequest>(
             onBlockBreak(info)
             info.startBreakPacket(world, interaction)
             if (config.swing.isEnabled()) swingHand(config.swingType, Hand.MAIN_HAND)
-            return true
+            return
         }
 
         val blockState = blockState(ctx.blockPos)
         if (blockState.isEmpty) {
             info.nullify()
             info.request.onCancel?.invoke(ctx.blockPos)
             logger.warning("Block state was unexpectedly empty", info)
-            return false
+            return
         }
 
+        if (swapMode.isEnabled() && swapMode == BreakConfig.SwapMode.Constant && !swapped) return
+
         info.breakingTicks++
         val breakDelta = blockState.calcBreakDelta(player, world, ctx.blockPos, config)
         val progress = breakDelta * (info.breakingTicks - config.fudgeFactor)
@@ -728,7 +734,9 @@ object BreakManager : RequestHandler<BreakRequest>(
         }
 
         val swing = config.swing
-        if (progress >= info.getBreakThreshold() && swapped) {
+        if (progress >= info.getBreakThreshold()) {
+            if (swapMode.isEnabled() && swapMode != BreakConfig.SwapMode.Start && !swapped) return
+
             logger.success("Breaking", info)
             if (info.type == Primary) {
                 onBlockBreak(info)
@@ -742,7 +750,7 @@ object BreakManager : RequestHandler<BreakRequest>(
             if (swing == BreakConfig.SwingMode.Constant) swingHand(config.swingType, Hand.MAIN_HAND)
         }
 
-        return true
+        return
     }
 
     /**
@@ -808,12 +816,10 @@ object BreakManager : RequestHandler<BreakRequest>(
 
         val progress = blockState.calcBreakDelta(player, world, ctx.blockPos, info.breakConfig)
 
-        if (!swapped) return true
-
-        val instantBreakable = progress >= info.getBreakThreshold() && swapped
+        val instantBreakable = progress >= info.getBreakThreshold()
         if (instantBreakable) {
             logger.success("Instant breaking", info)
-            info.vanillaInstantBreakable = progress >= 1 && swapped
+            info.vanillaInstantBreakable = progress >= 1
             onBlockBreak(info)
             if (!info.vanillaInstantBreakable) breakCooldown = info.breakConfig.breakDelay
         } else {

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

@@ -70,8 +70,7 @@ object RebreakHandler {
             else player.mainHandStack
             val breakDelta = info.context.cachedState.calcBreakDelta(player, world, info.context.blockPos, info.breakConfig, stack)
             val possible = reBreak.breakConfig.rebreak &&
-                    info.context.blockPos == reBreak.context.blockPos &&
-                    !reBreak.updatedThisTick
+                    info.context.blockPos == reBreak.context.blockPos
             val instant = (reBreak.breakingTicks - info.breakConfig.fudgeFactor) * breakDelta >= info.breakConfig.breakThreshold
             when {
                 possible && instant -> RebreakPotential.Instant
@@ -89,7 +88,7 @@ object RebreakHandler {
             val context = reBreak.context
             val breakDelta = context.cachedState.calcBreakDelta(player, world, context.blockPos, reBreak.breakConfig)
             val breakTicks = reBreak.breakingTicks - reBreak.breakConfig.fudgeFactor
-            return@runSafe if (breakTicks * breakDelta >= reBreak.getBreakThreshold() && BreakManager.swapped) {
+            return@runSafe if (breakTicks * breakDelta >= reBreak.getBreakThreshold()) {
                 if (reBreak.breakConfig.breakConfirmation != BreakConfig.BreakConfirmationMode.AwaitThenBreak) {
                     destroyBlock(reBreak)
                 }

src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt

@@ -195,24 +195,22 @@ object PacketMine : Module(
         breakRequest(
             breakContexts, pendingInteractions, rotation, hotbar, interact, inventory, build,
         ) {
-            onStart { queuePositions.removePos(it)
-                if (breakPositions.none { pos -> pos == it }) {
-                    addBreak(it)
-                }
-            }
-            onUpdate {
-                queuePositions.removePos(it)
-                if (breakPositions.none { pos -> pos == it }) {
-                    addBreak(it)
-                }
-            }
+            onStart { onProgress(it) }
+            onUpdate { onProgress(it) }
             onStop { removeBreak(it); breaks++ }
             onCancel { removeBreak(it, true) }
             onReBreakStart { reBreakPos = it }
-            onReBreak { reBreakPos = it }
+            onReBreak { removeBreak(it); reBreakPos = it }
         }.submit()
     }
 
+    private fun onProgress(blockPos: BlockPos) {
+        queuePositions.removePos(blockPos)
+        if (breakPositions.none { pos -> pos == blockPos }) {
+            addBreak(blockPos)
+        }
+    }
+
     private fun SafeContext.breakContexts(positions: Collection<BlockPos?>) =
         positions
             .asSequence()
@@ -247,9 +245,8 @@ object PacketMine : Module(
     private fun ArrayList<MutableCollection<BlockPos>>.removePos(element: BlockPos): Boolean {
         var anyRemoved = false
         removeIf {
-            val removed = it.remove(element)
-            anyRemoved = anyRemoved or removed
-            return@removeIf removed && it.isEmpty()
+            anyRemoved = anyRemoved or it.remove(element)
+            return@removeIf it.isEmpty()
         }
         return anyRemoved
     }