Rework event structure, add some missing ones

Author: Avanatiker

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

@@ -18,7 +18,7 @@
 package com.lambda.mixin.entity;
 
 import com.lambda.event.EventFlow;
-import com.lambda.event.events.LocalPlayerEvent;
+import com.lambda.event.events.PlayerEvent;
 import net.minecraft.client.MinecraftClient;
 import net.minecraft.client.network.ClientPlayerEntity;
 import net.minecraft.client.network.ClientPlayerInteractionManager;
@@ -28,6 +28,7 @@
 import net.minecraft.util.ActionResult;
 import net.minecraft.util.Hand;
 import net.minecraft.util.hit.BlockHitResult;
+import net.minecraft.util.hit.EntityHitResult;
 import net.minecraft.util.math.BlockPos;
 import net.minecraft.util.math.Direction;
 import org.spongepowered.asm.mixin.Final;
@@ -43,38 +44,55 @@ public class ClientPlayInteractionManagerMixin {
 
     @Shadow
     public float currentBreakingProgress;
-    @Final
-    @Shadow
-    private MinecraftClient client;
 
-    @Inject(method = "interactBlock", at = @At("HEAD"))
+    @Inject(method = "interactBlock", at = @At("HEAD"), cancellable = true)
     public void interactBlockHead(final ClientPlayerEntity player, final Hand hand, final BlockHitResult hitResult, final CallbackInfoReturnable<ActionResult> cir) {
-        if (client.world == null) return;
-        EventFlow.post(new LocalPlayerEvent.BlockInteract(client.world, hitResult));
+        if (EventFlow.post(new PlayerEvent.Interact.Block(hand, hitResult)).isCanceled()) {
+            cir.setReturnValue(ActionResult.FAIL);
+        }
     }
 
-    @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 LocalPlayerEvent.SlotClick(syncId, slotId, button, actionType, player.currentScreenHandler);
-        if (EventFlow.post(click).isCanceled()) ci.cancel();
+    @Inject(method = "interactEntityAtLocation", at = @At("HEAD"), cancellable = true)
+    public void interactEntityAtLocation(PlayerEntity player, Entity entity, EntityHitResult hitResult, Hand hand, CallbackInfoReturnable<ActionResult> cir) {
+        if (EventFlow.post(new PlayerEvent.Interact.Entity(hand, entity, hitResult)).isCanceled()) {
+            cir.setReturnValue(ActionResult.FAIL);
+        }
+    }
+
+    @Inject(method = "interactItem", at = @At("HEAD"), cancellable = true)
+    public void interactItemHead(PlayerEntity player, Hand hand, CallbackInfoReturnable<ActionResult> cir) {
+        if (EventFlow.post(new PlayerEvent.Interact.Item(hand)).isCanceled()) {
+            cir.setReturnValue(ActionResult.FAIL);
+        }
+    }
+
+    @Inject(method = "attackBlock", at = @At("HEAD"))
+    public void onAttackBlock(BlockPos pos, Direction side, CallbackInfoReturnable<Boolean> cir) {
+        if (EventFlow.post(new PlayerEvent.Attack.Block(pos, side)).isCanceled()) cir.cancel();
     }
 
     @Inject(method = "attackEntity", at = @At("HEAD"), cancellable = true)
     void onAttackPre(PlayerEntity player, Entity target, CallbackInfo ci) {
-        if (EventFlow.post(new LocalPlayerEvent.EntityAttack(target)).isCanceled()) ci.cancel();
+        if (EventFlow.post(new PlayerEvent.Attack.Entity(target)).isCanceled()) ci.cancel();
     }
 
-    @Inject(method = "attackBlock", at = @At("HEAD"), cancellable = true)
-    public void onAttackBlock(BlockPos pos, Direction side, CallbackInfoReturnable<Boolean> cir) {
-        if (EventFlow.post(new LocalPlayerEvent.BlockAttack(pos, side)).isCanceled()) cir.cancel();
+    @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 PlayerEvent.SlotClick(syncId, slotId, button, actionType, player.currentScreenHandler);
+        if (EventFlow.post(click).isCanceled()) ci.cancel();
     }
 
     @Inject(method = "updateBlockBreakingProgress", at = @At("HEAD"), cancellable = true)
     private void updateBlockBreakingProgressPre(BlockPos pos, Direction side, CallbackInfoReturnable<Boolean> cir) {
-        var event = EventFlow.post(new LocalPlayerEvent.BreakingProgress(pos, side, currentBreakingProgress));
-        if (event.isCanceled()) cir.cancel();
+        var event = EventFlow.post(new PlayerEvent.Breaking.Update(pos, side, currentBreakingProgress));
+        if (event.isCanceled()) cir.setReturnValue(false);
 
         currentBreakingProgress = event.getProgress();
     }
+
+    @Inject(method = "cancelBlockBreaking", at = @At("HEAD"), cancellable = true)
+    private void cancelBlockBreakingPre(CallbackInfo ci) {
+        if (EventFlow.post(new PlayerEvent.Breaking.Cancel(currentBreakingProgress)).isCanceled()) ci.cancel();
+    }
 }

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

