now or nothing requests

Author: beanbag44

src/main/java/com/lambda/mixin/entity/PlayerInventoryMixin.java

@@ -18,29 +18,19 @@
 package com.lambda.mixin.entity;
 
 import com.lambda.interaction.request.hotbar.HotbarManager;
-import com.lambda.interaction.request.hotbar.HotbarRequest;
 import com.llamalad7.mixinextras.injector.ModifyExpressionValue;
 import net.minecraft.entity.player.PlayerInventory;
 import org.objectweb.asm.Opcodes;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.injection.At;
-import org.spongepowered.asm.mixin.injection.Inject;
-import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
 
 @Mixin(PlayerInventory.class)
 public class PlayerInventoryMixin {
-    @SuppressWarnings({"MixinAnnotationTarget", "UnresolvedMixinReference"})
+    @SuppressWarnings({"MixinAnnotationTarget"})
     @ModifyExpressionValue(method = "*", at = @At(value = "FIELD", target = "Lnet/minecraft/entity/player/PlayerInventory;selectedSlot:I", opcode = Opcodes.GETFIELD))
     private int modifySelectedSlot(int original) {
-        final HotbarRequest hotbarRequest = HotbarManager.INSTANCE.getActiveRequest();
-        if (hotbarRequest == null) return original;
-        return hotbarRequest.getSlot();
-    }
-
-    @Inject(method = "getSelectedSlot", at = @At("HEAD"), cancellable = true)
-    private void redirectGetSelectedSlot(CallbackInfoReturnable<Integer> cir) {
-        final HotbarRequest hotbarRequest = HotbarManager.INSTANCE.getActiveRequest();
-        if (hotbarRequest == null) return;
-        cir.setReturnValue(hotbarRequest.getSlot());
+        final int hotbarSlot = HotbarManager.getActiveSlot();
+        if (hotbarSlot == -1) return original;
+        return hotbarSlot;
     }
 }

src/main/kotlin/com/lambda/context/AutomationConfig.kt

