RepoMirrors/kami-blue
1
0
Fork 1
mirror of https://github.com/kami-blue/client synced 2025-01-02 21:12:16 +00:00
Code Issues Releases Wiki Activity

Replaced usages of visibility lambda

Browse Source
This commit is contained in:
Xiaro 2021-03-11 22:18:17 -05:00
parent 3617a9945a
commit 980fb22136
No known key found for this signature in database
GPG Key ID: 996D265D6E155377
63 changed files with 712 additions and 585 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

92
src/main/kotlin/org/kamiblue/client/module/modules/chat/AntiSpam.kt
View File

@ -5,6 +5,9 @@ import net.minecraftforge.client.event.ClientChatReceivedEvent
import org.kamiblue.client.KamiMod
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.and
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.atValue
import org.kamiblue.client.util.text.*
import org.kamiblue.event.listener.listener
import java.util.concurrent.ConcurrentHashMap
@ -16,29 +19,31 @@ internal object AntiSpam : Module(
description = "Removes spam and advertising from the chat",
showOnArray = false
) {
private val mode = setting("Mode", Mode.REPLACE)
private val replaceMode = setting("Replace Mode", ReplaceMode.ASTERISKS, { mode.value == Mode.REPLACE })
private val mode0 = setting("Mode", Mode.REPLACE)
private val mode by mode0
private val replaceMode by setting("Replace Mode", ReplaceMode.ASTERISKS, mode0.atValue(Mode.REPLACE))
private val page = setting("Page", Page.TYPE)
/* Page One */
private val discordLinks = setting("Discord", true, { page.value == Page.TYPE })
private val slurs = setting("Slurs", true, { page.value == Page.TYPE })
private val swears = setting("Swears", false, { page.value == Page.TYPE })
private val automated = setting("Automated", true, { page.value == Page.TYPE })
private val ips = setting("Server Ips", true, { page.value == Page.TYPE })
private val specialCharEnding = setting("Special Ending", true, { page.value == Page.TYPE })
private val specialCharBegin = setting("Special Begin", true, { page.value == Page.TYPE })
private val greenText = setting("Green Text", false, { page.value == Page.TYPE })
private val fancyChat = setting("Fancy Chat", false, { page.value == Page.TYPE })
private val discordLinks = setting("Discord", true, page.atValue(Page.TYPE))
private val slurs = setting("Slurs", true, page.atValue(Page.TYPE))
private val swears = setting("Swears", false, page.atValue(Page.TYPE))
private val automated = setting("Automated", true, page.atValue(Page.TYPE))
private val ips = setting("Server Ips", true, page.atValue(Page.TYPE))
private val specialCharEnding = setting("Special Ending", true, page.atValue(Page.TYPE))
private val specialCharBegin = setting("Special Begin", true, page.atValue(Page.TYPE))
private val greenText = setting("Green Text", false, page.atValue(Page.TYPE))
private val fancyChat by setting("Fancy Chat", false, page.atValue(Page.TYPE))
/* Page Two */
private val aggressiveFiltering = setting("Aggressive Filtering", true, { page.value == Page.SETTINGS })
private val duplicates = setting("Duplicates", true, { page.value == Page.SETTINGS })
private val duplicatesTimeout = setting("Duplicates Timeout", 30, 1..600, 5, { duplicates.value && page.value == Page.SETTINGS })
private val filterOwn = setting("Filter Own", false, { page.value == Page.SETTINGS })
private val filterDMs = setting("Filter DMs", false, { page.value == Page.SETTINGS })
private val filterServer = setting("Filter Server", false, { page.value == Page.SETTINGS })
private val showBlocked = setting("Show Blocked", ShowBlocked.LOG_FILE, { page.value == Page.SETTINGS })
private val aggressiveFiltering by setting("Aggressive Filtering", true, page.atValue(Page.SETTINGS))
private val duplicates0 = setting("Duplicates", true, page.atValue(Page.SETTINGS))
private val duplicates by duplicates0
private val duplicatesTimeout by setting("Duplicates Timeout", 30, 1..600, 5, page.atValue(Page.SETTINGS) and duplicates0.atTrue())
private val filterOwn by setting("Filter Own", false, page.atValue(Page.SETTINGS))
private val filterDMs by setting("Filter DMs", false, page.atValue(Page.SETTINGS))
private val filterServer by setting("Filter Server", false, page.atValue(Page.SETTINGS))
private val showBlocked by setting("Show Blocked", ShowBlocked.LOG_FILE, page.atValue(Page.SETTINGS))
private enum class Mode {
REPLACE, HIDE
@ -59,20 +64,20 @@ internal object AntiSpam : Module(
}
private val messageHistory = ConcurrentHashMap<String, Long>()
private val settingMap = hashMapOf(
greenText to SpamFilters.greenText,
specialCharBegin to SpamFilters.specialBeginning,
specialCharEnding to SpamFilters.specialEnding,
automated to SpamFilters.ownsMeAndAll,
automated to SpamFilters.thanksTo,
private val settingArray = arrayOf(
discordLinks to SpamFilters.discordInvite,
ips to SpamFilters.ipAddress,
slurs to SpamFilters.slurs,
swears to SpamFilters.swears,
automated to SpamFilters.announcer,
automated to SpamFilters.spammer,
automated to SpamFilters.insulter,
automated to SpamFilters.greeter,
slurs to SpamFilters.slurs,
swears to SpamFilters.swears
automated to SpamFilters.ownsMeAndAll,
automated to SpamFilters.thanksTo,
ips to SpamFilters.ipAddress,
specialCharBegin to SpamFilters.specialBeginning,
specialCharEnding to SpamFilters.specialEnding,
greenText to SpamFilters.greenText,
)
init {
@ -85,21 +90,21 @@ internal object AntiSpam : Module(
messageHistory.values.removeIf { System.currentTimeMillis() - it > 600000 }
if (duplicates.value && checkDupes(event.message.unformattedText)) {
if (duplicates && checkDupes(event.message.unformattedText)) {
event.isCanceled = true
}
val pattern = isSpam(event.message.unformattedText)
if (pattern != null) { // null means no pattern found
if (mode.value == Mode.HIDE) {
if (mode == Mode.HIDE) {
event.isCanceled = true
} else if (mode.value == Mode.REPLACE) {
event.message = TextComponentString(sanitize(event.message.formattedText, pattern, replaceMode.value.redaction))
} else if (mode == Mode.REPLACE) {
event.message = TextComponentString(sanitize(event.message.formattedText, pattern, replaceMode.redaction))
}
}
if (fancyChat.value) {
if (fancyChat) {
val message = sanitizeFancyChat(event.message.unformattedText)
if (message.trim { it <= ' ' }.isEmpty()) { // this should be removed if we are going for an intelligent de-fancy
event.message = TextComponentString(getUsername(event.message.unformattedText) + " [Fancychat]")
@ -109,7 +114,7 @@ internal object AntiSpam : Module(
}
private fun sanitize(toClean: String, matcher: String, replacement: String): String {
return if (!aggressiveFiltering.value) {
return if (!aggressiveFiltering) {
toClean.replace("\\b$matcher|$matcher\\b".toRegex(), replacement) // only check for start or end of a word
} else { // We might encounter the scunthorpe problem, so aggressive mode is off by default.
toClean.replace(matcher.toRegex(), replacement)
@ -117,9 +122,9 @@ internal object AntiSpam : Module(
}
private fun isSpam(message: String): String? {
return if (!filterOwn.value && isOwn(message)
|| !filterDMs.value && MessageDetection.Direct.ANY detect message
|| !filterServer.value && MessageDetection.Server.ANY detect message) {
return if (!filterOwn && isOwn(message)
|| !filterDMs && MessageDetection.Direct.ANY detect message
|| !filterServer && MessageDetection.Server.ANY detect message) {
null
} else {
detectSpam(removeUsername(message))
@ -127,10 +132,11 @@ internal object AntiSpam : Module(
}
private fun detectSpam(message: String): String? {
for ((key, value) in settingMap) {
val pattern = findPatterns(value, message)
if (key.value && pattern != null) {
sendResult(key.name, message)
for ((setting, strings) in settingArray) {
val pattern = findPatterns(strings, message)
if (setting.value && pattern != null) {
sendResult(setting.name, message)
return pattern
}
}
@ -153,7 +159,7 @@ internal object AntiSpam : Module(
private fun checkDupes(message: String): Boolean {
var isDuplicate = false
if (messageHistory.containsKey(message) && (System.currentTimeMillis() - messageHistory[message]!!) / 1000 < duplicatesTimeout.value) isDuplicate = true
if (messageHistory.containsKey(message) && (System.currentTimeMillis() - messageHistory[message]!!) / 1000 < duplicatesTimeout) isDuplicate = true
messageHistory[message] = System.currentTimeMillis()
if (isDuplicate) {
@ -186,7 +192,7 @@ internal object AntiSpam : Module(
}
private fun sendResult(name: String, message: String) {
if (showBlocked.value == ShowBlocked.CHAT || showBlocked.value == ShowBlocked.BOTH) MessageSendHelper.sendChatMessage("$chatName $name: $message")
if (showBlocked.value == ShowBlocked.LOG_FILE || showBlocked.value == ShowBlocked.BOTH) KamiMod.LOG.info("$chatName $name: $message")
if (showBlocked == ShowBlocked.CHAT || showBlocked == ShowBlocked.BOTH) MessageSendHelper.sendChatMessage("$chatName $name: $message")
if (showBlocked == ShowBlocked.LOG_FILE || showBlocked == ShowBlocked.BOTH) KamiMod.LOG.info("$chatName $name: $message")
}
}

3
src/main/kotlin/org/kamiblue/client/module/modules/chat/AutoReply.kt
View File

@ -7,6 +7,7 @@ import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.text.MessageDetection
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.text.MessageSendHelper.sendServerMessage
@ -19,7 +20,7 @@ internal object AutoReply : Module(
category = Category.CHAT
) {
private val customMessage = setting("Custom Message", false)
private val customText = setting("Custom Text", "unchanged", { customMessage.value })
private val customText = setting("Custom Text", "unchanged", customMessage.atTrue())
private val timer = TickTimer(TimeUnit.SECONDS)

3
src/main/kotlin/org/kamiblue/client/module/modules/chat/ChatFilter.kt
View File

@ -4,6 +4,7 @@ import net.minecraftforge.client.event.ClientChatReceivedEvent
import org.kamiblue.client.KamiMod
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.BOOLEAN_SUPPLIER_FALSE
import org.kamiblue.client.util.text.MessageDetection
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.text.formatValue
@ -18,7 +19,7 @@ internal object ChatFilter : Module(
) {
private val filterOwn by setting("Filter Own", false)
private val filterDMs by setting("Filter DMs", false)
private var hasRunInfo by setting("Info", false, { false })
private var hasRunInfo by setting("Info", false, BOOLEAN_SUPPLIER_FALSE)
private val chatFilter = ArrayList<Regex>()
private val file = File(KamiMod.DIRECTORY + "chat_filter.txt")

16
src/main/kotlin/org/kamiblue/client/module/modules/chat/DiscordNotifs.kt
View File

@ -14,6 +14,8 @@ import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atFalse
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.text.*
import org.kamiblue.client.util.threads.defaultScope
import org.kamiblue.client.util.threads.safeListener
@ -25,15 +27,17 @@ internal object DiscordNotifs : Module(
category = Category.CHAT,
description = "Sends your chat to a set Discord channel"
) {
private val timeout by setting("Timeout", true)
private val timeoutTime by setting("Seconds", 10, 0..120, 5, { timeout })
private val timeout0 = setting("Timeout", true)
private val timeout by timeout0
private val timeoutTime by setting("Seconds", 10, 0..120, 5, timeout0.atTrue())
private val time by setting("Timestamp", true)
private val importantPings by setting("Important Pings", false)
private val connectionChange by setting("Connection Change", true, description = "When you get disconnected or reconnected to the server")
private val all by setting("All Messages", false)
private val direct by setting("DMs", true, { !all })
private val queue by setting("Queue Position", true, { !all })
private val restart by setting("Restart", true, { !all }, description = "Server restart notifications")
private val all0 = setting("All Messages", false)
private val all by all0
private val direct by setting("DMs", true, all0.atFalse())
private val queue by setting("Queue Position", true, all0.atFalse())
private val restart by setting("Restart", true, all0.atFalse(), description = "Server restart notifications")
val url = setting("URL", "unchanged")
val pingID = setting("Ping ID", "unchanged")

3
src/main/kotlin/org/kamiblue/client/module/modules/chat/FancyChat.kt
View File

@ -3,6 +3,7 @@ package org.kamiblue.client.module.modules.chat
import org.kamiblue.client.manager.managers.MessageManager.newMessageModifier
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atFalse
import org.kamiblue.client.util.text.MessageDetection
import org.kamiblue.commons.utils.MathUtils
import kotlin.math.min
@ -19,7 +20,7 @@ internal object FancyChat : Module(
private val mock = setting("mOcK", false)
private val green = setting(">", false)
private val blue = setting("`", false)
private val randomSetting = setting("Random Case", true, { mock.value })
private val randomSetting = setting("Random Case", true, mock.atFalse())
private val commands = setting("Commands", false)
private val spammer = setting("Spammer", false)

3
src/main/kotlin/org/kamiblue/client/module/modules/chat/Spammer.kt
View File

@ -8,6 +8,7 @@ import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.text.MessageDetection
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.text.MessageSendHelper.sendServerMessage
@ -28,7 +29,7 @@ internal object Spammer : Module(
private val modeSetting = setting("Order", Mode.RANDOM_ORDER)
private val delay = setting("Delay", 10, 1..180, 1, description = "Delay between messages, in seconds")
private val loadRemote = setting("Load From URL", false)
private val remoteURL = setting("Remote URL", "Unchanged", { loadRemote.value })
private val remoteURL = setting("Remote URL", "Unchanged", loadRemote.atTrue())
private val file = File(KamiMod.DIRECTORY + "spammer.txt")
private val spammer = ArrayList<String>().synchronized()

5
src/main/kotlin/org/kamiblue/client/module/modules/client/CommandConfig.kt
View File

@ -4,6 +4,7 @@ import net.minecraftforge.fml.common.gameevent.TickEvent
import org.kamiblue.client.KamiMod
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.BOOLEAN_SUPPLIER_FALSE
import org.kamiblue.client.util.TickTimer
import org.kamiblue.event.listener.listener
import org.lwjgl.opengl.Display
@ -15,10 +16,10 @@ internal object CommandConfig : Module(
showOnArray = false,
alwaysEnabled = true
) {
val prefix = setting("Prefix", ";", { false })
val prefix = setting("Prefix", ";", BOOLEAN_SUPPLIER_FALSE)
val toggleMessages = setting("Toggle Messages", false)
private val customTitle = setting("Window Title", true)
val modifierEnabled = setting("Modifier Enabled", false, { false })
val modifierEnabled = setting("Modifier Enabled", false)
private val timer = TickTimer()
private val prevTitle = Display.getTitle()

8
src/main/kotlin/org/kamiblue/client/module/modules/client/Configurations.kt
View File

@ -18,6 +18,7 @@ import org.kamiblue.client.setting.settings.impl.primitive.StringSetting
import org.kamiblue.client.util.ConfigUtils
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.text.formatValue
import org.kamiblue.client.util.threads.BackgroundScope
@ -39,9 +40,10 @@ internal object Configurations : AbstractModule(
) {
private const val defaultPreset = "default"
private val autoSaving by setting("Auto Saving", true)
private val savingFeedBack by setting("Saving FeedBack", false, { autoSaving })
private val savingInterval by setting("Interval", 10, 1..30, 1, { autoSaving }, description = "Frequency of auto saving in minutes")
private val autoSaving0 = setting("Auto Saving", true)
private val autoSaving by autoSaving0
private val savingFeedBack by setting("Saving FeedBack", false, autoSaving0.atTrue())
private val savingInterval by setting("Interval", 10, 1..30, 1, autoSaving0.atTrue(), description = "Frequency of auto saving in minutes")
val serverPreset by setting("Server Preset", false)
private val guiPresetSetting = setting("Gui Preset", defaultPreset)
private val modulePresetSetting = setting("Module Preset", defaultPreset)

6
src/main/kotlin/org/kamiblue/client/module/modules/combat/AutoEZ.kt
View File

@ -9,6 +9,7 @@ import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atValue
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.text.MessageSendHelper.sendServerMessage
import org.kamiblue.client.util.text.formatValue
@ -28,8 +29,9 @@ internal object AutoEZ : Module(
private const val HYPIXEL_MESSAGE = "\$HYPIXEL_MESSAGE"
private val detectMode by setting("Detect Mode", DetectMode.HEALTH)
private val messageMode by setting("Message Mode", MessageMode.ONTOP)
private val customText by setting("Custom Text", UNCHANGED, { messageMode == MessageMode.CUSTOM })
private val messageMode0 = setting("Message Mode", MessageMode.ONTOP)
private val messageMode by messageMode0
private val customText by setting("Custom Text", UNCHANGED, messageMode0.atValue(MessageMode.CUSTOM))
private enum class DetectMode {
BROADCAST, HEALTH

18
src/main/kotlin/org/kamiblue/client/module/modules/combat/AutoLog.kt
View File

@ -18,6 +18,7 @@ import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.module.modules.combat.AutoLog.Reasons.*
import org.kamiblue.client.util.EntityUtils.isFakeOrSelf
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.combat.CombatUtils.scaledHealth
import org.kamiblue.client.util.items.allSlots
import org.kamiblue.client.util.items.countItem
@ -34,13 +35,16 @@ internal object AutoLog : Module(
private val disableMode by setting("Disable Mode", DisableMode.ALWAYS)
private val health by setting("Health", 10, 6..36, 1)
private val crystals by setting("Crystals", false)
private val creeper by setting("Creepers", true)
private val creeperDistance by setting("Creeper Distance", 5, 1..10, 1, { creeper })
private val totem by setting("Totem", false)
private val minTotems by setting("Min Totems", 2, 1..10, 1, { totem })
private val players by setting("Players", false)
private val playerDistance by setting("Player Distance", 64, 32..128, 4, { players })
private val friends by setting("Friends", false, { players })
private val creeper0 = setting("Creepers", true)
private val creeper by creeper0
private val creeperDistance by setting("Creeper Distance", 5, 1..10, 1, creeper0.atTrue())
private val totem0 = setting("Totem", false)
private val totem by totem0
private val minTotems by setting("Min Totems", 2, 1..10, 1, totem0.atTrue())
private val players0 = setting("Players", false)
private val players by players0
private val playerDistance by setting("Player Distance", 64, 32..128, 4, players0.atTrue())
private val friends by setting("Friends", false, players0.atTrue())
@Suppress("UNUSED")
private enum class DisableMode {

12
src/main/kotlin/org/kamiblue/client/module/modules/combat/AutoMend.kt
View File

@ -17,8 +17,10 @@ import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils.isFakeOrSelf
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.items.swapToSlot
import org.kamiblue.client.util.math.Vec2f
import org.kamiblue.client.util.notAtValue
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.threads.runSafe
import org.kamiblue.client.util.threads.safeListener
@ -32,10 +34,12 @@ internal object AutoMend : Module(
) {
private val autoThrow by setting("Auto Throw", true)
private val throwDelay = setting("Throw Delay", 2, 0..5, 1, description = "Number of ticks between throws to allow absorption")
private val autoSwitch by setting("Auto Switch", true)
private val autoDisable by setting("Auto Disable", false, { autoSwitch })
private val cancelNearby by setting("Cancel Nearby", NearbyMode.OFF, description = "Don't mend when an enemy is nearby")
private val pauseNearbyRadius by setting("Nearby Radius", 8, 1..8, 1, { cancelNearby != NearbyMode.OFF })
private val autoSwitch0 = setting("Auto Switch", true)
private val autoSwitch by autoSwitch0
private val autoDisable by setting("Auto Disable", false, autoSwitch0.atTrue())
private val cancelNearby0 = setting("Cancel Nearby", NearbyMode.OFF, description = "Don't mend when an enemy is nearby")
private val cancelNearby by cancelNearby0
private val pauseNearbyRadius by setting("Nearby Radius", 8, 1..8, 1, cancelNearby0.notAtValue(NearbyMode.OFF))
private val threshold by setting("Repair At", 75, 1..100, 1, description = "Percentage to start repairing any armor piece")
private val gui by setting("Allow GUI", false, description = "Allow mending when inside a GUI")

48
src/main/kotlin/org/kamiblue/client/module/modules/combat/AutoOffhand.kt
View File

@ -33,41 +33,45 @@ internal object AutoOffhand : Module(
description = "Manages item in your offhand",
category = Category.COMBAT
) {
private val type by setting("Type", Type.TOTEM)
private val type = setting("Type", Type.TOTEM)
// Totem
private val hpThreshold by setting("Hp Threshold", 5f, 1f..20f, 0.5f, { type == Type.TOTEM })
private val bindTotem by setting("Bind Totem", Bind(), { type == Type.TOTEM })
private val checkDamage by setting("Check Damage", true, { type == Type.TOTEM })
private val mob by setting("Mob", true, { type == Type.TOTEM && checkDamage })
private val player by setting("Player", true, { type == Type.TOTEM && checkDamage })
private val crystal by setting("Crystal", true, { type == Type.TOTEM && checkDamage })
private val falling by setting("Falling", true, { type == Type.TOTEM && checkDamage })
private val hpThreshold by setting("Hp Threshold", 5f, 1f..20f, 0.5f, type.atValue(Type.TOTEM))
private val bindTotem by setting("Bind Totem", Bind(), type.atValue(Type.TOTEM))
private val checkDamage0 = setting("Check Damage", true, type.atValue(Type.TOTEM))
private val checkDamage by checkDamage0
private val mob by setting("Mob", true, type.atValue(Type.TOTEM) and checkDamage0.atTrue())
private val player by setting("Player", true, type.atValue(Type.TOTEM) and checkDamage0.atTrue())
private val crystal by setting("Crystal", true, type.atValue(Type.TOTEM) and checkDamage0.atTrue())
private val falling by setting("Falling", true, type.atValue(Type.TOTEM) and checkDamage0.atTrue())
// Gapple
private val offhandGapple by setting("Offhand Gapple", false, { type == Type.GAPPLE })
private val bindGapple by setting("Bind Gapple", Bind(), { type == Type.GAPPLE && offhandGapple })
private val checkAuraG by setting("Check Aura G", true, { type == Type.GAPPLE && offhandGapple })
private val checkWeaponG by setting("Check Weapon G", false, { type == Type.GAPPLE && offhandGapple })
private val checkCAGapple by setting("Check CrystalAura G", true, { type == Type.GAPPLE && offhandGapple && !offhandCrystal })
private val offhandGapple0 = setting("Offhand Gapple", false, type.atValue(Type.GAPPLE))
private val offhandGapple by offhandGapple0
private val bindGapple by setting("Bind Gapple", Bind(), type.atValue(Type.GAPPLE) and offhandGapple0.atTrue())
private val checkAuraG by setting("Check Aura G", true, type.atValue(Type.GAPPLE) and offhandGapple0.atTrue())
private val checkWeaponG by setting("Check Weapon G", false, type.atValue(Type.GAPPLE) and offhandGapple0.atTrue())
private val checkCAGapple by setting("Check CrystalAura G", true, type.atValue(Type.GAPPLE) and offhandGapple0.atTrue() and { !offhandCrystal })
// Strength
private val offhandStrength by setting("Offhand Strength", false, { type == Type.STRENGTH })
private val bindStrength by setting("Bind Strength", Bind(), { type == Type.STRENGTH && offhandStrength })
private val checkAuraS by setting("Check Aura S", true, { type == Type.STRENGTH && offhandStrength })
private val checkWeaponS by setting("Check Weapon S", false, { type == Type.STRENGTH && offhandStrength })
private val offhandStrength0 = setting("Offhand Strength", false, type.atValue(Type.STRENGTH))
private val offhandStrength by offhandStrength0
private val bindStrength by setting("Bind Strength", Bind(), type.atValue(Type.STRENGTH) and offhandStrength0.atTrue())
private val checkAuraS by setting("Check Aura S", true, type.atValue(Type.STRENGTH) and offhandStrength0.atTrue())
private val checkWeaponS by setting("Check Weapon S", false, type.atValue(Type.STRENGTH) and offhandStrength0.atTrue())
// Crystal
private val offhandCrystal by setting("Offhand Crystal", false, { type == Type.CRYSTAL })
private val bindCrystal by setting("Bind Crystal", Bind(), { type == Type.CRYSTAL && offhandCrystal })
private val checkCACrystal by setting("Check Crystal Aura C", false, { type == Type.CRYSTAL && offhandCrystal })
private val offhandCrystal0 = setting("Offhand Crystal", false, type.atValue(Type.STRENGTH))
private val offhandCrystal by offhandCrystal0
private val bindCrystal by setting("Bind Crystal", Bind(), type.atValue(Type.STRENGTH) and offhandCrystal0.atTrue())
private val checkCACrystal by setting("Check Crystal Aura C", false, type.atValue(Type.STRENGTH) and offhandCrystal0.atTrue())
// General
private val priority by setting("Priority", Priority.HOTBAR)
private val switchMessage by setting("Switch Message", true)
private val delay by setting("Delay", 2, 1..20, 1,
private val delay by setting("Delay", 1, 1..20, 1,
description = "Ticks to wait between each move")
private val confirmTimeout by setting("Confirm Timeout", 5, 1..20, 1,
private val confirmTimeout by setting("Confirm Timeout", 4, 1..20, 1,
description = "Maximum ticks to wait for confirm packets from server")
private enum class Type(val filter: (ItemStack) -> Boolean) {

2
src/main/kotlin/org/kamiblue/client/module/modules/combat/BedAura.kt
View File

@ -44,7 +44,7 @@ internal object BedAura : Module(
private val hitDelay = setting("Hit Delay", 5, 1..10, 1)
private val refillDelay = setting("Refill Delay", 2, 1..5, 1)
private val minDamage = setting("Min Damage", 10f, 1f..20f, 0.25f)
private val maxSelfDamage = setting("Max Self Damage", 4f, 1f..10f, 0.25f, { !suicideMode.value })
private val maxSelfDamage = setting("Max Self Damage", 4f, 1f..10f, 0.25f, suicideMode.atFalse())
private val range = setting("Range", 5f, 1f..5f, 0.25f)
private val wallRange = setting("Wall Range", 2.5f, 1f..5f, 0.25f)

48
src/main/kotlin/org/kamiblue/client/module/modules/combat/CombatSetting.kt
View File

@ -54,34 +54,34 @@ internal object CombatSetting : Module(
private val page = setting("Page", Page.TARGETING)
/* Targeting */
private val filter = setting("Filter", TargetFilter.ALL, { page.value == Page.TARGETING })
private val fov = setting("FOV", 90.0f, 0.0f..180.0f, 5.0f, { page.value == Page.TARGETING && filter.value == TargetFilter.FOV })
private val priority = setting("Priority", TargetPriority.DISTANCE, { page.value == Page.TARGETING })
private val players = setting("Players", true, { page.value == Page.TARGETING })
private val friends = setting("Friends", false, { page.value == Page.TARGETING && players.value })
private val teammates = setting("Teammates", false, { page.value == Page.TARGETING && players.value })
private val sleeping = setting("Sleeping", false, { page.value == Page.TARGETING && players.value })
private val mobs = setting("Mobs", true, { page.value == Page.TARGETING })
private val passive = setting("Passive Mobs", false, { page.value == Page.TARGETING && mobs.value })
private val neutral = setting("Neutral Mobs", false, { page.value == Page.TARGETING && mobs.value })
private val hostile = setting("Hostile Mobs", false, { page.value == Page.TARGETING && mobs.value })
private val tamed = setting("Tamed Mobs", false, { page.value == Page.TARGETING && mobs.value })
private val invisible = setting("Invisible", true, { page.value == Page.TARGETING })
private val ignoreWalls = setting("Ignore Walls", false, { page.value == Page.TARGETING })
private val range = setting("Target Range", 16.0f, 2.0f..64.0f, 2.0f, { page.value == Page.TARGETING })
private val filter = setting("Filter", TargetFilter.ALL, page.atValue(Page.TARGETING))
private val fov = setting("FOV", 90.0f, 0.0f..180.0f, 5.0f, page.atValue(Page.TARGETING) and filter.atValue(TargetFilter.FOV))
private val priority = setting("Priority", TargetPriority.DISTANCE, page.atValue(Page.TARGETING))
private val players = setting("Players", true, page.atValue(Page.TARGETING))
private val friends = setting("Friends", false, page.atValue(Page.TARGETING) and players.atTrue())
private val teammates = setting("Teammates", false, page.atValue(Page.TARGETING) and players.atTrue())
private val sleeping = setting("Sleeping", false, page.atValue(Page.TARGETING) and players.atTrue())
private val mobs = setting("Mobs", true, page.atValue(Page.TARGETING))
private val passive = setting("Passive Mobs", false, page.atValue(Page.TARGETING) and mobs.atTrue())
private val neutral = setting("Neutral Mobs", false, page.atValue(Page.TARGETING) and mobs.atTrue())
private val hostile = setting("Hostile Mobs", false, page.atValue(Page.TARGETING) and mobs.atTrue())
private val tamed = setting("Tamed Mobs", false, page.atValue(Page.TARGETING) and mobs.atTrue())
private val invisible = setting("Invisible", true, page.atValue(Page.TARGETING))
private val ignoreWalls = setting("Ignore Walls", false, page.atValue(Page.TARGETING))
private val range = setting("Target Range", 16.0f, 2.0f..64.0f, 2.0f, page.atValue(Page.TARGETING))
/* In Combat */
private val pauseForDigging = setting("Pause For Digging", true, { page.value == Page.IN_COMBAT })
private val pauseForEating = setting("Pause For Eating", true, { page.value == Page.IN_COMBAT })
private val ignoreOffhandEating = setting("Ignore Offhand Eating", true, { page.value == Page.IN_COMBAT && pauseForEating.value })
private val pauseBaritone = setting("Pause Baritone", true, { page.value == Page.IN_COMBAT })
private val resumeDelay = setting("Resume Delay", 3, 1..10, 1, { page.value == Page.IN_COMBAT && pauseBaritone.value })
private val motionPrediction = setting("Motion Prediction", true, { page.value == Page.IN_COMBAT })
private val pingSync = setting("Ping Sync", true, { page.value == Page.IN_COMBAT && motionPrediction.value })
private val ticksAhead = setting("Ticks Ahead", 5, 0..20, 1, { page.value == Page.IN_COMBAT && motionPrediction.value && !pingSync.value })
private val pauseForDigging = setting("Pause For Digging", true, page.atValue(Page.IN_COMBAT))
private val pauseForEating = setting("Pause For Eating", true, page.atValue(Page.IN_COMBAT))
private val ignoreOffhandEating = setting("Ignore Offhand Eating", true, page.atValue(Page.IN_COMBAT) and pauseForEating.atTrue())
private val pauseBaritone = setting("Pause Baritone", true, page.atValue(Page.IN_COMBAT))
private val resumeDelay = setting("Resume Delay", 3, 1..10, 1, page.atValue(Page.IN_COMBAT) and pauseBaritone.atTrue())
private val motionPrediction = setting("Motion Prediction", true, page.atValue(Page.IN_COMBAT))
private val pingSync = setting("Ping Sync", true, page.atValue(Page.IN_COMBAT) and motionPrediction.atTrue())
private val ticksAhead = setting("Ticks Ahead", 5, 0..20, 1, page.atValue(Page.IN_COMBAT) and motionPrediction.atTrue() and pingSync.atFalse())
/* Render */
private val renderPredictedPos = setting("Render Predicted Position", false, { page.value == Page.RENDER })
private val renderPredictedPos = setting("Render Predicted Position", false, page.atValue(Page.RENDER))
private enum class Page {
TARGETING, IN_COMBAT, RENDER

9
src/main/kotlin/org/kamiblue/client/module/modules/combat/Criticals.kt
View File

@ -16,6 +16,8 @@ import org.kamiblue.client.mixin.extension.isInWeb
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils.isInOrAboveLiquid
import org.kamiblue.client.util.atValue
import org.kamiblue.client.util.notAtValue
import org.kamiblue.client.util.threads.safeListener
import org.kamiblue.commons.interfaces.DisplayEnum
import org.kamiblue.event.listener.listener
@ -25,9 +27,10 @@ internal object Criticals : Module(
category = Category.COMBAT,
description = "Always do critical attacks"
) {
private val mode by setting("Mode", Mode.PACKET)
private val jumpMotion by setting("Jump Motion", 0.25, 0.1..0.5, 0.01, { mode == Mode.MINI_JUMP }, fineStep = 0.001)
private val attackFallDistance by setting("Attack Fall Distance", 0.1, 0.05..1.0, 0.05, { mode != Mode.PACKET })
private val mode0 = setting("Mode", Mode.PACKET)
private val mode by mode0
private val jumpMotion by setting("Jump Motion", 0.25, 0.1..0.5, 0.01, mode0.atValue(Mode.MINI_JUMP), fineStep = 0.001)
private val attackFallDistance by setting("Attack Fall Distance", 0.1, 0.05..1.0, 0.05, mode0.notAtValue(Mode.PACKET))
private enum class Mode(override val displayName: String) : DisplayEnum {
PACKET("Packet"),

44
src/main/kotlin/org/kamiblue/client/module/modules/combat/CrystalESP.kt
View File

@ -13,7 +13,7 @@ import org.kamiblue.client.manager.managers.CombatManager
import org.kamiblue.client.manager.managers.PlayerPacketManager
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.Quad
import org.kamiblue.client.util.*
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.combat.CrystalUtils.canPlaceCollide
import org.kamiblue.client.util.graphics.ESPRenderer
@ -38,29 +38,29 @@ internal object CrystalESP : Module(
) {
private val page = setting("Page", Page.DAMAGE_ESP)
private val damageESP = setting("Damage ESP", false, { page.value == Page.DAMAGE_ESP })
private val minAlpha = setting("Min Alpha", 0, 0..255, 1, { page.value == Page.DAMAGE_ESP })
private val maxAlpha = setting("Max Alpha", 63, 0..255, 1, { page.value == Page.DAMAGE_ESP })
private val damageRange = setting("Damage ESP Range", 4.0f, 0.0f..8.0f, 0.5f, { page.value == Page.DAMAGE_ESP })
private val damageESP = setting("Damage ESP", false, page.atValue(Page.DAMAGE_ESP))
private val minAlpha = setting("Min Alpha", 0, 0..255, 1, page.atValue(Page.DAMAGE_ESP))
private val maxAlpha = setting("Max Alpha", 63, 0..255, 1, page.atValue(Page.DAMAGE_ESP))
private val damageRange = setting("Damage ESP Range", 4.0f, 0.0f..8.0f, 0.5f, page.atValue(Page.DAMAGE_ESP))
private val crystalESP = setting("Crystal ESP", true, { page.value == Page.CRYSTAL_ESP })
private val onlyOwn = setting("Only Own", false, { page.value == Page.CRYSTAL_ESP && crystalESP.value })
private val filled = setting("Filled", true, { page.value == Page.CRYSTAL_ESP && crystalESP.value })
private val outline = setting("Outline", true, { page.value == Page.CRYSTAL_ESP && crystalESP.value })
private val tracer = setting("Tracer", true, { page.value == Page.CRYSTAL_ESP && crystalESP.value })
private val showDamage = setting("Damage", true, { page.value == Page.CRYSTAL_ESP && crystalESP.value })
private val showSelfDamage = setting("Self Damage", true, { page.value == Page.CRYSTAL_ESP && crystalESP.value })
private val textScale = setting("Text Scale", 1.0f, 0.0f..4.0f, 0.25f, { page.value == Page.CRYSTAL_ESP && crystalESP.value })
private val animationScale = setting("Animation Scale", 1.0f, 0.0f..2.0f, 0.1f, { page.value == Page.CRYSTAL_ESP && crystalESP.value })
private val crystalRange = setting("Crystal ESP Range", 16.0f, 0.0f..16.0f, 0.5f, { page.value == Page.CRYSTAL_ESP })
private val crystalESP = setting("Crystal ESP", true, page.atValue(Page.CRYSTAL_ESP))
private val onlyOwn = setting("Only Own", false, page.atValue(Page.CRYSTAL_ESP) and (crystalESP.atTrue()))
private val filled = setting("Filled", true, page.atValue(Page.CRYSTAL_ESP) and (crystalESP.atTrue()))
private val outline = setting("Outline", true, page.atValue(Page.CRYSTAL_ESP) and (crystalESP.atTrue()))
private val tracer = setting("Tracer", true, page.atValue(Page.CRYSTAL_ESP) and (crystalESP.atTrue()))
private val showDamage = setting("Damage", true, page.atValue(Page.CRYSTAL_ESP) and (crystalESP.atTrue()))
private val showSelfDamage = setting("Self Damage", true, page.atValue(Page.CRYSTAL_ESP) and (crystalESP.atTrue()))
private val textScale = setting("Text Scale", 1.0f, 0.0f..4.0f, 0.25f, page.atValue(Page.CRYSTAL_ESP) and (crystalESP.atTrue()))
private val animationScale = setting("Animation Scale", 1.0f, 0.0f..2.0f, 0.1f, page.atValue(Page.CRYSTAL_ESP) and (crystalESP.atTrue()))
private val crystalRange = setting("Crystal ESP Range", 16.0f, 0.0f..16.0f, 0.5f, page.atValue(Page.DAMAGE_ESP))
private val r = setting("Red", 155, 0..255, 1, { page.value == Page.CRYSTAL_ESP_COLOR && crystalESP.value })
private val g = setting("Green", 144, 0..255, 1, { page.value == Page.CRYSTAL_ESP_COLOR && crystalESP.value })
private val b = setting("Blue", 255, 0..255, 1, { page.value == Page.CRYSTAL_ESP_COLOR && crystalESP.value })
private val aFilled = setting("Filled Alpha", 47, 0..255, 1, { page.value == Page.CRYSTAL_ESP_COLOR && crystalESP.value && filled.value })
private val aOutline = setting("Outline Alpha", 127, 0..255, 1, { page.value == Page.CRYSTAL_ESP_COLOR && crystalESP.value && outline.value })
private val aTracer = setting("Tracer Alpha", 200, 0..255, 1, { page.value == Page.CRYSTAL_ESP_COLOR && crystalESP.value && tracer.value })
private val thickness = setting("Thickness", 2.0f, 0.25f..4.0f, 0.25f, { page.value == Page.CRYSTAL_ESP_COLOR && crystalESP.value && (outline.value || tracer.value) })
private val r = setting("Red", 155, 0..255, 1, page.atValue(Page.CRYSTAL_ESP_COLOR) and (crystalESP.atTrue()))
private val g = setting("Green", 144, 0..255, 1, page.atValue(Page.CRYSTAL_ESP_COLOR) and (crystalESP.atTrue()))
private val b = setting("Blue", 255, 0..255, 1, page.atValue(Page.CRYSTAL_ESP_COLOR) and (crystalESP.atTrue()))
private val aFilled = setting("Filled Alpha", 47, 0..255, 1, page.atValue(Page.CRYSTAL_ESP_COLOR) and crystalESP.atTrue() and filled.atTrue())
private val aOutline = setting("Outline Alpha", 127, 0..255, 1, page.atValue(Page.CRYSTAL_ESP_COLOR) and crystalESP.atTrue() and outline.atTrue())
private val aTracer = setting("Tracer Alpha", 200, 0..255, 1, page.atValue(Page.CRYSTAL_ESP_COLOR) and crystalESP.atTrue() and tracer.atTrue())
private val thickness = setting("Thickness", 2.0f, 0.25f..4.0f, 0.25f, page.atValue(Page.CRYSTAL_ESP_COLOR) and crystalESP.atTrue() and (outline.atTrue() or tracer.atTrue()))
private enum class Page {
DAMAGE_ESP, CRYSTAL_ESP, CRYSTAL_ESP_COLOR

18
src/main/kotlin/org/kamiblue/client/module/modules/combat/HoleESP.kt
View File

@ -7,6 +7,7 @@ import org.kamiblue.client.event.events.RenderWorldEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.combat.SurroundUtils
import org.kamiblue.client.util.combat.SurroundUtils.checkHole
@ -25,14 +26,14 @@ internal object HoleESP : Module(
private val filled = setting("Filled", true)
private val outline = setting("Outline", true)
private val hideOwn = setting("Hide Own", true)
private val r1 = setting("Obby Red", 208, 0..255, 1, { shouldAddObsidian() })
private val g1 = setting("Obby Green", 144, 0..255, 1, { shouldAddObsidian() })
private val b1 = setting("Obby Blue", 255, 0..255, 1, { shouldAddObsidian() })
private val r2 = setting("Bedrock Red", 144, 0..255, 1, { shouldAddBedrock() })
private val g2 = setting("Bedrock Green", 144, 0..255, 1, { shouldAddBedrock() })
private val b2 = setting("Bedrock Blue", 255, 0..255, 1, { shouldAddBedrock() })
private val aFilled = setting("Filled Alpha", 31, 0..255, 1, { filled.value })
private val aOutline = setting("Outline Alpha", 127, 0..255, 1, { outline.value })
private val r1 = setting("Obby Red", 208, 0..255, 1, ::shouldAddObsidian)
private val g1 = setting("Obby Green", 144, 0..255, 1, ::shouldAddObsidian)
private val b1 = setting("Obby Blue", 255, 0..255, 1, ::shouldAddObsidian)
private val r2 = setting("Bedrock Red", 144, 0..255, 1, ::shouldAddBedrock)
private val g2 = setting("Bedrock Green", 144, 0..255, 1, ::shouldAddBedrock)
private val b2 = setting("Bedrock Blue", 255, 0..255, 1, ::shouldAddBedrock)
private val aFilled = setting("Filled Alpha", 31, 0..255, 1, filled.atTrue())
private val aOutline = setting("Outline Alpha", 127, 0..255, 1, outline.atTrue())
private val renderMode = setting("Mode", Mode.BLOCK_HOLE)
private val holeType = setting("Hole Type", HoleType.BOTH)
@ -94,5 +95,4 @@ internal object HoleESP : Module(
private fun shouldAddObsidian() = holeType.value == HoleType.OBSIDIAN || holeType.value == HoleType.BOTH
private fun shouldAddBedrock() = holeType.value == HoleType.BEDROCK || holeType.value == HoleType.BOTH
}

14
src/main/kotlin/org/kamiblue/client/module/modules/combat/KillAura.kt
View File

@ -9,9 +9,7 @@ import org.kamiblue.client.manager.managers.CombatManager
import org.kamiblue.client.manager.managers.PlayerPacketManager
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.TpsCalculator
import org.kamiblue.client.util.*
import org.kamiblue.client.util.combat.CombatUtils
import org.kamiblue.client.util.combat.CombatUtils.equipBestWeapon
import org.kamiblue.client.util.combat.CombatUtils.scaledHealth
@ -29,14 +27,16 @@ internal object KillAura : Module(
description = "Hits entities around you",
modulePriority = 50
) {
private val mode by setting("Mode", Mode.COOLDOWN)
private val mode0 = setting("Mode", Mode.COOLDOWN)
private val mode by mode0
private val rotationMode by setting("Rotation Mode", RotationMode.SPOOF)
private val attackDelay by setting("Attack Delay", 5, 1..40, 1, { mode == Mode.TICKS })
private val attackDelay by setting("Attack Delay", 5, 1..40, 1, mode0.atValue(Mode.TICKS))
private val disableOnDeath by setting("Disable On Death", false)
private val tpsSync by setting("TPS Sync", false)
private val weaponOnly by setting("Weapon Only", false)
private val autoWeapon by setting("Auto Weapon", true)
private val prefer by setting("Prefer", CombatUtils.PreferWeapon.SWORD, { autoWeapon })
private val autoWeapon0 = setting("Auto Weapon", true)
private val autoWeapon by autoWeapon0
private val prefer by setting("Prefer", CombatUtils.PreferWeapon.SWORD, autoWeapon0.atTrue())
private val minSwapHealth by setting("Min Swap Health", 5.0f, 1.0f..20.0f, 0.5f)
private val swapDelay by setting("Swap Delay", 10, 0..50, 1)
val range by setting("Range", 4.0f, 0.0f..6.0f, 0.1f)

7
src/main/kotlin/org/kamiblue/client/module/modules/combat/Surround.kt
View File

@ -36,10 +36,11 @@ internal object Surround : Module(
) {
private val placeSpeed by setting("Places Per Tick", 4f, 0.25f..5f, 0.25f)
private val disableStrafe by setting("Disable Strafe", true)
private val autoDisable by setting("Auto Disable", AutoDisableMode.OUT_OF_HOLE)
private val outOfHoleTimeout by setting("Out Of Hole Timeout", 10, 1..50, 5, { autoDisable == AutoDisableMode.OUT_OF_HOLE }, description = "Delay before disabling Surround when you are out of hole, in ticks")
private val autoDisable0 = setting("Auto Disable", AutoDisableMode.OUT_OF_HOLE)
private val autoDisable by autoDisable0
private val outOfHoleTimeout by setting("Out Of Hole Timeout", 10, 1..50, 5, autoDisable0.atValue(AutoDisableMode.OUT_OF_HOLE), description = "Delay before disabling Surround when you are out of hole, in ticks")
private val enableInHole = setting("Enable In Hole", false)
private val inHoleTimeout by setting("In Hole Timeout", 50, 1..100, 5, { enableInHole.value }, description = "Delay before enabling Surround when you are in hole, in ticks")
private val inHoleTimeout by setting("In Hole Timeout", 50, 1..100, 5, enableInHole.atTrue(), description = "Delay before enabling Surround when you are in hole, in ticks")
private val toggleMessage by setting("Toggle Message", true)
private enum class AutoDisableMode {

6
src/main/kotlin/org/kamiblue/client/module/modules/combat/VisualRange.kt
View File

@ -13,6 +13,7 @@ import org.kamiblue.client.util.EntityUtils.flooredPosition
import org.kamiblue.client.util.EntityUtils.isFakeOrSelf
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.text.MessageSendHelper.sendServerMessage
import org.kamiblue.client.util.text.format
@ -28,12 +29,13 @@ internal object VisualRange : Module(
private const val NAME_FORMAT = "\$NAME"
private val playSound by setting("Play Sound", false)
private val leaving by setting("Count Leaving", false)
private val leaving0 = setting("Count Leaving", false)
private val leaving by leaving0
private val friends by setting("Friends", true)
private val uwuAura by setting("UwU Aura", false)
private val logToFile by setting("Log To File", false)
private val enterMessage by setting("Enter Message", "$NAME_FORMAT spotted!")
private val leaveMessage by setting("Leave Message", "$NAME_FORMAT left!", { leaving })
private val leaveMessage by setting("Leave Message", "$NAME_FORMAT left!", leaving0.atTrue())
private val playerSet = LinkedHashSet<EntityPlayer>()
private val timer = TickTimer(TimeUnit.SECONDS)

3
src/main/kotlin/org/kamiblue/client/module/modules/misc/AntiAFK.kt
View File

@ -16,6 +16,7 @@ import org.kamiblue.client.util.BaritoneUtils
import org.kamiblue.client.util.MovementUtils.realSpeed
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.text.MessageDetection
import org.kamiblue.client.util.text.MessageSendHelper.sendServerMessage
import org.kamiblue.client.util.threads.safeListener
@ -40,7 +41,7 @@ internal object AntiAFK : Module(
private val walk = setting("Walk", true)
private val radius by setting("Radius", 64, 8..128, 8, fineStep = 1)
private val inputTimeout by setting("Idle Timeout", 0, 0..15, 1, description = "Starts AntiAFK after being idle for longer than specific minutes, 0 to disable")
private val allowBreak by setting("Allow Breaking Blocks", false, { walk.value })
private val allowBreak by setting("Allow Breaking Blocks", false, walk.atTrue())
private var startPos: BlockPos? = null
private var squareStep = 0

3
src/main/kotlin/org/kamiblue/client/module/modules/misc/AutoFish.kt
View File

@ -10,6 +10,7 @@ import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.WorldUtils.isWater
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.threads.safeListener
import java.lang.Math.random
import kotlin.math.abs
@ -21,7 +22,7 @@ internal object AutoFish : Module(
) {
private val mode = setting("Mode", Mode.BOUNCE)
private val autoCast = setting("Auto Cast", true)
private val castDelay = setting("Auto Cast Delay", 5, 1..20, 1, { autoCast.value }, description = "Delay before starting fishing when holding a fishing rod, in seconds")
private val castDelay = setting("Auto Cast Delay", 5, 1..20, 1, autoCast.atTrue(), description = "Delay before starting fishing when holding a fishing rod, in seconds")
private val catchDelay = setting("Catch Delay", 300, 50..2000, 50, description = "Delay before catching the fish, in milliseconds")
private val recastDelay = setting("Recast Delay", 450, 50..2000, 50, description = "Delay before recasting the fishing rod, in milliseconds")
private val variation = setting("Variation", 100, 0..1000, 50, description = "Randomize the delays in specific range, in milliseconds")

20
src/main/kotlin/org/kamiblue/client/module/modules/misc/AutoObsidian.kt
View File

@ -62,14 +62,18 @@ internal object AutoObsidian : Module(
description = "Breaks down Ender Chests to restock obsidian",
modulePriority = 15
) {
private val fillMode by setting("Fill Mode", FillMode.TARGET_STACKS)
private val searchShulker by setting("Search Shulker", false)
private val leaveEmptyShulkers by setting("Leave Empty Shulkers", true, { searchShulker })
private val autoRefill by setting("Auto Refill", false, { fillMode != FillMode.INFINITE })
private val instantMining by setting("Instant Mining", true)
private val instantMiningDelay by setting("Instant Mining Delay", 10, 1..20, 1, { instantMining })
private val threshold by setting("Refill Threshold", 32, 1..64, 1, { autoRefill && fillMode != FillMode.INFINITE })
private val targetStacks by setting("Target Stacks", 1, 1..20, 1, { fillMode == FillMode.TARGET_STACKS })
private val fillMode0 = setting("Fill Mode", FillMode.TARGET_STACKS)
private val fillMode by fillMode0
private val searchShulker0 = setting("Search Shulker", false)
private val searchShulker by searchShulker0
private val leaveEmptyShulkers by setting("Leave Empty Shulkers", true, searchShulker0.atTrue())
private val autoRefill0 = setting("Auto Refill", false, fillMode0.notAtValue(FillMode.INFINITE))
private val autoRefill by autoRefill0
private val instantMining0 = setting("Instant Mining", true)
private val instantMining by instantMining0
private val instantMiningDelay by setting("Instant Mining Delay", 10, 1..20, 1, instantMining0.atTrue())
private val threshold by setting("Refill Threshold", 32, 1..64, 1, autoRefill0.atTrue() and fillMode0.notAtValue(FillMode.INFINITE))
private val targetStacks by setting("Target Stacks", 1, 1..20, 1, fillMode0.atValue(FillMode.TARGET_STACKS))
private val delayTicks by setting("Delay Ticks", 4, 1..10, 1)
private val rotationMode by setting("Rotation Mode", RotationMode.SPOOF)
private val maxReach by setting("Max Reach", 4.9f, 2.0f..6.0f, 0.1f)

12
src/main/kotlin/org/kamiblue/client/module/modules/misc/AutoSpawner.kt
View File

@ -31,12 +31,14 @@ internal object AutoSpawner : Module(
category = Category.MISC,
description = "Automatically spawns Withers, Iron Golems and Snowmen"
) {
private val useMode by setting("Use Mode", UseMode.SPAM)
private val party by setting("Party", false)
private val partyWithers by setting("Withers", false, { party })
private var entityMode by setting("Entity Mode", EntityMode.SNOW, { !party })
private val useMode0 = setting("Use Mode", UseMode.SPAM)
private val useMode by useMode0
private val party0 = setting("Party", false)
private val party by party0
private val partyWithers by setting("Withers", false, party0.atTrue())
private var entityMode by setting("Entity Mode", EntityMode.SNOW, party0.atFalse())
private val placeRange by setting("Place Range", 3.5f, 2f..10f, 0.5f)
private val delay by setting("Delay", 20, 10..100, 5, { useMode == UseMode.SPAM })
private val delay by setting("Delay", 20, 10..100, 5, useMode0.atValue(UseMode.SPAM))
private val rotate by setting("Rotate", true)
private val debug by setting("Info", true)

3
src/main/kotlin/org/kamiblue/client/module/modules/misc/AutoTool.kt
View File

@ -11,6 +11,7 @@ import org.kamiblue.client.event.events.PlayerAttackEvent
import org.kamiblue.client.mixin.extension.syncCurrentPlayItem
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.combat.CombatUtils
import org.kamiblue.client.util.combat.CombatUtils.equipBestWeapon
import org.kamiblue.client.util.items.swapToSlot
@ -24,7 +25,7 @@ internal object AutoTool : Module(
category = Category.MISC
) {
private val switchBack = setting("Switch Back", true)
private val timeout by setting("Timeout", 20, 1..100, 5, { switchBack.value })
private val timeout by setting("Timeout", 20, 1..100, 5, switchBack.atTrue())
private val swapWeapon by setting("Switch Weapon", false)
private val preferWeapon by setting("Prefer", CombatUtils.PreferWeapon.SWORD)

2
src/main/kotlin/org/kamiblue/client/module/modules/misc/DiscordRPC.kt
View File

@ -34,7 +34,7 @@ internal object DiscordRPC : Module(
private val line1Right by setting("Line 1 Right", LineInfo.USERNAME) // details right
private val line2Left by setting("Line 2 Left", LineInfo.SERVER_IP) // state left
private val line2Right by setting("Line 2 Right", LineInfo.HEALTH) // state right
private val coordsConfirm by setting("Coords Confirm", false, { showCoordsConfirm() })
private val coordsConfirm by setting("Coords Confirm", false, ::showCoordsConfirm)
private enum class LineInfo {
VERSION, WORLD, DIMENSION, USERNAME, HEALTH, HUNGER, SERVER_IP, COORDS, SPEED, HELD_ITEM, FPS, TPS, NONE

33
src/main/kotlin/org/kamiblue/client/module/modules/misc/NoteBot.kt
View File

@ -42,26 +42,27 @@ internal object NoteBot : Module(
category = Category.MISC,
description = "Plays music with note blocks; put .mid or .nbs songs in .minecraft/kamiblue/songs"
) {
private val isNotNbsFormat = { !isNbsFormat }
private val togglePlay = setting("Toggle Play", false)
private val reloadSong = setting("Reload Song", false)
private val songName = setting("Song Name", "Unchanged")
private val channel1 = setting("Channel 1", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel2 = setting("Channel 2", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel3 = setting("Channel 3", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel4 = setting("Channel 4", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel5 = setting("Channel 5", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel6 = setting("Channel 6", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel7 = setting("Channel 7", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel8 = setting("Channel 8", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel9 = setting("Channel 9", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel10 = setting("Channel 10", NoteBlockEvent.Instrument.PIANO, { false })
private val channel11 = setting("Channel 11", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel12 = setting("Channel 12", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel13 = setting("Channel 13", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel14 = setting("Channel 14", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel15 = setting("Channel 15", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel16 = setting("Channel 16", NoteBlockEvent.Instrument.PIANO, { !isNbsFormat })
private val channel1 = setting("Channel 1", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel2 = setting("Channel 2", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel3 = setting("Channel 3", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel4 = setting("Channel 4", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel5 = setting("Channel 5", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel6 = setting("Channel 6", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel7 = setting("Channel 7", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel8 = setting("Channel 8", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel9 = setting("Channel 9", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel10 = setting("Channel 10", NoteBlockEvent.Instrument.PIANO, BOOLEAN_SUPPLIER_FALSE)
private val channel11 = setting("Channel 11", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel12 = setting("Channel 12", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel13 = setting("Channel 13", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel14 = setting("Channel 14", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel15 = setting("Channel 15", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val channel16 = setting("Channel 16", NoteBlockEvent.Instrument.PIANO, isNotNbsFormat)
private val isNbsFormat get() = songName.value.endsWith(".nbs")

26
src/main/kotlin/org/kamiblue/client/module/modules/misc/StashLogger.kt
View File

@ -15,6 +15,7 @@ import org.kamiblue.client.module.modules.movement.AutoWalk
import org.kamiblue.client.util.BaritoneUtils
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.math.CoordinateConverter.asString
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.threads.defaultScope
@ -35,16 +36,21 @@ internal object StashLogger : Module(
private val saveToWaypoints by setting("Save To Waypoints", true)
private val logToChat by setting("Log To Chat", true)
private val playSound by setting("Play Sound", true)
private val logChests by setting("Chests", true)
private val chestDensity by setting("Min Chests", 5, 1..20, 1, { logChests })
private val logShulkers by setting("Shulkers", true)
private val shulkerDensity by setting("Min Shulkers", 1, 1..20, 1, { logShulkers })
private val logDroppers by setting("Droppers", true)
private val dropperDensity by setting("Min Droppers", 5, 1..20, 1, { logDroppers })
private val logDispensers by setting("Dispensers", true)
private val dispenserDensity by setting("Min Dispensers", 5, 1..20, 1, { logDispensers })
private val logHoppers by setting("Hoppers", true)
private val hopperDensity by setting("Min Hoppers", 5, 1..20, 1, { logHoppers })
private val logChests0 = setting("Chests", true)
private val logChests by logChests0
private val chestDensity by setting("Min Chests", 5, 1..20, 1, logChests0.atTrue())
private val logShulkers0 = setting("Shulkers", true)
private val logShulkers by logShulkers0
private val shulkerDensity by setting("Min Shulkers", 1, 1..20, 1, logShulkers0.atTrue())
private val logDroppers0 = setting("Droppers", true)
private val logDroppers by logDroppers0
private val dropperDensity by setting("Min Droppers", 5, 1..20, 1, logDroppers0.atTrue())
private val logDispensers0 = setting("Dispensers", true)
private val logDispensers by logDispensers0
private val dispenserDensity by setting("Min Dispensers", 5, 1..20, 1, logDispensers0.atTrue())
private val logHoppers0 = setting("Hoppers", true)
private val logHoppers by logHoppers0
private val hopperDensity by setting("Min Hoppers", 5, 1..20, 1, logHoppers0.atTrue())
private val disableAutoWalk by setting("Disable Auto Walk", false, description = "Disables AutoWalk when a stash is found")
private val cancelBaritone by setting("Cancel Baritone", false, description = "Cancels Baritone when a stash is found")

3
src/main/kotlin/org/kamiblue/client/module/modules/misc/TeleportLogger.kt
View File

@ -6,6 +6,7 @@ import org.kamiblue.client.manager.managers.WaypointManager
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils.isFakeOrSelf
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.threads.safeListener
import org.kamiblue.commons.utils.MathUtils
@ -18,7 +19,7 @@ internal object TeleportLogger : Module(
private val saveToWaypoints = setting("Save To Waypoints", true)
private val remove = setting("Remove In Range", true)
private val printAdd = setting("Print Add", true)
private val printRemove = setting("Print Remove", true, { remove.value })
private val printRemove = setting("Print Remove", true, remove.atTrue())
private val minimumDistance = setting("Minimum Distance", 512, 128..2048, 128)
private val teleportedPlayers = HashMap<String, BlockPos>()

6
src/main/kotlin/org/kamiblue/client/module/modules/movement/Anchor.kt
View File

@ -8,6 +8,7 @@ import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils.flooredPosition
import org.kamiblue.client.util.MovementUtils.centerPlayer
import org.kamiblue.client.util.MovementUtils.isCentered
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.combat.SurroundUtils
import org.kamiblue.client.util.combat.SurroundUtils.checkHole
import org.kamiblue.client.util.threads.safeListener
@ -21,8 +22,9 @@ internal object Anchor : Module(
private val autoCenter by setting("Auto Center", true)
private val stopYMotion by setting("Stop Y Motion", false)
private val disableInHole by setting("Disable In Hole", false)
private val pitchTrigger by setting("Pitch Trigger", true)
private val pitch by setting("Pitch", 75, 0..80, 1, { pitchTrigger })
private val pitchTrigger0 = setting("Pitch Trigger", true)
private val pitchTrigger by pitchTrigger0
private val pitch by setting("Pitch", 75, 0..80, 1, pitchTrigger0.atTrue())
private val verticalRange by setting("Vertical Range", 3, 1..5, 1)
private enum class Mode {

76
src/main/kotlin/org/kamiblue/client/module/modules/movement/ElytraFlight.kt
View File

@ -16,6 +16,7 @@ import org.kamiblue.client.mixin.extension.timer
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.module.modules.player.LagNotifier
import org.kamiblue.client.util.*
import org.kamiblue.client.util.MovementUtils.calcMoveYaw
import org.kamiblue.client.util.MovementUtils.speed
import org.kamiblue.client.util.WorldUtils.getGroundPos
@ -35,60 +36,65 @@ internal object ElytraFlight : Module(
modulePriority = 1000
) {
private val mode = setting("Mode", ElytraFlightMode.CONTROL)
private val page by setting("Page", Page.GENERIC_SETTINGS)
private val durabilityWarning by setting("Durability Warning", true, { page == Page.GENERIC_SETTINGS })
private val threshold by setting("Warning Threshold", 5, 1..50, 1, { durabilityWarning && page == Page.GENERIC_SETTINGS }, description = "Threshold of durability to start sending warnings")
private var autoLanding by setting("Auto Landing", false, { page == Page.GENERIC_SETTINGS })
private val page = setting("Page", Page.GENERIC_SETTINGS)
private val durabilityWarning0 = setting("Durability Warning", true, page.atValue(Page.GENERIC_SETTINGS))
private val durabilityWarning by durabilityWarning0
private val threshold by setting("Warning Threshold", 5, 1..50, 1, page.atValue(Page.GENERIC_SETTINGS) and (durabilityWarning0.atTrue()), description = "Threshold of durability to start sending warnings")
private var autoLanding by setting("Auto Landing", false, page.atValue(Page.GENERIC_SETTINGS))
/* Generic Settings */
/* Takeoff */
private val easyTakeOff by setting("Easy Takeoff", true, { page == Page.GENERIC_SETTINGS })
private val timerControl by setting("Takeoff Timer", true, { easyTakeOff && page == Page.GENERIC_SETTINGS })
private val highPingOptimize by setting("High Ping Optimize", false, { easyTakeOff && page == Page.GENERIC_SETTINGS })
private val minTakeoffHeight by setting("Min Takeoff Height", 0.5f, 0.0f..1.5f, 0.1f, { easyTakeOff && !highPingOptimize && page == Page.GENERIC_SETTINGS })
private val easyTakeOff0 = setting("Easy Takeoff", true, page.atValue(Page.GENERIC_SETTINGS))
private val easyTakeOff by easyTakeOff0
private val timerControl by setting("Takeoff Timer", true, page.atValue(Page.GENERIC_SETTINGS))
private val highPingOptimize0 = setting("High Ping Optimize", false, page.atValue(Page.GENERIC_SETTINGS) and easyTakeOff0.atTrue())
private val highPingOptimize by highPingOptimize0
private val minTakeoffHeight by setting("Min Takeoff Height", 0.5f, 0.0f..1.5f, 0.1f, page.atValue(Page.GENERIC_SETTINGS) and easyTakeOff0.atTrue() and highPingOptimize0.atFalse())
/* Acceleration */
private val accelerateStartSpeed by setting("Start Speed", 100, 0..100, 5, { mode.value != ElytraFlightMode.BOOST && page == Page.GENERIC_SETTINGS })
private val accelerateTime by setting("Accelerate Time", 0.0f, 0.0f..20.0f, 0.25f, { mode.value != ElytraFlightMode.BOOST && page == Page.GENERIC_SETTINGS })
private val accelerateStartSpeed by setting("Start Speed", 100, 0..100, 5, page.atValue(Page.GENERIC_SETTINGS) and mode.notAtValue(ElytraFlightMode.BOOST))
private val accelerateTime by setting("Accelerate Time", 0.0f, 0.0f..20.0f, 0.25f, page.atValue(Page.GENERIC_SETTINGS) and mode.notAtValue(ElytraFlightMode.BOOST))
/* Spoof Pitch */
private val spoofPitch by setting("Spoof Pitch", true, { mode.value != ElytraFlightMode.BOOST && page == Page.GENERIC_SETTINGS })
private val blockInteract by setting("Block Interact", false, { spoofPitch && mode.value != ElytraFlightMode.BOOST && page == Page.GENERIC_SETTINGS })
private val forwardPitch by setting("Forward Pitch", 0, -90..90, 5, { spoofPitch && mode.value != ElytraFlightMode.BOOST && page == Page.GENERIC_SETTINGS })
private val spoofPitch0 = setting("Spoof Pitch", true, page.atValue(Page.GENERIC_SETTINGS) and mode.notAtValue(ElytraFlightMode.BOOST))
private val spoofPitch by spoofPitch0
private val blockInteract by setting("Block Interact", false, page.atValue(Page.GENERIC_SETTINGS) and mode.notAtValue(ElytraFlightMode.BOOST) and spoofPitch0.atTrue())
private val forwardPitch by setting("Forward Pitch", 0, -90..90, 5, page.atValue(Page.GENERIC_SETTINGS) and mode.notAtValue(ElytraFlightMode.BOOST) and spoofPitch0.atTrue())
/* Extra */
val elytraSounds by setting("Elytra Sounds", true, { page == Page.GENERIC_SETTINGS })
private val swingSpeed by setting("Swing Speed", 1.0f, 0.0f..2.0f, 0.1f, { page == Page.GENERIC_SETTINGS && (mode.value == ElytraFlightMode.CONTROL || mode.value == ElytraFlightMode.PACKET) })
private val swingAmount by setting("Swing Amount", 0.8f, 0.0f..2.0f, 0.1f, { page == Page.GENERIC_SETTINGS && (mode.value == ElytraFlightMode.CONTROL || mode.value == ElytraFlightMode.PACKET) })
val elytraSounds by setting("Elytra Sounds", true, page.atValue(Page.GENERIC_SETTINGS))
private val swingSpeed by setting("Swing Speed", 1.0f, 0.0f..2.0f, 0.1f, page.atValue(Page.GENERIC_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL, ElytraFlightMode.PACKET))
private val swingAmount by setting("Swing Amount", 0.8f, 0.0f..2.0f, 0.1f, page.atValue(Page.GENERIC_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL, ElytraFlightMode.PACKET))
/* End of Generic Settings */
/* Mode Settings */
/* Boost */
private val speedBoost by setting("Speed B", 1.0f, 0.0f..10.0f, 0.1f, { mode.value == ElytraFlightMode.BOOST && page == Page.MODE_SETTINGS })
private val upSpeedBoost by setting("Up Speed B", 1.0f, 1.0f..5.0f, 0.1f, { mode.value == ElytraFlightMode.BOOST && page == Page.MODE_SETTINGS })
private val downSpeedBoost by setting("Down Speed B", 1.0f, 1.0f..5.0f, 0.1f, { mode.value == ElytraFlightMode.BOOST && page == Page.MODE_SETTINGS })
private val speedBoost by setting("Speed B", 1.0f, 0.0f..10.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.BOOST))
private val upSpeedBoost by setting("Up Speed B", 1.0f, 1.0f..5.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.BOOST))
private val downSpeedBoost by setting("Down Speed B", 1.0f, 1.0f..5.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.BOOST))
/* Control */
private val boostPitchControl by setting("Base Boost Pitch", 20, 0..90, 5, { mode.value == ElytraFlightMode.CONTROL && page == Page.MODE_SETTINGS })
private val ncpStrict by setting("NCP Strict", true, { mode.value == ElytraFlightMode.CONTROL && page == Page.MODE_SETTINGS })
private val legacyLookBoost by setting("Legacy Look Boost", false, { mode.value == ElytraFlightMode.CONTROL && page == Page.MODE_SETTINGS })
private val altitudeHoldControl by setting("Auto Control Altitude", false, { mode.value == ElytraFlightMode.CONTROL && page == Page.MODE_SETTINGS })
private val dynamicDownSpeed by setting("Dynamic Down Speed", false, { mode.value == ElytraFlightMode.CONTROL && page == Page.MODE_SETTINGS })
private val speedControl by setting("Speed C", 1.81f, 0.0f..10.0f, 0.1f, { mode.value == ElytraFlightMode.CONTROL && page == Page.MODE_SETTINGS })
private val fallSpeedControl by setting("Fall Speed C", 0.00000000000003f, 0.0f..0.3f, 0.01f, { mode.value == ElytraFlightMode.CONTROL && page == Page.MODE_SETTINGS })
private val downSpeedControl by setting("Down Speed C", 1.0f, 1.0f..5.0f, 0.1f, { mode.value == ElytraFlightMode.CONTROL && page == Page.MODE_SETTINGS })
private val fastDownSpeedControl by setting("Dynamic Down Speed C", 2.0f, 1.0f..5.0f, 0.1f, { mode.value == ElytraFlightMode.CONTROL && dynamicDownSpeed && page == Page.MODE_SETTINGS })
private val boostPitchControl by setting("Base Boost Pitch", 20, 0..90, 5, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL))
private val ncpStrict by setting("NCP Strict", true, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL))
private val legacyLookBoost by setting("Legacy Look Boost", false, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL))
private val altitudeHoldControl by setting("Auto Control Altitude", false, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL))
private val dynamicDownSpeed0 = setting("Dynamic Down Speed", false, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL))
private val dynamicDownSpeed by dynamicDownSpeed0
private val speedControl by setting("Speed C", 1.81f, 0.0f..10.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL))
private val fallSpeedControl by setting("Fall Speed C", 0.00000000000003f, 0.0f..0.3f, 0.01f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL))
private val downSpeedControl by setting("Down Speed C", 1.0f, 1.0f..5.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL))
private val fastDownSpeedControl by setting("Dynamic Down Speed C", 2.0f, 1.0f..5.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CONTROL) and dynamicDownSpeed0.atTrue())
/* Creative */
private val speedCreative by setting("Speed CR", 1.8f, 0.0f..10.0f, 0.1f, { mode.value == ElytraFlightMode.CREATIVE && page == Page.MODE_SETTINGS })
private val fallSpeedCreative by setting("Fall Speed CR", 0.00001f, 0.0f..0.3f, 0.01f, { mode.value == ElytraFlightMode.CREATIVE && page == Page.MODE_SETTINGS })
private val upSpeedCreative by setting("Up Speed CR", 1.0f, 1.0f..5.0f, 0.1f, { mode.value == ElytraFlightMode.CREATIVE && page == Page.MODE_SETTINGS })
private val downSpeedCreative by setting("Down Speed CR", 1.0f, 1.0f..5.0f, 0.1f, { mode.value == ElytraFlightMode.CREATIVE && page == Page.MODE_SETTINGS })
private val speedCreative by setting("Speed CR", 1.8f, 0.0f..10.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CREATIVE))
private val fallSpeedCreative by setting("Fall Speed CR", 0.00001f, 0.0f..0.3f, 0.01f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CREATIVE))
private val upSpeedCreative by setting("Up Speed CR", 1.0f, 1.0f..5.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CREATIVE))
private val downSpeedCreative by setting("Down Speed CR", 1.0f, 1.0f..5.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.CREATIVE))
/* Packet */
private val speedPacket by setting("Speed P", 1.8f, 0.0f..20.0f, 0.1f, { mode.value == ElytraFlightMode.PACKET && page == Page.MODE_SETTINGS })
private val fallSpeedPacket by setting("Fall Speed P", 0.00001f, 0.0f..0.3f, 0.01f, { mode.value == ElytraFlightMode.PACKET && page == Page.MODE_SETTINGS })
private val downSpeedPacket by setting("Down Speed P", 1.0f, 0.1f..5.0f, 0.1f, { mode.value == ElytraFlightMode.PACKET && page == Page.MODE_SETTINGS })
private val speedPacket by setting("Speed P", 1.8f, 0.0f..20.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.PACKET))
private val fallSpeedPacket by setting("Fall Speed P", 0.00001f, 0.0f..0.3f, 0.01f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.PACKET))
private val downSpeedPacket by setting("Down Speed P", 1.0f, 0.1f..5.0f, 0.1f, page.atValue(Page.MODE_SETTINGS) and mode.atValue(ElytraFlightMode.PACKET))
/* End of Mode Settings */
private enum class ElytraFlightMode {

5
src/main/kotlin/org/kamiblue/client/module/modules/movement/ElytraReplace.kt
View File

@ -11,6 +11,7 @@ import net.minecraft.item.ItemStack
import net.minecraftforge.fml.common.gameevent.TickEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.threads.safeListener
@ -23,8 +24,8 @@ internal object ElytraReplace : Module(
private val autoChest = setting("Auto Chest", false)
private val elytraFlightCheck = setting("ElytraFlight Check", true)
private val logToChat = setting("Missing Warning", false)
private val playSound = setting("Play Sound", false, { logToChat.value })
private val logThreshold = setting("Warning Threshold", 2, 1..10, 1, { logToChat.value })
private val playSound = setting("Play Sound", false, logToChat.atTrue())
private val logThreshold = setting("Warning Threshold", 2, 1..10, 1, logToChat.atTrue())
private val threshold = setting("Damage Threshold", 7, 1..50, 1)
private var elytraCount = 0

7
src/main/kotlin/org/kamiblue/client/module/modules/movement/EntitySpeed.kt
View File

@ -18,6 +18,7 @@ import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.MovementUtils
import org.kamiblue.client.util.MovementUtils.calcMoveYaw
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.threads.safeListener
import kotlin.math.cos
import kotlin.math.sin
@ -30,11 +31,11 @@ internal object EntitySpeed : Module(
private val speed = setting("Speed", 1.0f, 0.1f..25.0f, 0.1f)
private val antiStuck = setting("Anti Stuck", true)
private val flight = setting("Flight", false)
private val glideSpeed = setting("Glide Speed", 0.1f, 0.0f..1.0f, 0.01f, { flight.value })
private val upSpeed = setting("Up Speed", 1.0f, 0.0f..5.0f, 0.1f, { flight.value })
private val glideSpeed = setting("Glide Speed", 0.1f, 0.0f..1.0f, 0.01f, flight.atTrue())
private val upSpeed = setting("Up Speed", 1.0f, 0.0f..5.0f, 0.1f, flight.atTrue())
private val opacity = setting("Boat Opacity", 1.0f, 0.0f..1.0f, 0.01f)
private val forceInteract = setting("Force Interact", false)
private val interactTickDelay = setting("Interact Delay", 2, 1..20, 1, { forceInteract.value }, description = "Force interact packet delay, in ticks.")
private val interactTickDelay = setting("Interact Delay", 2, 1..20, 1, forceInteract.atTrue(), description = "Force interact packet delay, in ticks.")
init {
safeListener<PacketEvent.Send> {

12
src/main/kotlin/org/kamiblue/client/module/modules/movement/NoSlowDown.kt
View File

@ -15,6 +15,7 @@ import org.kamiblue.client.mixin.client.world.MixinBlockWeb
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils.flooredPosition
import org.kamiblue.client.util.atFalse
import org.kamiblue.client.util.threads.safeListener
/**
@ -31,11 +32,12 @@ internal object NoSlowDown : Module(
val soulSand by setting("Soul Sand", true)
val cobweb by setting("Cobweb", true)
private val slime by setting("Slime", true)
private val allItems by setting("All Items", false)
private val food by setting("Food", true, { !allItems })
private val bow by setting("Bows", true, { !allItems })
private val potion by setting("Potions", true, { !allItems })
private val shield by setting("Shield", true, { !allItems })
private val allItems0 = setting("All Items", false)
private val allItems by allItems0
private val food by setting("Food", true, allItems0.atFalse())
private val bow by setting("Bows", true, allItems0.atFalse())
private val potion by setting("Potions", true, allItems0.atFalse())
private val shield by setting("Shield", true, allItems0.atFalse())
/*
* InputUpdateEvent is called just before the player is slowed down @see EntityPlayerSP.onLivingUpdate)

28
src/main/kotlin/org/kamiblue/client/module/modules/movement/Strafe.kt
View File

@ -8,15 +8,12 @@ import org.kamiblue.client.manager.managers.TimerManager.resetTimer
import org.kamiblue.client.mixin.extension.isInWeb
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.BaritoneUtils
import org.kamiblue.client.util.*
import org.kamiblue.client.util.EntityUtils.isInOrAboveLiquid
import org.kamiblue.client.util.MovementUtils
import org.kamiblue.client.util.MovementUtils.applySpeedPotionEffects
import org.kamiblue.client.util.MovementUtils.calcMoveYaw
import org.kamiblue.client.util.MovementUtils.setSpeed
import org.kamiblue.client.util.MovementUtils.speed
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.threads.safeListener
import kotlin.math.cos
import kotlin.math.sin
@ -27,23 +24,24 @@ internal object Strafe : Module(
description = "Improves control in air",
modulePriority = 100
) {
private val mode by setting("Mode", SpeedBoost.NCP)
private val page by setting("Page", Page.GENERIC_SETTINGS)
private val mode0 = setting("Mode", SpeedBoost.NCP)
private val mode by mode0
private val page = setting("Page", Page.GENERIC_SETTINGS)
/* Generic Settings */
private val airSpeedBoost by setting("Air Speed Boost", true, { page == Page.GENERIC_SETTINGS })
private val groundSpeedBoost by setting("Ground Speed Boost", true, { page == Page.GENERIC_SETTINGS })
private val timerBoost by setting("Timer Boost", true, { page == Page.GENERIC_SETTINGS })
private val autoJump by setting("Auto Jump", true, { page == Page.GENERIC_SETTINGS })
private val onHoldingSprint by setting("On Holding Sprint", false, { page == Page.GENERIC_SETTINGS })
private val cancelInertia by setting("Cancel Inertia", false, { page == Page.GENERIC_SETTINGS })
private val airSpeedBoost by setting("Air Speed Boost", true, page.atValue(Page.GENERIC_SETTINGS))
private val groundSpeedBoost by setting("Ground Speed Boost", true, page.atValue(Page.GENERIC_SETTINGS))
private val timerBoost by setting("Timer Boost", true, page.atValue(Page.GENERIC_SETTINGS))
private val autoJump by setting("Auto Jump", true, page.atValue(Page.GENERIC_SETTINGS))
private val onHoldingSprint by setting("On Holding Sprint", false, page.atValue(Page.GENERIC_SETTINGS))
private val cancelInertia by setting("Cancel Inertia", false, page.atValue(Page.GENERIC_SETTINGS))
/* NCP Mode */
private val ncpStrict by setting("NCP Strict", false, { mode == SpeedBoost.NCP && page == Page.MODE_SETTINGS })
private val ncpStrict by setting("NCP Strict", false, page.atValue(Page.MODE_SETTINGS) and mode0.atValue(SpeedBoost.NCP))
/* Custom Mode */
private val settingSpeed by setting("Speed", 0.28, 0.0..1.0, 0.01, { mode == SpeedBoost.CUSTOM && page == Page.MODE_SETTINGS })
private val constantSpeed by setting("Constant Speed", false, { mode == SpeedBoost.CUSTOM && page == Page.MODE_SETTINGS })
private val settingSpeed by setting("Speed", 0.28, 0.0..1.0, 0.01, page.atValue(Page.MODE_SETTINGS) and mode0.atValue(SpeedBoost.CUSTOM))
private val constantSpeed by setting("Constant Speed", false, page.atValue(Page.MODE_SETTINGS) and mode0.atValue(SpeedBoost.CUSTOM))
private enum class SpeedBoost {
NCP, CUSTOM

12
src/main/kotlin/org/kamiblue/client/module/modules/movement/Velocity.kt
View File

@ -12,6 +12,7 @@ import org.kamiblue.client.mixin.extension.packetMotionY
import org.kamiblue.client.mixin.extension.packetMotionZ
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.threads.safeListener
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo
import kotlin.math.absoluteValue
@ -28,11 +29,12 @@ internal object Velocity : Module(
category = Category.MOVEMENT,
description = "Modify player velocity",
) {
private val horizontal by setting("Horizontal", 0f, -5f..5f, 0.05f)
private val vertical by setting("Vertical", 0f, -5f..5f, 0.05f)
private val noPush by setting("No Push", true)
private val entity by setting("Entity", true, { noPush })
private val liquid by setting("Liquid", true, { noPush })
private val horizontal by setting("Horizontal", 0.0f, -5.0f..5.0f, 0.05f)
private val vertical by setting("Vertical", 0.0f, -5.0f..5.0f, 0.05f)
private val noPush0 = setting("No Push", true)
private val noPush by noPush0
private val entity by setting("Entity", true, noPush0.atTrue())
private val liquid by setting("Liquid", true, noPush0.atTrue())
init {
safeListener<PacketEvent.Receive> {

6
src/main/kotlin/org/kamiblue/client/module/modules/player/Blink.kt
View File

@ -11,6 +11,7 @@ import org.kamiblue.client.mixin.extension.y
import org.kamiblue.client.mixin.extension.z
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.threads.runSafe
import org.kamiblue.client.util.threads.safeListener
import org.kamiblue.event.listener.listener
@ -22,8 +23,9 @@ internal object Blink : Module(
description = "Cancels server side packets"
) {
private val cancelPacket by setting("Cancel Packets", false)
private val autoReset by setting("Auto Reset", true)
private val resetThreshold by setting("Reset Threshold", 20, 1..100, 5, { autoReset })
private val autoReset0 = setting("Auto Reset", true)
private val autoReset by autoReset0
private val resetThreshold by setting("Reset Threshold", 20, 1..100, 5, autoReset0.atTrue())
private const val ENTITY_ID = -114514
private val packets = ArrayDeque<CPacketPlayer>()

12
src/main/kotlin/org/kamiblue/client/module/modules/player/BlockInteraction.kt
View File

@ -7,6 +7,8 @@ import org.kamiblue.client.mixin.client.render.MixinEntityRenderer
import org.kamiblue.client.mixin.client.world.MixinBlockLiquid
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.and
import org.kamiblue.client.util.atTrue
/**
* @see MixinBlockLiquid Liquid Interact
@ -21,10 +23,12 @@ internal object BlockInteraction : Module(
) {
private val liquidInteract by setting("Liquid Interact", false, description = "Place block on liquid")
private val multiTask by setting("Multi Task", true, description = "Breaks block and uses item at the same time")
private val noEntityTrace by setting("No Entity Trace", true, description = "Interact with blocks through entity")
private val checkBlocks by setting("Check Blocks", true, { noEntityTrace }, description = "Only ignores entity when there is block behind")
private val checkPickaxe by setting("Check Pickaxe", true, { noEntityTrace }, description = "Only ignores entity when holding pickaxe")
private val sneakOverrides by setting("Sneak Override", true, { noEntityTrace && checkPickaxe }, description = "Overrides pickaxe check if sneaking")
private val noEntityTrace0 = setting("No Entity Trace", true, description = "Interact with blocks through entity")
private val noEntityTrace by noEntityTrace0
private val checkBlocks by setting("Check Blocks", true, noEntityTrace0.atTrue(), description = "Only ignores entity when there is block behind")
private val checkPickaxe0 = setting("Check Pickaxe", true, noEntityTrace0.atTrue(), description = "Only ignores entity when holding pickaxe")
private val checkPickaxe by checkPickaxe0
private val sneakOverrides by setting("Sneak Override", true, noEntityTrace0.atTrue() and checkPickaxe0.atTrue(), description = "Overrides pickaxe check if sneaking")
@JvmStatic
val isLiquidInteractEnabled

10
src/main/kotlin/org/kamiblue/client/module/modules/player/FastBreak.kt
View File

@ -12,6 +12,7 @@ import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.threads.safeListener
import java.util.*
@ -21,10 +22,11 @@ internal object FastBreak : Module(
description = "Breaks block faster and nullifies the break delay"
) {
private val breakDelay by setting("Break Delay", 0, 0..5, 1)
private val packetMine by setting("Packet Mine", true)
private val sneakTrigger by setting("Sneak Trigger", true, { packetMine })
private val morePackets by setting("More Packets", false, { packetMine })
private val spamDelay by setting("Spam Delay", 4, 1..10, 1, { packetMine })
private val packetMine0 = setting("Packet Mine", true)
private val packetMine by packetMine0
private val sneakTrigger by setting("Sneak Trigger", true, packetMine0.atTrue())
private val morePackets by setting("More Packets", false, packetMine0.atTrue())
private val spamDelay by setting("Spam Delay", 4, 1..10, 1, packetMine0.atTrue())
private val spamTimer = TickTimer(TimeUnit.TICKS)
private var miningInfo: Triple<Long, BlockPos, EnumFacing>? = null

15
src/main/kotlin/org/kamiblue/client/module/modules/player/FastUse.kt
View File

@ -12,6 +12,9 @@ import org.kamiblue.client.event.events.PacketEvent
import org.kamiblue.client.mixin.extension.rightClickDelayTimer
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atFalse
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.or
import org.kamiblue.client.util.threads.safeListener
import org.kamiblue.event.listener.listener
@ -26,12 +29,12 @@ internal object FastUse : Module(
private val delay = setting("Delay", 0, 0..10, 1)
private val blocks = setting("Blocks", false)
private val allItems = setting("All Items", false)
private val expBottles = setting("Exp Bottles", true, { !allItems.value })
private val endCrystals = setting("End Crystals", true, { !allItems.value })
private val fireworks = setting("Fireworks", false, { !allItems.value })
private val bow = setting("Bow", true, { !allItems.value })
private val chargeSetting = setting("Bow Charge", 3, 0..20, 1, { allItems.value || bow.value })
private val chargeVariation = setting("Charge Variation", 5, 0..20, 1, { allItems.value || bow.value })
private val expBottles = setting("Exp Bottles", true, allItems.atFalse())
private val endCrystals = setting("End Crystals", true, allItems.atFalse())
private val fireworks = setting("Fireworks", false, allItems.atFalse())
private val bow = setting("Bow", true, allItems.atFalse())
private val chargeSetting = setting("Bow Charge", 3, 0..20, 1, allItems.atTrue() or bow.atTrue())
private val chargeVariation = setting("Charge Variation", 5, 0..20, 1, allItems.atTrue() or bow.atTrue())
private var lastUsedHand = EnumHand.MAIN_HAND
private var randomVariation = 0

5
src/main/kotlin/org/kamiblue/client/module/modules/player/Freecam.kt
View File

@ -46,9 +46,10 @@ internal object Freecam : Module(
category = Category.PLAYER,
description = "Leave your body and transcend into the realm of the gods"
) {
private val directionMode by setting("Flight Mode", FlightMode.CREATIVE)
private val directionMode0 = setting("Flight Mode", FlightMode.CREATIVE)
private val directionMode by directionMode0
private val horizontalSpeed by setting("Horizontal Speed", 20.0f, 1.0f..50.0f, 1f)
private val verticalSpeed by setting("Vertical Speed", 20.0f, 1.0f..50.0f, 1f, { directionMode == FlightMode.CREATIVE })
private val verticalSpeed by setting("Vertical Speed", 20.0f, 1.0f..50.0f, 1f, directionMode0.atValue(FlightMode.CREATIVE))
private val autoRotate by setting("Auto Rotate", true)
private val arrowKeyMove by setting("Arrow Key Move", true)
private val disableOnDisconnect by setting("Disconnect Disable", true)

17
src/main/kotlin/org/kamiblue/client/module/modules/player/InventoryManager.kt
View File

@ -32,14 +32,17 @@ internal object InventoryManager : Module(
"minecraft:cobblestone"
)
private val autoRefill by setting("Auto Refill", true)
private val buildingMode by setting("Building Mode", false, { autoRefill })
private val autoRefill0 = setting("Auto Refill", true)
private val autoRefill by autoRefill0
private val buildingMode by setting("Building Mode", false, autoRefill0.atTrue())
var buildingBlockID by setting("Building Block ID", 0, 0..1000, 1, { false })
private val refillThreshold by setting("Refill Threshold", 16, 1..63, 1, { autoRefill })
private val itemSaver by setting("Item Saver", false)
private val duraThreshold by setting("Durability Threshold", 5, 1..50, 1, { itemSaver })
private val autoEject by setting("Auto Eject", false)
private val fullOnly by setting("Only At Full", false, { autoEject })
private val refillThreshold by setting("Refill Threshold", 16, 1..63, 1, autoRefill0.atTrue())
private val itemSaver0 = setting("Item Saver", false)
private val itemSaver by itemSaver0
private val duraThreshold by setting("Durability Threshold", 5, 1..50, 1, itemSaver0.atTrue())
private val autoEject0 = setting("Auto Eject", false)
private val autoEject by autoEject0
private val fullOnly by setting("Only At Full", false, autoEject0.atTrue())
private val pauseMovement by setting("Pause Movement", true)
private val delay by setting("Delay Ticks", 1, 0..20, 1)
val ejectList = setting(CollectionSetting("Eject List", defaultEjectList))

5
src/main/kotlin/org/kamiblue/client/module/modules/player/LagNotifier.kt
View File

@ -30,10 +30,11 @@ internal object LagNotifier : Module(
category = Category.PLAYER
) {
private val detectRubberBand by setting("Detect Rubber Band", true)
private val pauseBaritone by setting("Pause Baritone", true)
private val pauseBaritone0 = setting("Pause Baritone", true)
private val pauseBaritone by pauseBaritone0
val pauseTakeoff by setting("Pause Elytra Takeoff", true)
val pauseAutoWalk by setting("Pause Auto Walk", true)
private val feedback by setting("Pause Feedback", true, { pauseBaritone })
private val feedback by setting("Pause Feedback", true, pauseBaritone0.atTrue())
private val timeout by setting("Timeout", 3.5f, 0.0f..10.0f, 0.5f)
private val pingTimer = TickTimer(TimeUnit.SECONDS)

7
src/main/kotlin/org/kamiblue/client/module/modules/player/NoFall.kt
View File

@ -18,6 +18,7 @@ import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils
import org.kamiblue.client.util.WorldUtils.getGroundPos
import org.kamiblue.client.util.atValue
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.threads.safeListener
@ -28,9 +29,9 @@ internal object NoFall : Module(
) {
private val distance = setting("Distance", 3, 1..10, 1)
private val mode = setting("Mode", Mode.CATCH)
private val fallModeSetting = setting("Fall", FallMode.PACKET, { mode.value == Mode.FALL })
private val catchModeSetting = setting("Catch", CatchMode.MOTION, { mode.value == Mode.CATCH })
private val voidOnly = setting("Void Only", false, { mode.value == Mode.CATCH })
private val fallModeSetting = setting("Fall", FallMode.PACKET, mode.atValue(Mode.FALL))
private val catchModeSetting = setting("Catch", CatchMode.MOTION, mode.atValue(Mode.CATCH))
private val voidOnly = setting("Void Only", false, mode.atValue(Mode.CATCH))
private enum class Mode {
FALL, CATCH

14
src/main/kotlin/org/kamiblue/client/module/modules/player/PacketCancel.kt
View File

@ -4,6 +4,7 @@ import net.minecraft.network.play.client.*
import org.kamiblue.client.event.events.PacketEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atFalse
import org.kamiblue.event.listener.listener
internal object PacketCancel : Module(
@ -11,12 +12,13 @@ internal object PacketCancel : Module(
description = "Cancels specific packets used for various actions",
category = Category.PLAYER
) {
private val all by setting("All", false)
private val packetInput by setting("CPacket Input", true, { !all })
private val packetPlayer by setting("CPacket Player", true, { !all })
private val packetEntityAction by setting("CPacket Entity Action", true, { !all })
private val packetUseEntity by setting("CPacket Use Entity", true, { !all })
private val packetVehicleMove by setting("CPacket Vehicle Move", true, { !all })
private val all0 = setting("All", false)
private val all by all0
private val packetInput by setting("CPacket Input", true, all0.atFalse())
private val packetPlayer by setting("CPacket Player", true, all0.atFalse())
private val packetEntityAction by setting("CPacket Entity Action", true, all0.atFalse())
private val packetUseEntity by setting("CPacket Use Entity", true, all0.atFalse())
private val packetVehicleMove by setting("CPacket Vehicle Move", true, all0.atFalse())
private var numPackets = 0

9
src/main/kotlin/org/kamiblue/client/module/modules/player/Timer.kt
View File

@ -5,6 +5,8 @@ import org.kamiblue.client.manager.managers.TimerManager.modifyTimer
import org.kamiblue.client.manager.managers.TimerManager.resetTimer
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atFalse
import org.kamiblue.client.util.atTrue
import org.kamiblue.event.listener.listener
internal object Timer : Module(
@ -13,9 +15,10 @@ internal object Timer : Module(
description = "Changes your client tick speed",
modulePriority = 500
) {
private val slow by setting("Slow Mode", false)
private val tickNormal by setting("Tick N", 2.0f, 1f..10f, 0.1f, { !slow })
private val tickSlow by setting("Tick S", 8f, 1f..10f, 0.1f, { slow })
private val slow0 = setting("Slow Mode", false)
private val slow by slow0
private val tickNormal by setting("Tick N", 2.0f, 1f..10f, 0.1f, slow0.atFalse())
private val tickSlow by setting("Tick S", 8f, 1f..10f, 0.1f, slow0.atTrue())
init {
onDisable {

28
src/main/kotlin/org/kamiblue/client/module/modules/player/ViewLock.kt
View File

@ -5,6 +5,10 @@ import net.minecraft.entity.Entity
import net.minecraftforge.fml.common.gameevent.TickEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.and
import org.kamiblue.client.util.atFalse
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.atValue
import org.kamiblue.client.util.threads.safeListener
import org.spongepowered.asm.mixin.injection.callback.CallbackInfo
import java.util.*
@ -20,19 +24,21 @@ internal object ViewLock : Module(
category = Category.PLAYER,
description = "Locks your camera view"
) {
private val page by setting("Page", Page.YAW)
private val page = setting("Page", Page.YAW)
private val yaw by setting("Yaw", true, { page == Page.YAW })
private val autoYaw = setting("Auto Yaw", true, { page == Page.YAW && yaw })
private val disableMouseYaw by setting("Disable Mouse Yaw", false, { page == Page.YAW && yaw && yaw })
private val specificYaw by setting("Specific Yaw", 180.0f, -180.0f..180.0f, 1.0f, { page == Page.YAW && !autoYaw.value && yaw })
private val yawSlice = setting("Yaw Slice", 8, 2..32, 1, { page == Page.YAW && autoYaw.value && yaw })
private val yaw0 = setting("Yaw", true, page.atValue(Page.YAW))
private val yaw by yaw0
private val autoYaw = setting("Auto Yaw", true, page.atValue(Page.YAW) and yaw0.atTrue())
private val disableMouseYaw by setting("Disable Mouse Yaw", false, page.atValue(Page.YAW) and yaw0.atTrue())
private val specificYaw by setting("Specific Yaw", 180.0f, -180.0f..180.0f, 1.0f, page.atValue(Page.YAW) and yaw0.atTrue() and autoYaw.atFalse())
private val yawSlice = setting("Yaw Slice", 8, 2..32, 1, page.atValue(Page.YAW) and yaw0.atTrue() and autoYaw.atTrue())
private val pitch by setting("Pitch", true, { page == Page.PITCH })
private val autoPitch = setting("Auto Pitch", true, { page == Page.PITCH && pitch })
private val disableMousePitch by setting("Disable Mouse Pitch", false, { page == Page.PITCH && pitch && pitch })
private val specificPitch by setting("Specific Pitch", 0.0f, -90.0f..90.0f, 1.0f, { page == Page.PITCH && !autoPitch.value && pitch })
private val pitchSlice = setting("Pitch Slice", 5, 2..32, 1, { page == Page.PITCH && autoPitch.value && pitch })
private val pitch0 = setting("Pitch", true, page.atValue(Page.PITCH))
private val pitch by pitch0
private val autoPitch = setting("Auto Pitch", true, page.atValue(Page.YAW) and pitch0.atTrue())
private val disableMousePitch by setting("Disable Mouse Pitch", false, page.atValue(Page.YAW) and pitch0.atTrue())
private val specificPitch by setting("Specific Pitch", 0.0f, -90.0f..90.0f, 1.0f, page.atValue(Page.YAW) and pitch0.atTrue() and autoPitch.atFalse())
private val pitchSlice = setting("Pitch Slice", 5, 2..32, 1, page.atValue(Page.YAW) and pitch0.atTrue() and autoPitch.atTrue())
private enum class Page {
YAW, PITCH

7
src/main/kotlin/org/kamiblue/client/module/modules/render/BreakingESP.kt
View File

@ -12,6 +12,7 @@ import org.kamiblue.client.event.events.RenderOverlayEvent
import org.kamiblue.client.event.events.RenderWorldEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.graphics.ESPRenderer
import org.kamiblue.client.util.graphics.font.FontRenderAdapter
@ -40,9 +41,9 @@ internal object BreakingESP : Module(
private val r = setting("Red", 255, 0..255, 1)
private val g = setting("Green", 255, 0..255, 1)
private val b = setting("Blue", 255, 0..255, 1)
private val aFilled = setting("Filled Alpha", 31, 0..255, 1, { filled.value })
private val aOutline = setting("Outline Alpha", 200, 0..255, 1, { outline.value })
private val aTracer = setting("Tracer Alpha", 255, 0..255, 1, { outline.value })
private val aFilled = setting("Filled Alpha", 31, 0..255, 1, filled.atTrue())
private val aOutline = setting("Outline Alpha", 200, 0..255, 1, outline.atTrue())
private val aTracer = setting("Tracer Alpha", 255, 0..255, 1, tracer.atTrue())
private val thickness = setting("Line Thickness", 2.0f, 0.25f..5.0f, 0.25f)
private val breakingBlockList = LinkedHashMap<Int, Triple<BlockPos, Int, Pair<Boolean, Boolean>>>() /* <BreakerID, <Position, Progress, <Warned, Render>> */

53
src/main/kotlin/org/kamiblue/client/module/modules/render/Chams.kt
View File

@ -13,7 +13,7 @@ import org.kamiblue.client.event.Phase
import org.kamiblue.client.event.events.RenderEntityEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils
import org.kamiblue.client.util.*
import org.kamiblue.client.util.EntityUtils.mobTypeSettings
import org.kamiblue.client.util.color.HueCycler
import org.kamiblue.client.util.graphics.GlStateUtils
@ -26,34 +26,37 @@ internal object Chams : Module(
category = Category.RENDER,
description = "Modify entity rendering"
) {
private val page by setting("Page", Page.ENTITY_TYPE)
private val page = setting("Page", Page.ENTITY_TYPE)
/* Entity type settings */
private val self by setting("Self", false, { page == Page.ENTITY_TYPE })
private val all by setting("All Entities", false, { page == Page.ENTITY_TYPE })
private val experience by setting("Experience", false, { page == Page.ENTITY_TYPE && !all })
private val arrows by setting("Arrows", false, { page == Page.ENTITY_TYPE && !all })
private val throwable by setting("Throwable", false, { page == Page.ENTITY_TYPE && !all })
private val items by setting("Items", false, { page == Page.ENTITY_TYPE && !all })
private val crystals by setting("Crystals", false, { page == Page.ENTITY_TYPE && !all })
private val players by setting("Players", true, { page == Page.ENTITY_TYPE && !all })
private val friends by setting("Friends", false, { page == Page.ENTITY_TYPE && !all && players })
private val sleeping by setting("Sleeping", false, { page == Page.ENTITY_TYPE && !all && players })
private val mobs by setting("Mobs", true, { page == Page.ENTITY_TYPE && !all })
private val passive by setting("Passive Mobs", false, { page == Page.ENTITY_TYPE && !all && mobs })
private val neutral by setting("Neutral Mobs", true, { page == Page.ENTITY_TYPE && !all && mobs })
private val hostile by setting("Hostile Mobs", true, { page == Page.ENTITY_TYPE && !all && mobs })
private val self by setting("Self", false, page.atValue(Page.ENTITY_TYPE))
private val all0 = setting("All Entities", false, page.atValue(Page.ENTITY_TYPE))
private val all by all0
private val experience by setting("Experience", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val arrows by setting("Arrows", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val throwable by setting("Throwable", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val items by setting("Items", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val crystals by setting("Crystals", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val players by setting("Players", true, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val friends by setting("Friends", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val sleeping by setting("Sleeping", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val mobs by setting("Mobs", true, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val passive by setting("Passive Mobs", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val neutral by setting("Neutral Mobs", true, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val hostile by setting("Hostile Mobs", true, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
/* Rendering settings */
private val throughWall by setting("Through Wall", true, { page == Page.RENDERING })
private val texture by setting("Texture", false, { page == Page.RENDERING })
private val lightning by setting("Lightning", false, { page == Page.RENDERING })
private val customColor by setting("Custom Color", false, { page == Page.RENDERING })
private val rainbow by setting("Rainbow", false, { page == Page.RENDERING && customColor })
private val r by setting("Red", 255, 0..255, 1, { page == Page.RENDERING && customColor && !rainbow })
private val g by setting("Green", 255, 0..255, 1, { page == Page.RENDERING && customColor && !rainbow })
private val b by setting("Blue", 255, 0..255, 1, { page == Page.RENDERING && customColor && !rainbow })
private val a by setting("Alpha", 160, 0..255, 1, { page == Page.RENDERING && customColor })
private val throughWall by setting("Through Wall", true, page.atValue(Page.RENDERING))
private val texture by setting("Texture", false, page.atValue(Page.RENDERING))
private val lightning by setting("Lightning", false, page.atValue(Page.RENDERING))
private val customColor0 = setting("Custom Color", false, page.atValue(Page.RENDERING))
private val customColor by customColor0
private val rainbow0 = setting("Rainbow", false, page.atValue(Page.RENDERING) and customColor0.atTrue())
private val rainbow by rainbow0
private val r by setting("Red", 255, 0..255, 1, page.atValue(Page.RENDERING) and customColor0.atTrue() and rainbow0.atFalse())
private val g by setting("Green", 255, 0..255, 1, page.atValue(Page.RENDERING) and customColor0.atTrue() and rainbow0.atFalse())
private val b by setting("Blue", 255, 0..255, 1, page.atValue(Page.RENDERING) and customColor0.atTrue() and rainbow0.atFalse())
private val a by setting("Alpha", 160, 0..255, 1, page.atValue(Page.RENDERING) and customColor0.atTrue())
private enum class Page {
ENTITY_TYPE, RENDERING

69
src/main/kotlin/org/kamiblue/client/module/modules/render/ESP.kt
View File

@ -17,7 +17,7 @@ import org.kamiblue.client.event.events.RenderWorldEvent
import org.kamiblue.client.mixin.extension.*
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils
import org.kamiblue.client.util.*
import org.kamiblue.client.util.EntityUtils.getTargetList
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.graphics.ESPRenderer
@ -35,42 +35,45 @@ internal object ESP : Module(
category = Category.RENDER,
description = "Highlights entities"
) {
private val page by setting("Page", Page.ENTITY_TYPE)
private val page = setting("Page", Page.ENTITY_TYPE)
/* Entity type settings */
private val all by setting("All Entities", false, { page == Page.ENTITY_TYPE })
private val experience by setting("Experience", false, { page == Page.ENTITY_TYPE && !all })
private val arrows by setting("Arrows", false, { page == Page.ENTITY_TYPE && !all })
private val throwable by setting("Throwable", false, { page == Page.ENTITY_TYPE && !all })
private val items by setting("Items", true, { page == Page.ENTITY_TYPE && !all })
private val players by setting("Players", true, { page == Page.ENTITY_TYPE && !all })
private val friends by setting("Friends", false, { page == Page.ENTITY_TYPE && !all && players })
private val sleeping by setting("Sleeping", false, { page == Page.ENTITY_TYPE && !all && players })
private val mobs by setting("Mobs", true, { page == Page.ENTITY_TYPE && !all })
private val passive by setting("Passive Mobs", false, { page == Page.ENTITY_TYPE && !all && mobs })
private val neutral by setting("Neutral Mobs", true, { page == Page.ENTITY_TYPE && !all && mobs })
private val hostile by setting("Hostile Mobs", true, { page == Page.ENTITY_TYPE && !all && mobs })
private val invisible by setting("Invisible", true, { page == Page.ENTITY_TYPE && !all })
private val range by setting("Range", 32.0f, 8.0f..64.0f, 0.5f, { page == Page.ENTITY_TYPE })
private val all0 = setting("All Entities", false, page.atValue(Page.ENTITY_TYPE))
private val all by all0
private val experience by setting("Experience", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val arrows by setting("Arrows", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val throwable by setting("Throwable", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val items by setting("Items", true, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val players0 = setting("Players", true, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val players by players0
private val friends by setting("Friends", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse() and players0.atTrue())
private val sleeping by setting("Sleeping", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse() and players0.atTrue())
private val mobs0 = setting("Mobs", true, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val mobs by mobs0
private val passive by setting("Passive Mobs", false, page.atValue(Page.ENTITY_TYPE) and all0.atFalse() and mobs0.atTrue())
private val neutral by setting("Neutral Mobs", true, page.atValue(Page.ENTITY_TYPE) and all0.atFalse() and mobs0.atTrue())
private val hostile by setting("Hostile Mobs", true, page.atValue(Page.ENTITY_TYPE) and all0.atFalse() and mobs0.atTrue())
private val invisible by setting("Invisible", true, page.atValue(Page.ENTITY_TYPE) and all0.atFalse())
private val range by setting("Range", 32.0f, 8.0f..64.0f, 0.5f, page.atValue(Page.ENTITY_TYPE))
/* Rendering settings */
private val mode = setting("Mode", ESPMode.SHADER, { page == Page.RENDERING })
private val hideOriginal by setting("Hide Original", false, { page == Page.RENDERING && mode.value == ESPMode.SHADER })
private val filled by setting("Filled", false, { page == Page.RENDERING && (mode.value == ESPMode.BOX || mode.value == ESPMode.SHADER) })
private val outline by setting("Outline", true, { page == Page.RENDERING && (mode.value == ESPMode.BOX || mode.value == ESPMode.SHADER) })
private val r by setting("Red", 155, 0..255, 1, { page == Page.RENDERING && (mode.value == ESPMode.BOX || mode.value == ESPMode.SHADER) })
private val g by setting("Green", 144, 0..255, 1, { page == Page.RENDERING && (mode.value == ESPMode.BOX || mode.value == ESPMode.SHADER) })
private val b by setting("Blue", 255, 0..255, 1, { page == Page.RENDERING && (mode.value == ESPMode.BOX || mode.value == ESPMode.SHADER) })
private val aFilled by setting("Filled Alpha", 63, 0..255, 1, { page == Page.RENDERING && (mode.value == ESPMode.BOX || mode.value == ESPMode.SHADER) })
private val aOutline by setting("Outline Alpha", 255, 0..255, 1, { page == Page.RENDERING && (mode.value == ESPMode.BOX || mode.value == ESPMode.SHADER) })
private val blurRadius by setting("Blur Radius", 0f, 0f..16f, 0.5f, { page == Page.RENDERING && mode.value == ESPMode.SHADER })
private val width by setting("Width", 2f, 1f..8f, 0.25f, { page == Page.RENDERING })
private val mode = setting("Mode", Mode.SHADER, page.atValue(Page.RENDERING))
private val hideOriginal by setting("Hide Original", false, page.atValue(Page.RENDERING) and mode.atValue(Mode.SHADER))
private val filled by setting("Filled", false, page.atValue(Page.RENDERING) and mode.atValue(Mode.BOX, Mode.SHADER))
private val outline by setting("Outline", true, page.atValue(Page.RENDERING) and mode.atValue(Mode.BOX, Mode.SHADER))
private val r by setting("Red", 155, 0..255, 1, page.atValue(Page.RENDERING) and mode.atValue(Mode.BOX, Mode.SHADER))
private val g by setting("Green", 144, 0..255, 1, page.atValue(Page.RENDERING) and mode.atValue(Mode.BOX, Mode.SHADER))
private val b by setting("Blue", 255, 0..255, 1, page.atValue(Page.RENDERING) and mode.atValue(Mode.BOX, Mode.SHADER))
private val aFilled by setting("Filled Alpha", 63, 0..255, 1, page.atValue(Page.RENDERING) and mode.atValue(Mode.BOX, Mode.SHADER))
private val aOutline by setting("Outline Alpha", 255, 0..255, 1, page.atValue(Page.RENDERING) and mode.atValue(Mode.BOX, Mode.SHADER))
private val blurRadius by setting("Blur Radius", 0f, 0f..16f, 0.5f, page.atValue(Page.RENDERING) and mode.atValue(Mode.SHADER))
private val width by setting("Width", 2f, 1f..8f, 0.25f, page.atValue(Page.RENDERING))
private enum class Page {
ENTITY_TYPE, RENDERING
}
private enum class ESPMode {
private enum class Mode {
BOX, GLOW, SHADER
}
@ -82,7 +85,7 @@ internal object ESP : Module(
init {
listener<RenderEntityEvent.All> {
if (it.phase == Phase.PRE
&& mode.value == ESPMode.SHADER
&& mode.value == Mode.SHADER
&& !mc.renderManager.renderOutlines
&& hideOriginal
&& entityList.contains(it.entity)) {
@ -98,7 +101,7 @@ internal object ESP : Module(
safeListener<RenderWorldEvent>(69420) {
when (mode.value) {
ESPMode.BOX -> {
Mode.BOX -> {
val color = ColorHolder(r, g, b)
val renderer = ESPRenderer()
renderer.aFilled = if (filled) aFilled else 0
@ -109,7 +112,7 @@ internal object ESP : Module(
}
renderer.render(true)
}
ESPMode.SHADER -> {
Mode.SHADER -> {
drawEntities()
drawShader()
}
@ -184,7 +187,7 @@ internal object ESP : Module(
entityList.addAll(getEntityList())
when (mode.value) {
ESPMode.GLOW -> {
Mode.GLOW -> {
if (entityList.isNotEmpty()) {
for (shader in mc.renderGlobal.entityOutlineShader.listShaders) {
shader.shaderManager.getShaderUniform("Radius")?.set(width)
@ -197,7 +200,7 @@ internal object ESP : Module(
resetGlow()
}
}
ESPMode.SHADER -> {
Mode.SHADER -> {
shaderHelper.shader?.let {
for (shader in it.listShaders) {
setShaderSettings(shader)

31
src/main/kotlin/org/kamiblue/client/module/modules/render/EyeFinder.kt
View File

@ -11,6 +11,9 @@ import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils.getInterpolatedAmount
import org.kamiblue.client.util.EntityUtils.getTargetList
import org.kamiblue.client.util.and
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.atValue
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.graphics.ESPRenderer
import org.kamiblue.client.util.graphics.KamiTessellator
@ -27,22 +30,22 @@ internal object EyeFinder : Module(
private val page = setting("Page", Page.ENTITY_TYPE)
/* Entity type settings */
private val players = setting("Players", true, { page.value == Page.ENTITY_TYPE })
private val friends = setting("Friends", false, { page.value == Page.ENTITY_TYPE && players.value })
private val sleeping = setting("Sleeping", false, { page.value == Page.ENTITY_TYPE && players.value })
private val mobs = setting("Mobs", true, { page.value == Page.ENTITY_TYPE })
private val passive = setting("Passive Mobs", false, { page.value == Page.ENTITY_TYPE && mobs.value })
private val neutral = setting("Neutral Mobs", true, { page.value == Page.ENTITY_TYPE && mobs.value })
private val hostile = setting("Hostile Mobs", true, { page.value == Page.ENTITY_TYPE && mobs.value })
private val invisible = setting("Invisible", true, { page.value == Page.ENTITY_TYPE })
private val range = setting("Range", 64, 8..128, 8, { page.value == Page.ENTITY_TYPE })
private val players = setting("Players", true, page.atValue(Page.ENTITY_TYPE))
private val friends = setting("Friends", false, page.atValue(Page.RENDERING) and players.atTrue())
private val sleeping = setting("Sleeping", false, page.atValue(Page.RENDERING) and players.atTrue())
private val mobs = setting("Mobs", true, page.atValue(Page.ENTITY_TYPE))
private val passive = setting("Passive Mobs", false, page.atValue(Page.RENDERING) and mobs.atTrue())
private val neutral = setting("Neutral Mobs", true, page.atValue(Page.RENDERING) and mobs.atTrue())
private val hostile = setting("Hostile Mobs", true, page.atValue(Page.RENDERING) and mobs.atTrue())
private val invisible = setting("Invisible", true, page.atValue(Page.ENTITY_TYPE))
private val range = setting("Range", 64, 8..128, 8, page.atValue(Page.ENTITY_TYPE))
/* Rendering settings */
private val r = setting("Red", 155, 0..255, 1, { page.value == Page.RENDERING })
private val g = setting("Green", 144, 0..255, 1, { page.value == Page.RENDERING })
private val b = setting("Blue", 255, 0..255, 1, { page.value == Page.RENDERING })
private val a = setting("Alpha", 200, 0..255, 1, { page.value == Page.RENDERING })
private val thickness = setting("Thickness", 2.0f, 0.25f..5.0f, 0.25f, { page.value == Page.RENDERING })
private val r = setting("Red", 155, 0..255, 1, page.atValue(Page.RENDERING))
private val g = setting("Green", 144, 0..255, 1, page.atValue(Page.RENDERING))
private val b = setting("Blue", 255, 0..255, 1, page.atValue(Page.RENDERING))
private val a = setting("Alpha", 200, 0..255, 1, page.atValue(Page.RENDERING))
private val thickness = setting("Thickness", 2.0f, 0.25f..5.0f, 0.25f, page.atValue(Page.RENDERING))
private enum class Page {

3
src/main/kotlin/org/kamiblue/client/module/modules/render/FullBright.kt
View File

@ -3,6 +3,7 @@ package org.kamiblue.client.module.modules.render
import net.minecraftforge.fml.common.gameevent.TickEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.BOOLEAN_SUPPLIER_FALSE
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.threads.safeListener
import kotlin.math.max
@ -16,7 +17,7 @@ internal object FullBright : Module(
) {
private val gamma by setting("Gamma", 12.0f, 5.0f..15.0f, 0.5f)
private val transitionLength by setting("Transition Length", 3.0f, 0.0f..10.0f, 0.5f)
private var oldValue by setting("Old Value", 1.0f, 0.0f..1.0f, 0.1f, { false })
private var oldValue by setting("Old Value", 1.0f, 0.0f..1.0f, 0.1f, BOOLEAN_SUPPLIER_FALSE)
private var gammaSetting: Float
get() = mc.gameSettings.gammaSetting

35
src/main/kotlin/org/kamiblue/client/module/modules/render/ItemModel.kt
View File

@ -7,6 +7,8 @@ import net.minecraft.util.EnumHand
import net.minecraft.util.EnumHandSide
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.and
import org.kamiblue.client.util.atValue
internal object ItemModel : Module(
name = "ItemModel",
@ -14,25 +16,26 @@ internal object ItemModel : Module(
description = "Modify hand item rendering in first person",
category = Category.RENDER
) {
private val mode by setting("Mode", Mode.BOTH)
private val page by setting("Page", Page.POSITION)
private val mode0 = setting("Mode", Mode.BOTH)
private val mode by mode0
private val page = setting("Page", Page.POSITION)
private val posX by setting("Pos X", 0.0f, -5.0f..5.0f, 0.025f, { page == Page.POSITION })
private val posY by setting("Pos Y", 0.0f, -5.0f..5.0f, 0.025f, { page == Page.POSITION })
private val posZ by setting("Pos Z", 0.0f, -5.0f..5.0f, 0.025f, { page == Page.POSITION })
private val posXR by setting("Pos X Right", 0.0f, -5.0f..5.0f, 0.025f, { page == Page.POSITION && mode == Mode.SEPARATE })
private val posYR by setting("Pos Y Right", 0.0f, -5.0f..5.0f, 0.025f, { page == Page.POSITION && mode == Mode.SEPARATE })
private val posZR by setting("Pos Z Right", 0.0f, -5.0f..5.0f, 0.025f, { page == Page.POSITION && mode == Mode.SEPARATE })
private val posX by setting("Pos X", 0.0f, -5.0f..5.0f, 0.025f, page.atValue(Page.POSITION))
private val posY by setting("Pos Y", 0.0f, -5.0f..5.0f, 0.025f, page.atValue(Page.POSITION))
private val posZ by setting("Pos Z", 0.0f, -5.0f..5.0f, 0.025f, page.atValue(Page.POSITION))
private val posXR by setting("Pos X Right", 0.0f, -5.0f..5.0f, 0.025f, page.atValue(Page.POSITION) and mode0.atValue(Mode.SEPARATE))
private val posYR by setting("Pos Y Right", 0.0f, -5.0f..5.0f, 0.025f, page.atValue(Page.POSITION) and mode0.atValue(Mode.SEPARATE))
private val posZR by setting("Pos Z Right", 0.0f, -5.0f..5.0f, 0.025f, page.atValue(Page.POSITION) and mode0.atValue(Mode.SEPARATE))
private val rotateX by setting("Rotate X", 0.0f, -180.0f..180.0f, 1.0f, { page == Page.ROTATION })
private val rotateY by setting("Rotate Y", 0.0f, -180.0f..180.0f, 1.0f, { page == Page.ROTATION })
private val rotateZ by setting("Rotate Z", 0.0f, -180.0f..180.0f, 1.0f, { page == Page.ROTATION })
private val rotateXR by setting("Rotate X Right", 0.0f, -180.0f..180.0f, 1.0f, { page == Page.ROTATION && mode == Mode.SEPARATE })
private val rotateYR by setting("Rotate Y Right", 0.0f, -180.0f..180.0f, 1.0f, { page == Page.ROTATION && mode == Mode.SEPARATE })
private val rotateZR by setting("Rotate Z Right", 0.0f, -180.0f..180.0f, 1.0f, { page == Page.ROTATION && mode == Mode.SEPARATE })
private val rotateX by setting("Rotate X", 0.0f, -180.0f..180.0f, 1.0f, page.atValue(Page.ROTATION))
private val rotateY by setting("Rotate Y", 0.0f, -180.0f..180.0f, 1.0f, page.atValue(Page.ROTATION))
private val rotateZ by setting("Rotate Z", 0.0f, -180.0f..180.0f, 1.0f, page.atValue(Page.ROTATION))
private val rotateXR by setting("Rotate X Right", 0.0f, -180.0f..180.0f, 1.0f, page.atValue(Page.ROTATION) and mode0.atValue(Mode.SEPARATE))
private val rotateYR by setting("Rotate Y Right", 0.0f, -180.0f..180.0f, 1.0f, page.atValue(Page.ROTATION) and mode0.atValue(Mode.SEPARATE))
private val rotateZR by setting("Rotate Z Right", 0.0f, -180.0f..180.0f, 1.0f, page.atValue(Page.ROTATION) and mode0.atValue(Mode.SEPARATE))
private val scale by setting("Scale", 1.0f, 0.1f..3.0f, 0.025f, { page == Page.SCALE })
private val scaleR by setting("Scale Right", 1.0f, 0.1f..3.0f, 0.025f, { page == Page.SCALE && mode == Mode.SEPARATE })
private val scale by setting("Scale", 1.0f, 0.1f..3.0f, 0.025f, page.atValue(Page.SCALE))
private val scaleR by setting("Scale Right", 1.0f, 0.1f..3.0f, 0.025f, page.atValue(Page.SCALE) and mode0.atValue(Mode.SEPARATE))
private val modifyHand by setting("Modify Hand", false)

105
src/main/kotlin/org/kamiblue/client/module/modules/render/Nametags.kt
View File

@ -15,8 +15,7 @@ import net.minecraftforge.fml.common.gameevent.TickEvent
import org.kamiblue.client.event.events.RenderOverlayEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EnchantmentUtils
import org.kamiblue.client.util.EntityUtils
import org.kamiblue.client.util.*
import org.kamiblue.client.util.color.ColorGradient
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.graphics.*
@ -45,65 +44,65 @@ internal object Nametags : Module(
private val page = setting("Page", Page.ENTITY_TYPE)
/* Entity type settings */
private val self = setting("Self", false, { page.value == Page.ENTITY_TYPE })
private val experience = setting("Experience", false, { page.value == Page.ENTITY_TYPE })
private val items = setting("Items", true, { page.value == Page.ENTITY_TYPE })
private val players = setting("Players", true, { page.value == Page.ENTITY_TYPE })
private val mobs = setting("Mobs", true, { page.value == Page.ENTITY_TYPE })
private val passive = setting("Passive Mobs", false, { page.value == Page.ENTITY_TYPE && mobs.value })
private val neutral = setting("Neutral Mobs", true, { page.value == Page.ENTITY_TYPE && mobs.value })
private val hostile = setting("Hostile Mobs", true, { page.value == Page.ENTITY_TYPE && mobs.value })
private val invisible = setting("Invisible", true, { page.value == Page.ENTITY_TYPE })
private val range = setting("Range", 64, 0..128, 4, { page.value == Page.ENTITY_TYPE })
private val self = setting("Self", false, page.atValue(Page.ENTITY_TYPE))
private val experience = setting("Experience", false, page.atValue(Page.ENTITY_TYPE))
private val items = setting("Items", true, page.atValue(Page.ENTITY_TYPE))
private val players = setting("Players", true, page.atValue(Page.ENTITY_TYPE))
private val mobs = setting("Mobs", true, page.atValue(Page.ENTITY_TYPE))
private val passive = setting("Passive Mobs", false, page.atValue(Page.ENTITY_TYPE) and mobs.atTrue())
private val neutral = setting("Neutral Mobs", true, page.atValue(Page.ENTITY_TYPE) and mobs.atTrue())
private val hostile = setting("Hostile Mobs", true, page.atValue(Page.ENTITY_TYPE) and mobs.atTrue())
private val invisible = setting("Invisible", true, page.atValue(Page.ENTITY_TYPE))
private val range = setting("Range", 64, 0..128, 4, page.atValue(Page.ENTITY_TYPE))
/* Content */
private val line1left = setting("Line 1 Left", ContentType.NONE, { page.value == Page.CONTENT })
private val line1center = setting("Line 1 Center", ContentType.NONE, { page.value == Page.CONTENT })
private val line1right = setting("Line 1 Right", ContentType.NONE, { page.value == Page.CONTENT })
private val line2left = setting("Line 2 Left", ContentType.NAME, { page.value == Page.CONTENT })
private val line2center = setting("Line 2 Center", ContentType.PING, { page.value == Page.CONTENT })
private val line2right = setting("Line 2 Right", ContentType.TOTAL_HP, { page.value == Page.CONTENT })
private val dropItemCount = setting("Drop Item Count", true, { page.value == Page.CONTENT && items.value })
private val maxDropItems = setting("Max Drop Items", 5, 2..16, 1, { page.value == Page.CONTENT && items.value })
private val line1left = setting("Line 1 Left", ContentType.NONE, page.atValue(Page.CONTENT))
private val line1center = setting("Line 1 Center", ContentType.NONE, page.atValue(Page.CONTENT))
private val line1right = setting("Line 1 Right", ContentType.NONE, page.atValue(Page.CONTENT))
private val line2left = setting("Line 2 Left", ContentType.NAME, page.atValue(Page.CONTENT))
private val line2center = setting("Line 2 Center", ContentType.PING, page.atValue(Page.CONTENT))
private val line2right = setting("Line 2 Right", ContentType.TOTAL_HP, page.atValue(Page.CONTENT))
private val dropItemCount = setting("Drop Item Count", true, page.atValue(Page.CONTENT) and items.atTrue())
private val maxDropItems = setting("Max Drop Items", 5, 2..16, 1, page.atValue(Page.CONTENT) and items.atTrue())
/* Item */
private val mainHand = setting("Main Hand", true, { page.value == Page.ITEM })
private val offhand = setting("Off Hand", true, { page.value == Page.ITEM })
private val invertHand = setting("Invert Hand", false, { page.value == Page.ITEM && (mainHand.value || offhand.value) })
private val armor = setting("Armor", true, { page.value == Page.ITEM })
private val count = setting("Count", true, { page.value == Page.ITEM && (mainHand.value || offhand.value || armor.value) })
private val dura = setting("Dura", true, { page.value == Page.ITEM && (mainHand.value || offhand.value || armor.value) })
private val enchantment = setting("Enchantment", true, { page.value == Page.ITEM && (mainHand.value || offhand.value || armor.value) })
private val itemScale = setting("Item Scale", 1f, 0.25f..2f, 0.25f, { page.value == Page.ITEM })
private val mainHand = setting("Main Hand", true, page.atValue(Page.ITEM))
private val offhand = setting("Off Hand", true, page.atValue(Page.ITEM))
private val invertHand = setting("Invert Hand", false, page.atValue(Page.ITEM) and (mainHand.atTrue() or offhand.atTrue()))
private val armor = setting("Armor", true, page.atValue(Page.ITEM))
private val count = setting("Count", true, page.atValue(Page.ITEM) and (mainHand.atTrue() or offhand.atTrue() or armor.atTrue()))
private val dura = setting("Dura", true, page.atValue(Page.ITEM) and (mainHand.atTrue() or offhand.atTrue() or armor.atTrue()))
private val enchantment = setting("Enchantment", true, page.atValue(Page.ITEM) and (mainHand.atTrue() or offhand.atTrue() or armor.atTrue()))
private val itemScale = setting("Item Scale", 1f, 0.25f..2f, 0.25f, page.atValue(Page.ITEM))
/* Frame */
private val nameFrame = setting("Name Frame", true, { page.value == Page.FRAME })
private val itemFrame = setting("Item Frame", false, { page.value == Page.FRAME })
private val dropItemFrame = setting("Drop Item Frame", true, { page.value == Page.FRAME })
private val filled = setting("Filled", true, { page.value == Page.FRAME })
private val rFilled = setting("Filled Red", 39, 0..255, 1, { page.value == Page.FRAME && filled.value })
private val gFilled = setting("Filled Green", 36, 0..255, 1, { page.value == Page.FRAME && filled.value })
private val bFilled = setting("Filled Blue", 64, 0..255, 1, { page.value == Page.FRAME && filled.value })
private val aFilled = setting("Filled Alpha", 169, 0..255, 1, { page.value == Page.FRAME && filled.value })
private val outline = setting("Outline", true, { page.value == Page.FRAME })
private val rOutline = setting("Outline Red", 155, 0..255, 1, { page.value == Page.FRAME && outline.value })
private val gOutline = setting("Outline Green", 144, 0..255, 1, { page.value == Page.FRAME && outline.value })
private val bOutline = setting("Outline Blue", 255, 0..255, 1, { page.value == Page.FRAME && outline.value })
private val aOutline = setting("Outline Alpha", 240, 0..255, 1, { page.value == Page.FRAME && outline.value })
private val outlineWidth = setting("Outline Width", 2.0f, 0.0f..5.0f, 0.1f, { page.value == Page.FRAME && outline.value })
private val margins = setting("Margins", 2.0f, 0.0f..10.0f, 0.1f, { page.value == Page.FRAME })
private val cornerRadius = setting("Corner Radius", 2.0f, 0.0f..10.0f, 0.1f, { page.value == Page.FRAME })
private val nameFrame = setting("Name Frame", true, page.atValue(Page.FRAME))
private val itemFrame = setting("Item Frame", false, page.atValue(Page.FRAME))
private val dropItemFrame = setting("Drop Item Frame", true, page.atValue(Page.FRAME))
private val filled = setting("Filled", true, page.atValue(Page.FRAME))
private val rFilled = setting("Filled Red", 39, 0..255, 1, page.atValue(Page.FRAME) and filled.atTrue())
private val gFilled = setting("Filled Green", 36, 0..255, 1, page.atValue(Page.FRAME) and filled.atTrue())
private val bFilled = setting("Filled Blue", 64, 0..255, 1, page.atValue(Page.FRAME) and filled.atTrue())
private val aFilled = setting("Filled Alpha", 169, 0..255, 1, page.atValue(Page.FRAME) and filled.atTrue())
private val outline = setting("Outline", true, page.atValue(Page.FRAME))
private val rOutline = setting("Outline Red", 155, 0..255, 1, page.atValue(Page.FRAME) and outline.atTrue())
private val gOutline = setting("Outline Green", 144, 0..255, 1, page.atValue(Page.FRAME) and outline.atTrue())
private val bOutline = setting("Outline Blue", 255, 0..255, 1, page.atValue(Page.FRAME) and outline.atTrue())
private val aOutline = setting("Outline Alpha", 240, 0..255, 1, page.atValue(Page.FRAME) and outline.atTrue())
private val outlineWidth = setting("Outline Width", 2.0f, 0.0f..5.0f, 0.1f, page.atValue(Page.FRAME) and outline.atTrue())
private val margins = setting("Margins", 2.0f, 0.0f..10.0f, 0.1f, page.atValue(Page.FRAME))
private val cornerRadius = setting("Corner Radius", 2.0f, 0.0f..10.0f, 0.1f, page.atValue(Page.FRAME))
/* Rendering settings */
private val rText = setting("Text Red", 232, 0..255, 1, { page.value == Page.RENDERING })
private val gText = setting("Text Green", 229, 0..255, 1, { page.value == Page.RENDERING })
private val bText = setting("Text Blue", 255, 0..255, 1, { page.value == Page.RENDERING })
private val aText = setting("Text Alpha", 255, 0..255, 1, { page.value == Page.RENDERING })
private val customFont = setting("Custom Font", true, { page.value == Page.RENDERING })
private val yOffset = setting("Y Offset", 0.5f, -2.5f..2.5f, 0.05f, { page.value == Page.RENDERING })
private val scale = setting("Scale", 1f, 0.25f..5f, 0.25f, { page.value == Page.RENDERING })
private val distScaleFactor = setting("Distance Scale Factor", 0.0f, 0.0f..1.0f, 0.05f, { page.value == Page.RENDERING })
private val minDistScale = setting("Min Distance Scale", 0.35f, 0.0f..1.0f, 0.05f, { page.value == Page.RENDERING })
private val rText = setting("Text Red", 232, 0..255, 1, page.atValue(Page.RENDERING))
private val gText = setting("Text Green", 229, 0..255, 1, page.atValue(Page.RENDERING))
private val bText = setting("Text Blue", 255, 0..255, 1, page.atValue(Page.RENDERING))
private val aText = setting("Text Alpha", 255, 0..255, 1, page.atValue(Page.RENDERING))
private val customFont = setting("Custom Font", true, page.atValue(Page.RENDERING))
private val yOffset = setting("Y Offset", 0.5f, -2.5f..2.5f, 0.05f, page.atValue(Page.RENDERING))
private val scale = setting("Scale", 1f, 0.25f..5f, 0.25f, page.atValue(Page.RENDERING))
private val distScaleFactor = setting("Distance Scale Factor", 0.0f, 0.0f..1.0f, 0.05f, page.atValue(Page.RENDERING))
private val minDistScale = setting("Min Distance Scale", 0.35f, 0.0f..1.0f, 0.05f, page.atValue(Page.RENDERING))
private enum class Page {
ENTITY_TYPE, CONTENT, ITEM, FRAME, RENDERING

6
src/main/kotlin/org/kamiblue/client/module/modules/render/NewChunks.kt
View File

@ -13,6 +13,7 @@ import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils.getInterpolatedPos
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.atValue
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.graphics.GlStateUtils
import org.kamiblue.client.util.graphics.KamiTessellator
@ -38,8 +39,9 @@ internal object NewChunks : Module(
private val thickness by setting("Thickness", 1.5f, 0.1f..4.0f, 0.1f, description = "Thickness of the highlighting square")
private val range by setting("Render Range", 512, 64..2048, 32, description = "Maximum range for chunks to be highlighted")
private val autoClear by setting("Auto Clear", false, description = "Clears the new chunks every 10 minutes")
private val removeMode by setting("Remove Mode", RemoveMode.MAX_NUMBER, description = "Mode to use for removing chunks")
private val maxNumber by setting("Max Number", 5000, 1000..10000, 500, { removeMode == RemoveMode.MAX_NUMBER }, description = "Maximum number of chunks to keep")
private val removeMode0 = setting("Remove Mode", RemoveMode.MAX_NUMBER, description = "Mode to use for removing chunks")
private val removeMode by removeMode0
private val maxNumber by setting("Max Number", 5000, 1000..10000, 500, removeMode0.atValue(RemoveMode.MAX_NUMBER), description = "Maximum number of chunks to keep")
@Suppress("unused")
private enum class RemoveMode {

52
src/main/kotlin/org/kamiblue/client/module/modules/render/NoRender.kt
View File

@ -21,6 +21,7 @@ import org.kamiblue.client.event.events.PacketEvent
import org.kamiblue.client.event.events.RenderEntityEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atValue
import org.kamiblue.client.util.threads.runSafe
import org.kamiblue.client.util.threads.safeListener
import org.kamiblue.event.listener.listener
@ -31,38 +32,37 @@ internal object NoRender : Module(
category = Category.RENDER,
description = "Ignore entity spawn packets"
) {
private val packets = setting("Cancel Packets", true)
private val page = setting("Page", Page.OTHER)
// Entities
private val mobs = setting("Mobs", false, { page.value == Page.ENTITIES })
private val animals = setting("Animals", false, { page.value == Page.ENTITIES })
private val player = setting("Players", false, { page.value == Page.ENTITIES })
private val paint = setting("Paintings", false, { page.value == Page.ENTITIES })
private val sign = setting("Signs", false, { page.value == Page.ENTITIES })
private val skull = setting("Heads", false, { page.value == Page.ENTITIES })
private val armorStand = setting("Armor Stands", false, { page.value == Page.ENTITIES })
private val endPortal = setting("End Portals", false, { page.value == Page.ENTITIES })
private val banner = setting("Banners", false, { page.value == Page.ENTITIES })
private val itemFrame = setting("Item Frames", false, { page.value == Page.ENTITIES })
private val xp = setting("XP", false, { page.value == Page.ENTITIES })
private val items = setting("Items", false, { page.value == Page.ENTITIES })
private val crystal = setting("Crystals", false, { page.value == Page.ENTITIES })
private val firework = setting("Firework", false, { page.value == Page.ENTITIES })
private val mobs = setting("Mobs", false, page.atValue(Page.ENTITIES))
private val animals = setting("Animals", false, page.atValue(Page.ENTITIES))
private val player = setting("Players", false, page.atValue(Page.ENTITIES))
private val paint = setting("Paintings", false, page.atValue(Page.ENTITIES))
private val sign = setting("Signs", false, page.atValue(Page.ENTITIES))
private val skull = setting("Heads", false, page.atValue(Page.ENTITIES))
private val armorStand = setting("Armor Stands", false, page.atValue(Page.ENTITIES))
private val endPortal = setting("End Portals", false, page.atValue(Page.ENTITIES))
private val banner = setting("Banners", false, page.atValue(Page.ENTITIES))
private val itemFrame = setting("Item Frames", false, page.atValue(Page.ENTITIES))
private val xp = setting("XP", false, page.atValue(Page.ENTITIES))
private val items = setting("Items", false, page.atValue(Page.ENTITIES))
private val crystal = setting("Crystals", false, page.atValue(Page.ENTITIES))
private val firework = setting("Firework", false, page.atValue(Page.ENTITIES))
// Others
val map = setting("Maps", false, { page.value == Page.OTHER })
private val explosion = setting("Explosions", true, { page.value == Page.OTHER })
val signText = setting("Sign Text", false, { page.value == Page.OTHER })
private val particles = setting("Particles", true, { page.value == Page.OTHER })
private val falling = setting("Falling Blocks", true, { page.value == Page.OTHER })
val beacon = setting("Beacon Beams", true, { page.value == Page.OTHER })
val skylight = setting("SkyLight Updates", true, { page.value == Page.OTHER })
private val enchantingTable = setting("Enchanting Books", true, { page.value == Page.OTHER })
private val enchantingTableSnow = setting("Enchanting Table Snow", false, { page.value == Page.OTHER }, description = "Replace enchanting table models with snow layers")
private val projectiles = setting("Projectiles", false, { page.value == Page.OTHER })
private val lightning = setting("Lightning", true, { page.value == Page.OTHER })
val map = setting("Maps", false, page.atValue(Page.OTHER))
private val explosion = setting("Explosions", true, page.atValue(Page.OTHER))
val signText = setting("Sign Text", false, page.atValue(Page.OTHER))
private val particles = setting("Particles", true, page.atValue(Page.OTHER))
private val falling = setting("Falling Blocks", true, page.atValue(Page.OTHER))
val beacon = setting("Beacon Beams", true, page.atValue(Page.OTHER))
val skylight = setting("SkyLight Updates", true, page.atValue(Page.OTHER))
private val enchantingTable = setting("Enchanting Books", true, page.atValue(Page.OTHER))
private val enchantingTableSnow = setting("Enchanting Table Snow", false, page.atValue(Page.OTHER), description = "Replace enchanting table models with snow layers")
private val projectiles = setting("Projectiles", false, page.atValue(Page.OTHER))
private val lightning = setting("Lightning", true, page.atValue(Page.OTHER))
private enum class Page {
ENTITIES, OTHER

33
src/main/kotlin/org/kamiblue/client/module/modules/render/Search.kt
View File

@ -16,12 +16,15 @@ import org.kamiblue.client.event.events.RenderWorldEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.setting.settings.impl.collection.CollectionSetting
import org.kamiblue.client.util.BOOLEAN_SUPPLIER_FALSE
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.graphics.ESPRenderer
import org.kamiblue.client.util.graphics.GeometryMasks
import org.kamiblue.client.util.graphics.ShaderHelper
import org.kamiblue.client.util.math.VectorUtils.distanceTo
import org.kamiblue.client.util.or
import org.kamiblue.client.util.text.MessageSendHelper
import org.kamiblue.client.util.text.formatValue
import org.kamiblue.client.util.threads.defaultScope
@ -40,20 +43,24 @@ internal object Search : Module(
private val updateDelay by setting("Update Delay", 1000, 500..3000, 50)
private val range by setting("Search Range", 128, 0..256, 8)
private val maximumBlocks by setting("Maximum Blocks", 256, 16..4096, 128)
private val filled by setting("Filled", true)
private val outline by setting("Outline", true)
private val tracer by setting("Tracer", true)
private val customColors by setting("Custom Colors", false)
private val r by setting("Red", 155, 0..255, 1, { customColors })
private val g by setting("Green", 144, 0..255, 1, { customColors })
private val b by setting("Blue", 255, 0..255, 1, { customColors })
private val aFilled by setting("Filled Alpha", 31, 0..255, 1, { filled })
private val aOutline by setting("Outline Alpha", 127, 0..255, 1, { outline })
private val aTracer by setting("Tracer Alpha", 200, 0..255, 1, { tracer })
private val thickness by setting("Line Thickness", 2.0f, 0.25f..5.0f, 0.25f)
private val filled0 = setting("Filled", true)
private val filled by filled0
private val outline0 = setting("Outline", true)
private val outline by outline0
private val tracer0 = setting("Tracer", true)
private val tracer by tracer0
private val customColors0 = setting("Custom Colors", false)
private val customColors by customColors0
private val r by setting("Red", 155, 0..255, 1, customColors0.atTrue())
private val g by setting("Green", 144, 0..255, 1, customColors0.atTrue())
private val b by setting("Blue", 255, 0..255, 1, customColors0.atTrue())
private val aFilled by setting("Filled Alpha", 31, 0..255, 1, filled0.atTrue())
private val aOutline by setting("Outline Alpha", 127, 0..255, 1, outline0.atTrue())
private val aTracer by setting("Tracer Alpha", 200, 0..255, 1, tracer0.atTrue())
private val thickness by setting("Line Thickness", 2.0f, 0.25f..5.0f, 0.25f, outline0.atTrue() or tracer0.atTrue())
var overrideWarning by setting("Override Warning", false, { false })
val searchList = setting(CollectionSetting("Search List", defaultSearchList, { false }))
var overrideWarning by setting("Override Warning", false, BOOLEAN_SUPPLIER_FALSE)
val searchList = setting(CollectionSetting("Search List", defaultSearchList, BOOLEAN_SUPPLIER_FALSE))
private val renderer = ESPRenderer()
private val updateTimer = TickTimer()

5
src/main/kotlin/org/kamiblue/client/module/modules/render/SelectionHighlight.kt
View File

@ -5,6 +5,7 @@ import net.minecraftforge.fml.common.gameevent.TickEvent
import org.kamiblue.client.event.events.RenderWorldEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.graphics.ESPRenderer
import org.kamiblue.client.util.graphics.GeometryMasks
@ -27,8 +28,8 @@ internal object SelectionHighlight : Module(
private val r = setting("Red", 155, 0..255, 1)
private val g = setting("Green", 144, 0..255, 1)
private val b = setting("Blue", 255, 0..255, 1)
private val aFilled = setting("Filled Alpha", 63, 0..255, 1, { filled.value })
private val aOutline = setting("Outline Alpha", 200, 0..255, 1, { outline.value })
private val aFilled = setting("Filled Alpha", 63, 0..255, 1, filled.atTrue())
private val aOutline = setting("Outline Alpha", 200, 0..255, 1, outline.atTrue())
private val thickness = setting("Line Thickness", 2.0f, 0.25f..5.0f, 0.25f)
private val renderer = ESPRenderer()

58
src/main/kotlin/org/kamiblue/client/module/modules/render/StorageESP.kt
View File

@ -13,11 +13,15 @@ import org.kamiblue.client.event.SafeClientEvent
import org.kamiblue.client.event.events.RenderWorldEvent
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.and
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.atValue
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.color.DyeColors
import org.kamiblue.client.util.color.HueCycler
import org.kamiblue.client.util.graphics.ESPRenderer
import org.kamiblue.client.util.graphics.GeometryMasks
import org.kamiblue.client.util.or
import org.kamiblue.client.util.threads.safeAsyncListener
import org.kamiblue.event.listener.listener
@ -26,37 +30,41 @@ internal object StorageESP : Module(
description = "Draws an ESP on top of storage units",
category = Category.RENDER
) {
private val page by setting("Page", Page.TYPE)
private val page = setting("Page", Page.TYPE)
/* Type settings */
private val chest by setting("Chest", true, { page == Page.TYPE })
private val shulker by setting("Shulker", true, { page == Page.TYPE })
private val enderChest by setting("Ender Chest", true, { page == Page.TYPE })
private val frame by setting("Item Frame", true, { page == Page.TYPE })
private val withShulkerOnly by setting("With Shulker Only", true, { page == Page.TYPE && frame })
private val furnace by setting("Furnace", false, { page == Page.TYPE })
private val dispenser by setting("Dispenser", false, { page == Page.TYPE })
private val hopper by setting("Hopper", false, { page == Page.TYPE })
private val cart by setting("Minecart", false, { page == Page.TYPE })
private val chest by setting("Chest", true, page.atValue(Page.TYPE))
private val shulker by setting("Shulker", true, page.atValue(Page.TYPE))
private val enderChest by setting("Ender Chest", true, page.atValue(Page.TYPE))
private val frame0 = setting("Item Frame", true, page.atValue(Page.TYPE))
private val frame by frame0
private val withShulkerOnly by setting("With Shulker Only", true, page.atValue(Page.TYPE) and frame0.atTrue())
private val furnace by setting("Furnace", false, page.atValue(Page.TYPE))
private val dispenser by setting("Dispenser", false, page.atValue(Page.TYPE))
private val hopper by setting("Hopper", false, page.atValue(Page.TYPE))
private val cart by setting("Minecart", false, page.atValue(Page.TYPE))
/* Color settings */
private val colorChest by setting("Chest Color", DyeColors.ORANGE, { page == Page.COLOR })
private val colorDispenser by setting("Dispenser Color", DyeColors.LIGHT_GRAY, { page == Page.COLOR })
private val colorShulker by setting("Shulker Color", DyeColors.MAGENTA, { page == Page.COLOR })
private val colorEnderChest by setting("Ender Chest Color", DyeColors.PURPLE, { page == Page.COLOR })
private val colorFurnace by setting("Furnace Color", DyeColors.LIGHT_GRAY, { page == Page.COLOR })
private val colorHopper by setting("Hopper Color", DyeColors.GRAY, { page == Page.COLOR })
private val colorCart by setting("Cart Color", DyeColors.GREEN, { page == Page.COLOR })
private val colorFrame by setting("Frame Color", DyeColors.ORANGE, { page == Page.COLOR })
private val colorChest by setting("Chest Color", DyeColors.ORANGE, page.atValue(Page.TYPE))
private val colorDispenser by setting("Dispenser Color", DyeColors.LIGHT_GRAY, page.atValue(Page.TYPE))
private val colorShulker by setting("Shulker Color", DyeColors.MAGENTA, page.atValue(Page.TYPE))
private val colorEnderChest by setting("Ender Chest Color", DyeColors.PURPLE, page.atValue(Page.TYPE))
private val colorFurnace by setting("Furnace Color", DyeColors.LIGHT_GRAY, page.atValue(Page.TYPE))
private val colorHopper by setting("Hopper Color", DyeColors.GRAY, page.atValue(Page.TYPE))
private val colorCart by setting("Cart Color", DyeColors.GREEN, page.atValue(Page.TYPE))
private val colorFrame by setting("Frame Color", DyeColors.ORANGE, page.atValue(Page.TYPE))
/* Render settings */
private val filled by setting("Filled", true, { page == Page.RENDER })
private val outline by setting("Outline", true, { page == Page.RENDER })
private val tracer by setting("Tracer", true, { page == Page.RENDER })
private val aFilled by setting("Filled Alpha", 31, 0..255, 1, { page == Page.RENDER && filled })
private val aOutline by setting("Outline Alpha", 127, 0..255, 1, { page == Page.RENDER && outline })
private val aTracer by setting("Tracer Alpha", 200, 0..255, 1, { page == Page.RENDER && tracer })
private val thickness by setting("Line Thickness", 2.0f, 0.25f..5.0f, 0.25f, { page == Page.RENDER })
private val filled0 = setting("Filled", true, page.atValue(Page.RENDER))
private val filled by filled0
private val outline0 = setting("Outline", true, page.atValue(Page.RENDER))
private val outline by outline0
private val tracer0 = setting("Tracer", true, page.atValue(Page.RENDER))
private val tracer by tracer0
private val aFilled by setting("Filled Alpha", 31, 0..255, 1, page.atValue(Page.RENDER) and filled0.atTrue())
private val aOutline by setting("Outline Alpha", 127, 0..255, 1, page.atValue(Page.RENDER) and outline0.atTrue())
private val aTracer by setting("Tracer Alpha", 200, 0..255, 1, page.atValue(Page.RENDER) and tracer0.atTrue())
private val thickness by setting("Line Thickness", 2.0f, 0.25f..5.0f, 0.25f, page.atValue(Page.RENDER) and (outline0.atTrue() or tracer0.atTrue()))
private enum class Page {
TYPE, COLOR, RENDER

47
src/main/kotlin/org/kamiblue/client/module/modules/render/Tracers.kt
View File

@ -10,6 +10,9 @@ import org.kamiblue.client.module.Module
import org.kamiblue.client.util.EntityUtils.getTargetList
import org.kamiblue.client.util.EntityUtils.isNeutral
import org.kamiblue.client.util.EntityUtils.isPassive
import org.kamiblue.client.util.and
import org.kamiblue.client.util.atTrue
import org.kamiblue.client.util.atValue
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.color.DyeColors
import org.kamiblue.client.util.color.HueCycler
@ -28,32 +31,32 @@ internal object Tracers : Module(
private val page = setting("Page", Page.ENTITY_TYPE)
/* Entity type settings */
private val players = setting("Players", true, { page.value == Page.ENTITY_TYPE })
private val friends = setting("Friends", false, { page.value == Page.ENTITY_TYPE && players.value })
private val sleeping = setting("Sleeping", false, { page.value == Page.ENTITY_TYPE && players.value })
private val mobs = setting("Mobs", true, { page.value == Page.ENTITY_TYPE })
private val passive = setting("Passive Mobs", false, { page.value == Page.ENTITY_TYPE && mobs.value })
private val neutral = setting("Neutral Mobs", true, { page.value == Page.ENTITY_TYPE && mobs.value })
private val hostile = setting("Hostile Mobs", true, { page.value == Page.ENTITY_TYPE && mobs.value })
private val invisible = setting("Invisible", true, { page.value == Page.ENTITY_TYPE })
private val range = setting("Range", 64, 8..512, 8, { page.value == Page.ENTITY_TYPE })
private val players = setting("Players", true, page.atValue(Page.ENTITY_TYPE))
private val friends = setting("Friends", false, page.atValue(Page.ENTITY_TYPE) and players.atTrue())
private val sleeping = setting("Sleeping", false, page.atValue(Page.ENTITY_TYPE) and players.atTrue())
private val mobs = setting("Mobs", true, page.atValue(Page.ENTITY_TYPE))
private val passive = setting("Passive Mobs", false, page.atValue(Page.ENTITY_TYPE) and mobs.atTrue())
private val neutral = setting("Neutral Mobs", true, page.atValue(Page.ENTITY_TYPE) and mobs.atTrue())
private val hostile = setting("Hostile Mobs", true, page.atValue(Page.ENTITY_TYPE) and mobs.atTrue())
private val invisible = setting("Invisible", true, page.atValue(Page.ENTITY_TYPE))
private val range = setting("Range", 64, 8..512, 8, page.atValue(Page.ENTITY_TYPE))
/* Color settings */
private val colorPlayer = setting("Player Color", DyeColors.KAMI, { page.value == Page.COLOR })
private val colorFriend = setting("Friend Color", DyeColors.RAINBOW, { page.value == Page.COLOR })
private val colorPassive = setting("Passive Mob Color", DyeColors.GREEN, { page.value == Page.COLOR })
private val colorNeutral = setting("Neutral Mob Color", DyeColors.YELLOW, { page.value == Page.COLOR })
private val colorHostile = setting("Hostile Mob Color", DyeColors.RED, { page.value == Page.COLOR })
private val colorPlayer = setting("Player Color", DyeColors.KAMI, page.atValue(Page.COLOR))
private val colorFriend = setting("Friend Color", DyeColors.RAINBOW, page.atValue(Page.COLOR))
private val colorPassive = setting("Passive Mob Color", DyeColors.GREEN, page.atValue(Page.COLOR))
private val colorNeutral = setting("Neutral Mob Color", DyeColors.YELLOW, page.atValue(Page.COLOR))
private val colorHostile = setting("Hostile Mob Color", DyeColors.RED, page.atValue(Page.COLOR))
private val colorFar = setting("Far Color", DyeColors.WHITE, page.atValue(Page.COLOR))
/* General rendering settings */
private val rangedColor = setting("Ranged Color", true, { page.value == Page.RENDERING })
private val colorChangeRange = setting("Color Change Range", 16, 8..128, 8, { page.value == Page.RENDERING && rangedColor.value })
private val playerOnly = setting("Player Only", true, { page.value == Page.RENDERING && rangedColor.value })
private val colorFar = setting("Far Color", DyeColors.WHITE, { page.value == Page.COLOR })
private val aFar = setting("Far Alpha", 127, 0..255, 1, { page.value == Page.RENDERING && rangedColor.value })
private val a = setting("Tracer Alpha", 255, 0..255, 1, { page.value == Page.RENDERING })
private val yOffset = setting("y Offset Percentage", 0, 0..100, 5, { page.value == Page.RENDERING })
private val thickness = setting("Line Thickness", 2.0f, 0.25f..5.0f, 0.25f, { page.value == Page.RENDERING })
private val rangedColor = setting("Ranged Color", true, page.atValue(Page.RENDERING))
private val colorChangeRange = setting("Color Change Range", 16, 8..128, 8, page.atValue(Page.RENDERING) and rangedColor.atTrue())
private val playerOnly = setting("Player Only", true, page.atValue(Page.RENDERING) and rangedColor.atTrue())
private val aFar = setting("Far Alpha", 127, 0..255, 1, page.atValue(Page.RENDERING) and rangedColor.atTrue())
private val a = setting("Tracer Alpha", 255, 0..255, 1, page.atValue(Page.RENDERING))
private val yOffset = setting("y Offset Percentage", 0, 0..100, 5, page.atValue(Page.RENDERING))
private val thickness = setting("Line Thickness", 2.0f, 0.25f..5.0f, 0.25f, page.atValue(Page.RENDERING))
private enum class Page {
ENTITY_TYPE, COLOR, RENDERING

44
src/main/kotlin/org/kamiblue/client/module/modules/render/WaypointRender.kt
View File

@ -8,8 +8,7 @@ import org.kamiblue.client.manager.managers.WaypointManager
import org.kamiblue.client.manager.managers.WaypointManager.Waypoint
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.TickTimer
import org.kamiblue.client.util.TimeUnit
import org.kamiblue.client.util.*
import org.kamiblue.client.util.color.ColorHolder
import org.kamiblue.client.util.graphics.*
import org.kamiblue.client.util.graphics.font.HAlign
@ -30,31 +29,30 @@ internal object WaypointRender : Module(
description = "Render saved waypoints",
category = Category.RENDER
) {
private val page = setting("Page", Page.INFO_BOX)
/* Page one */
private val dimension = setting("Dimension", Dimension.CURRENT, { page.value == Page.INFO_BOX })
private val showName = setting("Show Name", true, { page.value == Page.INFO_BOX })
private val showDate = setting("Show Date", false, { page.value == Page.INFO_BOX })
private val showCoords = setting("Show Coords", true, { page.value == Page.INFO_BOX })
private val showDist = setting("Show Distance", true, { page.value == Page.INFO_BOX })
private val textScale = setting("Text Scale", 1.0f, 0.0f..2.0f, 0.1f, { page.value == Page.INFO_BOX })
private val infoBoxRange = setting("Info Box Range", 512, 128..2048, 64, { page.value == Page.INFO_BOX })
private val dimension = setting("Dimension", Dimension.CURRENT, page.atValue(Page.INFO_BOX))
private val showName = setting("Show Name", true, page.atValue(Page.INFO_BOX))
private val showDate = setting("Show Date", false, page.atValue(Page.INFO_BOX))
private val showCoords = setting("Show Coords", true, page.atValue(Page.INFO_BOX))
private val showDist = setting("Show Distance", true, page.atValue(Page.INFO_BOX))
private val textScale = setting("Text Scale", 1.0f, 0.0f..2.0f, 0.1f, page.atValue(Page.INFO_BOX))
private val infoBoxRange = setting("Info Box Range", 512, 128..2048, 64, page.atValue(Page.INFO_BOX))
/* Page two */
private val espRangeLimit = setting("Render Range", true, { page.value == Page.ESP })
private val espRange = setting("Range", 4096, 1024..16384, 1024, { page.value == Page.ESP && espRangeLimit.value })
private val filled = setting("Filled", true, { page.value == Page.ESP })
private val outline = setting("Outline", true, { page.value == Page.ESP })
private val tracer = setting("Tracer", true, { page.value == Page.ESP })
private val r = setting("Red", 31, 0..255, 1, { page.value == Page.ESP })
private val g = setting("Green", 200, 0..255, 1, { page.value == Page.ESP })
private val b = setting("Blue", 63, 0..255, 1, { page.value == Page.ESP })
private val aFilled = setting("Filled Alpha", 63, 0..255, 1, { page.value == Page.ESP && filled.value })
private val aOutline = setting("Outline Alpha", 160, 0..255, 1, { page.value == Page.ESP && outline.value })
private val aTracer = setting("Tracer Alpha", 200, 0..255, 1, { page.value == Page.ESP && tracer.value })
private val thickness = setting("Line Thickness", 2.0f, 0.25f..8.0f, 0.25f)
private val renderRange = setting("Render Range", true, page.atValue(Page.ESP))
private val espRange = setting("Range", 4096, 1024..16384, 1024, page.atValue(Page.ESP) and renderRange.atTrue())
private val filled = setting("Filled", true, page.atValue(Page.ESP))
private val outline = setting("Outline", true, page.atValue(Page.ESP))
private val tracer = setting("Tracer", true, page.atValue(Page.ESP))
private val r = setting("Red", 31, 0..255, 1, page.atValue(Page.ESP))
private val g = setting("Green", 200, 0..255, 1, page.atValue(Page.ESP))
private val b = setting("Blue", 63, 0..255, 1, page.atValue(Page.ESP))
private val aFilled = setting("Filled Alpha", 63, 0..255, 1, page.atValue(Page.ESP) and filled.atTrue())
private val aOutline = setting("Outline Alpha", 160, 0..255, 1, page.atValue(Page.ESP) and outline.atTrue())
private val aTracer = setting("Tracer Alpha", 200, 0..255, 1, page.atValue(Page.ESP) and tracer.atTrue())
private val thickness = setting("Line Thickness", 2.0f, 0.25f..8.0f, 0.25f, page.atValue(Page.ESP) and (outline.atTrue() or tracer.atTrue()))
private enum class Dimension {
CURRENT, ANY
@ -85,7 +83,7 @@ internal object WaypointRender : Module(
GlStateUtils.depth(false)
for (waypoint in waypointMap.keys) {
val distance = mc.player.distanceTo(waypoint.pos)
if (espRangeLimit.value && distance > espRange.value) continue
if (renderRange.value && distance > espRange.value) continue
renderer.add(AxisAlignedBB(waypoint.pos), color) /* Adds pos to ESPRenderer list */
drawVerticalLines(waypoint.pos, color, aOutline.value) /* Draw lines from y 0 to y 256 */
}

3
src/main/kotlin/org/kamiblue/client/module/modules/render/Zoom.kt
View File

@ -2,6 +2,7 @@ package org.kamiblue.client.module.modules.render
import org.kamiblue.client.module.Category
import org.kamiblue.client.module.Module
import org.kamiblue.client.util.atTrue
internal object Zoom : Module(
name = "Zoom",
@ -14,7 +15,7 @@ internal object Zoom : Module(
private val fovChange = setting("FOV", 40.0f, 1.0f..180.0f, 0.5f)
private val modifySensitivity = setting("Modify Sensitivity", true)
private val sensitivityMultiplier = setting("Sensitivity Multiplier", 1.0f, 0.25f..2.0f, 0.25f, { modifySensitivity.value })
private val sensitivityMultiplier = setting("Sensitivity Multiplier", 1.0f, 0.25f..2.0f, 0.25f, modifySensitivity.atTrue())
private val smoothCamera = setting("Cinematic Camera", false)
init {

2
src/main/kotlin/org/kamiblue/client/util/LambdaUtils.kt
View File

@ -15,7 +15,7 @@ fun <T : Any> AbstractSetting<T>.atValue(value: T) =
this.value == value
}
fun <T : Any> AbstractSetting<T>.atValues(value1: T, value2: T) =
fun <T : Any> AbstractSetting<T>.atValue(value1: T, value2: T) =
BooleanSupplier {
this.value == value1 || this.value == value2
}