separated interact settings into their own page in the build config and removed unused priority var's

Author: beanbag44

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

@@ -19,16 +19,14 @@ package com.lambda.config.groups
 
 import com.lambda.config.Configurable
 import com.lambda.event.events.TickEvent
-import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.breaking.BreakConfig
 import com.lambda.util.BlockUtils.allSigns
 import java.awt.Color
 
 class BreakSettings(
     c: Configurable,
-    priority: Priority = 0,
     vis: () -> Boolean = { true }
-) : BreakConfig(priority) {
+) : BreakConfig() {
     val page by c.setting("Break Page", Page.General, visibility = vis)
     override val breakMode by c.setting("Break Mode", BreakMode.Packet) { 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 }

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

@@ -32,6 +32,9 @@ interface BuildConfig {
     // Placing
     val placing: PlaceSettings
 
+    // Interacting
+    val interacting: InteractSettings
+
     enum class SwingType {
         Vanilla,
         Server,

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

@@ -26,7 +26,7 @@ class BuildSettings(
     vis: () -> Boolean = { true }
 ) : BuildConfig {
     enum class Page {
-        General, Break, Place
+        General, Break, Place, Interact
     }
 
     private val page by c.setting("Build Page", Page.General, "Current page", vis)
@@ -44,5 +44,12 @@ class BuildSettings(
     // Placing
     override val placing = PlaceSettings(c) { page == Page.Place && vis() }
 
-    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks") { vis() && ((page == Page.Place && placing.placeConfirmationMode != PlaceConfig.PlaceConfirmationMode.None) || (page == Page.Break && breaking.breakConfirmation != BreakConfirmationMode.None)) }
+    //Interacting
+    override val interacting = InteractSettings(c) { page == Page.Interact && vis() }
+
+    override val interactionTimeout by c.setting("Interaction Timeout", 10, 1..30, 1, "Timeout for block breaks in ticks", unit = " ticks") {
+        vis() && ((page == Page.Place && placing.placeConfirmationMode != PlaceConfig.PlaceConfirmationMode.None)
+                || (page == Page.Break && breaking.breakConfirmation != BreakConfirmationMode.None)
+                || (page == Page.Interact && interacting.interactConfirmationMode != InteractionConfig.InteractConfirmationMode.None))
+    }
 }

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

@@ -19,14 +19,12 @@ package com.lambda.config.groups
 
 import com.lambda.config.Configurable
 import com.lambda.event.events.TickEvent
-import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.hotbar.HotbarConfig
 
 class HotbarSettings(
     c: Configurable,
-    priority: Priority = 0,
     vis: () -> Boolean = { true }
-) : HotbarConfig(priority) {
+) : HotbarConfig() {
     override val keepTicks by c.setting("Keep Ticks", 3, 0..20, 1, "The number of ticks to keep the current hotbar selection active", " ticks", visibility = vis)
     override val swapDelay by c.setting("Swap Delay", 0, 0..3, 1, "The number of ticks delay before allowing another hotbar selection swap", " ticks", visibility = vis)
     override val swapsPerTick by c.setting("Swaps Per Tick", 3, 1..10, 1, "The number of hotbar selection swaps that can take place each tick") { swapDelay <= 0 && vis() }

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

@@ -0,0 +1,34 @@
+/*
+ * 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.config.groups.InteractionConfig.InteractConfirmationMode
+import com.lambda.interaction.request.RequestConfig
+import com.lambda.interaction.request.interacting.InteractionManager
+import com.lambda.interaction.request.interacting.InteractionRequest
+
+abstract class InteractConfig : RequestConfig<InteractionRequest>() {
+    abstract val rotate: Boolean
+    abstract val swingHand: Boolean
+    abstract val interactSwingType: BuildConfig.SwingType
+    abstract val interactConfirmationMode: InteractConfirmationMode
+
+    override fun requestInternal(request: InteractionRequest, queueIfClosed: Boolean) {
+        InteractionManager.request(request, queueIfClosed)
+    }
+}

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

@@ -0,0 +1,30 @@
+/*
+ * 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.config.Configurable
+
+class InteractSettings(
+    c: Configurable,
+    vis: () -> Boolean =  { true }
+) : InteractConfig() {
+    override val rotate by c.setting("Rotate For Interact", true, "Rotates the player to look at the block when interacting", visibility = vis)
+    override val swingHand by c.setting("Swing On Interact", true, "Swings the players hand after interacting", visibility = vis)
+    override val interactSwingType by c.setting("Interact Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swingHand }
+    override val interactConfirmationMode by c.setting("Interact Confirmation Mode", InteractionConfig.InteractConfirmationMode.InteractThenAwait, "The style of confirmation for interactions", visibility = vis)
+}

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

@@ -22,9 +22,7 @@ import com.lambda.interaction.request.interacting.InteractionManager
 import com.lambda.interaction.request.interacting.InteractionRequest
 import com.lambda.interaction.request.rotating.visibilty.PointSelection
 
-abstract class InteractionConfig(
-    priority: Int
-) : RequestConfig<InteractionRequest>(priority) {
+abstract class InteractionConfig : RequestConfig<InteractionRequest>() {
     /**
      * Maximum entity interaction distance
      */
@@ -35,11 +33,6 @@ abstract class InteractionConfig(
      */
     abstract val interactReach: Double
 
-    /**
-     * Rotates the player for block interactions. For example, right-clicking a chest to open it.
-     */
-    abstract val rotate: Boolean
-
     /**
      * Maximum possible interaction distance
      *
@@ -69,21 +62,6 @@ abstract class InteractionConfig(
      */
     abstract val pointSelection: PointSelection
 
-    /**
-     * The method of confirming the interaction had taken place server side
-     */
-    abstract val interactConfirmationMode: InteractConfirmationMode
-
-    /**
-     * Whether to swing the hand when interacting.
-     */
-    abstract val swingHand: Boolean
-
-    /**
-     * The style of hand swing to use
-     */
-    abstract val interactSwingType: BuildConfig.SwingType
-
     override fun requestInternal(request: InteractionRequest, queueIfClosed: Boolean) {
         InteractionManager.request(request, queueIfClosed)
     }

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

@@ -26,14 +26,12 @@ class InteractionSettings(
     c: Configurable,
     private val usage: InteractionMask,
     vis: () -> Boolean = { true },
-) : InteractionConfig(0) {
+) : InteractionConfig() {
     // Reach
     private val useDefaultReach by c.setting("Default Reach", true, "Whether to use vanilla interaction ranges", visibility = vis)
     private val attackReachSetting = if (usage.entity) c.setting("Attack Reach", DEFAULT_ATTACK_REACH, 1.0..10.0, 0.01, "Maximum entity interaction distance") { vis() && !useDefaultReach } else null
     private val interactReachSetting = if (usage.block) c.setting("Interact Reach", DEFAULT_INTERACT_REACH, 1.0..10.0, 0.01, "Maximum block interaction distance") { vis() && !useDefaultReach } else null
 
-    override val rotate by c.setting("Rotate For Interactions", true, "Rotates the player for block interactions. For example, right-clicking a chest to open it", visibility = vis)
-
     override val attackReach: Double get() {
         check(usage.entity) {
             "Given interaction config has no attack reach implementation"
@@ -62,12 +60,6 @@ class InteractionSettings(
     override val resolution by c.setting("Resolution", 5, 1..20, 1, "The amount of grid divisions per surface of the hit box", "", visibility = vis)
     override val pointSelection by c.setting("Point Selection", PointSelection.Optimum, "The strategy to select the best hit point", visibility = vis)
 
-    override val interactConfirmationMode by c.setting("Interact Confirmation Mode", InteractConfirmationMode.InteractThenAwait, "The style of confirmation used when interacting", visibility = vis)
-
-    // Swing
-    override val swingHand by c.setting("Swing Hand", true, "Whether to swing hand on interactions", visibility = vis)
-    override val interactSwingType by c.setting("Interact Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swingHand }
-
     companion object {
         const val DEFAULT_ATTACK_REACH = 3.0
         const val DEFAULT_INTERACT_REACH = 4.5

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

@@ -19,22 +19,20 @@ package com.lambda.config.groups
 
 import com.lambda.config.Configurable
 import com.lambda.event.events.TickEvent
-import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.placing.PlaceConfig
 
 class PlaceSettings(
     c: Configurable,
-    priority: Priority = 0,
     vis: () -> Boolean = { true }
-) : PlaceConfig(priority) {
+) : PlaceConfig() {
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing", visibility = vis)
     override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces", visibility = vis)
     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() }
     override val placeStageMask by c.setting("Place Sequence Mode", setOf(TickEvent.Pre, TickEvent.Input.Pre, TickEvent.Player.Post), "The sub-tick timing at which break actions are performed", visibility = vis)
     override val placeConfirmationMode by c.setting("Place Confirmation", PlaceConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation", visibility = vis)
     override val maxPendingPlacements by c.setting("Max Pending Placements", 5, 0..30, 1, "The maximum amount of pending placements", visibility = vis)
     override val placementsPerTick by c.setting("Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick", visibility = vis)
-    override val swing by c.setting("Swing", true, "Swings the players hand when placing", visibility = vis)
+    override val swing by c.setting("Swing On Place", true, "Swings the players hand when placing", visibility = vis)
     override val swingType by c.setting("Place Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing }
     override val sounds by c.setting("Place Sounds", true, "Plays the placing sounds", visibility = vis)
 }

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

@@ -18,7 +18,6 @@
 package com.lambda.config.groups
 
 import com.lambda.config.Configurable
-import com.lambda.interaction.request.Priority
 import com.lambda.interaction.request.rotating.RotationConfig
 import com.lambda.interaction.request.rotating.RotationMode
 import kotlin.math.PI
@@ -30,9 +29,8 @@ import kotlin.random.Random
 
 class RotationSettings(
     c: Configurable,
-    priority: Priority = 0,
     vis: () -> Boolean = { true }
-) : RotationConfig(priority) {
+) : RotationConfig() {
     override var rotationMode by c.setting("Mode", RotationMode.Sync, "SILENT - server-side rotation, SYNC - server-side rotation; client-side movement, LOCK - Lock camera, NONE - No rotation", visibility = vis)
 
     /** How many ticks to keep the rotation before resetting */