@@ -60,7 +60,6 @@ object AutomationConfig : Configurable(LambdaConfig), Automated {
     override val eatConfig = EatSettings(this, Group.Eat)
 
     val avoidDesync by setting("Avoid Desync", true, "Cancels incoming inventory update packets if they match previous actions").group(Group.Debug)
-    val maxDesyncCache by setting("Max Desync Cache", 30, 1..30, 1, "Maximum cached previous inventory actions") { avoidDesync }.group(Group.Debug)
     val desyncTimeout by setting("Desync Timeout", 30, 1..30, 1, unit = " ticks", description = "Time to store previous inventory actions before dropping the cache") { avoidDesync }.group(Group.Debug)
     val showAllEntries by setting("Show All Entries", false, "Show all entries in the task tree").group(Group.Debug)
     val shrinkFactor by setting("Shrink Factor", 0.001, 0.0..1.0, 0.001).group(Group.Debug)

src/main/kotlin/com/lambda/interaction/request/Request.kt

@@ -30,6 +30,8 @@ abstract class Request : Automated {
     abstract val requestId: Int
     var fresh = true
 
+    abstract val nowOrNothing: Boolean
+
     abstract val done: Boolean
 
     abstract fun submit(queueIfClosed: Boolean = true): Request

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

@@ -307,15 +307,21 @@ object BreakManager : RequestHandler<BreakRequest>(
 
     /**
      * Attempts to accept and process the request, if there is not already an [activeRequest] and the
-     * [BreakRequest.contexts] collection is not empty.
+     * [BreakRequest.contexts] collection is not empty. If nowOrNothing is true, the request is cleared
+     * after the first process.
      *
      * @see processRequest
      */
     override fun AutomatedSafeContext.handleRequest(request: BreakRequest) {
         if (activeRequest != null || request.contexts.isEmpty()) return
+        if (PlaceManager.activeThisTick || InteractionManager.activeThisTick) return
 
         activeRequest = request
         processRequest(request)
+        if (request.nowOrNothing) {
+            activeRequest = null
+            breaks = mutableListOf()
+        }
     }
 
     /**
@@ -328,8 +334,6 @@ object BreakManager : RequestHandler<BreakRequest>(
      * @see updateBreakProgress
      */
     private fun SafeContext.processRequest(request: BreakRequest?) {
-        if (PlaceManager.activeThisTick || InteractionManager.activeThisTick) return
-
         request?.let { request ->
             logger.debug("Processing request", request)
             if (request.fresh) populateFrom(request)
@@ -385,7 +389,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         // Sanitize the new breaks
         val newBreaks = request.contexts
             .distinctBy { it.blockPos }
-            .filter { canAccept(it) }
+            .filter { canAccept(it) && (!request.nowOrNothing || it.instantBreak) }
             .toMutableList()
 
         // Update the current break infos
@@ -705,11 +709,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         info.progressedThisTick = true
 
         if (!info.breaking) {
-            if (breakConfig.swapMode.isEnabled() &&
-                (breakConfig.swapMode != BreakConfig.SwapMode.End ||
-                        info.context.instantBreak ||
-                        info.rebreakPotential.isPossible()) &&
-                !swapped) return
+            if (info.swapInfo.swap && !swapped) return
             if (!startBreaking(info)) {
                 info.nullify()
                 info.request.onCancel?.invoke(this, ctx.blockPos)
@@ -736,7 +736,7 @@ object BreakManager : RequestHandler<BreakRequest>(
             return
         }
 
-        if (breakConfig.swapMode.isEnabled() && breakConfig.swapMode == BreakConfig.SwapMode.Constant && !swapped) return
+        if (breakConfig.swapMode == BreakConfig.SwapMode.Constant && !swapped) return
 
         info.breakingTicks++
         val breakDelta = blockState.calcBreakDelta(ctx.blockPos)
@@ -770,7 +770,7 @@ object BreakManager : RequestHandler<BreakRequest>(
 
         val swing = breakConfig.swing
         if (progress >= info.getBreakThreshold()) {
-            if (breakConfig.swapMode.isEnabled() && breakConfig.swapMode != BreakConfig.SwapMode.Start && !swapped) return
+            if (info.swapInfo.swap && !swapped) return
 
             logger.success("Breaking", info)
             onBlockBreak(info)
@@ -782,8 +782,6 @@ object BreakManager : RequestHandler<BreakRequest>(
             if (swing == BreakConfig.SwingMode.Constant)
                 swingHand(breakConfig.swingType, Hand.MAIN_HAND)
         }
-
-        return
     }
 
     /**

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

@@ -47,7 +47,8 @@ import net.minecraft.util.math.BlockPos
 data class BreakRequest private constructor(
     val contexts: Collection<BreakContext>,
     val pendingInteractions: MutableCollection<BuildContext>,
-    private val automated: Automated
+    private val automated: Automated,
+    override val nowOrNothing: Boolean = false
 ) : Request(), LogContext, Automated by automated {
     override val requestId = ++requestCount
 
@@ -88,9 +89,10 @@ data class BreakRequest private constructor(
     class BreakRequestBuilder(
         contexts: Collection<BreakContext>,
         pendingInteractions: MutableCollection<BuildContext>,
+        nowOrNothing: Boolean,
         automated: Automated
     ) {
-        val request = BreakRequest(contexts, pendingInteractions, automated)
+        val request = BreakRequest(contexts, pendingInteractions, automated, nowOrNothing)
 
         @BreakRequestDsl
         fun onStart(callback: SafeContext.(BlockPos) -> Unit) {
@@ -135,8 +137,9 @@ data class BreakRequest private constructor(
         fun Automated.breakRequest(
             contexts: Collection<BreakContext>,
             pendingInteractions: MutableCollection<BuildContext>,
+            nowOrNothing: Boolean = false,
             builder: (BreakRequestBuilder.() -> Unit)? = null
-        ) = BreakRequestBuilder(contexts, pendingInteractions, this).apply { builder?.invoke(this) }.build()
+        ) = BreakRequestBuilder(contexts, pendingInteractions, nowOrNothing, this).apply { builder?.invoke(this) }.build()
 
         @BreakRequestDsl
         private fun BreakRequestBuilder.build(): BreakRequest = request

src/main/kotlin/com/lambda/interaction/request/hotbar/HotbarManager.kt

@@ -29,9 +29,10 @@ import com.lambda.interaction.request.ManagerUtils.newStage
 import com.lambda.interaction.request.ManagerUtils.newTick
 import com.lambda.interaction.request.RequestHandler
 import com.lambda.interaction.request.hotbar.HotbarManager.activeRequest
+import com.lambda.interaction.request.hotbar.HotbarManager.activeSlot
 import com.lambda.interaction.request.hotbar.HotbarManager.checkResetSwap
-import com.lambda.interaction.request.hotbar.HotbarManager.maxSwapsThisTick
 import com.lambda.interaction.request.hotbar.HotbarManager.setActiveRequest
+import com.lambda.interaction.request.hotbar.HotbarManager.setActiveSlot
 import com.lambda.module.hud.ManagerDebugLoggers.hotbarManagerLogger
 import com.lambda.threading.runSafe
 import net.minecraft.item.ItemStack
@@ -50,12 +51,20 @@ object HotbarManager : RequestHandler<HotbarRequest>(
     TickEvent.Input.Pre,
     TickEvent.Input.Post,
     TickEvent.Player.Post,
-    onOpen = { if (HotbarManager.activeRequest != null) HotbarManager.logger.newStage(HotbarManager.tickStage) },
+    onOpen = {
+        if (activeRequest != null) {
+            setActiveSlot()
+            HotbarManager.logger.newStage(HotbarManager.tickStage)
+        }
+             },
     onClose = { checkResetSwap() }
 ), Logger {
+    var activeRequest: HotbarRequest? = null
+    @JvmStatic var activeSlot: Int = -1
+
     val serverSlot get() = runSafe {
         interaction.lastSelectedSlot
-    } ?: 0
+    } ?: -1
     //ToDo: something to manage stacks so the hotbar manager is strictly index based
     private var previousStack: ItemStack? = null
     private var swappedTicks = 0
@@ -64,8 +73,6 @@ object HotbarManager : RequestHandler<HotbarRequest>(
     private var maxSwapsThisTick = 0
     private var swapDelay = 0
 
-    var activeRequest: HotbarRequest? = null
-
     override val logger = hotbarManagerLogger
 
     override fun load(): String {
@@ -86,6 +93,7 @@ object HotbarManager : RequestHandler<HotbarRequest>(
             previousStack = currentStack
 
             val activeInfo = activeRequest ?: return@listen
+            if (activeInfo.slot != activeSlot) return@listen
             activeInfo.swapPauseAge = swappedTicks
             activeInfo.activeRequestAge++
             activeInfo.keepTicks--
@@ -95,52 +103,60 @@ object HotbarManager : RequestHandler<HotbarRequest>(
     }
 
     /**
-     * Attempts to accept the request and process it. If the [activeRequest] is not null, the new [request] matches hotbar index,
-     * and the new request has an equal or longer [HotbarRequest.keepTicks] than the current request, the new request is accepted.
-     * Otherwise, if the [activeRequest] is null, or is from an old request, assuming the swap doesn't exceed [maxSwapsThisTick],
-     * the request is accepted.
+     * If the [activeRequest] is not null, being kept, and the [request]'s slot matches the [activeSlot], the
+     * [request]'s swapPauseAge is set to the swapped ticks and the request is denied. Otherwise, the active
+     * request is set and it attempts to set the active slot.
      *
      * @see setActiveRequest
+     * @see setActiveSlot
      */
     override fun AutomatedSafeContext.handleRequest(request: HotbarRequest) {
         logger.debug("Handling request:", request)
 
-        if (tickStage !in hotbarConfig.sequenceStageMask) return
+        if (request.nowOrNothing && tickStage !in hotbarConfig.sequenceStageMask) return
 
         activeRequest?.let { active ->
-            if (request.slot == serverSlot && request.keepTicks >= active.keepTicks) {
-                logger.debug("Request is the same as current, but longer or the same keep time", request)
-                setActiveRequest(request)
+            if (active.activeRequestAge <= 0 && active.keepTicks > 0) {
+                if (activeSlot == request.slot) request.swapPauseAge = swappedTicks
                 return
             }
-
-            if (active.activeRequestAge <= 0 && active.keepTicks > 0) return
-        } ?: run { maxSwapsThisTick = hotbarConfig.swapsPerTick }
-
-        if (request.slot != serverSlot)
-            if (swapsThisTick + 1 > maxSwapsThisTick || swapDelay > 0) return
+        }
 
         setActiveRequest(request)
+        if (!setActiveSlot() && request.nowOrNothing) {
+            activeRequest = null
+            activeSlot = -1
+        }
     }
 
-    /**
-     * Sets the [activeRequest]. This also calls syncSelectedSlot to
-     * update the server now to keep predictability.
-     *
-     * @see net.minecraft.client.network.ClientPlayerInteractionManager.syncSelectedSlot
-     */
     private fun AutomatedSafeContext.setActiveRequest(request: HotbarRequest) {
         maxSwapsThisTick = hotbarConfig.swapsPerTick
-        if (request.slot != serverSlot) {
-            swapsThisTick++
-            swappedTicks = 0
-            swapDelay = hotbarConfig.swapDelay
-        } else request.swapPauseAge = swappedTicks
         activeRequest = request
-        interaction.syncSelectedSlot()
         logger.success("Set active request", request)
     }
 
+    /**
+     * Sets the [activeSlot]. This also calls syncSelectedSlot to
+     * update the server to keep predictability.
+     *
+     * @see net.minecraft.client.network.ClientPlayerInteractionManager.syncSelectedSlot
+     */
+    private fun SafeContext.setActiveSlot(): Boolean {
+        activeRequest?.let { activeRequest ->
+            if (serverSlot != activeRequest.slot) {
+                if (tickStage !in activeRequest.hotbarConfig.sequenceStageMask) return false
+                if (swapsThisTick + 1 > maxSwapsThisTick || swapDelay > 0) return false
+                swapsThisTick++
+                swappedTicks = 0
+                swapDelay = activeRequest.hotbarConfig.swapDelay
+            } else activeRequest.swapPauseAge = swappedTicks
+            if (activeRequest.slot == activeSlot) return true
+            activeSlot = activeRequest.slot
+            interaction.syncSelectedSlot()
+        }
+        return true
+    }
+
     /**
      * Called after every [tickStage] closes. This method checks if the current [activeRequest] should be stopped.
      * This action is counted as another swap, so the conditions for a regular swap must be met. If the requests
@@ -153,8 +169,11 @@ object HotbarManager : RequestHandler<HotbarRequest>(
             val canStopSwap = swapsThisTick < maxSwapsThisTick
             if (active.keepTicks <= 0 && tickStage in active.hotbarConfig.sequenceStageMask && canStopSwap) {
                 logger.debug("Clearing request and syncing slot", activeRequest)
+                val prevSlot = activeSlot
                 activeRequest = null
+                activeSlot = -1
                 interaction.syncSelectedSlot()
+                if (serverSlot != prevSlot) swapsThisTick++
             }
         }
     }

src/main/kotlin/com/lambda/interaction/request/hotbar/HotbarRequest.kt

@@ -26,15 +26,16 @@ class HotbarRequest(
     val slot: Int,
     automated: Automated,
     var keepTicks: Int = automated.hotbarConfig.keepTicks,
-    var swapPause: Int = automated.hotbarConfig.swapPause
+    var swapPause: Int = automated.hotbarConfig.swapPause,
+    override val nowOrNothing: Boolean = true
 ) : Request(), LogContext, Automated by automated {
     override val requestId = ++requestCount
 
     var activeRequestAge = 0
     var swapPauseAge = 0
 
     override val done: Boolean
-        get() = slot == HotbarManager.serverSlot && swapPauseAge >= swapPause
+        get() = slot == HotbarManager.activeSlot && swapPauseAge >= swapPause
 
     override fun submit(queueIfClosed: Boolean) =
         HotbarManager.request(this, queueIfClosed)

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

@@ -31,6 +31,7 @@ data class InteractRequest(
     val contexts: Collection<InteractionContext>,
     val pendingInteractionsList: MutableCollection<BuildContext>,
     private val automated: Automated,
+    override val nowOrNothing: Boolean = false,
     val onInteract: ((BlockPos) -> Unit)?
 ) : Request(), LogContext, Automated by automated {
     override val requestId = ++requestCount

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

@@ -100,15 +100,20 @@ object InteractionManager : RequestHandler<InteractRequest>(
 
     /**
      * Attempts to accept and process the request, if there is not already an [activeRequest] and the request's [InteractRequest.contexts]
-     * collection is not empty.
+     * collection is not empty. If nowOrNothing is true, the request is cleared after the first process.
      *
      * @see processRequest
      */
     override fun AutomatedSafeContext.handleRequest(request: InteractRequest) {
         if (activeRequest != null || request.contexts.isEmpty()) return
+        if (BreakManager.activeThisTick || PlaceManager.activeThisTick) return
 
         activeRequest = request
         processRequest(request)
+        if (request.nowOrNothing) {
+            activeRequest = null
+            potentialInteractions = mutableListOf()
+        }
         if (interactionsThisTick > 0) activeThisTick = true
     }
 
@@ -118,8 +123,6 @@ object InteractionManager : RequestHandler<InteractRequest>(
      * @see populateFrom
      */
     fun AutomatedSafeContext.processRequest(request: InteractRequest) {
-        if (BreakManager.activeThisTick || PlaceManager.activeThisTick) return
-
         logger.debug("Processing request", request)
 
         if (request.fresh) populateFrom(request)