more request creation functions for break and place requests. Omitted improving interact request as i plan to merge the interaction and place managers into one

Author: beanbag44

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

@@ -18,9 +18,15 @@
 package com.lambda.interaction.request.breaking
 
 import com.lambda.context.Automated
+import com.lambda.context.AutomatedSafeContext
 import com.lambda.context.SafeContext
 import com.lambda.interaction.construction.context.BreakContext
 import com.lambda.interaction.construction.context.BuildContext
+import com.lambda.interaction.construction.result.BuildResult
+import com.lambda.interaction.construction.result.Dependent
+import com.lambda.interaction.construction.result.results.BreakResult
+import com.lambda.interaction.construction.simulation.BuildSimulator.simulate
+import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.request.LogContext
 import com.lambda.interaction.request.LogContext.Companion.LogContextBuilder
 import com.lambda.interaction.request.Request
@@ -134,13 +140,40 @@ data class BreakRequest private constructor(
     companion object {
         var requestCount = 0
 
+	    @BreakRequestDsl
+	    fun AutomatedSafeContext.breakRequest(
+			positions: Collection<BlockPos>,
+			pendingInteractions: MutableCollection<BuildContext>,
+			nowOrNothing: Boolean = false,
+			builder: (BreakRequestBuilder.() -> Unit)? = null
+		) = positions
+			.associateWith { TargetState.Empty }
+		    .simulate()
+		    .breakRequest(pendingInteractions, nowOrNothing, builder)
+
+	    @BreakRequestDsl
+	    context(automated: Automated)
+	    fun Collection<BuildResult>.breakRequest(
+			pendingInteractions: MutableCollection<BuildContext>,
+			nowOrNothing: Boolean = false,
+			builder: (BreakRequestBuilder.() -> Unit)? = null
+		) = asSequence()
+		    .map { if (it is Dependent) it.lastDependency else it }
+		    .filterIsInstance<BreakResult.Break>()
+		    .map { it.context }
+		    .toSet()
+		    .takeIf { it.isNotEmpty() }
+		    ?.let { automated.breakRequest(it, pendingInteractions, nowOrNothing, builder) }
+
         @BreakRequestDsl
         fun Automated.breakRequest(
             contexts: Collection<BreakContext>,
             pendingInteractions: MutableCollection<BuildContext>,
             nowOrNothing: Boolean = false,
             builder: (BreakRequestBuilder.() -> Unit)? = null
-        ) = BreakRequestBuilder(contexts, pendingInteractions, nowOrNothing, 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/placing/PlaceRequest.kt

@@ -21,6 +21,9 @@ import com.lambda.context.Automated
 import com.lambda.context.SafeContext
 import com.lambda.interaction.construction.context.BuildContext
 import com.lambda.interaction.construction.context.PlaceContext
+import com.lambda.interaction.construction.result.BuildResult
+import com.lambda.interaction.construction.result.Dependent
+import com.lambda.interaction.construction.result.results.PlaceResult
 import com.lambda.interaction.request.LogContext
 import com.lambda.interaction.request.LogContext.Companion.LogContextBuilder
 import com.lambda.interaction.request.Request
@@ -29,16 +32,17 @@ import com.lambda.util.BlockUtils.blockState
 import com.lambda.util.BlockUtils.matches
 import net.minecraft.util.math.BlockPos
 
-data class PlaceRequest(
+data class PlaceRequest private constructor(
     val contexts: Collection<PlaceContext>,
     val pendingInteractions: MutableCollection<BuildContext>,
     private val automated: Automated,
     override val nowOrNothing: Boolean = false,
-    val onPlace: (SafeContext.(BlockPos) -> Unit)? = null
 ) : Request(), LogContext, Automated by automated {
     override val requestId = ++requestCount
     override val tickStageMask get() = placeConfig.tickStageMask
 
+	var onPlace: (SafeContext.(BlockPos) -> Unit)? = null
+
     override val done: Boolean
         get() = runSafe {
             contexts.all { it.expectedState.matches(blockState(it.blockPos)) }
@@ -54,7 +58,50 @@ data class PlaceRequest(
         }
     }
 
+	@DslMarker
+	annotation class PlaceRequestDsl
+
+	@PlaceRequestDsl
+	class PlaceRequestBuilder(
+		contexts: Collection<PlaceContext>,
+		pendingInteractions: MutableCollection<BuildContext>,
+		nowOrNothing: Boolean,
+		automated: Automated
+	) {
+		val request = PlaceRequest(contexts, pendingInteractions, automated, nowOrNothing)
+
+		@PlaceRequestDsl
+		fun onPlace(callback: SafeContext.(BlockPos) -> Unit) {
+			request.onPlace = callback
+		}
+	}
+
     companion object {
         var requestCount = 0
+
+	    @PlaceRequestDsl
+	    context(automated: Automated)
+	    fun Collection<BuildResult>.placeRequest(
+			pendingInteractions: MutableCollection<BuildContext>,
+			nowOrNothing: Boolean = false,
+			builder: (PlaceRequestBuilder.() -> Unit)? = null
+		) = asSequence()
+		    .map { if (it is Dependent) it.lastDependency else it }
+		    .filterIsInstance<PlaceResult.Place>()
+		    .map { it.context }
+		    .toSet()
+		    .takeIf { it.isNotEmpty() }
+		    ?.let { automated.placeRequest(it, pendingInteractions, nowOrNothing, builder) }
+
+	    @PlaceRequestDsl
+	    fun Automated.placeRequest(
+		    contexts: Collection<PlaceContext>,
+		    pendingInteractions: MutableCollection<BuildContext>,
+		    nowOrNothing: Boolean = false,
+			builder: (PlaceRequestBuilder.() -> Unit)? = null
+		) = PlaceRequestBuilder(contexts, pendingInteractions, nowOrNothing, this).apply { builder?.invoke(this) }.build()
+
+	    @PlaceRequestDsl
+	    fun PlaceRequestBuilder.build() = request
     }
 }

src/main/kotlin/com/lambda/module/modules/player/FastBreak.kt

@@ -23,9 +23,6 @@ import com.lambda.event.events.PlayerEvent
 import com.lambda.event.events.TickEvent
 import com.lambda.event.listener.SafeListener.Companion.listen
 import com.lambda.interaction.construction.context.BuildContext
-import com.lambda.interaction.construction.result.results.BreakResult
-import com.lambda.interaction.construction.simulation.BuildSimulator.simulate
-import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.request.breaking.BreakRequest.Companion.breakRequest
 import com.lambda.module.Module
 import com.lambda.module.tag.ModuleTag
@@ -77,17 +74,9 @@ object FastBreak : Module(
         listen<PlayerEvent.Attack.Block> { it.cancel() }
         listen<PlayerEvent.Breaking.Update> { event ->
             event.cancel()
-
-	        val breakContexts =
-				runSafeAutomated {
-					buildMap { put(event.pos, TargetState.Empty) }
-						.simulate()
-						.filterIsInstance<BreakResult.Break>()
-						.map { it.context }
-						.takeIf { it.isNotEmpty() }
-				} ?: return@listen
-
-            breakRequest(breakContexts, pendingInteractions).submit()
+	        runSafeAutomated {
+				breakRequest(listOf(event.pos), pendingInteractions)?.submit()
+			}
         }
     }
 }

src/main/kotlin/com/lambda/task/tasks/BuildTask.kt

@@ -50,7 +50,7 @@ import com.lambda.interaction.construction.verify.TargetState
 import com.lambda.interaction.request.breaking.BreakRequest.Companion.breakRequest
 import com.lambda.interaction.request.interacting.InteractRequest
 import com.lambda.interaction.request.inventory.InventoryRequest.Companion.inventoryRequest
-import com.lambda.interaction.request.placing.PlaceRequest
+import com.lambda.interaction.request.placing.PlaceRequest.Companion.placeRequest
 import com.lambda.task.Task
 import com.lambda.task.tasks.EatTask.Companion.eat
 import com.lambda.threading.runSafeAutomated
@@ -168,32 +168,19 @@ class BuildTask private constructor(
             is Contextual -> {
                 if (atMaxPendingInteractions) return
                 when (result) {
-                    is BreakResult.Break -> {
-                        val breakResults = allResults
-                            .map { if (it is Dependent) it.lastDependency else it }
-                            .filterIsInstance<BreakResult.Break>()
-                            .map { it.context }
-
-                        breakRequest(breakResults, pendingInteractions) {
+                    is BreakResult.Break ->
+                        allResults.breakRequest(pendingInteractions) {
                             onStop { breaks++ }
                             onItemDrop?.let { onItemDrop ->
                                 onItemDrop { onItemDrop(it) }
                             }
-                        }.submit(queueIfMismatchedStage = true)
-                        return
-                    }
-                    is PlaceResult.Place -> {
-                        val placeResults = allResults
-                            .map { if (it is Dependent) it.lastDependency else it }
-                            .filterIsInstance<PlaceResult.Place>()
-                            .map { it.context }
+                        }?.submit()
+
+                    is PlaceResult.Place ->
+                        allResults.placeRequest(pendingInteractions, false) {
+							onPlace { placements++ }
+						}?.submit()
 
-                        PlaceRequest(
-                            placeResults,
-                            pendingInteractions,
-                            this@BuildTask
-                        ) { placements++ }.submit(queueIfMismatchedStage = true)
-                    }
                     is InteractResult.Interact -> {
                         val interactResults = allResults
                             .map { if (it is Dependent) it.lastDependency else it }
@@ -258,7 +245,7 @@ class BuildTask private constructor(
         @Ta5kBuilder
         fun Automated.build(
             finishOnDone: Boolean = true,
-            collectDrops: Boolean = DEFAULT.buildConfig.collectDrops,
+            collectDrops: Boolean = buildConfig.collectDrops,
             lifeMaintenance: Boolean = false,
             blueprint: () -> Blueprint
         ) = BuildTask(blueprint(), finishOnDone, collectDrops, lifeMaintenance, this)
@@ -267,15 +254,15 @@ class BuildTask private constructor(
         context(automated: Automated)
         fun Structure.build(
             finishOnDone: Boolean = true,
-            collectDrops: Boolean = DEFAULT.buildConfig.collectDrops,
+            collectDrops: Boolean = automated.buildConfig.collectDrops,
             lifeMaintenance: Boolean = false
         ) = BuildTask(toBlueprint(), finishOnDone, collectDrops, lifeMaintenance, automated)
 
         @Ta5kBuilder
         context(automated: Automated)
         fun Blueprint.build(
             finishOnDone: Boolean = true,
-            collectDrops: Boolean = DEFAULT.buildConfig.collectDrops,
+            collectDrops: Boolean = automated.buildConfig.collectDrops,
             lifeMaintenance: Boolean = false
         ) = BuildTask(this, finishOnDone, collectDrops, lifeMaintenance, automated)
 
@@ -289,16 +276,5 @@ class BuildTask private constructor(
             blockPos.toStructure(TargetState.Air).toBlueprint(),
             finishOnDone, collectDrops, lifeMaintenance, this
         )
-
-        @Ta5kBuilder
-        fun Automated.breakBlock(
-            blockPos: BlockPos,
-            finishOnDone: Boolean = true,
-            collectDrops: Boolean = DEFAULT.buildConfig.collectDrops,
-            lifeMaintenance: Boolean = false
-        ) = BuildTask(
-            blockPos.toStructure(TargetState.Air).toBlueprint(),
-            finishOnDone, collectDrops, lifeMaintenance, this
-        )
     }
 }