Taskflow improvements

build.gradle.kts

@@ -1,3 +1,20 @@
+/*
+ * Copyright 2024 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/>.
+ */
+
 import org.gradle.internal.jvm.*
 import net.fabricmc.loom.api.LoomGradleExtensionAPI
 import org.apache.tools.ant.taskdefs.condition.Os

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

@@ -20,7 +20,7 @@
 import com.lambda.Lambda;
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.ClientEvent;
-import com.lambda.event.events.ScreenHandlerEvent;
+import com.lambda.event.events.InventoryEvent;
 import com.lambda.event.events.TickEvent;
 import com.lambda.module.modules.player.Interact;
 import net.minecraft.client.MinecraftClient;
@@ -78,15 +78,15 @@ 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 InventoryEvent.Open(handledScreen.getScreenHandler()));
         }
     }
 
     @Inject(method = "setScreen", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/gui/screen/Screen;removed()V", shift = At.Shift.AFTER))
     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 InventoryEvent.Close(handledScreen.getScreenHandler()));
         }
     }
 

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

@@ -66,9 +66,11 @@ public void interactItemHead(PlayerEntity player, Hand hand, CallbackInfoReturna
         }
     }
 
-    @Inject(method = "attackBlock", at = @At("HEAD"))
+    @Inject(method = "attackBlock", at = @At("HEAD"), cancellable = true)
     public void onAttackBlock(BlockPos pos, Direction side, CallbackInfoReturnable<Boolean> cir) {
-        if (EventFlow.post(new PlayerEvent.Attack.Block(pos, side)).isCanceled()) cir.cancel();
+        if (EventFlow.post(new PlayerEvent.Attack.Block(pos, side)).isCanceled()) {
+            cir.setReturnValue(false);
+        }
     }
 
     @Inject(method = "attackEntity", at = @At("HEAD"), cancellable = true)

common/src/main/java/com/lambda/mixin/network/ClientPlayNetworkHandlerMixin.java