@@ -19,7 +19,7 @@
 
 import com.lambda.Lambda;
 import com.lambda.event.EventFlow;
-import com.lambda.event.events.LocalPlayerEvent;
+import com.lambda.event.events.PlayerEvent;
 import com.lambda.event.events.MovementEvent;
 import com.lambda.event.events.TickEvent;
 import com.lambda.interaction.PlayerPacketManager;
@@ -50,9 +50,6 @@ public abstract class ClientPlayerEntityMixin extends EntityMixin {
     @Shadow
     protected abstract void autoJump(float dx, float dz);
 
-    @Shadow
-    public abstract boolean isUsingItem();
-
     @Inject(method = "move", at = @At("HEAD"), cancellable = true)
     void onMove(MovementType movementType, Vec3d movement, CallbackInfo ci) {
         ClientPlayerEntity self = (ClientPlayerEntity) (Object) this;
@@ -63,9 +60,9 @@ void onMove(MovementType movementType, Vec3d movement, CallbackInfo ci) {
         float prevX = (float) self.getX();
         float prevZ = (float) self.getZ();
 
-        EventFlow.post(new MovementEvent.Pre());
+        EventFlow.post(new MovementEvent.Player.Pre(movementType, movement));
         super.move(movementType, self.getVelocity());
-        EventFlow.post(new MovementEvent.Post());
+        EventFlow.post(new MovementEvent.Player.Post(movementType, movement));
 
         float currX = (float) self.getX();
         float currZ = (float) self.getZ();
@@ -125,6 +122,6 @@ float fixHeldItemPitch(ClientPlayerEntity instance) {
 
     @Inject(method = "swingHand", at = @At("HEAD"), cancellable = true)
     void onSwingHandPre(Hand hand, CallbackInfo ci) {
-        if (EventFlow.post(new LocalPlayerEvent.SwingHand(hand)).isCanceled()) ci.cancel();
+        if (EventFlow.post(new PlayerEvent.SwingHand(hand)).isCanceled()) ci.cancel();
     }
 }

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

@@ -19,7 +19,7 @@
 
 import com.lambda.Lambda;
 import com.lambda.event.EventFlow;
-import com.lambda.event.events.LocalPlayerEvent;
+import com.lambda.event.events.PlayerEvent;
 import com.lambda.event.events.WorldEvent;
 import com.lambda.interaction.RotationManager;
 import com.lambda.util.math.Vec2d;
@@ -87,7 +87,7 @@ float fixDirectionPitch2(Entity entity) {
 
     @Inject(method = "changeLookDirection", at = @At("HEAD"), cancellable = true)
     private void changeLookDirection(double cursorDeltaX, double cursorDeltaY, CallbackInfo ci) {
-        if (EventFlow.post(new LocalPlayerEvent.ChangeLookDirection(cursorDeltaX, cursorDeltaY)).isCanceled()) ci.cancel();
+        if (EventFlow.post(new PlayerEvent.ChangeLookDirection(cursorDeltaX, cursorDeltaY)).isCanceled()) ci.cancel();
     }
 
     @Inject(method = "onTrackedDataSet(Lnet/minecraft/entity/data/TrackedData;)V", at = @At("TAIL"))

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

@@ -63,18 +63,12 @@ void onJump(CallbackInfo ci) {
 
     @Inject(method = "travel", at = @At("HEAD"), cancellable = true)
     void onTravelPre(Vec3d movementInput, CallbackInfo ci) {
-        LivingEntity self = (LivingEntity) (Object) this;
-        if (self != Lambda.getMc().player) return;
-
-        if (EventFlow.post(new MovementEvent.Travel.Pre()).isCanceled()) ci.cancel();
+        if (EventFlow.post(new MovementEvent.Entity.Pre((LivingEntity) (Object) this, movementInput)).isCanceled()) ci.cancel();
     }
 
     @Inject(method = "travel", at = @At("TAIL"))
     void onTravelPost(Vec3d movementInput, CallbackInfo ci) {
-        LivingEntity self = (LivingEntity) (Object) this;
-        if (self != Lambda.getMc().player) return;
-
-        EventFlow.post(new MovementEvent.Travel.Post());
+        EventFlow.post(new MovementEvent.Entity.Post((LivingEntity) (Object) this, movementInput));
     }
 
     @Redirect(method = "travel", at = @At(value = "INVOKE", target = "Lnet/minecraft/entity/LivingEntity;getPitch()F"))

common/src/main/java/com/lambda/mixin/input/MouseMixin.java

@@ -19,7 +19,10 @@
 
 import com.lambda.event.EventFlow;
 import com.lambda.event.events.MouseEvent;
+import com.lambda.util.math.Vec2d;
 import net.minecraft.client.Mouse;
+import com.lambda.util.Mouse.Button;
+import com.lambda.util.Mouse.Action;
 import org.spongepowered.asm.mixin.Mixin;
 import org.spongepowered.asm.mixin.Shadow;
 import org.spongepowered.asm.mixin.injection.At;
@@ -34,18 +37,16 @@ public class MouseMixin {
 
     @Inject(method = "onMouseButton(JIII)V", at = @At("HEAD"), cancellable = true)
     private void onMouseButton(long window, int button, int action, int mods, CallbackInfo ci) {
-        com.lambda.util.Mouse.Button btn = com.lambda.util.Mouse.Button.Companion.fromMouseCode(button);
-        com.lambda.util.Mouse.Action act = com.lambda.util.Mouse.Action.Companion.fromActionCode(action);
-        com.lambda.util.math.Vec2d position = new com.lambda.util.math.Vec2d(x, y);
+        Vec2d position = new Vec2d(x, y);
 
-        if (EventFlow.post(new MouseEvent.Click(btn, act, mods, position)).isCanceled()) {
+        if (EventFlow.post(new MouseEvent.Click(button, action, mods, position)).isCanceled()) {
             ci.cancel();
         }
     }
 
     @Inject(method = "onMouseScroll(JDD)V", at = @At("HEAD"), cancellable = true)
     private void onMouseScroll(long window, double horizontal, double vertical, CallbackInfo ci) {
-        com.lambda.util.math.Vec2d delta = new com.lambda.util.math.Vec2d(horizontal, vertical);
+        Vec2d delta = new Vec2d(horizontal, vertical);
 
         if (EventFlow.post(new MouseEvent.Scroll(delta)).isCanceled()) {
             ci.cancel();
@@ -56,7 +57,7 @@ private void onMouseScroll(long window, double horizontal, double vertical, Call
     private void onCursorPos(long window, double x, double y, CallbackInfo ci) {
         if (x + y == this.x + this.y) return;
 
-        com.lambda.util.math.Vec2d position = new com.lambda.util.math.Vec2d(x, y);
+        Vec2d position = new Vec2d(x, y);
 
         if (EventFlow.post(new MouseEvent.Move(position)).isCanceled()) {
             ci.cancel();

common/src/main/kotlin/com/lambda/event/Subscriber.kt

@@ -35,7 +35,6 @@ class Subscriber : ConcurrentHashMap<KClass<out Event>, ConcurrentSkipListSet<Li
     val defaultListenerSet: ConcurrentSkipListSet<Listener<out Event>>
         get() = ConcurrentSkipListSet(Listener.comparator.reversed())
 
-
     /** Allows a [Listener] to start receiving a specific type of [Event] */
     inline fun <reified T : Event> subscribe(listener: Listener<T>) =
         getOrPut(T::class) { defaultListenerSet }.add(listener)

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

@@ -36,7 +36,14 @@ sealed class MouseEvent {
         val action: Mouse.Action,
         val modifiers: Int,
         val position: Vec2d
-    ) : ICancellable by Cancellable()
+    ) : ICancellable by Cancellable() {
+        constructor(button: Int, action: Int, modifiers: Int, position: Vec2d) : this(
+            Mouse.Button.fromMouseCode(button),
+            Mouse.Action.fromActionCode(action),
+            modifiers,
+            position
+        )
+    }
 
     /**
      * Represents a mouse scroll event