initial inventory manager implementation. Nothing has been swapped to using it yet

Author: beanbag44

build.gradle.kts

@@ -215,7 +215,7 @@ tasks {
 
 kotlin {
     compilerOptions {
-        freeCompilerArgs.add("-Xcontext-parameters")
+        freeCompilerArgs.addAll("-Xcontext-parameters", "-Xconsistent-data-class-copy-visibility")
     }
 
     jvmToolchain(21)

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

@@ -56,7 +56,7 @@ class BreakSettings(
     override val breakDelay by c.setting("Break Delay", 0, 0..6, 1, "The delay between breaking blocks", " tick(s)", visibility = vis).group(baseGroup, Group.General)
 
     // Timing
-    override val breakStageMask by c.setting("Break Stage Mask", setOf(TickEvent.Input.Post), description = "The sub-tick timing at which break actions can be performed", visibility = vis).group(baseGroup, Group.General)
+    override val tickStageMask by c.setting("Break Stage Mask", setOf<TickEvent>(TickEvent.Input.Post), description = "The sub-tick timing at which break actions can be performed", visibility = vis).group(baseGroup, Group.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", visibility = vis).group(baseGroup, Group.General)

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

@@ -29,7 +29,7 @@ class InteractSettings(
 ) : 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 swingHand by c.setting("Swing On Interact", true, "Swings the players hand after interacting", visibility = vis).group(baseGroup)
-    override val interactStageMask by c.setting("Interact Stage Mask", setOf(TickEvent.Input.Post), description = "The sub-tick timing at which interact actions are performed", 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)
     override val interactConfirmationMode by c.setting("Interact Confirmation Mode", InteractConfig.InteractConfirmationMode.InteractThenAwait, "The style of confirmation for interactions", visibility = vis).group(baseGroup)
 }

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

@@ -18,6 +18,7 @@
 package com.lambda.config.groups
 
 import com.lambda.config.Configurable
+import com.lambda.event.events.TickEvent
 import com.lambda.interaction.request.inventory.InventoryConfig
 import com.lambda.util.NamedEnum
 import com.lambda.util.item.ItemUtils
@@ -28,10 +29,13 @@ class InventorySettings(
     vis: () -> Boolean = { true }
 ) : InventoryConfig, SettingGroup(c) {
     enum class Group(override val displayName: String) : NamedEnum {
+        General("General"),
         Container("Container"),
         Access("Access")
     }
 
+    override val actionsPerSecond by c.setting("Actions Per Tick", 20, 0..100, 1, "How many inventory actions can be performed per tick", visibility = vis).group(baseGroup, Group.General)
+    override val tickStageMask by c.setting("Inventory Stage Mask", setOf<TickEvent>(TickEvent.Pre), description = "The sub-tick timing at which inventory actions are performed", visibility = vis).group(baseGroup, Group.General)
     override val disposables by c.setting("Disposables", ItemUtils.defaultDisposables, ItemUtils.defaultDisposables, "Items that will be ignored when checking for a free slot", vis).group(baseGroup, Group.Container)
     override val swapWithDisposables by c.setting("Swap With Disposables", true, "Swap items with disposable ones", vis).group(baseGroup, Group.Container)
     override val providerPriority by c.setting("Provider Priority", InventoryConfig.Priority.WithMinItems, "What container to prefer when retrieving the item from", vis).group(baseGroup, Group.Container)

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

@@ -32,7 +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 placeStageMask by c.setting("Place Stage mask", setOf(TickEvent.Input.Post), description = "The sub-tick timing at which place actions 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)
     override val placementsPerTick by c.setting("Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick", visibility = vis).group(baseGroup)

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

@@ -20,4 +20,4 @@ package com.lambda.context
 class AutomatedSafeContext(
     safeContext: SafeContext,
     automated: Automated
-) : SafeContext by safeContext, Automated by automated
+) : IAutomatedSafeContext, SafeContext by safeContext, Automated by automated

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

@@ -0,0 +1,20 @@
+/*
+ * 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.context
+
+interface IAutomatedSafeContext : SafeContext, Automated

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

@@ -40,7 +40,7 @@ interface BreakConfig : RequestConfig {
 //    abstract val desyncFix: Boolean
     val breakDelay: Int
 
-    val breakStageMask: Set<Event>
+    val tickStageMask: Set<Event>
 
     val swapMode: SwapMode
 

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

@@ -497,7 +497,7 @@ object BreakManager : RequestHandler<BreakRequest>(
 
         val breakInfo = BreakInfo(requestCtx, Primary, request)
         primaryBreak?.let { primaryInfo ->
-            if (tickStage !in primaryInfo.breakConfig.breakStageMask) return null
+            if (tickStage !in primaryInfo.breakConfig.tickStageMask) return null
 
             if (!primaryInfo.breakConfig.doubleBreak || secondaryBreak != null) {
                 if (!primaryInfo.updatedThisTick) {
@@ -543,7 +543,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         breakInfos
             .filterNotNull()
             .asSequence()
-            .filter { !it.updatedThisTick && tickStage in it.breakConfig.breakStageMask }
+            .filter { !it.updatedThisTick && tickStage in it.breakConfig.tickStageMask }
             .forEach { info ->
                 if (info.type == RedundantSecondary && !info.progressedThisTick) {
                     val cachedState = info.context.cachedState
@@ -604,7 +604,7 @@ object BreakManager : RequestHandler<BreakRequest>(
         logger.debug("Updating pre-processing", this@updatePreProcessing)
 
         shouldProgress = !progressedThisTick
-                && tickStage in breakConfig.breakStageMask
+                && tickStage in breakConfig.tickStageMask
                 && (rotated || type != Primary)
 
         if (updatedPreProcessingThisTick) return

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

@@ -29,7 +29,7 @@ import com.lambda.util.BlockUtils.isEmpty
 import net.minecraft.entity.ItemEntity
 import net.minecraft.util.math.BlockPos
 
-data class BreakRequest(
+data class BreakRequest private constructor(
     val contexts: Collection<BreakContext>,
     val pendingInteractions: MutableCollection<BuildContext>,
     private val automated: Automated
@@ -67,63 +67,63 @@ data class BreakRequest(
     }
 
     @DslMarker
-    annotation class BreakRequestBuilder
+    annotation class BreakRequestDsl
 
-    @BreakRequestBuilder
-    class RequestBuilder(
+    @BreakRequestDsl
+    class BreakRequestBuilder(
         contexts: Collection<BreakContext>,
         pendingInteractions: MutableCollection<BuildContext>,
         automated: Automated
     ) {
         val request = BreakRequest(contexts, pendingInteractions, automated)
 
-        @BreakRequestBuilder
+        @BreakRequestDsl
         fun onStart(callback: (BlockPos) -> Unit) {
             request.onStart = callback
         }
 
-        @BreakRequestBuilder
+        @BreakRequestDsl
         fun onUpdate(callback: (BlockPos) -> Unit) {
             request.onUpdate = callback
         }
 
-        @BreakRequestBuilder
+        @BreakRequestDsl
         fun onStop(callback: (BlockPos) -> Unit) {
             request.onStop = callback
         }
 
-        @BreakRequestBuilder
+        @BreakRequestDsl
         fun onCancel(callback: (BlockPos) -> Unit) {
             request.onCancel = callback
         }
 
-        @BreakRequestBuilder
+        @BreakRequestDsl
         fun onItemDrop(callback: (ItemEntity) -> Unit) {
             request.onItemDrop = callback
         }
 
-        @BreakRequestBuilder
+        @BreakRequestDsl
         fun onReBreakStart(callback: (BlockPos) -> Unit) {
             request.onReBreakStart = callback
         }
 
-        @BreakRequestBuilder
+        @BreakRequestDsl
         fun onReBreak(callback: (BlockPos) -> Unit) {
             request.onReBreak = callback
         }
-
-        @BreakRequestBuilder
-        fun build(): BreakRequest = request
     }
 
     companion object {
         var requestCount = 0
 
-        @BreakRequestBuilder
+        @BreakRequestDsl
         fun Automated.breakRequest(
             contexts: Collection<BreakContext>,
             pendingInteractions: MutableCollection<BuildContext>,
-            builder: RequestBuilder.() -> Unit
-        ) = RequestBuilder(contexts, pendingInteractions, this).apply(builder).build()
+            builder: (BreakRequestBuilder.() -> Unit)? = null
+        ) = BreakRequestBuilder(contexts, pendingInteractions, this).apply { builder?.invoke(this) }.build()
+
+        @BreakRequestDsl
+        private fun BreakRequestBuilder.build(): BreakRequest = request
     }
 }