Burrow.kt

package com.lambda.client.module.modules.combat

import com.lambda.client.commons.interfaces.DisplayEnum
import com.lambda.client.event.SafeClientEvent
import com.lambda.client.manager.managers.TimerManager.modifyTimer
import com.lambda.client.mixin.extension.isInWeb
import com.lambda.client.module.Category
import com.lambda.client.module.Module
import com.lambda.client.util.items.block
import com.lambda.client.util.items.firstItem
import com.lambda.client.util.items.hotbarSlots
import com.lambda.client.util.math.RotationUtils
import com.lambda.client.util.threads.safeListener
import net.minecraft.entity.EntityLivingBase
import net.minecraft.init.Blocks
import net.minecraft.inventory.Slot
import net.minecraft.item.ItemBlock
import net.minecraft.network.play.client.CPacketAnimation
import net.minecraft.network.play.client.CPacketHeldItemChange
import net.minecraft.network.play.client.CPacketPlayer
import net.minecraft.network.play.client.CPacketPlayerTryUseItemOnBlock
import net.minecraft.util.EnumFacing
import net.minecraft.util.EnumHand
import net.minecraft.util.math.AxisAlignedBB
import net.minecraft.util.math.BlockPos
import net.minecraft.util.math.Vec3d
import net.minecraftforge.fml.common.gameevent.TickEvent
import kotlin.math.abs
import kotlin.math.hypot

