swap mode setting

Author: beanbag44

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

@@ -37,21 +37,24 @@ class BreakSettings(
     // General
     override val breakMode by c.setting("Break Mode", BreakMode.Packet) { vis() && page == Page.General }
     override val sorter by c.setting("Sorter", SortMode.Closest, "The order in which breaks are performed") { vis() && page == Page.General }
-    override val breakThreshold by c.setting("Break Threshold", 0.70f, 0.1f..1.0f, 0.01f, "The break amount at which the block is considered broken") { vis() && page == Page.General }
     override val reBreak by c.setting("ReBreak", true, "Re-breaks blocks after they've been broken once") { vis() && page == Page.General }
 
     // Double break
     override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once") { vis() && page == Page.General }
     override val unsafeCancels by c.setting("Unsafe Cancels", true, "Allows cancelling block breaking even if the server might continue breaking sever side, potentially causing unexpected state changes") { vis() && page == Page.General }
 
     // Fixes / Delays
+    override val breakThreshold by c.setting("Break Threshold", 0.70f, 0.1f..1.0f, 0.01f, "The break amount at which the block is considered broken") { vis() && page == Page.General }
     override val fudgeFactor by c.setting("Fudge Factor", 1, 0..5, 1, "The amount of ticks to give double, aka secondary breaks extra for the server to recognise the break") { vis() && page == Page.General }
 //    override val desyncFix by c.setting("Desync Fix", false, "Predicts if the players breaking will be slowed next tick as block break packets are processed using the players next position") { vis() && page == Page.General }
     override val breakDelay by c.setting("Break Delay", 0, 0..6, 1, "The delay between breaking blocks", " ticks") { vis() && page == Page.General }
 
     // Timing
     override val breakStageMask by c.setting("Break Stage Mask", setOf(TickEvent.Input.Post, TickEvent.Player.Post), "The sub-tick timing at which break actions can be performed") { vis() && page == Page.General }
 
+    // Swap
+    override val swapMode by c.setting("Swap Mode", BreakConfig.SwapMode.End, "Decides when to swap to the best suited tool when breaking a block") { vis() && page == Page.General }
+
     // Swing
     override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand") { vis() && page == Page.General }
     override val swingType by c.setting("Break Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && page == Page.General && swing != SwingMode.None }

common/src/main/kotlin/com/lambda/interaction/construction/context/BreakContext.kt

@@ -77,7 +77,7 @@ data class BreakContext(
         withState(cachedState, blockPos, sideColor, result.side)
     }
 
-    fun requestDependencies(breakRequest: BreakRequest, minKeepTicks: Int = 0): Boolean =
+    fun requestSwap(breakRequest: BreakRequest, minKeepTicks: Int = 0): Boolean =
         HotbarRequest(
             hotbarIndex,
             breakRequest.hotbar,

common/src/main/kotlin/com/lambda/interaction/construction/simulation/BuildSimulator.kt

@@ -814,7 +814,7 @@ object BuildSimulator {
         breakContext.apply {
             hotbarIndex = player.hotbar.indexOf(swapStack)
             itemSelection = stackSelection
-            instantBreak = instantBreakable(state, pos, swapStack, breaking.breakThreshold)
+            instantBreak = instantBreakable(state, pos, if (breaking.swapMode.isEnabled()) swapStack else player.mainHandStack, breaking.breakThreshold)
         }
 	    acc.add(BreakResult.Break(pos, breakContext))
         return acc

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

@@ -39,6 +39,8 @@ interface BreakConfig : RequestConfig {
 
     val breakStageMask: Set<Event>
 
+    val swapMode: SwapMode
+
     val swing: SwingMode
     val swingType: BuildConfig.SwingType
 
@@ -90,6 +92,16 @@ interface BreakConfig : RequestConfig {
         Random
     }
 
+    enum class SwapMode {
+        None,
+        Start,
+        End,
+        StartAndEnd,
+        Constant;
+
+        fun isEnabled() = this != None
+    }
+
     enum class SwingMode {
         Constant,
         StartAndEnd,

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

@@ -27,6 +27,7 @@ import net.minecraft.entity.ItemEntity
 import net.minecraft.entity.player.PlayerEntity
 import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket
 import net.minecraft.network.packet.c2s.play.PlayerActionC2SPacket.Action
+import net.minecraft.world.WorldView
 
 data class BreakInfo(
     override var context: BreakContext,
@@ -93,6 +94,21 @@ data class BreakInfo(
         item = null
     }
 
+    fun shouldSwap(player: ClientPlayerEntity, world: WorldView): Boolean {
+        val item = player.inventory.getStack(context.hotbarIndex)
+        val breakDelta = context.cachedState.calcItemBlockBreakingDelta(player, world, context.blockPos, item)
+        val breakProgress = breakDelta * ((breakingTicks + 1) - breakConfig.fudgeFactor).let {
+            if (isSecondary) it + 1 else it
+        }
+        return when (breakConfig.swapMode) {
+            BreakConfig.SwapMode.None -> false
+            BreakConfig.SwapMode.Start -> !breaking
+            BreakConfig.SwapMode.End -> breakProgress >= getBreakThreshold()
+            BreakConfig.SwapMode.StartAndEnd -> !breaking || breakProgress >= getBreakThreshold()
+            BreakConfig.SwapMode.Constant -> true
+        }
+    }
+
     fun setBreakingTextureStage(
         player: ClientPlayerEntity,
         world: ClientWorld,

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

@@ -217,7 +217,7 @@ object BreakManager : RequestHandler<BreakRequest>(
                         world,
                         info.context.blockPos,
                         info.breakConfig,
-                        if (!info.isRedundant) activeStack else null
+                        if (!info.isRedundant && info.breakConfig.swapMode.isEnabled()) activeStack else null
                     ).toDouble()
                     val currentDelta = info.breakingTicks * breakDelta
 
@@ -298,6 +298,8 @@ object BreakManager : RequestHandler<BreakRequest>(
                             }
                     }
                     .also {
+                        if (breakInfos.none { it?.shouldSwap(player, world) == true }) return@also
+
                         it.firstOrNull()?.let { info ->
                             secondaryBreak?.let { secondary ->
                                 val breakDelta = secondary.context.cachedState.calcBreakDelta(
@@ -307,9 +309,9 @@ object BreakManager : RequestHandler<BreakRequest>(
                                     secondary.breakConfig,
                                     player.inventory.getStack(secondary.context.hotbarIndex)
                                 )
-                                val breakAmount = breakDelta * (secondary.breakingTicks + 1)
+                                val breakAmount = breakDelta * ((secondary.breakingTicks - secondary.breakConfig.fudgeFactor) + 1)
                                 val minKeepTicks = if (breakAmount >= 1.0f) 1 else 0
-                                if (!info.context.requestDependencies(info.request, minKeepTicks)) {
+                                if (!info.context.requestSwap(info.request, minKeepTicks)) {
                                     secondary.serverBreakTicks = 0
                                     return@run
                                 }
@@ -318,7 +320,7 @@ object BreakManager : RequestHandler<BreakRequest>(
                                 }
                                 return@also
                             }
-                            if (!info.context.requestDependencies(info.request, 0)) return@run
+                            if (!info.context.requestSwap(info.request, 0)) return@run
                         }
                     }
                     .asReversed()
@@ -458,13 +460,12 @@ object BreakManager : RequestHandler<BreakRequest>(
 
             if (!canAccept(ctx)) continue
 
-            if (!ctx.requestDependencies(request)) return false
+            if (request.build.breaking.swapMode.isEnabled() && !ctx.requestSwap(request)) return false
             rotationRequest = if (request.config.rotateForBreak) ctx.rotation.submit(false) else null
             if (!rotated || tickStage !in request.config.breakStageMask) return false
 
             val breakInfo = initNewBreak(ctx, request) ?: return false
             updateBreakProgress(breakInfo)
-            breaksThisTick++
             iterator.remove()
         }
         return true