Added Criticals -> Edit mode

src/main/java/com/lambda/mixin/accessor/network/AccessorCPacketPlayer.java

@@ -28,7 +28,13 @@ public interface AccessorCPacketPlayer {
     @Accessor("moving")
     boolean getMoving();
 
+    @Accessor("moving")
+    void setMoving(boolean value);
+
     @Accessor("rotating")
     boolean getRotating();
 
+    @Accessor("rotating")
+    void setRotating(boolean value);
+
 }

src/main/java/com/lambda/mixin/accessor/player/AccessorEntityPlayerSP.java

@@ -10,4 +10,7 @@ public interface AccessorEntityPlayerSP {
     @Accessor("handActive")
     void kbSetHandActive(boolean value);
 
+    @Accessor("lastReportedPosY")
+    void lcSetLastReportedPosY(double value);
+
 }

src/main/java/com/lambda/mixin/player/MixinEntityPlayerSP.java

@@ -1,6 +1,7 @@
 package com.lambda.mixin.player;
 
 import com.lambda.client.event.LambdaEventBus;
+import com.lambda.client.event.events.CriticalsUpdateWalkingEvent;
 import com.lambda.client.event.events.OnUpdateWalkingPlayerEvent;
 import com.lambda.client.event.events.PlayerMoveEvent;
 import com.lambda.client.event.events.PushOutOfBlocksEvent;
