fixed sim sort rule violation in result sorting

Author: beanbag44

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

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2025 Lambda
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.lambda.config.groups
+
+import com.lambda.util.Describable
+import com.lambda.util.NamedEnum
+
+interface ActionConfig {
+    val sorter: SortMode
+
+    enum class SortMode(
+        override val displayName: String,
+        override val description: String
+    ) : NamedEnum, Describable {
+        Closest("Closest", "Breaks blocks closest to the player eye position"),
+        Farthest("Farthest", "Breaks blocks farthest from the player eye position"),
+        Tool("Tool", "Breaks blocks with priority given to those with tools matching the current selected"),
+        Rotation("Rotation", "Breaks blocks closest to the player rotation"),
+        Random("Random", "Breaks blocks in a random order")
+    }
+}

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

@@ -23,7 +23,6 @@ import com.lambda.interaction.request.breaking.BreakConfig
 import com.lambda.interaction.request.breaking.BreakConfig.AnimationMode
 import com.lambda.interaction.request.breaking.BreakConfig.BreakConfirmationMode
 import com.lambda.interaction.request.breaking.BreakConfig.BreakMode
-import com.lambda.interaction.request.breaking.BreakConfig.SortMode
 import com.lambda.interaction.request.breaking.BreakConfig.SwingMode
 import com.lambda.util.BlockUtils.allSigns
 import com.lambda.util.NamedEnum
