Use event tick stages

Author: emyfops

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

@@ -24,11 +24,16 @@
 import com.lambda.event.events.TickEvent;
 import com.lambda.module.modules.player.Interact;
 import com.lambda.module.modules.player.PacketMine;
+import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
+import com.llamalad7.mixinextras.injector.wrapoperation.WrapOperation;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.screen.Screen;
 import net.minecraft.client.gui.screen.ingame.ScreenHandlerProvider;
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.client.network.ClientPlayerInteractionManager;
+import net.minecraft.client.render.WorldRenderer;
+import net.minecraft.client.sound.SoundManager;
 import net.minecraft.util.thread.ThreadExecutor;
 import net.minecraft.util.Hand;
 import net.minecraft.util.hit.HitResult;
@@ -40,7 +45,7 @@
 import org.spongepowered.asm.mixin.injection.Redirect;
 import org.spongepowered.asm.mixin.injection.callback.CallbackInfo;
 
-@Mixin(MinecraftClient.class)
+@Mixin(value = MinecraftClient.class, priority = Integer.MAX_VALUE)
 public class MinecraftClientMixin {
     @Shadow
     @Nullable
@@ -49,24 +54,46 @@ public class MinecraftClientMixin {
     @Nullable
     public HitResult crosshairTarget;
 
-    @Inject(method = "tick", at = @At("HEAD"))
-    void onTickPre(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Pre());
+    @WrapMethod(method = "render")
+    void onLoopTick(boolean tick, Operation<Void> original) {
+        EventFlow.post(TickEvent.Render.Pre.INSTANCE);
+        original.call(tick);
+        EventFlow.post(TickEvent.Render.Post.INSTANCE);
     }
 
-    @Inject(method = "tick", at = @At("RETURN"))
-    void onTickPost(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Post());
+    @WrapMethod(method = "tick")
+    void onTick(Operation<Void> original) {
+        EventFlow.post(TickEvent.Pre.INSTANCE);
+        original.call();
+        EventFlow.post(TickEvent.Post.INSTANCE);
     }
 
-    @Inject(method = "render", at = @At("HEAD"))
-    void onLoopTickPre(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Render.Pre());
+    @WrapOperation(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerInteractionManager;tick()V"))
+    void onNetwork(ClientPlayerInteractionManager instance, Operation<Void> original) {
+        EventFlow.post(TickEvent.Network.Pre.INSTANCE);
+        original.call(instance);
+        EventFlow.post(TickEvent.Network.Post.INSTANCE);
     }
 
-    @Inject(method = "render", at = @At("RETURN"))
-    void onLoopTickPost(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Render.Post());
+    @WrapOperation(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/MinecraftClient;handleInputEvents()V"))
+    void onInput(MinecraftClient instance, Operation<Void> original) {
+        EventFlow.post(TickEvent.Input.Pre.INSTANCE);
+        original.call(instance);
+        EventFlow.post(TickEvent.Input.Post.INSTANCE);
+    }
+
+    @WrapOperation(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/render/WorldRenderer;tick()V"))
+    void onWorldRenderer(WorldRenderer instance, Operation<Void> original) {
+        EventFlow.post(TickEvent.WorldRender.Pre.INSTANCE);
+        original.call(instance);
+        EventFlow.post(TickEvent.WorldRender.Post.INSTANCE);
+    }
+
+    @WrapOperation(method = "tick", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/sound/SoundManager;tick(Z)V"))
+    void onSound(SoundManager instance, boolean paused, Operation<Void> original) {
+        EventFlow.post(TickEvent.Sound.Pre.INSTANCE);
+        original.call(instance, paused);
+        EventFlow.post(TickEvent.Sound.Post.INSTANCE);
     }
 
     @Inject(at = @At(value = "INVOKE", target = "Lorg/slf4j/Logger;info(Ljava/lang/String;)V", shift = At.Shift.AFTER, remap = false), method = "stop")

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

@@ -25,6 +25,8 @@
 import com.lambda.interaction.PlayerPacketManager;
 import com.lambda.interaction.request.rotation.RotationManager;
 import com.lambda.module.modules.player.PortalGui;
+import com.llamalad7.mixinextras.injector.wrapmethod.WrapMethod;
+import com.llamalad7.mixinextras.injector.wrapoperation.Operation;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.gui.screen.DeathScreen;
 import net.minecraft.client.gui.screen.Screen;
@@ -129,14 +131,11 @@ void sendBegin(CallbackInfo ci) {
         autoJumpEnabled = Lambda.getMc().options.getAutoJump().getValue();
     }
 
-    @Inject(method = "tick", at = @At(value = "HEAD"))
-    void onTickPre(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Player.Pre());
-    }
-
-    @Inject(method = "tick", at = @At(value = "RETURN"))
-    void onTickPost(CallbackInfo ci) {
-        EventFlow.post(new TickEvent.Player.Post());
+    @WrapMethod(method = "tick")
+    void onTick(Operation<Void> original) {
+        EventFlow.post(TickEvent.Player.Pre.INSTANCE);
+        original.call();
+        EventFlow.post(TickEvent.Player.Post.INSTANCE);
     }
 
     @Redirect(method = "tickNewAi", at = @At(value = "INVOKE", target = "Lnet/minecraft/client/network/ClientPlayerEntity;getYaw()F"))

common/src/main/kotlin/com/lambda/config/groups/BreakSettings.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.Priority
 import com.lambda.interaction.request.breaking.BreakConfig
 import com.lambda.util.BlockUtils.allSigns
@@ -32,7 +33,7 @@ class BreakSettings(
     override val breakThreshold by c.setting("Break Threshold", 0.7f, 0.1f..1.0f, 0.02f, "The break amount at which the block is considered broken") { vis() }
     override val doubleBreak by c.setting("Double Break", true, "Allows breaking two blocks at once") { vis() }
     override val breakDelay by c.setting("Break Delay", 0, 0..5, 1, "The delay between breaking blocks", " ticks") { vis() }
-    override val breakStageMask by c.setting("Break Stage Mask", setOf(*TickStage.entries.toTypedArray()), "The sub-tick timing at which break actions can be performed", vis)
+    override val breakStageMask by c.setting("Break Stage Mask", setOf(TickEvent.Pre, TickEvent.Input.Pre, TickEvent.Player.Post), "The sub-tick timing at which break actions can be performed", vis)
     override val swing by c.setting("Swing Mode", SwingMode.Constant, "The times at which to swing the players hand") { vis() }
     override val swingType by c.setting("Break Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing != SwingMode.None }
     override val sounds by c.setting("Break Sounds", true, "Plays the breaking sounds") { vis() }
@@ -47,4 +48,4 @@ class BreakSettings(
     override val forceSilkTouch by c.setting("Force Silk Touch", false, "Force silk touch when breaking blocks") { vis() }
     override val forceFortunePickaxe by c.setting("Force Fortune Pickaxe", false, "Force fortune pickaxe when breaking blocks") { vis() }
     override val minFortuneLevel by c.setting("Min Fortune Level", 1, 1..3, 1, "The minimum fortune level to use") { vis() && forceFortunePickaxe }
-}
+}

common/src/main/kotlin/com/lambda/config/groups/HotbarSettings.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.Priority
 import com.lambda.interaction.request.hotbar.HotbarConfig
 
@@ -30,5 +31,5 @@ class HotbarSettings(
     override val swapDelay by c.setting("Swap Delay", 0, 0..3, 1, "The number of ticks delay before allowing another hotbar selection swap", " ticks", vis)
     override val swapsPerTick by c.setting("Swaps Per Tick", 3, 1..10, 1, "The number of hotbar selection swaps that can take place each tick") { swapDelay <= 0 && vis() }
     override val swapPause by c.setting("Swap Pause", 0, 0..20, 1, "The delay in ticks to pause actions after switching to the slot", " ticks", vis)
-    override val sequenceStageMask by c.setting("Hotbar Stage Mask", setOf(*TickStage.entries.toTypedArray()), "The sub-tick timing at which hotbar actions are performed", vis)
-}
+    override val sequenceStageMask by c.setting("Hotbar Stage Mask", setOf(TickEvent.Pre, TickEvent.Input.Pre, TickEvent.Player.Post), "The sub-tick timing at which hotbar actions are performed", vis)
+}

common/src/main/kotlin/com/lambda/config/groups/PlaceSettings.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.Priority
 import com.lambda.interaction.request.placing.PlaceConfig
 
@@ -29,11 +30,11 @@ class PlaceSettings(
     override val rotateForPlace by c.setting("Rotate For Place", true, "Rotate towards block while placing") { vis() }
     override val airPlace by c.setting("Air Place", AirPlaceMode.None, "Allows for placing blocks without adjacent faces") { vis() }
     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() }
-    override val placeStageMask by c.setting("Place Sequence Mode", setOf(*TickStage.entries.toTypedArray()), "The sub-tick timing at which break actions are performed") { vis() }
+    override val placeStageMask by c.setting("Place Sequence Mode", setOf(TickEvent.Pre, TickEvent.Input.Pre, TickEvent.Player.Post), "The sub-tick timing at which break actions are performed") { vis() }
     override val placeConfirmationMode by c.setting("Place Confirmation", PlaceConfirmationMode.PlaceThenAwait, "Wait for block placement confirmation") { vis() }
     override val maxPendingPlacements by c.setting("Max Pending Placements", 5, 0..30, 1, "The maximum amount of pending placements") { vis() }
     override val placementsPerTick by c.setting("Places Per Tick", 1, 1..30, 1, "Maximum instant block places per tick") { vis() }
     override val swing by c.setting("Swing", true, "Swings the players hand when placing") { vis() }
     override val swingType by c.setting("Place Swing Type", BuildConfig.SwingType.Vanilla, "The style of swing") { vis() && swing }
     override val sounds by c.setting("Place Sounds", true, "Plays the placing sounds") { vis() }
-}
+}

common/src/main/kotlin/com/lambda/event/events/TickEvent.kt

@@ -19,51 +19,97 @@ package com.lambda.event.events
 
 import com.lambda.event.Event
 
+/**
+ * Phases:
+ *
+ * 1. **Pre-Tick**: Increments uptime, steps world tick manager, decrement item use cooldown.
+ * 2. **GUI Update**: Processes delayed messages, updates HUD.
+ * 3. **Game Mode Update**: Updates targeted entity, ticks tutorial, and interaction managers.
+ * 4. **Texture Update**: Ticks texture manager.
+ * 5. **Screen Handling**: Manages screen logic, ticks current screen.
+ * 6. **Debug HUD Update**: Resets debug HUD chunk.
+ * 7. **Input Handling**: Handles input events, decrements attack cooldown.
+ * 8. **World Update**: Ticks game and world renderers, world entities.
+ * 9. **Music and Sound Update**: Ticks music tracker and sound manager.
+ * 10. **Tutorial and Social Interactions**: Handles tutorial and social interactions, ticks world.
+ * 11. **Pending Connection**: Ticks integrated server connection.
+ * 12. **Keyboard Handling**: Polls for debug crash key presses.
+ *
+ * @see net.minecraft.client.MinecraftClient.tick
+ */
 sealed class TickEvent {
     /**
      * Triggered before each iteration of the game loop.
      *
      * Phases:
      *
-     * 1. **Pre-Tick**: Increments uptime, steps world tick manager, decrement item use cooldown.
-     * 2. **GUI Update**: Processes delayed messages, updates HUD.
-     * 3. **Game Mode Update**: Updates targeted entity, ticks tutorial, and interaction managers.
-     * 4. **Texture Update**: Ticks texture manager.
-     * 5. **Screen Handling**: Manages screen logic, ticks current screen.
-     * 6. **Debug HUD Update**: Resets debug HUD chunk.
-     * 7. **Input Handling**: Handles input events, decrements attack cooldown.
-     * 8. **World Update**: Ticks game and world renderers, world entities.
-     * 9. **Music and Sound Update**: Ticks music tracker and sound manager.
-     * 10. **Tutorial and Social Interactions**: Handles tutorial and social interactions, ticks world.
-     * 11. **Pending Connection**: Ticks integrated server connection.
-     * 12. **Keyboard Handling**: Polls for debug crash key presses.
-     *
-     * @see net.minecraft.client.MinecraftClient.tick
+     * 1. Increments uptime
+     * 2. Steps world tick manager
+     * 3. Decrements item use cooldown
      */
-    class Pre : Event
+    data object Pre : Event
 
     /**
      * Triggered after each iteration of the game loop.
-     * Targeted at 20 ticks per second.
+     */
+    data object Post : Event
+
+    /**
+     * Triggered during the network tick stage only
+     *
+     * Phases:
+     *
+     * 1. Synchronizes player inventory slot changes
+     * 2. Clears the outgoing packet queue
+     * 3. Ticks packet listeners
+     * 4. Flushes the connection channel
+     * 5. Updates network statistics
+     * 6. Updates the packet logger
+     *
+     * @see net.minecraft.client.network.ClientPlayerInteractionManager.tick
+     */
+    sealed class Network {
+        data object Pre : Event
+        data object Post : Event
+    }
+
+    /**
+     * Triggered during the input tick stage
      *
      * Phases:
      *
-     * 1. **Pre-Tick**: Increments uptime, steps world tick manager, decrement item use cooldown.
-     * 2. **GUI Update**: Processes delayed messages, updates HUD.
-     * 3. **Game Mode Update**: Updates targeted entity, ticks tutorial, and interaction managers.
-     * 4. **Texture Update**: Ticks texture manager.
-     * 5. **Screen Handling**: Manages screen logic, ticks current screen.
-     * 6. **Debug HUD Update**: Resets debug HUD chunk.
-     * 7. **Input Handling**: Handles input events, decrements attack cooldown.
-     * 8. **World Update**: Ticks game and world renderers, world entities (such as [TickEvent.Player]).
-     * 9. **Music and Sound Update**: Ticks music tracker and sound manager.
-     * 10. **Tutorial**: Handles tutorials, ticks world.
-     * 11. **Pending Connection**: Ticks integrated server connection.
-     * 12. **Keyboard Handling**: Polls for debug crash key presses.
-     *
-     * @see net.minecraft.client.MinecraftClient.tick
+     * 1. Handles various game specific keys
+     * 2. Handles block breaking
+     * 3. Adds block breaking particles
+     * 4. Swings the player arm
+     * 5. Decrements attack cooldown
+     *
+     * @see net.minecraft.client.MinecraftClient.handleInputEvents
+     */
+    sealed class Input {
+        data object Pre : Event
+        data object Post : Event
+    }
+
+    /**
+     * Triggered during the world render tick stage
+     *
+     * @see net.minecraft.client.render.WorldRenderer.tick
      */
-    class Post : Event
+    sealed class WorldRender {
+        data object Pre : Event
+        data object Post : Event
+    }
+
+    /**
+     * Triggered during the sound update tick stage
+     *
+     * @see net.minecraft.client.sound.SoundManager.tick
+     */
+    sealed class Sound {
+        data object Pre : Event
+        data object Post : Event
+    }
 
     /**
      * Triggered before ([Pre]) and after ([Post]) each render tick.
@@ -82,12 +128,12 @@ sealed class TickEvent {
         /**
          * Triggered before each render tick ([TickEvent.Render]) of the game loop.
          */
-        class Pre : Event
+        data object Pre : Event
 
         /**
          * Triggered after each render tick ([TickEvent.Render]) of the game loop.
          */
-        class Post : Event
+        data object Post : Event
     }
 
     /**
@@ -106,11 +152,11 @@ sealed class TickEvent {
         /**
          * Triggered before each player tick ([TickEvent.Player]).
          */
-        class Pre : Event
+        data object Pre : Event
 
         /**
          * Triggered after each player tick ([TickEvent.Player]).
          */
-        class Post : Event
+        data object Post : Event
     }
 }

common/src/main/kotlin/com/lambda/interaction/request/Request.kt

@@ -24,4 +24,4 @@ abstract class Request (
     var fresh = true
 
     abstract val done: Boolean
-}
+}