Added SafeWalk and improved cancellable handling

Author: Avanatiker

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

@@ -21,9 +21,9 @@ public class ClientConnectionMixin {
 
     @Inject(method = "send(Lnet/minecraft/network/packet/Packet;)V", at = @At("HEAD"), cancellable = true)
     private void sendingPacket(Packet<?> packet, final CallbackInfo callbackInfo) {
-        PacketEvent.Send.Pre event = new PacketEvent.Send.Pre(packet);
-        EventFlow.post(event);
-        if (event.isCanceled()) callbackInfo.cancel();
+        if (EventFlow.post(new PacketEvent.Send.Pre(packet)).isCanceled()) {
+            callbackInfo.cancel();
+        }
     }
 
     @Inject(method = "send(Lnet/minecraft/network/packet/Packet;)V", at = @At("RETURN"))
@@ -38,10 +38,9 @@ private void receivingPacket(
             CallbackInfo callbackInfo
     ) {
         if (side != NetworkSide.CLIENTBOUND) return;
-
-        PacketEvent.Receive.Pre event = new PacketEvent.Receive.Pre(packet);
-        EventFlow.post(event);
-        if (event.isCanceled()) callbackInfo.cancel();
+        if (EventFlow.post(new PacketEvent.Receive.Pre(packet)).isCanceled()) {
+            callbackInfo.cancel();
+        }
     }
 
     @Inject(method = "channelRead0(Lio/netty/channel/ChannelHandlerContext;Lnet/minecraft/network/packet/Packet;)V", at = @At(value = "INVOKE", target = "Lnet/minecraft/network/ClientConnection;handlePacket(Lnet/minecraft/network/packet/Packet;Lnet/minecraft/network/listener/PacketListener;)V", shift = At.Shift.AFTER))

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

@@ -23,14 +23,14 @@ void onTickPost(CallbackInfo ci) {
 
     @Inject(at = @At(value = "INVOKE", target = "Lorg/slf4j/Logger;info(Ljava/lang/String;)V", shift = At.Shift.AFTER, remap = false), method = "stop")
     private void onShutdown(CallbackInfo ci) {
-        EventFlow.post(ClientEvent.Shutdown.INSTANCE);
+        EventFlow.post(new ClientEvent.Shutdown());
     }
 
     /**
      * Inject after the thread field is set so `ThreadExecutor#getThread` is available
      */
     @Inject(at = @At(value = "FIELD", target = "Lnet/minecraft/client/MinecraftClient;thread:Ljava/lang/Thread;", shift = At.Shift.AFTER, ordinal = 0), method = "run")
     private void onStartup(CallbackInfo ci) {
-        EventFlow.post(ClientEvent.Startup.INSTANCE);
+        EventFlow.post(new ClientEvent.Startup());
     }
 }

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

@@ -0,0 +1,19 @@
+package com.lambda.mixin;
+
+import com.lambda.event.EventFlow;
+import com.lambda.event.events.MovementEvent;
+import net.minecraft.entity.player.PlayerEntity;
+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.CallbackInfoReturnable;
+
+@Mixin(PlayerEntity.class)
+public class PlayerEntityMixin {
+    @Inject(method = "clipAtLedge", at = @At(value = "HEAD"), cancellable = true)
+    private void injectSafeWalk(CallbackInfoReturnable<Boolean> cir) {
+        if (EventFlow.post(new MovementEvent.ClipAtLedge()).isCanceled()) {
+            cir.setReturnValue(true);
+        }
+    }
+}

common/src/main/kotlin/com/lambda/config/Configuration.kt

@@ -55,7 +55,7 @@ abstract class Configuration : Jsonable {
             configurables.find {
                 it.name == name
             }?.loadFromJson(value)
-                ?: LOG.warn("No matching setting found for saved setting $name with $value in $configName config")
+                ?: LOG.warn("No matching setting found for saved setting $name with $value in ${configName.capitalize()} config")
         }
     }
 