@@ -41,7 +40,7 @@ class BreakSettings(
 
     // General
     override val breakMode by c.setting("Break Mode", BreakMode.Packet, visibility = vis).group(baseGroup, Group.General)
-    override val sorter by c.setting("Sorter", SortMode.Tool, "The order in which breaks are performed", visibility = vis).group(baseGroup, Group.General)
+    override val sorter by c.setting("Break Sorter", ActionConfig.SortMode.Tool, "The order in which breaks are performed", visibility = vis).group(baseGroup, Group.General)
     override val rebreak by c.setting("Rebreak", true, "Re-breaks blocks after they've been broken once", visibility = vis).group(baseGroup, Group.General)
 
     // Double break

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

@@ -28,6 +28,7 @@ class InteractSettings(
     vis: () -> Boolean = { true }
 ) : InteractConfig, SettingGroup(c) {
     override val rotate by c.setting("Rotate For Interact", true, "Rotates the player to look at the block when interacting", visibility = vis).group(baseGroup)
+    override val sorter by c.setting("Interact Sorter", ActionConfig.SortMode.Tool, "The order in which interactions are performed", visibility = vis).group(baseGroup)
     override val swingHand by c.setting("Swing On Interact", true, "Swings the players hand after interacting", visibility = vis).group(baseGroup)
     override val tickStageMask by c.setting("Interact Stage Mask", setOf<TickEvent>(TickEvent.Input.Post), description = "The sub-tick timing at which interact actions are performed", visibility = vis).group(baseGroup)
     override val interactSwingType by c.setting("Interact Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swingHand }.group(baseGroup)

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

@@ -32,6 +32,7 @@ class PlaceSettings(
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing", visibility = vis).group(baseGroup)
     override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces", visibility = vis).group(baseGroup)
     override val axisRotateSetting by c.setting("Axis Rotate", true, "Overrides the Rotate For Place setting and rotates the player on each axis to air place rotational blocks") { vis() && airPlace.isEnabled }.group(baseGroup)
+    override val sorter by c.setting("Place Sorter", ActionConfig.SortMode.Tool, "The order in which placements are performed", visibility = vis).group(baseGroup)
     override val tickStageMask by c.setting("Place Stage mask", setOf<TickEvent>(TickEvent.Input.Post), description = "The sub-tick timing at which place actions are performed", visibility = vis).group(baseGroup)
     override val placeConfirmationMode by c.setting("Place Confirmation", PlaceConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation", visibility = vis).group(baseGroup)
     override val maxPendingPlacements by c.setting("Max Pending Placements", 5, 0..30, 1, "The maximum amount of pending placements", visibility = vis).group(baseGroup)

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

@@ -25,27 +25,23 @@ import com.lambda.interaction.material.StackSelection
 import com.lambda.interaction.request.LogContext
 import com.lambda.interaction.request.LogContext.Companion.LogContextBuilder
 import com.lambda.interaction.request.LogContext.Companion.getLogContextBuilder
-import com.lambda.interaction.request.breaking.BreakConfig
-import com.lambda.interaction.request.hotbar.HotbarManager
 import com.lambda.interaction.request.rotating.RotationRequest
 import com.lambda.threading.runSafe
 import com.lambda.util.BlockUtils.emptyState
-import net.minecraft.block.Block
 import net.minecraft.block.BlockState
 import net.minecraft.block.FallingBlock
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
-import net.minecraft.util.math.Vec3d
 import java.awt.Color
 import kotlin.math.sqrt
-import kotlin.random.Random
 
 data class BreakContext(
     override val hitResult: BlockHitResult,
     override val rotationRequest: RotationRequest,
     override val hotbarIndex: Int,
     val itemSelection: StackSelection,
     val instantBreak: Boolean,
+    val insideBlock: Boolean,
     override var cachedState: BlockState,
     private val automated: Automated
 ) : BuildContext(), LogContext, Automated by automated {
@@ -54,42 +50,19 @@ data class BreakContext(
 
     override val blockPos: BlockPos = hitResult.blockPos
     override val expectedState = cachedState.emptyState
-
-    val random = Random.nextDouble()
-
-    override fun compareTo(other: BuildContext): Int = runSafe {
-        return when (other) {
-            is BreakContext -> compareByDescending<BreakContext> {
-                if (breakConfig.sorter == BreakConfig.SortMode.Tool)
-                    it.hotbarIndex == HotbarManager.serverSlot
-                else 0
-            }.thenBy {
-                when (breakConfig.sorter) {
-                    BreakConfig.SortMode.Tool,
-                    BreakConfig.SortMode.Closest -> player.eyePos.distance(it.hitResult.pos, it.cachedState.block)
-                    BreakConfig.SortMode.Farthest -> -player.eyePos.distance(it.hitResult.pos, it.cachedState.block)
-                    BreakConfig.SortMode.Rotation -> it.rotationRequest.target.angleDistance
-                    BreakConfig.SortMode.Random -> it.random
-                }
-            }.thenByDescending {
-                it.hotbarIndex == HotbarManager.serverSlot
-            }.thenBy {
-                it.instantBreak
-            }.compare(this@BreakContext, other)
-
-            else -> 1
-        }
-    } ?: 0
-
-    private fun Vec3d.distance(vec: Vec3d, block: Block): Double {
-        val d = vec.x - x
-        val e = (vec.y - y).let {
-            if (block is FallingBlock) it - (buildConfig.attackReach / 2)
+    override val sortDistance = runSafe {
+        val pov = player.eyePos
+        val vec = hitResult.pos
+        val d = vec.x - pov.x
+        val e = (vec.y - pov.y).let {
+            if (cachedState.block is FallingBlock) it - (buildConfig.attackReach / 2)
             else it
         }
-        val f = vec.z - z
-        return sqrt(d * d + e * e + f * f)
-    }
+        val f = vec.z - pov.z
+        sqrt(d * d + e * e + f * f)
+    } ?: Double.MAX_VALUE
+
+    override val sorter get() = breakConfig.sorter
 
     override fun ShapeBuilder.buildRenderer() {
         box(blockPos, cachedState, baseColor, sideColor, DirectionMask.ALL.exclude(hitResult.side))

src/main/kotlin/com/lambda/interaction/construction/context/BuildContext.kt

@@ -17,26 +17,30 @@
 
 package com.lambda.interaction.construction.context
 
+import com.lambda.config.groups.ActionConfig
 import com.lambda.context.Automated
 import com.lambda.interaction.construction.result.Drawable
 import com.lambda.interaction.request.rotating.RotationRequest
 import com.lambda.threading.runSafe
 import net.minecraft.block.BlockState
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
+import kotlin.random.Random
 
 /**
  * Holds the necessary information for managers to perform actions.
  */
-abstract class BuildContext : Comparable<BuildContext>, Drawable, Automated {
+abstract class BuildContext : Drawable, Automated {
     abstract val hitResult: BlockHitResult
     abstract val rotationRequest: RotationRequest
     abstract val hotbarIndex: Int
     abstract val cachedState: BlockState
     abstract val expectedState: BlockState
     abstract val blockPos: BlockPos
+    abstract val sorter: ActionConfig.SortMode
+    val random = Random.nextDouble()
 
-    val distance by lazy {
+    open val sortDistance by lazy {
         runSafe { player.eyePos.distanceTo(hitResult.pos) } ?: Double.MAX_VALUE
     }
 }

…nstruction/context/InteractionContext.kt …/construction/context/InteractContext.ktsrc/main/kotlin/com/lambda/interaction/construction/context/InteractionContext.kt renamed to src/main/kotlin/com/lambda/interaction/construction/context/InteractContext.kt src/main/kotlin/com/lambda/interaction/construction/context/InteractionContext.kt renamed to src/main/kotlin/com/lambda/interaction/construction/context/InteractContext.kt

@@ -24,17 +24,15 @@ import com.lambda.interaction.request.LogContext
 import com.lambda.interaction.request.LogContext.Companion.LogContextBuilder
 import com.lambda.interaction.request.LogContext.Companion.getLogContextBuilder
 import com.lambda.interaction.request.Request.Companion.submit
-import com.lambda.interaction.request.hotbar.HotbarManager
 import com.lambda.interaction.request.hotbar.HotbarRequest
 import com.lambda.interaction.request.interacting.InteractRequest
 import com.lambda.interaction.request.rotating.RotationRequest
-import com.lambda.util.BlockUtils
 import net.minecraft.block.BlockState
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
 import java.awt.Color
 
-class InteractionContext(
+class InteractContext(
     override val hitResult: BlockHitResult,
     override val rotationRequest: RotationRequest,
     override var hotbarIndex: Int,
@@ -47,22 +45,7 @@ class InteractionContext(
 
     override val blockPos: BlockPos = hitResult.blockPos
 
-    override fun compareTo(other: BuildContext) =
-        when {
-            other is InteractionContext -> compareBy<BuildContext> {
-                BlockUtils.fluids.indexOf(it.cachedState.fluidState.fluid)
-            }.thenByDescending {
-                it.cachedState.fluidState.level
-            }.thenBy {
-                it.rotationRequest.target.angleDistance
-            }.thenBy {
-                it.hotbarIndex == HotbarManager.serverSlot
-            }.thenBy {
-                it.distance
-            }.compare(this, other)
-
-            else -> 1
-        }
+    override val sorter get() = interactConfig.sorter
 
     override fun ShapeBuilder.buildRenderer() {
         box(blockPos, expectedState, baseColor, sideColor, hitResult.side.mask)

src/main/kotlin/com/lambda/interaction/construction/context/PlaceContext.kt

@@ -17,19 +17,16 @@
 
 package com.lambda.interaction.construction.context
 
-import com.lambda.Lambda.mc
 import com.lambda.context.Automated
 import com.lambda.graphics.renderer.esp.DirectionMask.mask
 import com.lambda.graphics.renderer.esp.ShapeBuilder
 import com.lambda.interaction.request.LogContext
 import com.lambda.interaction.request.LogContext.Companion.LogContextBuilder
 import com.lambda.interaction.request.LogContext.Companion.getLogContextBuilder
 import com.lambda.interaction.request.Request.Companion.submit
-import com.lambda.interaction.request.hotbar.HotbarManager
 import com.lambda.interaction.request.hotbar.HotbarRequest
 import com.lambda.interaction.request.placing.PlaceRequest
 import com.lambda.interaction.request.rotating.RotationRequest
-import com.lambda.util.BlockUtils
 import net.minecraft.block.BlockState
 import net.minecraft.util.hit.BlockHitResult
 import net.minecraft.util.math.BlockPos
@@ -43,35 +40,13 @@ data class PlaceContext(
     override var cachedState: BlockState,
     override val expectedState: BlockState,
     val sneak: Boolean,
-    val insideBlock: Boolean,
     val currentDirIsValid: Boolean = false,
     private val automated: Automated
 ) : BuildContext(), LogContext, Automated by automated {
     private val baseColor = Color(35, 188, 254, 25)
     private val sideColor = Color(35, 188, 254, 100)
 
-    override fun compareTo(other: BuildContext) =
-        when (other) {
-            is PlaceContext -> compareBy<PlaceContext> {
-                BlockUtils.fluids.indexOf(it.cachedState.fluidState.fluid)
-            }.thenByDescending {
-                if (it.cachedState.fluidState.level != 0) it.blockPos.y else 0
-            }.thenByDescending {
-                it.cachedState.fluidState.level
-            }.thenBy {
-                it.sneak == (mc.player?.isSneaking ?: false)
-            }.thenBy {
-                it.rotationRequest.target.angleDistance
-            }.thenBy {
-                it.hotbarIndex == HotbarManager.serverSlot
-            }.thenBy {
-                it.distance
-            }.thenBy {
-                it.insideBlock
-            }.compare(this, other)
-
-            else -> 1
-        }
+    override val sorter get() = placeConfig.sorter
 
     override fun ShapeBuilder.buildRenderer() {
         box(blockPos, expectedState, baseColor, sideColor, hitResult.side.mask)
@@ -94,7 +69,6 @@ data class PlaceContext(
             value("Cached State", cachedState)
             value("Expected State", expectedState)
             value("Sneak", sneak)
-            value("Inside Block", insideBlock)
             value("Current Dir Is Valid", currentDirIsValid)
         }
     }

src/main/kotlin/com/lambda/interaction/construction/result/Contextual.kt

@@ -17,24 +17,50 @@
 
 package com.lambda.interaction.construction.result
 
+import com.lambda.config.groups.ActionConfig
+import com.lambda.interaction.construction.context.BreakContext
 import com.lambda.interaction.construction.context.BuildContext
+import com.lambda.interaction.construction.context.PlaceContext
 import com.lambda.interaction.request.hotbar.HotbarManager
+import com.lambda.threading.runSafe
+import com.lambda.util.BlockUtils
 
 /**
  * Represents a result holding a [BuildContext].
  */
 interface Contextual : ComparableResult<Rank> {
     val context: BuildContext
 
-    override fun compareResult(other: ComparableResult<Rank>) =
+    override fun compareResult(other: ComparableResult<Rank>) = runSafe {
         when (other) {
-
-            is Contextual -> compareByDescending<Contextual> {
-                it.context.hotbarIndex == HotbarManager.serverSlot
+            is Contextual -> compareBy<BuildContext> {
+                if (it is PlaceContext) BlockUtils.fluids.indexOf(it.cachedState.fluidState.fluid)
+                else BlockUtils.fluids.size
+            }.thenByDescending {
+                if (it is PlaceContext && it.cachedState.fluidState.level != 0) it.blockPos.y
+                else Int.MIN_VALUE
+            }.thenByDescending {
+                if (it is PlaceContext) it.cachedState.fluidState.level
+                else Int.MIN_VALUE
+            }.thenByDescending {
+                context.sorter == ActionConfig.SortMode.Tool && it.hotbarIndex == HotbarManager.serverSlot
             }.thenBy {
-                it.compareBy.rank
-            }.compare(this, other)
+                when (it.sorter) {
+                    ActionConfig.SortMode.Tool,
+                    ActionConfig.SortMode.Closest -> it.sortDistance
+                    ActionConfig.SortMode.Farthest -> -it.sortDistance
+                    ActionConfig.SortMode.Rotation -> it.rotationRequest.target.angleDistance
+                    ActionConfig.SortMode.Random -> it.random
+                }
+            }.thenByDescending {
+                it is PlaceContext && it.sneak == player.isSneaking
+            }.thenByDescending {
+                it.hotbarIndex == HotbarManager.serverSlot
+            }.thenByDescending {
+                it is BreakContext && it.instantBreak
+            }.compare(context, other.context)
 
-            else -> compareBy.rank.compareTo(other.compareBy.rank)
+            else -> super.compareResult(other)
         }
+    } ?: 0
 }

src/main/kotlin/com/lambda/interaction/construction/result/results/BreakResult.kt

@@ -57,12 +57,6 @@ sealed class BreakResult : BuildResult() {
         override fun ShapeBuilder.buildRenderer() {
             with(context) { buildRenderer() }
         }
-
-        override fun compareResult(other: ComparableResult<Rank>) =
-            when (other) {
-                is Break -> context.compareTo(other.context)
-                else -> super<Contextual>.compareResult(other)
-            }
     }
 
     /**