Merge branch '1.21.5' into improvement/inventory-move

Author: beanbag44

src/main/kotlin/com/lambda/config/groups/Targeting.kt

@@ -60,33 +60,33 @@ abstract class Targeting(
      * The range within which entities can be targeted. This value is configurable and constrained
      * between 1.0 and [maxRange].
      */
-    override val targetingRange by owner.setting("Targeting Range", defaultRange, 1.0..maxRange, 0.05) { predicate() }
+    override val targetingRange by owner.setting("Targeting Range", defaultRange, 1.0..maxRange, 0.05) { predicate() }.group(baseGroup)
 
     /**
      * Whether players are included in the targeting scope.
      */
-    override val players by owner.setting("Players", true) { predicate() }
+    override val players by owner.setting("Players", true) { predicate() }.group(baseGroup)
 
     /**
      * Whether friends are included in the targeting scope.
      * Requires [players] to be true.
      */
-    override val friends by owner.setting("Friends", false) { predicate() && players }
+    override val friends by owner.setting("Friends", false) { predicate() && players }.group(baseGroup)
 
     /**
      * Whether mobs are included in the targeting scope.
      */
-    private val mobs by owner.setting("Mobs", true) { predicate() }
+    private val mobs by owner.setting("Mobs", true) { predicate() }.group(baseGroup)
 
     /**
      * Whether hostile mobs are included in the targeting scope
      */
-    private val hostilesSetting by owner.setting("Hostiles", true) { predicate() && mobs }
+    private val hostilesSetting by owner.setting("Hostiles", true) { predicate() && mobs }.group(baseGroup)
 
     /**
      * Whether passive animals are included in the targeting scope
      */
-    private val animalsSetting by owner.setting("Animals", true) { predicate() && mobs }
+    private val animalsSetting by owner.setting("Animals", true) { predicate() && mobs }.group(baseGroup)
 
     /**
      * Indicates whether hostile entities are included in the targeting scope.
@@ -101,12 +101,12 @@ abstract class Targeting(
     /**
      * Whether invisible entities are included in the targeting scope.
      */
-    override val invisible by owner.setting("Invisible", true) { predicate() }
+    override val invisible by owner.setting("Invisible", true) { predicate() }.group(baseGroup)
 
     /**
      * Whether dead entities are included in the targeting scope.
      */
-    override val dead by owner.setting("Dead", false) { predicate() }
+    override val dead by owner.setting("Dead", false) { predicate() }.group(baseGroup)
 
     /**
      * Validates whether a given entity is targetable by the player based on current settings.
@@ -144,7 +144,7 @@ abstract class Targeting(
         /**
          * The field of view limit for targeting entities. Configurable between 5 and 180 degrees.
          */
-        val fov by owner.setting("FOV Limit", 180, 5..180, 1) { predicate() }.group(baseGroup)
+        val fov by owner.setting("FOV Limit", 180, 5..180, 1) { predicate() && priority == Priority.FOV }.group(baseGroup)
 
         /**
          * The priority used to determine which entity is targeted. Configurable with default set to [Priority.DISTANCE].

src/main/kotlin/com/lambda/interaction/material/StackSelection.kt

@@ -33,8 +33,8 @@ import kotlin.reflect.KClass
  * [StackSelection] is a class that holds a predicate for matching [ItemStack]s.
  */
 class StackSelection {
-    var selector: (ItemStack) -> Boolean = { true }
-    var comparator: Comparator<ItemStack>? = null
+    var selector: (ItemStack) -> Boolean = EVERYTHING
+    var comparator: Comparator<ItemStack> = NO_COMPARE
     var count: Int = DEFAULT_AMOUNT
     var inShulkerBox: Boolean = false
 
@@ -48,25 +48,54 @@ class StackSelection {
     val optimalStack: ItemStack?
         get() = itemStack ?: item?.let { ItemStack(it, count) }
 
+    /**
+     * Filters the given [stacks], sorts them with the [comparator] and returns the first value
+     */
+    fun bestItemMatch(stacks: List<ItemStack>): ItemStack? = stacks.minWithOrNull(comparator)
+
     fun filterStack(stack: ItemStack) =
         if (inShulkerBox) stack.shulkerBoxContents.any { selector(it) }
         else selector(stack)
 
-    fun filterSlot(slot: Slot) = filterStack(slot.stack)
+    fun filterSlot(slot: Slot): Boolean = filterStack(slot.stack)
 
     fun filterStacks(stacks: List<ItemStack>): List<ItemStack> =
-        stacks.filter(::filterStack).let { filteredStacks ->
-            comparator?.run {
-                filteredStacks.sortedWith(this)
-            } ?: filteredStacks
-        }
+        stacks.filter(::filterStack).sortedWith(comparator)
 
     fun filterSlots(slots: List<Slot>): List<Slot> =
-        slots.filter(::filterSlot).let { filteredSlots ->
-            comparator?.run {
-                filteredSlots.sortedWith { slot, slot2 -> compare(slot.stack, slot2.stack) }
-            } ?: filteredSlots
-        }
+        slots.filter(::filterSlot).sortedWith { slot, slot2 -> comparator.compare(slot.stack, slot2.stack) }
+
+    @StackSelectionDsl
+    fun <R : Comparable<R>> sortBy(selector: (ItemStack) -> R?): StackSelection = apply {
+        comparator = compareBy(selector)
+    }
+
+    @StackSelectionDsl
+    fun <R : Comparable<R>> sortByDescending(selector: (ItemStack) -> R?): StackSelection = apply {
+        comparator = compareByDescending(selector)
+    }
+
+    @StackSelectionDsl
+    fun <R : Comparable<R>> thenBy(selector: (ItemStack) -> R?): StackSelection = apply {
+        check(comparator != NO_COMPARE) { "No comparator specified" }
+        comparator = comparator.thenBy(selector)
+    }
+
+    @StackSelectionDsl
+    fun <R : Comparable<R>> thenByDescending(selector: (ItemStack) -> R?): StackSelection = apply {
+        check(comparator != NO_COMPARE) { "No comparator specified" }
+        comparator = comparator.thenByDescending(selector)
+    }
+
+    @StackSelectionDsl
+    fun sortWith(custom: Comparator<ItemStack>): StackSelection = apply {
+        comparator = custom
+    }
+
+    @StackSelectionDsl
+    fun reversed(): StackSelection = apply {
+        comparator = comparator.reversed()
+    }
 
     /**
      * returns a function that finds a shulker box to push matching items into.
@@ -235,14 +264,12 @@ class StackSelection {
         annotation class StackSelectionDsl
 
         const val DEFAULT_AMOUNT = 1
-        val FULL_SHULKERS: (ItemStack) -> Boolean = { stack ->
-            stack.shulkerBoxContents.none { it.isEmpty }
-        }
-        val EMPTY_SHULKERS: (ItemStack) -> Boolean = { stack ->
-            stack.shulkerBoxContents.all { it.isEmpty }
-        }
+
+        val FULL_SHULKERS: (ItemStack) -> Boolean = { stack -> stack.shulkerBoxContents.none { it.isEmpty } }
+        val EMPTY_SHULKERS: (ItemStack) -> Boolean = { stack -> stack.shulkerBoxContents.all { it.isEmpty } }
         val EVERYTHING: (ItemStack) -> Boolean = { true }
         val NOTHING: (ItemStack) -> Boolean = { false }
+        val NO_COMPARE: Comparator<ItemStack> = Comparator { _, _ -> 0 }
 
         @StackSelectionDsl
         fun Item.select() = selectStack { isItem(this@select) }
@@ -261,29 +288,12 @@ class StackSelection {
         @StackSelectionDsl
         fun ((ItemStack) -> Boolean).select() = selectStack { this@select }
 
-        /**
-         * Builds a [StackSelection] with the given parameters.
-         * @param count The count of items to be selected.
-         * @param block The predicate to be used to select the items.
-         * @return A [StackSelection] with the given parameters.
-         */
-        @StackSelectionDsl
-        fun selectStack(
-            count: Int = DEFAULT_AMOUNT,
-            inShulkerBox: Boolean = false,
-            block: StackSelection.() -> (ItemStack) -> Boolean,
-        ) = StackSelection().apply {
-            selector = block()
-            this.count = count
-            this.inShulkerBox = inShulkerBox
-        }
-
         @StackSelectionDsl
         fun selectStack(
             count: Int = DEFAULT_AMOUNT,
             inShulkerBox: Boolean = false,
-            sorter: Comparator<ItemStack>? = null,
-            block: StackSelection.() -> (ItemStack) -> Boolean,
+            sorter: Comparator<ItemStack> = NO_COMPARE,
+            block: StackSelection.() -> (ItemStack) -> Boolean = { EVERYTHING },
         ) = StackSelection().apply {
             selector = block()
             comparator = sorter

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

@@ -54,10 +54,8 @@ 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.instantBreaks
 import com.lambda.interaction.request.breaking.BreakManager.maxBreaksThisTick
-import com.lambda.interaction.request.breaking.BreakManager.performInstantBreaks
-import com.lambda.interaction.request.breaking.BreakManager.processNewBreaks
+import com.lambda.interaction.request.breaking.BreakManager.processNewBreak
 import com.lambda.interaction.request.breaking.BreakManager.processRequest
 import com.lambda.interaction.request.breaking.BreakManager.simulateAbandoned
 import com.lambda.interaction.request.breaking.BreakManager.updateBreakProgress
@@ -94,7 +92,6 @@ import net.minecraft.util.math.Box
 import net.minecraft.world.BlockView
 import kotlin.math.max
 
-// ToDo: Fix root cause of breaks becoming redundant while the actual state is empty
 object BreakManager : RequestHandler<BreakRequest>(
     0,
     TickEvent.Pre,
@@ -155,7 +152,6 @@ object BreakManager : RequestHandler<BreakRequest>(
     private var maxBreaksThisTick = 0
 
     private var breaks = mutableListOf<BreakContext>()
-    private var instantBreaks = mutableListOf<BreakContext>()
 
     var lastPosStarted: BlockPos? = null
         set(value) {
@@ -185,7 +181,6 @@ object BreakManager : RequestHandler<BreakRequest>(
             }
             activeRequest = null
             breaks = mutableListOf()
-            instantBreaks = mutableListOf()
             breaksThisTick = 0
         }
 
@@ -313,37 +308,45 @@ object BreakManager : RequestHandler<BreakRequest>(
      * or the player needs to swap to a different hotbar slot.
      *
      * @see performInstantBreaks
-     * @see processNewBreaks
+     * @see processNewBreak
      * @see updateBreakProgress
      */
     private fun SafeContext.processRequest(breakRequest: BreakRequest?) {
         breakRequest?.let { request ->
             if (request.fresh) populateFrom(request)
         }
 
-        repeat(2) {
-            breakRequest?.let { request ->
-                if (performInstantBreaks(request)) {
-                    processNewBreaks(request)
-                }
-            }
+        var noNew = false
+        var noProgression = false
+
+        while (true) {
+            noNew = breakRequest?.let { request ->
+                !processNewBreak(request)
+            } != false
 
             // Reversed so that the breaking order feels natural to the user as the primary break is always the
             // last break to be started
-            if (handlePreProcessing()) {
+            noProgression = if (handlePreProcessing()) {
                 activeInfos
-                    .filter { it.updatedThisTick }
+                    .filter { it.updatedThisTick && it.shouldProgress }
                     .asReversed()
-                    .forEach { info ->
-                        if (info.shouldProgress)
-                            updateBreakProgress(info)
+                    .run {
+                        if (isEmpty()) {
+                            true
+                        } else {
+                            forEach { info ->
+                                updateBreakProgress(info)
+                            }
+                            false
+                        }
                     }
-            }
-        }
+            } else true
 
-        if (instantBreaks.isEmpty() && breaks.isEmpty()) {
-            activeRequest = null
+            if (noNew && noProgression) break
         }
+
+        if (breaks.isEmpty()) activeRequest = null
+
         if (breaksThisTick > 0 || activeInfos.isNotEmpty()) {
             activeThisTick = true
         }
@@ -384,12 +387,8 @@ object BreakManager : RequestHandler<BreakRequest>(
                 }
             }
 
-        instantBreaks = newBreaks
-            .filter { it.instantBreak }
-            .toMutableList()
-
         breaks = newBreaks
-            .filter { !it.instantBreak }
+            .sortedByDescending { it.instantBreak }
             .toMutableList()
 
         val breakConfig = request.config
@@ -451,50 +450,22 @@ object BreakManager : RequestHandler<BreakRequest>(
         return true
     }
 
-    /**
-     * Attempts to break as many [BreakContext]'s as possible from the [instantBreaks] collection within this tick.
-     *
-     * @return false if a break could not be performed.
-     */
-    private fun SafeContext.performInstantBreaks(request: BreakRequest): Boolean {
-        val iterator = instantBreaks.iterator()
-        while (iterator.hasNext()) {
-            if (breaksThisTick + 1 > maxBreaksThisTick) return false
-
-            val ctx = iterator.next()
-
-            if (!canAccept(ctx)) continue
-
-            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
-            if (!handlePreProcessing()) return false
-
-            updateBreakProgress(breakInfo)
-            iterator.remove()
-        }
-        return true
-    }
-
     /**
      * Attempts to start breaking as many [BreakContext]'s from the [breaks] collection as possible.
      *
      * @return false if a context cannot be started or the maximum active breaks has been reached.
      *
      * @see initNewBreak
      */
-    private fun SafeContext.processNewBreaks(request: BreakRequest): Boolean {
-        val iterator = breaks.iterator()
-        while (iterator.hasNext()) {
-            val ctx = iterator.next()
-
-            if (!canAccept(ctx)) continue
+    private fun SafeContext.processNewBreak(request: BreakRequest): Boolean {
+        breaks.forEach { ctx ->
+            if (!canAccept(ctx)) return@forEach
 
             initNewBreak(ctx, request) ?: return false
-            iterator.remove()
+            breaks.remove(ctx)
+            return true
         }
-        return true
+        return false
     }
 
     /**
@@ -517,10 +488,7 @@ object BreakManager : RequestHandler<BreakRequest>(
                 } else return null
             }
 
-            if (!primaryInfo.breaking) {
-                secondaryBreak = breakInfo.apply { type = Secondary }
-                return secondaryBreak
-            }
+            if (!primaryInfo.breaking) return null
 
             secondaryBreak = primaryInfo.apply { type = Secondary }
             secondaryBreak?.stopBreakPacket(world, interaction)

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

@@ -61,12 +61,12 @@ data class SwapInfo(
 
             val minKeepTicks = run {
                 if (type == Primary) {
-                    val swapTickProgress = breakDelta * (breakTicks + breakConfig.serverSwapTicks - 1)
+                    val swapTickProgress = breakDelta * (breakTicks + breakConfig.serverSwapTicks - 1).coerceAtLeast(1)
                     if (swapTickProgress >= threshold && swapStack.heldTicks < breakConfig.serverSwapTicks) 1
                     else 0
                 } else {
                     val serverSwapTicks = breakConfig.serverSwapTicks.coerceAtLeast(3)
-                    val swapTickProgress = breakDelta * (breakTicks + serverSwapTicks - 1)
+                    val swapTickProgress = breakDelta * (breakTicks + serverSwapTicks - 1).coerceAtLeast(1)
                     if (swapTickProgress >= threshold && swapStack.heldTicks < serverSwapTicks) 1
                     else 0
                 }