@@ -150,6 +151,10 @@ private void onUpdateInvokeOnUpdateWalkingPlayer(CallbackInfo ci) {
 
     @Inject(method = "onUpdateWalkingPlayer", at = @At("HEAD"), cancellable = true)
     private void onUpdateWalkingPlayerHead(CallbackInfo ci) {
+
+        CriticalsUpdateWalkingEvent criticalsEditEvent = new CriticalsUpdateWalkingEvent();
+        LambdaEventBus.INSTANCE.post(criticalsEditEvent);
+
         // Setup flags
         Vec3d position = new Vec3d(this.posX, this.getEntityBoundingBox().minY, this.posZ);
         Vec2f rotation = new Vec2f(this.rotationYaw, this.rotationPitch);

src/main/kotlin/com/lambda/client/event/events/CriticalsUpdateWalkingEvent.kt

@@ -0,0 +1,9 @@
+package com.lambda.client.event.events
+
+import com.lambda.client.event.Event
+
+/**
+ * @author Doogie13
+ * @since 20/12/2022
+ */
+class CriticalsUpdateWalkingEvent : Event

src/main/kotlin/com/lambda/client/event/events/OnUpdateWalkingPlayerEvent.kt

@@ -22,7 +22,6 @@ class OnUpdateWalkingPlayerEvent private constructor(
 
     var moving = moving
         @JvmName("isMoving") get
-        private set
 
     var rotating = rotating
         @JvmName("isRotating") get

src/main/kotlin/com/lambda/client/mixin/extension/Network.kt

@@ -26,33 +26,48 @@ var CPacketPlayer.playerX: Double
     set(value) {
         (this as AccessorCPacketPlayer).setX(value)
     }
+
 var CPacketPlayer.playerY: Double
     get() = this.getY(0.0)
     set(value) {
         (this as AccessorCPacketPlayer).setY(value)
     }
+
 var CPacketPlayer.playerZ: Double
     get() = this.getZ(0.0)
     set(value) {
         (this as AccessorCPacketPlayer).setZ(value)
     }
+
 var CPacketPlayer.playerYaw: Float
     get() = this.getYaw(0.0f)
     set(value) {
         (this as AccessorCPacketPlayer).setYaw(value)
     }
+
 var CPacketPlayer.playerPitch: Float
     get() = this.getPitch(0.0f)
     set(value) {
         (this as AccessorCPacketPlayer).setPitch(value)
     }
+
 var CPacketPlayer.playerIsOnGround: Boolean
     get() = this.isOnGround
     set(value) {
         (this as AccessorCPacketPlayer).setOnGround(value)
     }
-val CPacketPlayer.playerMoving: Boolean get() = (this as AccessorCPacketPlayer).moving
-val CPacketPlayer.playerRotating: Boolean get() = (this as AccessorCPacketPlayer).rotating
+
+var CPacketPlayer.playerMoving: Boolean
+    get() = (this as AccessorCPacketPlayer).moving
+    set(value) {
+        (this as AccessorCPacketPlayer).moving = value
+    }
+
+var CPacketPlayer.playerRotating: Boolean
+    get() = (this as AccessorCPacketPlayer).rotating
+    set(value) {
+        (this as AccessorCPacketPlayer).rotating = value
+    }
 
 var CPacketUseEntity.useEntityId: Int
     get() = (this as AccessorCPacketUseEntity).id
@@ -77,11 +92,13 @@ var SPacketEntityVelocity.entityVelocityMotionX: Int
     set(value) {
         (this as AccessorSPacketEntityVelocity).setMotionX(value)
     }
+
 var SPacketEntityVelocity.entityVelocityMotionY: Int
     get() = this.motionY
     set(value) {
         (this as AccessorSPacketEntityVelocity).setMotionY(value)
     }
+
 var SPacketEntityVelocity.entityVelocityMotionZ: Int
     get() = this.motionZ
     set(value) {
@@ -93,11 +110,13 @@ var SPacketExplosion.explosionMotionX: Float
     set(value) {
         (this as AccessorSPacketExplosion).setMotionX(value)
     }
+
 var SPacketExplosion.explosionMotionY: Float
     get() = this.motionY
     set(value) {
         (this as AccessorSPacketExplosion).setMotionY(value)
     }
+
 var SPacketExplosion.explosionMotionZ: Float
     get() = this.motionZ
     set(value) {
@@ -109,6 +128,7 @@ var SPacketPlayerPosLook.playerPosLookYaw: Float
     set(value) {
         (this as AccessorSPacketPosLook).setYaw(value)
     }
+
 var SPacketPlayerPosLook.playerPosLookPitch: Float
     get() = this.pitch
     set(value) {

src/main/kotlin/com/lambda/client/module/modules/combat/Criticals.kt

@@ -2,14 +2,18 @@ package com.lambda.client.module.modules.combat
 
 import com.lambda.client.commons.interfaces.DisplayEnum
 import com.lambda.client.event.SafeClientEvent
+import com.lambda.client.event.events.CriticalsUpdateWalkingEvent
 import com.lambda.client.event.events.PacketEvent
 import com.lambda.client.event.events.PlayerAttackEvent
-import com.lambda.client.event.listener.listener
 import com.lambda.client.mixin.extension.isInWeb
+import com.lambda.client.mixin.extension.playerIsOnGround
+import com.lambda.client.mixin.extension.playerMoving
+import com.lambda.client.mixin.extension.playerY
 import com.lambda.client.module.Category
 import com.lambda.client.module.Module
 import com.lambda.client.util.EntityUtils.isInOrAboveLiquid
 import com.lambda.client.util.threads.safeListener
+import com.lambda.mixin.accessor.player.AccessorEntityPlayerSP
 import net.minecraft.entity.Entity
 import net.minecraft.entity.EntityLivingBase
 import net.minecraft.init.MobEffects
@@ -25,19 +29,20 @@ object Criticals : Module(
     description = "Always do critical attacks",
     category = Category.COMBAT
 ) {
-    private val mode by setting("Mode", Mode.PACKET)
+    private val mode by setting("Mode", Mode.EDIT)
     private val jumpMotion by setting("Jump Motion", 0.25, 0.1..0.5, 0.01, { mode == Mode.MINI_JUMP }, fineStep = 0.001)
-    private val attackFallDistance by setting("Attack Fall Distance", 0.1, 0.05..1.0, 0.05, { mode != Mode.PACKET })
+    private val attackFallDistance by setting("Attack Fall Distance", 0.1, 0.05..1.0, 0.05, { mode == Mode.MINI_JUMP || mode == Mode.JUMP })
 
     private enum class Mode(override val displayName: String) : DisplayEnum {
         PACKET("Packet"),
+        EDIT("Edit"),
         JUMP("Jump"),
         MINI_JUMP("Mini Jump")
     }
 
     private var delayTick = -1
     private var target: Entity? = null
-    private var attacking = false
+    private var spoofedY = -1337.0
 
     override fun isActive(): Boolean {
         return isEnabled && !delaying()
@@ -52,47 +57,81 @@ object Criticals : Module(
             reset()
         }
 
-        listener<PacketEvent.Send> {
-            if (it.packet is CPacketAnimation && mode != Mode.PACKET && delayTick > -1) {
+        safeListener<CriticalsUpdateWalkingEvent> {
+            if (mode != Mode.EDIT) return@safeListener
+
+            // we need to ensure we are always sending packets as not to flag NCP for fight.critical
+            (player as AccessorEntityPlayerSP).lcSetLastReportedPosY(-1337.0)
+        }
+
+        safeListener<PacketEvent.Send> {
+            if (it.packet is CPacketAnimation
+                && mode != Mode.PACKET
+                && delayTick > -1
+            ) {
                 it.cancel()
+                return@safeListener
+            }
+
+            if (it.packet is CPacketPlayer
+                && mode == Mode.EDIT
+            ) {
+                // the advantage of this is that it doesn't delay anything and doesn't send extra packets
+                if (player.onGround) {
+                    if (spoofedY <= 0) {
+                        spoofedY = .01
+                    } else {
+                        spoofedY -= .00001
+                    }
+                } else spoofedY = -1337.0
+
+                it.packet.playerMoving = true
+                it.packet.playerIsOnGround = false
+
+                if (spoofedY >= 0) {
+                    it.packet.playerY += spoofedY
+                }
             }
         }
 
         safeListener<PlayerAttackEvent>(0) {
-            if (it.cancelled || attacking || it.entity !is EntityLivingBase || !canDoCriticals(true)) return@safeListener
+            if (it.cancelled|| it.entity !is EntityLivingBase || !canDoCriticals(true)) return@safeListener
 
             val cooldownReady = player.onGround && player.getCooledAttackStrength(0.5f) > 0.9f
 
             when (mode) {
                 Mode.PACKET -> {
-                    if (cooldownReady) {
-                        connection.sendPacket(CPacketPlayer.Position(player.posX, player.posY + 0.1, player.posZ, false))
-                        connection.sendPacket(CPacketPlayer.Position(player.posX, player.posY, player.posZ, false))
-                    }
+                    if (!cooldownReady) return@safeListener
+
+                    connection.sendPacket(CPacketPlayer.Position(player.posX, player.posY + 0.1, player.posZ, false))
+                    connection.sendPacket(CPacketPlayer.Position(player.posX, player.posY, player.posZ, false))
                 }
                 Mode.JUMP -> {
                     jumpAndCancel(it, cooldownReady, null)
                 }
                 Mode.MINI_JUMP -> {
                     jumpAndCancel(it, cooldownReady, jumpMotion)
                 }
+                else -> { }
             }
         }
 
         safeListener<TickEvent.ClientTickEvent> { event ->
-            if (event.phase != TickEvent.Phase.END || mode == Mode.PACKET || delayTick <= -1) return@safeListener
+            if (event.phase != TickEvent.Phase.END
+                || mode == Mode.PACKET
+                || delayTick <= -1
+            ) return@safeListener
 
             delayTick--
 
-            if (target != null && player.fallDistance >= attackFallDistance && canDoCriticals(!player.onGround)) {
-                val target = target
-                reset()
+            target?.let{ target ->
+                if (player.fallDistance >= attackFallDistance
+                    && canDoCriticals(!player.onGround)
+                ) {
+                    reset()
 
-                if (target != null) {
-                    attacking = true
                     connection.sendPacket(CPacketUseEntity(target))
                     connection.sendPacket(CPacketAnimation(EnumHand.MAIN_HAND))
-                    attacking = false
                 }
             }
         }