@@ -0,0 +1,41 @@
+/*
+ * Copyright 2024 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.mixin.network;
+
+import com.lambda.event.EventFlow;
+import com.lambda.event.events.InventoryEvent;
+import net.minecraft.client.network.ClientPlayNetworkHandler;
+import net.minecraft.network.packet.s2c.play.ScreenHandlerSlotUpdateS2CPacket;
+import net.minecraft.network.packet.s2c.play.UpdateSelectedSlotS2CPacket;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(ClientPlayNetworkHandler.class)
+public class ClientPlayNetworkHandlerMixin {
+    @Inject(method = "onUpdateSelectedSlot", at = @At(value = "TAIL"))
+    private void onUpdateSelectedSlot(UpdateSelectedSlotS2CPacket packet, CallbackInfo ci) {
+        EventFlow.post(new InventoryEvent.SelectedHotbarSlotUpdate(packet.getSlot()));
+    }
+
+    @Inject(method = "onScreenHandlerSlotUpdate", at = @At(value = "TAIL"))
+    private void onScreenHandlerSlotUpdate(ScreenHandlerSlotUpdateS2CPacket packet, CallbackInfo ci) {
+        EventFlow.post(new InventoryEvent.SlotUpdate(packet.getSyncId(), packet.getRevision(), packet.getSlot(), packet.getStack()));
+    }
+}

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

@@ -17,7 +17,7 @@
 
 package com.lambda.mixin.render;
 
-import com.lambda.task.RootTask;
+import com.lambda.task.TaskFlow;
 import com.lambda.util.DebugInfoHud;
 import net.minecraft.client.gui.hud.DebugHud;
 import org.spongepowered.asm.mixin.Mixin;
@@ -36,6 +36,6 @@ private void onGetRightText(CallbackInfoReturnable<List<String>> cir) {
 
     @Inject(method = "getLeftText", at = @At(value = "TAIL"))
     private void onGetLeftText(CallbackInfoReturnable<List<String>> cir) {
-        RootTask.INSTANCE.addInfo(cir.getReturnValue());
+        cir.getReturnValue().addAll(List.of(TaskFlow.INSTANCE.toString().split("\n")));
     }
 }

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

@@ -18,7 +18,7 @@
 package com.lambda.mixin.render;
 
 import com.lambda.event.EventFlow;
-import com.lambda.event.events.ScreenHandlerEvent;
+import com.lambda.event.events.InventoryEvent;
 import net.minecraft.item.ItemStack;
 import net.minecraft.screen.ScreenHandler;
 import org.spongepowered.asm.mixin.Mixin;
@@ -32,6 +32,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.Update(revision, stacks, cursorStack));
+        EventFlow.post(new InventoryEvent.FullUpdate(revision, stacks, cursorStack));
     }
 }

common/src/main/java/com/lambda/mixin/world/ClientWorldMixin.java

@@ -34,13 +34,6 @@
 
 @Mixin(ClientWorld.class)
 public class ClientWorldMixin {
-    @Inject(method = "handleBlockUpdate", at = @At("HEAD"), cancellable = true)
-    private void handleBlockUpdateInject(BlockPos pos, BlockState state, int flags, CallbackInfo ci) {
-        if (EventFlow.post(new WorldEvent.BlockUpdate(pos, state, flags)).isCanceled()) {
-            ci.cancel();
-        }
-    }
-
     @Inject(method = "addEntity", at = @At("HEAD"), cancellable = true)
     private void addEntity(Entity entity, CallbackInfo ci) {
         if (EventFlow.post(new WorldEvent.EntitySpawn(entity)).isCanceled()) ci.cancel();

common/src/main/java/com/lambda/mixin/world/StructureTemplateMixin.java

@@ -0,0 +1,53 @@
+/*
+ * Copyright 2024 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.mixin.world;
+
+import com.llamalad7.mixinextras.injector.ModifyReturnValue;
+import net.minecraft.block.Block;
+import net.minecraft.nbt.NbtCompound;
+import net.minecraft.registry.RegistryEntryLookup;
+import net.minecraft.structure.StructureTemplate;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.Shadow;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfoReturnable;
+
+import java.util.Objects;
+
+@Mixin(StructureTemplate.class)
+public class StructureTemplateMixin {
+    @Shadow
+    private String author;
+
+    @ModifyReturnValue(method = "getAuthor()Ljava/lang/String;", at = @At("RETURN"))
+    public String getAuthor(String original) {
+        return Objects.equals(original, "?") || Objects.equals(original, "") ? "Unknown" : original;
+    }
+
+    @Inject(method = "writeNbt(Lnet/minecraft/nbt/NbtCompound;)Lnet/minecraft/nbt/NbtCompound;", at = @At("TAIL"))
+    public void writeNbt(NbtCompound nbt, CallbackInfoReturnable<NbtCompound> cir) {
+        nbt.putString("author", author);
+    }
+
+    @Inject(method = "readNbt(Lnet/minecraft/registry/RegistryEntryLookup;Lnet/minecraft/nbt/NbtCompound;)V", at = @At("TAIL"))
+    public void readNbt(RegistryEntryLookup<Block> blockLookup, NbtCompound nbt, CallbackInfo ci) {
+        author = nbt.getString("author");
+    }
+}

common/src/main/java/com/lambda/mixin/world/WorldMixin.java

@@ -0,0 +1,36 @@
+/*
+ * Copyright 2024 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.mixin.world;
+
+import com.lambda.event.EventFlow;
+import com.lambda.event.events.WorldEvent;
+import net.minecraft.block.BlockState;
+import net.minecraft.util.math.BlockPos;
+import net.minecraft.world.World;
+import org.spongepowered.asm.mixin.Mixin;
+import org.spongepowered.asm.mixin.injection.At;
+import org.spongepowered.asm.mixin.injection.Inject;
+import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
+
+@Mixin(World.class)
+public abstract class WorldMixin {
+    @Inject(method = "onBlockChanged", at = @At("TAIL"))
+    void onBlockChanged(BlockPos pos, BlockState oldBlock, BlockState newBlock, CallbackInfo ci) {
+        EventFlow.post(new WorldEvent.BlockChange(pos, oldBlock, newBlock));
+    }
+}

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

@@ -17,18 +17,24 @@
 
 package com.lambda.command.commands
 
-import com.lambda.brigadier.argument.literal
-import com.lambda.brigadier.execute
+import com.lambda.brigadier.CommandResult
+import com.lambda.brigadier.argument.*
+import com.lambda.brigadier.executeWithResult
+import com.lambda.brigadier.optional
 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.interaction.construction.StructureRegistry
+import com.lambda.interaction.construction.blueprint.Blueprint.Companion.toStructure
+import com.lambda.interaction.construction.blueprint.StaticBlueprint.Companion.toBlueprint
+import com.lambda.task.TaskFlow.run
 import com.lambda.task.tasks.BuildTask.Companion.build
 import com.lambda.threading.runSafe
+import com.lambda.util.Communication.info
 import com.lambda.util.extension.CommandBuilder
-import net.minecraft.block.Blocks
-import net.minecraft.util.math.BlockBox
+import com.lambda.util.extension.move
+import java.nio.file.InvalidPathException
+import java.nio.file.NoSuchFileException
+import java.nio.file.Path
 
 object BuildCommand : LambdaCommand(
     name = "Build",
@@ -37,26 +43,37 @@ object BuildCommand : LambdaCommand(
 ) {
     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))
+            required(greedyString("structure")) { structure ->
+                suggests { _, builder ->
+                    StructureRegistry.forEach { key, _ -> builder.suggest(key) }
+                    builder.buildFuture()
+                }
+                executeWithResult {
+                    val pathString = structure().value()
+                    runSafe<Unit> {
+                        try {
+                            StructureRegistry
+                                .loadStructureByRelativePath(Path.of(pathString))
+                                ?.let { template ->
+                                    info("Building structure $pathString with dimensions ${template.size.toShortString()} created by ${template.author}")
+                                    template.toStructure()
+                                        .move(player.blockPos)
+                                        .toBlueprint()
+                                        .build()
+                                        .run()
 
-                    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)
-                            }
+                                    return@executeWithResult CommandResult.success()
+                                }
+                        } catch (e: InvalidPathException) {
+                            return@executeWithResult CommandResult.failure("Invalid path $pathString")
+                        } catch (e: NoSuchFileException) {
+                            return@executeWithResult CommandResult.failure("Structure $pathString not found")
+                        } catch (e: Exception) {
+                            return@executeWithResult CommandResult.failure(e.message ?: "Failed to load structure $pathString")
                         }
-                        .build(finishOnDone = false)
-                        .start(null)
+                    }
+
+                    CommandResult.failure("Structure $pathString not found")
                 }
             }
         }

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

@@ -30,6 +30,7 @@ import com.lambda.module.modules.player.Replay
 import com.lambda.util.FolderRegister
 import com.lambda.util.FolderRegister.listRecursive
 import com.lambda.util.extension.CommandBuilder
+import kotlin.io.path.exists
 
 object ReplayCommand : LambdaCommand(
     name = "replay",
@@ -48,7 +49,7 @@ object ReplayCommand : LambdaCommand(
         required(literal("load")) {
             required(greedyString("replay filepath")) { replayName ->
                 suggests { _, builder ->
-                    val dir = FolderRegister.replay
+                    val dir = FolderRegister.replay.toFile()
                     dir.listRecursive { it.isFile }.forEach {
                         builder.suggest(it.relativeTo(dir).path)
                     }
@@ -63,7 +64,7 @@ object ReplayCommand : LambdaCommand(
                     }
 
                     try {
-                        Replay.loadRecording(replayFile)
+                        Replay.loadRecording(replayFile.toFile())
                     } catch (e: JsonSyntaxException) {
                         return@executeWithResult CommandResult.failure("Failed to load replay file: ${e.message}")
                     }

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

@@ -21,20 +21,28 @@ 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.task.TaskFlow
 import com.lambda.util.Communication.info
 import com.lambda.util.extension.CommandBuilder
 
 object TaskCommand : LambdaCommand(
     name = "task",
-    usage = "task <cancel>",
+    usage = "task <cancel|clear>",
     description = "Control tasks"
 ) {
     override fun CommandBuilder.create() {
         required(literal("cancel")) {
             execute {
                 this@TaskCommand.info("Cancelling all tasks")
-                RootTask.cancel()
+                TaskFlow.cancel()
+            }
+        }
+
+        required(literal("clear")) {
+            execute {
+                this@TaskCommand.info("Clearing all tasks")
+                TaskFlow.cancel()
+                TaskFlow.clear()
             }
         }
     }