@@ -71,7 +71,7 @@ abstract class Configuration : Jsonable {
 
     private fun load(file: File) {
         check(file.exists()) {
-            "No configuration file found for $configName"
+            "No configuration file found for ${configName.capitalize()}"
         }
 
         loadFromJson(JsonParser.parseReader(file.reader()).asJsonObject)
@@ -82,19 +82,19 @@ abstract class Configuration : Jsonable {
             runCatching { load(primary) }
                 .onSuccess { LOG.info("[IO] Config Manager: ${configName.capitalize()} config loaded.") }
                 .onFailure {
-                    LOG.error("Failed to load $configName config, loading backup")
+                    LOG.error("Failed to load ${configName.capitalize()} config, loading backup")
                     runCatching { load(backup) }
-                        .onSuccess { LOG.info("$configName config loaded from backup") }
-                        .onFailure { LOG.error("Failed to load $configName config from backup, unrecoverable error", it) }
+                        .onSuccess { LOG.info("${configName.capitalize()} config loaded from backup") }
+                        .onFailure { LOG.error("Failed to load ${configName.capitalize()} config from backup, unrecoverable error", it) }
                 }
         }
     }
 
     private fun trySave() {
         lambdaScope.launch(Dispatchers.IO) {
             runCatching { save() }
-                .onSuccess { LOG.info("$configName config saved") }
-                .onFailure { LOG.error("Failed to save $configName config", it) }
+                .onSuccess { LOG.info("[IO] ${configName.capitalize()} config saved") }
+                .onFailure { LOG.error("Failed to save ${configName.capitalize()} config", it) }
         }
     }
 

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

@@ -63,6 +63,12 @@ object EventFlow {
         event.executeListenerSynchronous()
     }
 
+    @JvmStatic
+    fun post(cancellable: ICancellable): ICancellable {
+        post(cancellable as Event)
+        return cancellable
+    }
+
     /**
      * Unsubscribes from both synchronous and concurrent event flows for a specific [Event] type [T].
      *

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

@@ -4,6 +4,6 @@ import com.lambda.event.Event
 
 
 abstract class ClientEvent : Event {
-    data object Shutdown : ClientEvent()
-    data object Startup : ClientEvent()
+    class Shutdown : ClientEvent()
+    class Startup : ClientEvent()
 }

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

@@ -0,0 +1,9 @@
+package com.lambda.event.events
+
+import com.lambda.event.Event
+import com.lambda.event.cancellable.Cancellable
+import com.lambda.event.cancellable.ICancellable
+
+abstract class MovementEvent : Event {
+    class ClipAtLedge : MovementEvent(), ICancellable by Cancellable()
+}

common/src/main/kotlin/com/lambda/module/Module.kt

@@ -94,6 +94,7 @@ abstract class Module(
 ) : Nameable, Muteable, Configurable(ModuleConfig) {
     private val isEnabledSetting = setting("Enabled", enabledByDefault, { false })
     private val keybindSetting = setting("Keybind", defaultKeybind)
+    private val isVisible = setting("Visible", true)
     private val customTags = setting("Tags", defaultTags)
 
     var isEnabled by isEnabledSetting

common/src/main/kotlin/com/lambda/module/modules/SafeWalk.kt

@@ -0,0 +1,18 @@
+package com.lambda.module.modules
+
+import com.lambda.event.events.MovementEvent
+import com.lambda.event.listener.SafeListener.Companion.listener
+import com.lambda.module.Module
+import com.lambda.module.tag.ModuleTag
+
+object SafeWalk : Module(
+    name = "SafeWalk",
+    description = "Keeps you at the edge",
+    defaultTags = setOf(ModuleTag.MOVEMENT)
+) {
+    init {
+        listener<MovementEvent.ClipAtLedge> {
+            it.cancel()
+        }
+    }
+}

common/src/main/resources/lambda.mixins.common.json

@@ -8,7 +8,8 @@
     "ChatScreenMixin",
     "ClientConnectionMixin",
     "KeyboardMixin",
-    "MinecraftClientMixin"
+    "MinecraftClientMixin",
+    "PlayerEntityMixin"
   ],
   "injectors": {
     "defaultRequire": 1