Skip to content
  • Categories
  • Recent
  • Tags
  • Popular
  • Users
  • Groups
Skins
  • Light
  • Cerulean
  • Cosmo
  • Flatly
  • Journal
  • Litera
  • Lumen
  • Lux
  • Materia
  • Minty
  • Morph
  • Pulse
  • Sandstone
  • Simplex
  • Sketchy
  • Spacelab
  • United
  • Yeti
  • Zephyr
  • Dark
  • Cyborg
  • Darkly
  • Quartz
  • Slate
  • Solar
  • Superhero
  • Vapor

  • Default (No Skin)
  • No Skin
Collapse

LiquidBounce Forum

  1. Home
  2. Kotlin/Java
  3. KillAura Mark like Sigma5

KillAura Mark like Sigma5

Scheduled Pinned Locked Moved Kotlin/Java
16 Posts 10 Posters 2.6k Views
  • Oldest to Newest
  • Newest to Oldest
  • Most Votes
Reply
  • Reply as topic
Log in to reply
This topic has been deleted. Only users with topic management privileges can see it.
  • qwq LiulihaocaiQ qwq Liulihaocai

    modify killaura.kt
    works in b72 idk it work or not in b73

    //add variables
    private var markEntity: EntityLivingBase? = null
    private val markTimer=MSTimer()
    //add this in private fun attackEntity(entity: EntityLivingBase)
    markEntity=entity
    //rewrite onRender3d
        @EventTarget
        fun onRender3D(event: Render3DEvent) {
            if (cancelRun) {
                target = null
                currentTarget = null
                hitable = false
                stopBlocking()
            }
            if (currentTarget != null && attackTimer.hasTimePassed(attackDelay) &&
                currentTarget!!.hurtTime <= hurtTimeValue.get()) {
                clicks++
                attackTimer.reset()
                attackDelay = TimeUtils.randomClickDelay(minCPS.get(), maxCPS.get())
            }
    
            if (markValue.get() && markEntity!=null){
                if(markTimer.hasTimePassed(500) || markEntity!!.isDead){
                    markEntity=null
                    return
                }
                //can mark
                val drawTime = (System.currentTimeMillis() % 2000).toInt()
                val drawMode=drawTime>1000
                var drawPercent=drawTime/1000F
                //true when goes up
                if(!drawMode){
                    drawPercent=1-drawPercent
                }else{
                    drawPercent-=1
                }
                val points = mutableListOf<Vec3>()
                val bb=markEntity!!.entityBoundingBox
                val radius=bb.maxX-bb.minX
                val height=bb.maxY-bb.minY
                val posX = markEntity!!.lastTickPosX + (markEntity!!.posX - markEntity!!.lastTickPosX) * mc.timer.renderPartialTicks
                var posY = markEntity!!.lastTickPosY + (markEntity!!.posY - markEntity!!.lastTickPosY) * mc.timer.renderPartialTicks
                if(drawMode){
                    posY-=0.5
                }else{
                    posY+=0.5
                }
                val posZ = markEntity!!.lastTickPosZ + (markEntity!!.posZ - markEntity!!.lastTickPosZ) * mc.timer.renderPartialTicks
                for(i in 0..360 step 7){
                    points.add(Vec3(posX - sin(i * Math.PI / 180F) * radius,posY+height*drawPercent,posZ + cos(i * Math.PI / 180F) * radius))
                }
                points.add(points[0])
                //draw
                mc.entityRenderer.disableLightmap()
                GL11.glPushMatrix()
                GL11.glDisable(GL11.GL_TEXTURE_2D)
                GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA)
                GL11.glEnable(GL11.GL_LINE_SMOOTH)
                GL11.glEnable(GL11.GL_BLEND)
                GL11.glDisable(GL11.GL_DEPTH_TEST)
                GL11.glBegin(GL11.GL_LINE_STRIP)
                for(i in 0..20) {
                    var moveFace=(height/60F)*i
                    if(drawMode){
                        moveFace=-moveFace
                    }
                    val firstPoint=points[0]
                    GL11.glVertex3d(
                        firstPoint.xCoord - mc.renderManager.viewerPosX, firstPoint.yCoord - moveFace - mc.renderManager.viewerPosY,
                        firstPoint.zCoord - mc.renderManager.viewerPosZ
                    )
                    GL11.glColor4f(1F, 1F, 1F, 0.7F*(i/20F))
                    for (vec3 in points) {
                        GL11.glVertex3d(
                            vec3.xCoord - mc.renderManager.viewerPosX, vec3.yCoord - moveFace - mc.renderManager.viewerPosY,
                            vec3.zCoord - mc.renderManager.viewerPosZ
                        )
                    }
                    GL11.glColor4f(0F,0F,0F,0F)
                }
                GL11.glEnd()
                GL11.glEnable(GL11.GL_DEPTH_TEST)
                GL11.glDisable(GL11.GL_LINE_SMOOTH)
                GL11.glDisable(GL11.GL_BLEND)
                GL11.glEnable(GL11.GL_TEXTURE_2D)
                GL11.glPopMatrix()
            }
        }
    

    pic:
    QQ截图20210404100843.png

    B Offline
    B Offline
    BestNickName
    wrote on last edited by
    #4

    @qwq-liulihaocai give your discord

    qwq LiulihaocaiQ 1 Reply Last reply
    0
    • B BestNickName

      @qwq-liulihaocai give your discord

      qwq LiulihaocaiQ Offline
      qwq LiulihaocaiQ Offline
      qwq Liulihaocai
      wrote on last edited by qwq Liulihaocai
      #5

      @bestnickname i dont have discord,i only have qq 3320607236

      ? 1 Reply Last reply
      0
      • qwq LiulihaocaiQ qwq Liulihaocai

        @bestnickname i dont have discord,i only have qq 3320607236

        ? Offline
        ? Offline
        A Former User
        wrote on last edited by A Former User
        #6

        For people who want that mark thing, here:

        /*
         * LiquidBounce Hacked Client
         * A free open source mixin-based injection hacked client for Minecraft using Minecraft Forge.
         * https://github.com/CCBlueX/LiquidBounce/
         */
        package net.ccbluex.liquidbounce.features.module.modules.combat
        
        import net.ccbluex.liquidbounce.LiquidBounce
        import net.ccbluex.liquidbounce.api.MinecraftVersion
        import net.ccbluex.liquidbounce.api.enums.EnumFacingType
        import net.ccbluex.liquidbounce.api.enums.WEnumHand
        import net.ccbluex.liquidbounce.api.minecraft.client.entity.IEntity
        import net.ccbluex.liquidbounce.api.minecraft.client.entity.IEntityLivingBase
        import net.ccbluex.liquidbounce.api.minecraft.network.play.client.ICPacketPlayerDigging
        import net.ccbluex.liquidbounce.api.minecraft.network.play.client.ICPacketUseEntity
        import net.ccbluex.liquidbounce.api.minecraft.potion.PotionType
        import net.ccbluex.liquidbounce.api.minecraft.util.WBlockPos
        import net.ccbluex.liquidbounce.api.minecraft.util.WVec3
        import net.ccbluex.liquidbounce.api.minecraft.world.IWorldSettings
        import net.ccbluex.liquidbounce.event.*
        import net.ccbluex.liquidbounce.features.module.Module
        import net.ccbluex.liquidbounce.features.module.ModuleCategory
        import net.ccbluex.liquidbounce.features.module.ModuleInfo
        import net.ccbluex.liquidbounce.features.module.modules.misc.AntiBot
        import net.ccbluex.liquidbounce.features.module.modules.misc.Teams
        import net.ccbluex.liquidbounce.features.module.modules.player.Blink
        import net.ccbluex.liquidbounce.features.module.modules.render.FreeCam
        import net.ccbluex.liquidbounce.injection.backend.Backend
        import net.ccbluex.liquidbounce.utils.*
        import net.ccbluex.liquidbounce.utils.extensions.getDistanceToEntityBox
        import net.ccbluex.liquidbounce.utils.extensions.isAnimal
        import net.ccbluex.liquidbounce.utils.extensions.isClientFriend
        import net.ccbluex.liquidbounce.utils.extensions.isMob
        import net.ccbluex.liquidbounce.utils.misc.RandomUtils
        import net.ccbluex.liquidbounce.utils.render.RenderUtils
        import net.ccbluex.liquidbounce.utils.timer.MSTimer
        import net.ccbluex.liquidbounce.utils.timer.TimeUtils
        import net.ccbluex.liquidbounce.value.BoolValue
        import net.ccbluex.liquidbounce.value.FloatValue
        import net.ccbluex.liquidbounce.value.IntegerValue
        import net.ccbluex.liquidbounce.value.ListValue
        import net.minecraft.client.settings.KeyBinding
        import org.lwjgl.input.Keyboard
        import java.awt.Color
        import java.util.*
        import kotlin.math.*
        
        @ModuleInfo(name = "KillAura", description = "Automatically attacks targets around you.",
                category = ModuleCategory.COMBAT, keyBind = Keyboard.KEY_R)
        class KillAura : Module() {
        
            /**
             * OPTIONS
             */
        
            // CPS - Attack speed
            private val maxCPS: IntegerValue = object : IntegerValue("MaxCPS", 8, 1, 20) {
                override fun onChanged(oldValue: Int, newValue: Int) {
                    val i = minCPS.get()
                    if (i > newValue) set(i)
        
                    attackDelay = TimeUtils.randomClickDelay(minCPS.get(), this.get())
                }
            }
        
            private val minCPS: IntegerValue = object : IntegerValue("MinCPS", 5, 1, 20) {
                override fun onChanged(oldValue: Int, newValue: Int) {
                    val i = maxCPS.get()
                    if (i < newValue) set(i)
        
                    attackDelay = TimeUtils.randomClickDelay(this.get(), maxCPS.get())
                }
            }
        
            private val hurtTimeValue = IntegerValue("HurtTime", 10, 0, 10)
            private val cooldownValue = FloatValue("Cooldown", 1f, 0f, 1f)
        
            // Range
            private val rangeValue = FloatValue("Range", 3.7f, 1f, 8f)
            private val throughWallsRangeValue = FloatValue("ThroughWallsRange", 3f, 0f, 8f)
            private val rangeSprintReducementValue = FloatValue("RangeSprintReducement", 0f, 0f, 0.4f)
        
            // Modes
            private val priorityValue = ListValue("Priority", arrayOf("Health", "Distance", "Direction", "LivingTime"), "Distance")
            private val targetModeValue = ListValue("TargetMode", arrayOf("Single", "Switch", "Multi"), "Switch")
        
            // Bypass
            private val swingValue = BoolValue("Swing", true)
            private val keepSprintValue = BoolValue("KeepSprint", true)
        
            // AutoBlock
            private val autoBlockValue = ListValue("AutoBlock", arrayOf("Off", "Packet", "AfterTick"), "Packet")
            private val interactAutoBlockValue = BoolValue("InteractAutoBlock", true)
            private val blockRate = IntegerValue("BlockRate", 100, 1, 100)
        
            // Raycast
            private val raycastValue = BoolValue("RayCast", true)
            private val raycastIgnoredValue = BoolValue("RayCastIgnored", false)
            private val livingRaycastValue = BoolValue("LivingRayCast", true)
        
            // Bypass
            private val aacValue = BoolValue("AAC", false)
        
            // Turn Speed
            private val maxTurnSpeed: FloatValue = object : FloatValue("MaxTurnSpeed", 180f, 0f, 180f) {
                override fun onChanged(oldValue: Float, newValue: Float) {
                    val v = minTurnSpeed.get()
                    if (v > newValue) set(v)
                }
            }
        
            private val minTurnSpeed: FloatValue = object : FloatValue("MinTurnSpeed", 180f, 0f, 180f) {
                override fun onChanged(oldValue: Float, newValue: Float) {
                    val v = maxTurnSpeed.get()
                    if (v < newValue) set(v)
                }
            }
        
            private val silentRotationValue = BoolValue("SilentRotation", true)
            private val rotationStrafeValue = ListValue("Strafe", arrayOf("Off", "Strict", "Silent"), "Off")
            private val randomCenterValue = BoolValue("RandomCenter", true)
            private val outborderValue = BoolValue("Outborder", false)
            private val fovValue = FloatValue("FOV", 180f, 0f, 180f)
        
            // Predict
            private val predictValue = BoolValue("Predict", true)
        
            private val maxPredictSize: FloatValue = object : FloatValue("MaxPredictSize", 1f, 0.1f, 5f) {
                override fun onChanged(oldValue: Float, newValue: Float) {
                    val v = minPredictSize.get()
                    if (v > newValue) set(v)
                }
            }
        
            private val minPredictSize: FloatValue = object : FloatValue("MinPredictSize", 1f, 0.1f, 5f) {
                override fun onChanged(oldValue: Float, newValue: Float) {
                    val v = maxPredictSize.get()
                    if (v < newValue) set(v)
                }
            }
        
            // Bypass
            private val failRateValue = FloatValue("FailRate", 0f, 0f, 100f)
            private val fakeSwingValue = BoolValue("FakeSwing", true)
            private val noInventoryAttackValue = BoolValue("NoInvAttack", false)
            private val noInventoryDelayValue = IntegerValue("NoInvDelay", 200, 0, 500)
            private val limitedMultiTargetsValue = IntegerValue("LimitedMultiTargets", 0, 0, 50)
        
            // Visuals
            private val markValue = BoolValue("Mark", true)
            private val fakeSharpValue = BoolValue("FakeSharp", true)
        
            /**
             * MODULE
             */
        
            // Target
            var target: IEntityLivingBase? = null
            private var currentTarget: IEntityLivingBase? = null
            private var hitable = false
            private val prevTargetEntities = mutableListOf<Int>()
        
            // Attack delay
            private val attackTimer = MSTimer()
            private var attackDelay = 0L
            private var clicks = 0
        
            // Container Delay
            private var containerOpen = -1L
        
            // Fake block status
            var blockingStatus = false
        
            init {
                cooldownValue.isSupported = Backend.REPRESENTED_BACKEND_VERSION != MinecraftVersion.MC_1_8
            }
        
            /**
             * Enable kill aura module
             */
            override fun onEnable() {
                mc.thePlayer ?: return
                mc.theWorld ?: return
        
                updateTarget()
            }
        
            /**
             * Disable kill aura module
             */
            override fun onDisable() {
                target = null
                currentTarget = null
                hitable = false
                prevTargetEntities.clear()
                attackTimer.reset()
                clicks = 0
        
                stopBlocking()
            }
        
            /**
             * Motion event
             */
            @EventTarget
            fun onMotion(event: MotionEvent) {
                if (event.eventState == EventState.POST) {
                    target ?: return
                    currentTarget ?: return
        
                    // Update hitable
                    updateHitable()
        
                    // AutoBlock
                    if (autoBlockValue.get().equals("AfterTick", true) && canBlock)
                        startBlocking(currentTarget!!, hitable)
        
                    return
                }
        
                if (rotationStrafeValue.get().equals("Off", true))
                    update()
            }
        
            /**
             * Strafe event
             */
            @EventTarget
            fun onStrafe(event: StrafeEvent) {
                if (rotationStrafeValue.get().equals("Off", true))
                    return
        
                update()
        
                if (currentTarget != null && RotationUtils.targetRotation != null) {
                    when (rotationStrafeValue.get().toLowerCase()) {
                        "strict" -> {
                            val (yaw) = RotationUtils.targetRotation ?: return
                            var strafe = event.strafe
                            var forward = event.forward
                            val friction = event.friction
        
                            var f = strafe * strafe + forward * forward
        
                            if (f >= 1.0E-4F) {
                                f = sqrt(f)
        
                                if (f < 1.0F)
                                    f = 1.0F
        
                                f = friction / f
                                strafe *= f
                                forward *= f
        
                                val yawSin = sin((yaw * Math.PI / 180F).toFloat())
                                val yawCos = cos((yaw * Math.PI / 180F).toFloat())
        
                                val player = mc.thePlayer!!
        
                                player.motionX += strafe * yawCos - forward * yawSin
                                player.motionZ += forward * yawCos + strafe * yawSin
                            }
                            event.cancelEvent()
                        }
                        "silent" -> {
                            update()
        
                            RotationUtils.targetRotation.applyStrafeToPlayer(event)
                            event.cancelEvent()
                        }
                    }
                }
            }
        
            fun update() {
                if (cancelRun || (noInventoryAttackValue.get() && (classProvider.isGuiContainer(mc.currentScreen) ||
                                System.currentTimeMillis() - containerOpen < noInventoryDelayValue.get())))
                    return
        
                // Update target
                updateTarget()
        
                if (target == null) {
                    stopBlocking()
                    return
                }
        
                // Target
                currentTarget = target
        
                if (!targetModeValue.get().equals("Switch", ignoreCase = true) && isEnemy(currentTarget))
                    target = currentTarget
            }
        
            /**
             * Update event
             */
            @EventTarget
            fun onUpdate(event: UpdateEvent) {
                if (cancelRun) {
                    target = null
                    currentTarget = null
                    hitable = false
                    stopBlocking()
                    return
                }
        
                if (noInventoryAttackValue.get() && (classProvider.isGuiContainer(mc.currentScreen) ||
                                System.currentTimeMillis() - containerOpen < noInventoryDelayValue.get())) {
                    target = null
                    currentTarget = null
                    hitable = false
                    if (classProvider.isGuiContainer(mc.currentScreen)) containerOpen = System.currentTimeMillis()
                    return
                }
        
                if (target != null && currentTarget != null && (Backend.MINECRAFT_VERSION_MINOR == 8 || mc.thePlayer!!.getCooledAttackStrength(0.0F) >= cooldownValue.get())) {
                    while (clicks > 0) {
                        runAttack()
                        clicks--
                    }
                }
            }
        
            /**
             * Render event
             */
                //add variables
                private var markEntity: EntityLivingBase? = null
                private val markTimer=MSTimer()
                //add this in private fun attackEntity(entity: EntityLivingBase)
                markEntity=entity
            @EventTarget
            fun onRender3D(event: Render3DEvent) {
        if (cancelRun) {
                    target = null
                    currentTarget = null
                    hitable = false
                    stopBlocking()
                }
                if (currentTarget != null && attackTimer.hasTimePassed(attackDelay) &&
                    currentTarget!!.hurtTime <= hurtTimeValue.get()) {
                    clicks++
                    attackTimer.reset()
                    attackDelay = TimeUtils.randomClickDelay(minCPS.get(), maxCPS.get())
                }
        
                if (markValue.get() && markEntity!=null){
                    if(markTimer.hasTimePassed(500) || markEntity!!.isDead){
                        markEntity=null
                        return
                    }
                    //can mark
                    val drawTime = (System.currentTimeMillis() % 2000).toInt()
                    val drawMode=drawTime>1000
                    var drawPercent=drawTime/1000F
                    //true when goes up
                    if(!drawMode){
                        drawPercent=1-drawPercent
                    }else{
                        drawPercent-=1
                    }
                    val points = mutableListOf<Vec3>()
                    val bb=markEntity!!.entityBoundingBox
                    val radius=bb.maxX-bb.minX
                    val height=bb.maxY-bb.minY
                    val posX = markEntity!!.lastTickPosX + (markEntity!!.posX - markEntity!!.lastTickPosX) * mc.timer.renderPartialTicks
                    var posY = markEntity!!.lastTickPosY + (markEntity!!.posY - markEntity!!.lastTickPosY) * mc.timer.renderPartialTicks
                    if(drawMode){
                        posY-=0.5
                    }else{
                        posY+=0.5
                    }
                    val posZ = markEntity!!.lastTickPosZ + (markEntity!!.posZ - markEntity!!.lastTickPosZ) * mc.timer.renderPartialTicks
                    for(i in 0..360 step 7){
                        points.add(Vec3(posX - sin(i * Math.PI / 180F) * radius,posY+height*drawPercent,posZ + cos(i * Math.PI / 180F) * radius))
                    }
                    points.add(points[0])
                    //draw
                    mc.entityRenderer.disableLightmap()
                    GL11.glPushMatrix()
                    GL11.glDisable(GL11.GL_TEXTURE_2D)
                    GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA)
                    GL11.glEnable(GL11.GL_LINE_SMOOTH)
                    GL11.glEnable(GL11.GL_BLEND)
                    GL11.glDisable(GL11.GL_DEPTH_TEST)
                    GL11.glBegin(GL11.GL_LINE_STRIP)
                    for(i in 0..20) {
                        var moveFace=(height/60F)*i
                        if(drawMode){
                            moveFace=-moveFace
                        }
                        val firstPoint=points[0]
                        GL11.glVertex3d(
                            firstPoint.xCoord - mc.renderManager.viewerPosX, firstPoint.yCoord - moveFace - mc.renderManager.viewerPosY,
                            firstPoint.zCoord - mc.renderManager.viewerPosZ
                        )
                        GL11.glColor4f(1F, 1F, 1F, 0.7F*(i/20F))
                        for (vec3 in points) {
                            GL11.glVertex3d(
                                vec3.xCoord - mc.renderManager.viewerPosX, vec3.yCoord - moveFace - mc.renderManager.viewerPosY,
                                vec3.zCoord - mc.renderManager.viewerPosZ
                            )
                        }
                        GL11.glColor4f(0F,0F,0F,0F)
                    }
                    GL11.glEnd()
                    GL11.glEnable(GL11.GL_DEPTH_TEST)
                    GL11.glDisable(GL11.GL_LINE_SMOOTH)
                    GL11.glDisable(GL11.GL_BLEND)
                    GL11.glEnable(GL11.GL_TEXTURE_2D)
                    GL11.glPopMatrix()
                }
            }
        
            /**
             * Handle entity move
             */
            @EventTarget
            fun onEntityMove(event: EntityMovementEvent) {
                val movedEntity = event.movedEntity
        
                if (target == null || movedEntity != currentTarget)
                    return
        
                updateHitable()
            }
        
            /**
             * Attack enemy
             */
            private fun runAttack() {
                target ?: return
                currentTarget ?: return
                val thePlayer = mc.thePlayer ?: return
                val theWorld = mc.theWorld ?: return
        
                // Settings
                val failRate = failRateValue.get()
                val swing = swingValue.get()
                val multi = targetModeValue.get().equals("Multi", ignoreCase = true)
                val openInventory = aacValue.get() && classProvider.isGuiContainer(mc.currentScreen)
                val failHit = failRate > 0 && Random().nextInt(100) <= failRate
        
                // Close inventory when open
                if (openInventory)
                    mc.netHandler.addToSendQueue(classProvider.createCPacketCloseWindow())
        
                // Check is not hitable or check failrate
        
                if (!hitable || failHit) {
                    if (swing && (fakeSwingValue.get() || failHit))
                        thePlayer.swingItem()
                } else {
                    // Attack
                    if (!multi) {
                        attackEntity(currentTarget!!)
                    } else {
                        var targets = 0
        
                        for (entity in theWorld.loadedEntityList) {
                            val distance = thePlayer.getDistanceToEntityBox(entity)
        
                            if (classProvider.isEntityLivingBase(entity) && isEnemy(entity) && distance <= getRange(entity)) {
                                attackEntity(entity.asEntityLivingBase())
        
                                targets += 1
        
                                if (limitedMultiTargetsValue.get() != 0 && limitedMultiTargetsValue.get() <= targets)
                                    break
                            }
                        }
                    }
        
                    prevTargetEntities.add(if (aacValue.get()) target!!.entityId else currentTarget!!.entityId)
        
                    if (target == currentTarget)
                        target = null
                }
        
                // Open inventory
                if (openInventory)
                    mc.netHandler.addToSendQueue(createOpenInventoryPacket())
            }
        
            /**
             * Update current target
             */
            private fun updateTarget() {
                // Reset fixed target to null
                target = null
        
                // Settings
                val hurtTime = hurtTimeValue.get()
                val fov = fovValue.get()
                val switchMode = targetModeValue.get().equals("Switch", ignoreCase = true)
        
                // Find possible targets
                val targets = mutableListOf<IEntityLivingBase>()
        
                val theWorld = mc.theWorld!!
                val thePlayer = mc.thePlayer!!
        
                for (entity in theWorld.loadedEntityList) {
                    if (!classProvider.isEntityLivingBase(entity) || !isEnemy(entity) || (switchMode && prevTargetEntities.contains(entity.entityId)))
                        continue
        
                    val distance = thePlayer.getDistanceToEntityBox(entity)
                    val entityFov = RotationUtils.getRotationDifference(entity)
        
                    if (distance <= maxRange && (fov == 180F || entityFov <= fov) && entity.asEntityLivingBase().hurtTime <= hurtTime)
                        targets.add(entity.asEntityLivingBase())
                }
        
                // Sort targets by priority
                when (priorityValue.get().toLowerCase()) {
                    "distance" -> targets.sortBy { thePlayer.getDistanceToEntityBox(it) } // Sort by distance
                    "health" -> targets.sortBy { it.health } // Sort by health
                    "direction" -> targets.sortBy { RotationUtils.getRotationDifference(it) } // Sort by FOV
                    "livingtime" -> targets.sortBy { -it.ticksExisted } // Sort by existence
                }
        
                // Find best target
                for (entity in targets) {
                    // Update rotations to current target
                    if (!updateRotations(entity)) // when failed then try another target
                        continue
        
                    // Set target to current entity
                    target = entity
                    return
                }
        
                // Cleanup last targets when no target found and try again
                if (prevTargetEntities.isNotEmpty()) {
                    prevTargetEntities.clear()
                    updateTarget()
                }
            }
        
            /**
             * Check if [entity] is selected as enemy with current target options and other modules
             */
            private fun isEnemy(entity: IEntity?): Boolean {
                if (classProvider.isEntityLivingBase(entity) && entity != null && (EntityUtils.targetDead || isAlive(entity.asEntityLivingBase())) && entity != mc.thePlayer) {
                    if (!EntityUtils.targetInvisible && entity.invisible)
                        return false
        
                    if (EntityUtils.targetPlayer && classProvider.isEntityPlayer(entity)) {
                        val player = entity.asEntityPlayer()
        
                        if (player.spectator || AntiBot.isBot(player))
                            return false
        
                        if (player.isClientFriend() && !LiquidBounce.moduleManager[NoFriends::class.java].state)
                            return false
        
                        val teams = LiquidBounce.moduleManager[Teams::class.java] as Teams
        
                        return !teams.state || !teams.isInYourTeam(entity.asEntityLivingBase())
                    }
        
                    return EntityUtils.targetMobs && entity.isMob() || EntityUtils.targetAnimals && entity.isAnimal()
                }
        
                return false
            }
        
            /**
             * Attack [entity]
             */
            private fun attackEntity(entity: IEntityLivingBase) {
                // Stop blocking
                val thePlayer = mc.thePlayer!!
        
                if (thePlayer.isBlocking || blockingStatus)
                    stopBlocking()
        
                // Call attack event
                LiquidBounce.eventManager.callEvent(AttackEvent(entity))
        
                // Attack target
                if (swingValue.get() && Backend.MINECRAFT_VERSION_MINOR == 8)
                    thePlayer.swingItem()
        
                mc.netHandler.addToSendQueue(classProvider.createCPacketUseEntity(entity, ICPacketUseEntity.WAction.ATTACK))
        
                if (swingValue.get() && Backend.MINECRAFT_VERSION_MINOR != 8)
                    thePlayer.swingItem()
        
                if (keepSprintValue.get()) {
                    // Critical Effect
                    if (thePlayer.fallDistance > 0F && !thePlayer.onGround && !thePlayer.isOnLadder &&
                            !thePlayer.isInWater && !thePlayer.isPotionActive(classProvider.getPotionEnum(PotionType.BLINDNESS)) && !thePlayer.isRiding)
                        thePlayer.onCriticalHit(entity)
        
                    // Enchant Effect
                    if (functions.getModifierForCreature(thePlayer.heldItem, entity.creatureAttribute) > 0F)
                        thePlayer.onEnchantmentCritical(entity)
                } else {
                    if (mc.playerController.currentGameType != IWorldSettings.WGameType.SPECTATOR)
                        thePlayer.attackTargetEntityWithCurrentItem(entity)
                }
        
                // Extra critical effects
                val criticals = LiquidBounce.moduleManager[Criticals::class.java] as Criticals
        
                for (i in 0..2) {
                    // Critical Effect
                    if (thePlayer.fallDistance > 0F && !thePlayer.onGround && !thePlayer.isOnLadder && !thePlayer.isInWater && !thePlayer.isPotionActive(classProvider.getPotionEnum(PotionType.BLINDNESS)) && thePlayer.ridingEntity == null || criticals.state && criticals.msTimer.hasTimePassed(criticals.delayValue.get().toLong()) && !thePlayer.isInWater && !thePlayer.isInLava && !thePlayer.isInWeb)
                        thePlayer.onCriticalHit(target!!)
        
                    // Enchant Effect
                    if (functions.getModifierForCreature(thePlayer.heldItem, target!!.creatureAttribute) > 0.0f || fakeSharpValue.get())
                        thePlayer.onEnchantmentCritical(target!!)
                }
        
                // Start blocking after attack
                if (autoBlockValue.get().equals("Packet", true) && (thePlayer.isBlocking || canBlock))
                    startBlocking(entity, interactAutoBlockValue.get())
        
                @Suppress("ConstantConditionIf")
                if (Backend.MINECRAFT_VERSION_MINOR != 8) {
                    thePlayer.resetCooldown()
                }
            }
        
            /**
             * Update killaura rotations to enemy
             */
            private fun updateRotations(entity: IEntity): Boolean {
                if (maxTurnSpeed.get() <= 0F)
                    return true
        
                var boundingBox = entity.entityBoundingBox
        
                if (predictValue.get())
                    boundingBox = boundingBox.offset(
                            (entity.posX - entity.prevPosX - (mc.thePlayer!!.posX - mc.thePlayer!!.prevPosX)) * RandomUtils.nextFloat(minPredictSize.get(), maxPredictSize.get()),
                            (entity.posY - entity.prevPosY - (mc.thePlayer!!.posY - mc.thePlayer!!.prevPosY)) * RandomUtils.nextFloat(minPredictSize.get(), maxPredictSize.get()),
                            (entity.posZ - entity.prevPosZ - (mc.thePlayer!!.posZ - mc.thePlayer!!.prevPosZ)) * RandomUtils.nextFloat(minPredictSize.get(), maxPredictSize.get())
                    )
        
                val (_, rotation) = RotationUtils.searchCenter(
                        boundingBox,
                        outborderValue.get() && !attackTimer.hasTimePassed(attackDelay / 2),
                        randomCenterValue.get(),
                        predictValue.get(),
                        mc.thePlayer!!.getDistanceToEntityBox(entity) < throughWallsRangeValue.get(),
                        maxRange
                ) ?: return false
        
                val limitedRotation = RotationUtils.limitAngleChange(RotationUtils.serverRotation, rotation,
                        (Math.random() * (maxTurnSpeed.get() - minTurnSpeed.get()) + minTurnSpeed.get()).toFloat())
        
                if (silentRotationValue.get())
                    RotationUtils.setTargetRotation(limitedRotation, if (aacValue.get()) 15 else 0)
                else
                    limitedRotation.toPlayer(mc.thePlayer!!)
        
                return true
            }
        
            /**
             * Check if enemy is hitable with current rotations
             */
            private fun updateHitable() {
                // Disable hitable check if turn speed is zero
                if (maxTurnSpeed.get() <= 0F) {
                    hitable = true
                    return
                }
        
                val reach = min(maxRange.toDouble(), mc.thePlayer!!.getDistanceToEntityBox(target!!)) + 1
        
                if (raycastValue.get()) {
                    val raycastedEntity = RaycastUtils.raycastEntity(reach, object : RaycastUtils.EntityFilter {
                        override fun canRaycast(entity: IEntity?): Boolean {
                            return (!livingRaycastValue.get() || (classProvider.isEntityLivingBase(entity) && !classProvider.isEntityArmorStand(entity))) &&
                                    (isEnemy(entity) || raycastIgnoredValue.get() || aacValue.get() && mc.theWorld!!.getEntitiesWithinAABBExcludingEntity(entity, entity!!.entityBoundingBox).isNotEmpty())
                        }
        
                    })
        
                    if (raycastValue.get() && raycastedEntity != null && classProvider.isEntityLivingBase(raycastedEntity)
                            && (LiquidBounce.moduleManager[NoFriends::class.java].state || !(classProvider.isEntityPlayer(raycastedEntity) && raycastedEntity.asEntityPlayer().isClientFriend())))
                        currentTarget = raycastedEntity.asEntityLivingBase()
        
                    hitable = if (maxTurnSpeed.get() > 0F) currentTarget == raycastedEntity else true
                } else
                    hitable = RotationUtils.isFaced(currentTarget, reach)
            }
        
            /**
             * Start blocking
             */
            private fun startBlocking(interactEntity: IEntity, interact: Boolean) {
                if (!(blockRate.get() > 0 && Random().nextInt(100) <= blockRate.get()))
                    return
        
                if (interact) {
                    val positionEye = mc.renderViewEntity?.getPositionEyes(1F)
        
                    val expandSize = interactEntity.collisionBorderSize.toDouble()
                    val boundingBox = interactEntity.entityBoundingBox.expand(expandSize, expandSize, expandSize)
        
                    val (yaw, pitch) = RotationUtils.targetRotation ?: Rotation(mc.thePlayer!!.rotationYaw, mc.thePlayer!!.rotationPitch)
                    val yawCos = cos(-yaw * 0.017453292F - Math.PI.toFloat())
                    val yawSin = sin(-yaw * 0.017453292F - Math.PI.toFloat())
                    val pitchCos = -cos(-pitch * 0.017453292F)
                    val pitchSin = sin(-pitch * 0.017453292F)
                    val range = min(maxRange.toDouble(), mc.thePlayer!!.getDistanceToEntityBox(interactEntity)) + 1
                    val lookAt = positionEye!!.addVector(yawSin * pitchCos * range, pitchSin * range, yawCos * pitchCos * range)
        
                    val movingObject = boundingBox.calculateIntercept(positionEye, lookAt) ?: return
                    val hitVec = movingObject.hitVec
        
                    mc.netHandler.addToSendQueue(classProvider.createCPacketUseEntity(interactEntity, WVec3(
                            hitVec.xCoord - interactEntity.posX,
                            hitVec.yCoord - interactEntity.posY,
                            hitVec.zCoord - interactEntity.posZ)
                    ))
                    mc.netHandler.addToSendQueue(classProvider.createCPacketUseEntity(interactEntity, ICPacketUseEntity.WAction.INTERACT))
                }
        
                mc.netHandler.addToSendQueue(classProvider.createCPacketPlayerBlockPlacement(WBlockPos(-1, -1, -1),
                        255, mc.thePlayer!!.inventory.getCurrentItemInHand(), 0.0F, 0.0F, 0.0F))
                blockingStatus = true
            }
        
        
            /**
             * Stop blocking
             */
            private fun stopBlocking() {
                if (blockingStatus) {
                    mc.netHandler.addToSendQueue(classProvider.createCPacketPlayerDigging(ICPacketPlayerDigging.WAction.RELEASE_USE_ITEM, WBlockPos.ORIGIN, classProvider.getEnumFacing(EnumFacingType.DOWN)))
                    blockingStatus = false
                }
            }
        
            /**
             * Check if run should be cancelled
             */
            private val cancelRun: Boolean
                inline get() = mc.thePlayer!!.spectator || !isAlive(mc.thePlayer!!)
                        || LiquidBounce.moduleManager[Blink::class.java].state || LiquidBounce.moduleManager[FreeCam::class.java].state
        
            /**
             * Check if [entity] is alive
             */
            private fun isAlive(entity: IEntityLivingBase) = entity.entityAlive && entity.health > 0 ||
                    aacValue.get() && entity.hurtTime > 5
        
            /**
             * Check if player is able to block
             */
            private val canBlock: Boolean
                inline get() = mc.thePlayer!!.heldItem != null && classProvider.isItemSword(mc.thePlayer!!.heldItem!!.item) && Backend.MINECRAFT_VERSION_MINOR == 8
        
            /**
             * Range
             */
            private val maxRange: Float
                get() = max(rangeValue.get(), throughWallsRangeValue.get())
        
            private fun getRange(entity: IEntity) =
                    (if (mc.thePlayer!!.getDistanceToEntityBox(entity) >= throughWallsRangeValue.get()) rangeValue.get() else throughWallsRangeValue.get()) - if (mc.thePlayer!!.sprinting) rangeSprintReducementValue.get() else 0F
        
            /**
             * HUD Tag
             */
            override val tag: String?
                get() = targetModeValue.get()
        
            val isBlockingChestAura: Boolean
                get() = state && target != null
        }
        

        EDIT: I have no idea if this will work or not on b73, I just copied it from the gentleman and pasted it in the KillAura module.

        1 Reply Last reply
        1
        • qwq LiulihaocaiQ qwq Liulihaocai

          modify killaura.kt
          works in b72 idk it work or not in b73

          //add variables
          private var markEntity: EntityLivingBase? = null
          private val markTimer=MSTimer()
          //add this in private fun attackEntity(entity: EntityLivingBase)
          markEntity=entity
          //rewrite onRender3d
              @EventTarget
              fun onRender3D(event: Render3DEvent) {
                  if (cancelRun) {
                      target = null
                      currentTarget = null
                      hitable = false
                      stopBlocking()
                  }
                  if (currentTarget != null && attackTimer.hasTimePassed(attackDelay) &&
                      currentTarget!!.hurtTime <= hurtTimeValue.get()) {
                      clicks++
                      attackTimer.reset()
                      attackDelay = TimeUtils.randomClickDelay(minCPS.get(), maxCPS.get())
                  }
          
                  if (markValue.get() && markEntity!=null){
                      if(markTimer.hasTimePassed(500) || markEntity!!.isDead){
                          markEntity=null
                          return
                      }
                      //can mark
                      val drawTime = (System.currentTimeMillis() % 2000).toInt()
                      val drawMode=drawTime>1000
                      var drawPercent=drawTime/1000F
                      //true when goes up
                      if(!drawMode){
                          drawPercent=1-drawPercent
                      }else{
                          drawPercent-=1
                      }
                      val points = mutableListOf<Vec3>()
                      val bb=markEntity!!.entityBoundingBox
                      val radius=bb.maxX-bb.minX
                      val height=bb.maxY-bb.minY
                      val posX = markEntity!!.lastTickPosX + (markEntity!!.posX - markEntity!!.lastTickPosX) * mc.timer.renderPartialTicks
                      var posY = markEntity!!.lastTickPosY + (markEntity!!.posY - markEntity!!.lastTickPosY) * mc.timer.renderPartialTicks
                      if(drawMode){
                          posY-=0.5
                      }else{
                          posY+=0.5
                      }
                      val posZ = markEntity!!.lastTickPosZ + (markEntity!!.posZ - markEntity!!.lastTickPosZ) * mc.timer.renderPartialTicks
                      for(i in 0..360 step 7){
                          points.add(Vec3(posX - sin(i * Math.PI / 180F) * radius,posY+height*drawPercent,posZ + cos(i * Math.PI / 180F) * radius))
                      }
                      points.add(points[0])
                      //draw
                      mc.entityRenderer.disableLightmap()
                      GL11.glPushMatrix()
                      GL11.glDisable(GL11.GL_TEXTURE_2D)
                      GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA)
                      GL11.glEnable(GL11.GL_LINE_SMOOTH)
                      GL11.glEnable(GL11.GL_BLEND)
                      GL11.glDisable(GL11.GL_DEPTH_TEST)
                      GL11.glBegin(GL11.GL_LINE_STRIP)
                      for(i in 0..20) {
                          var moveFace=(height/60F)*i
                          if(drawMode){
                              moveFace=-moveFace
                          }
                          val firstPoint=points[0]
                          GL11.glVertex3d(
                              firstPoint.xCoord - mc.renderManager.viewerPosX, firstPoint.yCoord - moveFace - mc.renderManager.viewerPosY,
                              firstPoint.zCoord - mc.renderManager.viewerPosZ
                          )
                          GL11.glColor4f(1F, 1F, 1F, 0.7F*(i/20F))
                          for (vec3 in points) {
                              GL11.glVertex3d(
                                  vec3.xCoord - mc.renderManager.viewerPosX, vec3.yCoord - moveFace - mc.renderManager.viewerPosY,
                                  vec3.zCoord - mc.renderManager.viewerPosZ
                              )
                          }
                          GL11.glColor4f(0F,0F,0F,0F)
                      }
                      GL11.glEnd()
                      GL11.glEnable(GL11.GL_DEPTH_TEST)
                      GL11.glDisable(GL11.GL_LINE_SMOOTH)
                      GL11.glDisable(GL11.GL_BLEND)
                      GL11.glEnable(GL11.GL_TEXTURE_2D)
                      GL11.glPopMatrix()
                  }
              }
          

          pic:
          QQ截图20210404100843.png

          skiddermaster412S Offline
          skiddermaster412S Offline
          skiddermaster412
          wrote on last edited by
          #7
          package what.modules.render
          
          import net.ccbluex.liquidbounce.LiquidBounce
          import net.ccbluex.liquidbounce.event.EventTarget
          import net.ccbluex.liquidbounce.event.Render3DEvent
          import net.ccbluex.liquidbounce.features.module.Module
          import net.ccbluex.liquidbounce.features.module.ModuleCategory
          import net.ccbluex.liquidbounce.features.module.ModuleInfo
          import net.ccbluex.liquidbounce.features.module.modules.combat.KillAura
          import net.ccbluex.liquidbounce.utils.timer.MSTimer
          import net.minecraft.entity.EntityLivingBase
          import net.minecraft.util.Vec3
          import org.lwjgl.opengl.GL11
          import java.lang.Math.cos
          import java.lang.Math.sin
          
          @ModuleInfo(name = "TargetMark", description = "Draws a circle around your target just like sigma (BEST CLIENT 2021 DOWNLOAD NO VIRUS 2020 FREE)", category = ModuleCategory.RENDER)
          class TargetMark: Module() {
              private var markEntity: EntityLivingBase? = null
              private val markTimer = MSTimer()
          
              @EventTarget
              fun onRender3D(event: Render3DEvent) {
                  markEntity = (LiquidBounce.moduleManager[KillAura::class.java] as KillAura).target;
                  if (markEntity != null){
                      if(markTimer.hasTimePassed(500) || markEntity!!.isDead){
                          markTimer.reset()
                          markEntity = null
                          return
                      }
                      //can mark
                      val drawTime = (System.currentTimeMillis() % 2000).toInt()
                      val drawMode=drawTime>1000
                      var drawPercent=drawTime/1000F
                      //true when goes up
                      if(!drawMode){
                          drawPercent=1-drawPercent
                      }else{
                          drawPercent-=1
                      }
                      val points = mutableListOf<Vec3>()
                      val bb=markEntity!!.entityBoundingBox
                      val radius=bb.maxX-bb.minX
                      val height=bb.maxY-bb.minY
                      val posX = markEntity!!.lastTickPosX + (markEntity!!.posX - markEntity!!.lastTickPosX) * mc.timer.renderPartialTicks
                      var posY = markEntity!!.lastTickPosY + (markEntity!!.posY - markEntity!!.lastTickPosY) * mc.timer.renderPartialTicks
                      if(drawMode){
                          posY-=0.5
                      }else{
                          posY+=0.5
                      }
                      val posZ = markEntity!!.lastTickPosZ + (markEntity!!.posZ - markEntity!!.lastTickPosZ) * mc.timer.renderPartialTicks
                      for(i in 0..360 step 7){
                          points.add(Vec3(posX - sin(i * Math.PI / 180F) * radius,posY+height*drawPercent,posZ + cos(i * Math.PI / 180F) * radius))
                      }
                      points.add(points[0])
                      //draw
                      mc.entityRenderer.disableLightmap()
                      GL11.glPushMatrix()
                      GL11.glDisable(GL11.GL_TEXTURE_2D)
                      GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA)
                      GL11.glEnable(GL11.GL_LINE_SMOOTH)
                      GL11.glEnable(GL11.GL_BLEND)
                      GL11.glDisable(GL11.GL_DEPTH_TEST)
                      GL11.glBegin(GL11.GL_LINE_STRIP)
                      for(i in 0..20) {
                          var moveFace=(height/60F)*i
                          if(drawMode){
                              moveFace=-moveFace
                          }
                          val firstPoint=points[0]
                          GL11.glVertex3d(
                                  firstPoint.xCoord - mc.renderManager.viewerPosX, firstPoint.yCoord - moveFace - mc.renderManager.viewerPosY,
                                  firstPoint.zCoord - mc.renderManager.viewerPosZ
                          )
                          GL11.glColor4f(1F, 1F, 1F, 0.7F*(i/20F))
                          for (vec3 in points) {
                              GL11.glVertex3d(
                                      vec3.xCoord - mc.renderManager.viewerPosX, vec3.yCoord - moveFace - mc.renderManager.viewerPosY,
                                      vec3.zCoord - mc.renderManager.viewerPosZ
                              )
                          }
                          GL11.glColor4f(0F,0F,0F,0F)
                      }
                      GL11.glEnd()
                      GL11.glEnable(GL11.GL_DEPTH_TEST)
                      GL11.glDisable(GL11.GL_LINE_SMOOTH)
                      GL11.glDisable(GL11.GL_BLEND)
                      GL11.glEnable(GL11.GL_TEXTURE_2D)
                      GL11.glPopMatrix()
                  }
              }
          }
          

          independant module if some one doesn't want to replace anything

          1 Reply Last reply
          0
          • LitelyL Offline
            LitelyL Offline
            Litely
            wrote on last edited by
            #8

            why no download SIGMA instead of this

            1 Reply Last reply
            0
            • ? Offline
              ? Offline
              A Former User
              wrote on last edited by
              #9

              sigma on top

              TherealloT 1 Reply Last reply
              0
              • ? A Former User

                sigma on top

                TherealloT Offline
                TherealloT Offline
                Thereallo
                wrote on last edited by
                #10
                This post is deleted!
                1 Reply Last reply
                0
                • qwq LiulihaocaiQ qwq Liulihaocai

                  modify killaura.kt
                  works in b72 idk it work or not in b73

                  //add variables
                  private var markEntity: EntityLivingBase? = null
                  private val markTimer=MSTimer()
                  //add this in private fun attackEntity(entity: EntityLivingBase)
                  markEntity=entity
                  //rewrite onRender3d
                      @EventTarget
                      fun onRender3D(event: Render3DEvent) {
                          if (cancelRun) {
                              target = null
                              currentTarget = null
                              hitable = false
                              stopBlocking()
                          }
                          if (currentTarget != null && attackTimer.hasTimePassed(attackDelay) &&
                              currentTarget!!.hurtTime <= hurtTimeValue.get()) {
                              clicks++
                              attackTimer.reset()
                              attackDelay = TimeUtils.randomClickDelay(minCPS.get(), maxCPS.get())
                          }
                  
                          if (markValue.get() && markEntity!=null){
                              if(markTimer.hasTimePassed(500) || markEntity!!.isDead){
                                  markEntity=null
                                  return
                              }
                              //can mark
                              val drawTime = (System.currentTimeMillis() % 2000).toInt()
                              val drawMode=drawTime>1000
                              var drawPercent=drawTime/1000F
                              //true when goes up
                              if(!drawMode){
                                  drawPercent=1-drawPercent
                              }else{
                                  drawPercent-=1
                              }
                              val points = mutableListOf<Vec3>()
                              val bb=markEntity!!.entityBoundingBox
                              val radius=bb.maxX-bb.minX
                              val height=bb.maxY-bb.minY
                              val posX = markEntity!!.lastTickPosX + (markEntity!!.posX - markEntity!!.lastTickPosX) * mc.timer.renderPartialTicks
                              var posY = markEntity!!.lastTickPosY + (markEntity!!.posY - markEntity!!.lastTickPosY) * mc.timer.renderPartialTicks
                              if(drawMode){
                                  posY-=0.5
                              }else{
                                  posY+=0.5
                              }
                              val posZ = markEntity!!.lastTickPosZ + (markEntity!!.posZ - markEntity!!.lastTickPosZ) * mc.timer.renderPartialTicks
                              for(i in 0..360 step 7){
                                  points.add(Vec3(posX - sin(i * Math.PI / 180F) * radius,posY+height*drawPercent,posZ + cos(i * Math.PI / 180F) * radius))
                              }
                              points.add(points[0])
                              //draw
                              mc.entityRenderer.disableLightmap()
                              GL11.glPushMatrix()
                              GL11.glDisable(GL11.GL_TEXTURE_2D)
                              GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA)
                              GL11.glEnable(GL11.GL_LINE_SMOOTH)
                              GL11.glEnable(GL11.GL_BLEND)
                              GL11.glDisable(GL11.GL_DEPTH_TEST)
                              GL11.glBegin(GL11.GL_LINE_STRIP)
                              for(i in 0..20) {
                                  var moveFace=(height/60F)*i
                                  if(drawMode){
                                      moveFace=-moveFace
                                  }
                                  val firstPoint=points[0]
                                  GL11.glVertex3d(
                                      firstPoint.xCoord - mc.renderManager.viewerPosX, firstPoint.yCoord - moveFace - mc.renderManager.viewerPosY,
                                      firstPoint.zCoord - mc.renderManager.viewerPosZ
                                  )
                                  GL11.glColor4f(1F, 1F, 1F, 0.7F*(i/20F))
                                  for (vec3 in points) {
                                      GL11.glVertex3d(
                                          vec3.xCoord - mc.renderManager.viewerPosX, vec3.yCoord - moveFace - mc.renderManager.viewerPosY,
                                          vec3.zCoord - mc.renderManager.viewerPosZ
                                      )
                                  }
                                  GL11.glColor4f(0F,0F,0F,0F)
                              }
                              GL11.glEnd()
                              GL11.glEnable(GL11.GL_DEPTH_TEST)
                              GL11.glDisable(GL11.GL_LINE_SMOOTH)
                              GL11.glDisable(GL11.GL_BLEND)
                              GL11.glEnable(GL11.GL_TEXTURE_2D)
                              GL11.glPopMatrix()
                          }
                      }
                  

                  pic:
                  QQ截图20210404100843.png

                  I Offline
                  I Offline
                  Itz_pander
                  wrote on last edited by
                  #11

                  @qwq-liulihaocai where is killaura.kt? Xd

                  ? qwq LiulihaocaiQ 2 Replies Last reply
                  0
                  • I Itz_pander

                    @qwq-liulihaocai where is killaura.kt? Xd

                    ? Offline
                    ? Offline
                    A Former User
                    wrote on last edited by
                    #12

                    @itz_pander said in KillAura Mark like Sigma5:

                    @qwq-liulihaocai where is killaura.kt? Xd

                    if you don't know where is it then don't learn how to code

                    1 Reply Last reply
                    0
                    • I Itz_pander

                      @qwq-liulihaocai where is killaura.kt? Xd

                      qwq LiulihaocaiQ Offline
                      qwq LiulihaocaiQ Offline
                      qwq Liulihaocai
                      wrote on last edited by
                      #13

                      @itz_pander if u cant find it,it proofs u dont know how 2 modify it

                      1 Reply Last reply
                      0
                      • F Offline
                        F Offline
                        Fidazxaaa
                        wrote on last edited by
                        #14

                        QQ图片20210529211615.png
                        How to solve it, please give me some demonstration

                        1 Reply Last reply
                        0
                        • ? Offline
                          ? Offline
                          A Former User
                          wrote on last edited by
                          #15

                          @Fidazxaaa maybe actually read the // lines?

                          F 1 Reply Last reply
                          0
                          • ? A Former User

                            @Fidazxaaa maybe actually read the // lines?

                            F Offline
                            F Offline
                            Fidazxaaa
                            wrote on last edited by
                            #16

                            @chocopiexd Did not notice thank u :)

                            1 Reply Last reply
                            0
                            Reply
                            • Reply as topic
                            Log in to reply
                            • Oldest to Newest
                            • Newest to Oldest
                            • Most Votes


                            About
                            • Terms of Service
                            • Privacy Policy
                            • Status
                            • Contact Us
                            Downloads
                            • Releases
                            • Source code
                            • License
                            Docs
                            • Tutorials
                            • CustomHUD
                            • AutoSettings
                            • ScriptAPI
                            Community
                            • Forum
                            • Guilded
                            • YouTube
                            • Twitter
                            • D.Tube
                            • Login

                            • Login or register to search.
                            • First post
                              Last post
                            0
                            • Categories
                            • Recent
                            • Tags
                            • Popular
                            • Users
                            • Groups