[1.20.x] [All]: Stability improvements for TaskFlow (#48)

- More coherent task hierarchy
- Removed generic screen events
- Build command added
- Task control command added
- Dynamic disposable material use
- Iterative inventory transactions
- TaskFlow HUD
- InventoryTweaks module added
- Fixed rotation timings

---------

Co-authored-by: Kamigen <46357922+Edouard127@users.noreply.github.com>

Author: Avanatiker

common/src/main/java/com/lambda/mixin/MinecraftClientMixin.java

@@ -57,7 +57,7 @@ private void onStartup(CallbackInfo ci) {
     private void onScreenOpen(@Nullable Screen screen, CallbackInfo ci) {
         if (screen == null) return;
         if (screen instanceof ScreenHandlerProvider<?> handledScreen) {
-            EventFlow.post(new ScreenHandlerEvent.Open<>(handledScreen.getScreenHandler()));
+            EventFlow.post(new ScreenHandlerEvent.Open(handledScreen.getScreenHandler()));
         }
 
         EventFlow.post(new ScreenEvent.Open<>(screen));
@@ -67,7 +67,7 @@ private void onScreenOpen(@Nullable Screen screen, CallbackInfo ci) {
     private void onScreenRemove(@Nullable Screen screen, CallbackInfo ci) {
         if (currentScreen == null) return;
         if (currentScreen instanceof ScreenHandlerProvider<?> handledScreen) {
-            EventFlow.post(new ScreenHandlerEvent.Close<>(handledScreen.getScreenHandler()));
+            EventFlow.post(new ScreenHandlerEvent.Close(handledScreen.getScreenHandler()));
         }
 
         EventFlow.post(new ScreenEvent.Close<>(currentScreen));

common/src/main/java/com/lambda/mixin/entity/ClientPlayInteractionManagerMixin.java

@@ -8,6 +8,7 @@
 import net.minecraft.client.network.ClientPlayerInteractionManager;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.player.PlayerEntity;
+import net.minecraft.screen.slot.SlotActionType;
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
 import net.minecraft.util.hit.BlockHitResult;
@@ -37,6 +38,13 @@ public void interactBlockHead(final ClientPlayerEntity player, final Hand hand,
         EventFlow.post(new InteractionEvent.Block(client.world, hitResult));
     }
 
+    @Inject(method = "clickSlot", at = @At("HEAD"), cancellable = true)
+    public void clickSlotHead(int syncId, int slotId, int button, SlotActionType actionType, PlayerEntity player, CallbackInfo ci) {
+        if (syncId != player.currentScreenHandler.syncId) return;
+        var click = new InteractionEvent.SlotClick(syncId, slotId, button, actionType, player.currentScreenHandler);
+        if (EventFlow.post(click).isCanceled()) ci.cancel();
+    }
+
     @Inject(method = "attackEntity", at = @At("HEAD"), cancellable = true)
     void onAttackPre(PlayerEntity player, Entity target, CallbackInfo ci) {
         if (EventFlow.post(new AttackEvent.Pre(target)).isCanceled()) ci.cancel();

common/src/main/java/com/lambda/mixin/entity/EntityMixin.java

@@ -3,10 +3,12 @@
 import com.lambda.Lambda;
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.EntityEvent;
+import com.lambda.event.events.WorldEvent;
 import com.lambda.interaction.RotationManager;
 import com.lambda.util.math.Vec2d;
 import net.minecraft.entity.Entity;
 import net.minecraft.entity.MovementType;
+import net.minecraft.entity.data.TrackedData;
 import net.minecraft.util.math.Vec3d;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
@@ -70,4 +72,11 @@ float fixDirectionPitch2(Entity entity) {
     private void changeLookDirection(double cursorDeltaX, double cursorDeltaY, CallbackInfo ci) {
         if (EventFlow.post(new EntityEvent.ChangeLookDirection(cursorDeltaX, cursorDeltaY)).isCanceled()) ci.cancel();
     }
-}
+
+    @Inject(method = "onTrackedDataSet(Lnet/minecraft/entity/data/TrackedData;)V", at = @At("TAIL"))
+    public void onTrackedDataSet(TrackedData<?> data, CallbackInfo ci) {
+        Entity entity = (Entity) (Object) this;
+
+        EventFlow.post(new WorldEvent.EntityUpdate(entity, data));
+    }
+}

common/src/main/java/com/lambda/mixin/render/ScreenHandlerMixin.java

@@ -1,7 +1,6 @@
 package com.lambda.mixin.render;
 
 import com.lambda.event.EventFlow;
-import com.lambda.event.events.ScreenEvent;
 import com.lambda.event.events.ScreenHandlerEvent;
 import net.minecraft.item.ItemStack;
 import net.minecraft.screen.ScreenHandler;
@@ -16,6 +15,6 @@
 public class ScreenHandlerMixin {
     @Inject(method = "updateSlotStacks", at = @At("TAIL"))
     private void onUpdateSlotStacksHead(int revision, List<ItemStack> stacks, ItemStack cursorStack, CallbackInfo ci) {
-        EventFlow.post(new ScreenHandlerEvent.Loaded(revision, stacks, cursorStack));
+        EventFlow.post(new ScreenHandlerEvent.Update(revision, stacks, cursorStack));
     }
 }

common/src/main/kotlin/com/lambda/command/LambdaCommand.kt

@@ -22,7 +22,7 @@ abstract class LambdaCommand(
     // ToDo: Include usage and description in the help command
     init {
         (listOf(name) + aliases).forEach {
-            val argument = LiteralArgumentBuilder.literal<CommandSource>(it)
+            val argument = LiteralArgumentBuilder.literal<CommandSource>(it.lowercase())
             argument.create()
             dispatcher.register(argument)
         }

common/src/main/kotlin/com/lambda/command/commands/BuildCommand.kt

@@ -0,0 +1,47 @@
+package com.lambda.command.commands
+
+import com.lambda.brigadier.argument.literal
+import com.lambda.brigadier.execute
+import com.lambda.brigadier.required
+import com.lambda.command.LambdaCommand
+import com.lambda.interaction.construction.Blueprint.Companion.toStructure
+import com.lambda.interaction.construction.DynamicBlueprint.Companion.toBlueprint
+import com.lambda.interaction.construction.verify.TargetState
+import com.lambda.task.tasks.BuildTask.Companion.build
+import com.lambda.threading.runSafe
+import com.lambda.util.extension.CommandBuilder
+import net.minecraft.block.Blocks
+import net.minecraft.util.math.BlockBox
+
+object BuildCommand : LambdaCommand(
+    name = "Build",
+    description = "Builds a structure",
+    usage = "build <structure>"
+) {
+    override fun CommandBuilder.create() {
+        required(literal("place")) {
+            execute {
+                runSafe {
+                    val materials = setOf(
+                        TargetState.Block(Blocks.NETHERRACK),
+                        TargetState.Block(Blocks.AIR),
+                        TargetState.Block(Blocks.COBBLESTONE),
+                        TargetState.Block(Blocks.AIR),
+                    )
+                    val facing = player.horizontalFacing
+                    val pos = player.blockPos.add(facing.vector.multiply(2))
+
+                    BlockBox.create(pos, pos.add(facing.rotateYClockwise().vector.multiply(3)))
+                        .toStructure(TargetState.Block(Blocks.NETHERRACK))
+                        .toBlueprint {
+                            it.mapValues { (_, _) ->
+                                materials.elementAt((System.currentTimeMillis() / 5000).toInt() % materials.size)
+                            }
+                        }
+                        .build(finishOnDone = false)
+                        .start(null)
+                }
+            }
+        }
+    }
+}

common/src/main/kotlin/com/lambda/command/commands/TaskCommand.kt

@@ -0,0 +1,24 @@
+package com.lambda.command.commands
+
+import com.lambda.brigadier.argument.literal
+import com.lambda.brigadier.execute
+import com.lambda.brigadier.required
+import com.lambda.command.LambdaCommand
+import com.lambda.task.RootTask
+import com.lambda.util.Communication.info
+import com.lambda.util.extension.CommandBuilder
+
+object TaskCommand : LambdaCommand(
+    name = "task",
+    usage = "task <cancel>",
+    description = "Control tasks"
+) {
+    override fun CommandBuilder.create() {
+        required(literal("cancel")) {
+            execute {
+                this@TaskCommand.info("Cancelling all tasks")
+                RootTask.cancel()
+            }
+        }
+    }
+}

common/src/main/kotlin/com/lambda/command/commands/TransferCommand.kt

@@ -18,7 +18,7 @@ object TransferCommand : LambdaCommand(
     usage = "transfer <move|cancel|undo> <item> <amount> <to>",
     description = "Transfer items from anywhere to anywhere",
 ) {
-    private var lastTransfer: TransferResult.Success? = null
+    private var lastTransfer: TransferResult.Transfer? = null
 
     override fun CommandBuilder.create() {
         required(itemStack("stack", registry)) { stack ->
@@ -61,10 +61,10 @@ object TransferCommand : LambdaCommand(
                             } ?: return@executeWithResult failure("To container not found")
 
                             when (val result = fromContainer.transfer(selection, toContainer)) {
-                                is TransferResult.Success -> {
+                                is TransferResult.Transfer -> {
                                     info("$result started.")
                                     lastTransfer = result
-                                    result.solve.onSuccess { _, _ ->
+                                    result.onSuccess { _, _ ->
                                         info("$lastTransfer completed.")
                                     }.start(null)
                                     return@executeWithResult success()
@@ -86,23 +86,13 @@ object TransferCommand : LambdaCommand(
 
         required(literal("cancel")) {
             executeWithResult {
-                lastTransfer?.solve?.cancel() ?: run {
+                lastTransfer?.cancel() ?: run {
                     return@executeWithResult failure("No transfer to cancel")
                 }
                 info("$lastTransfer cancelled")
                 lastTransfer = null
                 success()
             }
         }
-
-        required(literal("undo")) {
-            executeWithResult {
-                lastTransfer?.undo ?: run {
-                    return@executeWithResult failure("No transfer to undo")
-                }
-                info("Undoing $lastTransfer")
-                success()
-            }
-        }
     }
 }

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

@@ -1,8 +1,6 @@
 package com.lambda.config.groups
 
 interface BuildConfig {
-    val breakCoolDown: Int
-    val placeCooldown: Int
     val breakConfirmation: Boolean
     val placeConfirmation: Boolean
     val collectDrops: Boolean
@@ -11,5 +9,4 @@ interface BuildConfig {
     val breaksPerTick: Int
     val rotateForBreak: Boolean
     val rotateForPlace: Boolean
-    val pingTimeout: Boolean
 }

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

@@ -7,23 +7,21 @@ class BuildSettings(
     vis: () -> Boolean = { true }
 ) : BuildConfig {
     enum class Page {
-        BREAK, PLACE, GENERAL
+        GENERAL, BREAK, PLACE
     }
 
-    private val page by c.setting("Build Page", Page.BREAK, "Current page", vis)
+    private val page by c.setting("Build Page", Page.GENERAL, "Current page", vis)
+
+    override val pathing by c.setting("Pathing", true, "Path to blocks") { vis() && page == Page.GENERAL }
 
-    override val breakCoolDown by c.setting("Break Cooldown", 0, 0..1000, 1, "Delay between breaking blocks", " ms") { vis() && page == Page.BREAK }
     override val breakConfirmation by c.setting("Break Confirmation", false, "Wait for block break confirmation") { vis() && page == Page.BREAK }
     override val breakWeakBlocks by c.setting("Break Weak Blocks", false, "Break blocks that dont have structural integrity (e.g: grass)") { vis() && page == Page.BREAK }
     override val breaksPerTick by c.setting("Instant Breaks Per Tick", 10, 1..30, 1, "Maximum instant block breaks per tick") { vis() && page == Page.BREAK }
-    override val rotateForBreak by c.setting("Rotate For Break", false, "Rotate towards block while breaking") { vis() && page == Page.BREAK }
+    override val rotateForBreak by c.setting("Rotate For Break", true, "Rotate towards block while breaking") { vis() && page == Page.BREAK }
+
     override val collectDrops by c.setting("Collect All Drops", false, "Collect all drops when breaking blocks") { vis() && page == Page.BREAK }
 
-    override val placeCooldown by c.setting("Place Cooldown", 0, 0..1000, 1, "Delay between placing blocks", " ms") { vis() && page == Page.PLACE }
     override val placeConfirmation by c.setting("Place Confirmation", true, "Wait for block placement confirmation") { vis() && page == Page.PLACE }
 
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() && page == Page.PLACE }
-
-    override val pathing by c.setting("Pathing", true, "Path to blocks") { vis() && page == Page.GENERAL }
-    override val pingTimeout by c.setting("Ping Timeout", true, "Timeout on high ping") { vis() && page == Page.GENERAL }
 }