Merge branch 'feature/taskflow' into feature/packetmine

# Conflicts:
#	common/src/main/kotlin/com/lambda/module/modules/player/PacketMine.kt

Author: beanbag44

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/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/Lambda.kt

@@ -63,10 +63,9 @@ object Lambda {
         .registerTypeAdapter(Optional::class.java, OptionalSerializer)
         .create()
 
-    fun initialize(block: () -> Unit) {
+    fun initialize(block: (Long) -> Unit) {
         recordRenderCall {
-            Loader.initialize()
-            block()
+            block(Loader.initialize())
         }
     }
 }

common/src/main/kotlin/com/lambda/brigadier/argument/IdentifierArguments.kt

@@ -0,0 +1,117 @@
+/*
+ * Copyright 2024 The Quilt Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package com.lambda.brigadier.argument
+
+import com.lambda.brigadier.*
+import com.lambda.brigadier.assumeSourceNotUsed
+import net.minecraft.advancement.AdvancementEntry
+import net.minecraft.command.argument.IdentifierArgumentType
+import net.minecraft.loot.condition.LootCondition
+import net.minecraft.loot.function.LootFunction
+import net.minecraft.recipe.RecipeEntry
+import net.minecraft.server.command.ServerCommandSource
+import net.minecraft.util.Identifier
+
+/**
+ * Reads the [Identifier] value from the
+ * argument in the receiver [ArgumentReader].
+ *
+ * @see IdentifierArgumentType.getIdentifier
+ */
+@JvmName("valueIdentifierArg")
+@BrigadierDsl
+fun DefaultArgumentReader<IdentifierArgumentType>.value(): Identifier {
+    return IdentifierArgumentType.getIdentifier(context.assumeSourceNotUsed(), name)
+}
+
+/**
+ * Reads the [Identifier] value from the
+ * argument in the receiver [ArgumentReader]
+ * as an [AdvancementEntry].
+ *
+ * @see IdentifierArgumentType.getAdvancementArgument
+ */
+@BrigadierDsl
+fun ArgumentReader<
+        ServerCommandSource,
+        DefaultArgumentDescriptor<
+                IdentifierArgumentType
+                >
+        >.asAdvancement(): AdvancementEntry {
+    return IdentifierArgumentType.getAdvancementArgument(context, name)
+}
+
+/**
+ * Reads the [Identifier] value from the
+ * argument in the receiver [ArgumentReader]
+ * as a [LootCondition].
+ *
+ * @see IdentifierArgumentType.getPredicateArgument
+ */
+@BrigadierDsl
+fun ArgumentReader<
+        ServerCommandSource,
+        DefaultArgumentDescriptor<
+                IdentifierArgumentType
+                >
+        >.asPredicate(): LootCondition {
+    return IdentifierArgumentType.getPredicateArgument(context, name)
+}
+
+/**
+ * Reads the [Identifier] value from the
+ * argument in the receiver [ArgumentReader]
+ * as a [LootFunction].
+ *
+ * @see IdentifierArgumentType.getItemModifierArgument
+ */
+@BrigadierDsl
+fun ArgumentReader<
+        ServerCommandSource,
+        DefaultArgumentDescriptor<
+                IdentifierArgumentType
+                >
+        >.asItemModifier(): LootFunction {
+    return IdentifierArgumentType.getItemModifierArgument(context, name)
+}
+
+/**
+ * Reads the [Identifier] value from the
+ * argument in the receiver [ArgumentReader]
+ * as a [RecipeEntry].
+ *
+ * @see IdentifierArgumentType.getRecipeArgument
+ */
+@BrigadierDsl
+fun ArgumentReader<
+        ServerCommandSource,
+        DefaultArgumentDescriptor<
+                IdentifierArgumentType
+                >
+        >.asRecipe(): RecipeEntry<*> {
+    return IdentifierArgumentType.getRecipeArgument(context, name)
+}
+
+/**
+ * Creates an identifier argument with [name] as the parameter name.
+ */
+@BrigadierDsl
+fun <S> identifier(
+    name: String
+): DefaultArgumentConstructor<S, IdentifierArgumentType> {
+    return argument(name, IdentifierArgumentType.identifier())
+}