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.
  • 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