object Burrow : Module(
    name = "Burrow",
    alias = arrayOf("SelfFill", "SelfBlock", "RubberFill", "RubberBlock", "FootConcrete", "BlockLag"),
    description = "Automatically burrows you in a hole",
    category = Category.COMBAT
) {

    // behaviour
    private val nearby by setting("Nearby", true,
        description = "Burrows only if a player is nearby")
    private val range by setting("Range", 4.25f, 0.25f..6f, 0.25f,
        description = "Range to search for a player", visibility = { nearby })
    private val cancel by setting("Cancel On ", Cancel.NONE,
        description = "When to disable burrow", visibility = { nearby })
    private val autoDisable by setting("Auto Disable", true,
        description = "Automatically disables when burrowed")

    // bypass
    private val packetMode by setting("Rubberband Mode", PacketMode.SMART,
        description = "The method to use to rubberband")
    private val offset by setting("Offset", 2.0, -25.0..25.0, 1.0,
        description = "Offset to send to the server", visibility = { packetMode == PacketMode.DUMB })
    private val strength by setting("Strength", 20, 1..50, 1,
        description = "Strength of the rubberband, higher meaning more likely to work but flags more afterwards",
        visibility = { packetMode == PacketMode.ALTERNATIVE || packetMode == PacketMode.SPIN })

    // QOL
    private val smooth by setting("Smooth", true,
        description = "Smooths out the rubberbanding", visibility = { packetMode != PacketMode.NONE })
    private val noTimerFlag by setting("No Timer Flag", true,
        description = "Prevents flagging for timer",
        visibility = { packetMode != PacketMode.ALTERNATIVE })

    // generic
    private val rotate by setting("Rotate", true,
        description = "Rotates towards the block",)
    private val noPeerRotate by setting("No Peer Rotate", true,
        description = "Prevents peers from seeing our rotation",
        visibility = { rotate })

    private var lastBurrow = 0L

    enum class Cancel(override val displayName: String, val should: () -> Boolean) : DisplayEnum {
        NONE("None", { false }),
        // this returns true when moved up by knockback or a piston
        JUMP("Jump", { mc.player.motionY > 0 }),
        // this is a larger distance than a block
        MOVE("Move", { hypot(mc.player.posX - mc.player.prevPosX,
            mc.player.posZ - mc.player.prevPosZ) > .2 || JUMP.should.invoke() }),
    }

    enum class PacketMode(override val displayName: String, val rubberband: Runnable) : DisplayEnum {
        NONE("None", {
            // we just want to jump up and place to surprise the enemy gamer, this shouldn't flag at all
        }),

        DUMB("Dumb", {
            // offset by a given amount
            sendPos(offset + 1)
        }),

        WEIRD("Weird", {
            // this moves us back into the block we placed
            sendPos(0.42)
            sendPos(0.75)
        }),

        SMART("Smart", {
            // offset an amount that doesn't collide with a block and isn't our position
            for (i in -5..5) {

                // offset too close won't rubberband
                if (abs(i) <= 1)
                    continue

                if (!mc.world.collidesWithAnyBlock(mc.player.entityBoundingBox
                        .offset(0.0, 1 + i.toDouble(), 0.0))) {
                    sendPos(1 + i.toDouble())
                    break
                }

            }
        }),

        HORIZONTAL("Horizontal", {
            // we want to rubberband horizontally, so we check X and Z
            for (x in -5..5)
                for (z in -5..5)
                    if (!mc.world.collidesWithAnyBlock(mc.player.entityBoundingBox
                            .offset(x.toDouble(), 1.0, z.toDouble()))) {
                        mc.player.connection.sendPacket(
                            CPacketPlayer.Position(
                                mc.player.posX + x,
                                mc.player.posY + 1.0,
                                mc.player.posZ + z,
                                mc.player.onGround)
                        )
                        break
                    }
        }),

        ALTERNATIVE("Alternative", {
            // this flags for timer, which used to bypass 2b2tpvp and .cc and likely bypasses other rubbish patches
            for (i in 0..strength / 2) {
                sendPos(1.0 + Math.random() * 0.1)
                sendPos(1.0)
            }
        }),

        SPIN("Rotations", {
            // this flags for timer, which used to bypass 2b2tpvp and .cc and likely bypasses other rubbish patches
            for (i in 0..strength) {
                mc.player.connection.sendPacket(
                    CPacketPlayer.Rotation(
                        RotationUtils.normalizeAngle(
                            mc.player.rotationYaw + Math.random().toFloat() * 360f
                        ), mc.player.rotationPitch, mc.player.onGround)
                )
            }
        }),
    }

    var packets = 0

    init {

        safeListener<TickEvent.ClientTickEvent> { event ->

            if (event.phase.equals(TickEvent.Phase.START))
                return@safeListener

            // we don't want to burrow more than once a second, to give time to catch up with the server. Re-burrowing
            // within 1 second is always either instant mine or we never burrowed in the first place. Allowing NONE
            // means it can be used as a tower and without the timer setting also bypassed 2b2tpvp at one point.
            if (System.currentTimeMillis() - lastBurrow < 1000 && packetMode != PacketMode.NONE)
                return@safeListener

            // if we should disable due to motion or anything
            if (cancel.should.invoke()) {
                disable()
                return@safeListener
            }

            if (!player.onGround)
                return@safeListener

            // check we aren't in an invalid position to burrow
            if (mc.player.isInWeb || mc.player.isInLava || mc.player.isInWater || mc.player.isInLava
                || world.collidesWithAnyBlock(player.entityBoundingBox)) {
                if (autoDisable)
                    disable()
                return@safeListener
            }

            // check that we are near players or don't care
            if (nearby && world.playerEntities.none {
                    Vec3d(BlockPos(player.positionVector)).add(.0, 1.0, .0)
                        .squareDistanceTo(it.posX, it.posY, it.posZ) <= range * range && it != player
                })
                return@safeListener

            // check any colliding entities
            if (world.getEntitiesWithinAABB(EntityLivingBase::class.java,
                    AxisAlignedBB(BlockPos(player.posX, player.posY, player.posZ))).any { it != player })
                return@safeListener

            // get slot
            val slot = player.hotbarSlots.firstItem<ItemBlock, Slot> {
                it.item is ItemBlock && it.item.block.let { b -> b == Blocks.OBSIDIAN || b == Blocks.ENDER_CHEST }
            } ?: return@safeListener

            burrow(slot.slotIndex)

        }

        onDisable {
            packets = 0
        }

    }

    private fun SafeClientEvent.burrow(slot: Int) {

        // basically No003
        if (smooth)
            sendPos(0.0)

        // start of a jump
        sendPos(0.42)
        sendPos(0.75)

        // Vanilla would have us go to ~1.01 but if we aren't rubberbanding we want 1.0 so that we don't have to fall
        if (packetMode != PacketMode.NONE) {
            sendPos(1.01)
            sendPosRot(1.16)
        } else {
            sendPosRot(1.0)
        }

        // swap to block
        if (player.inventory.currentItem != slot)
            connection.sendPacket(CPacketHeldItemChange(slot))

        // swing arm to place
        connection.sendPacket(CPacketAnimation(EnumHand.MAIN_HAND))

        // place block, we don't need to use the util since we don't need to check for collision with ourself
        connection.sendPacket(CPacketPlayerTryUseItemOnBlock(
            BlockPos(mc.player.posX, mc.player.posY, mc.player.posZ).offset(EnumFacing.DOWN),
            EnumFacing.UP, EnumHand.MAIN_HAND, 0.5f, 1f, 0.5f
        ))

        // we want to return our rotation so other players can't see we rotated.
        // this is kinda useless but means its slightly less obvious that we burrowed
        // slightly.
        // todo: if we are rotating from another module we don't need to do this
        if (noPeerRotate)
            connection.sendPacket(CPacketPlayer.Rotation(mc.player.rotationYaw, mc.player.rotationPitch, mc.player.onGround))

        // set last burrow
        lastBurrow = System.currentTimeMillis()

        // swap back
        if (player.inventory.currentItem != slot)
            connection.sendPacket(CPacketHeldItemChange(player.inventory.currentItem))

        // rubberband
        packetMode.rubberband.run()

        // we don't do this in the rubberband since we need the slot
        if (packetMode == PacketMode.NONE) {
            world.setBlockState(BlockPos(player.posX, player.posY, player.posZ),
                (player.hotbarSlots[slot].stack.item as ItemBlock).block.defaultState)
            player.setPosition(player.posX, player.posY + 1, player.posZ)
        }

        // account for timer, alternative needs us to flag timer so we don't care about it
        if (noTimerFlag && packetMode != PacketMode.ALTERNATIVE) {
            modifyTimer(50f * packets)
            packets = 0
        }

        // we might not want to disable
        if (autoDisable) disable()

    }

    private fun sendPos(y: Double) {
        mc.player.connection.sendPacket(CPacketPlayer.Position(mc.player.posX, mc.player.posY + y, mc.player.posZ,
            false))
        packets++
    }

    private fun sendPosRot(y: Double) {
        if (rotate)
            mc.player.connection.sendPacket(CPacketPlayer.PositionRotation(mc.player.posX, mc.player.posY + y, mc.player.posZ,
                mc.player.rotationYaw, 90f, false))
        else
            sendPos(y)
        packets++
    }

}