If false, the value is neither written to nor read from config files, but still reaches the GUI. For values whose state lives elsewhere, such as another client's modules.

key

var key: String?

open val mc: Minecraft

name

@SerializedName(value = "name")

val name: String

network

open val network: ClientPacketListener

notAnOption

var notAnOption: Boolean

If true, value will not be included in generated RestAPI config.

parent

override val parent: ModeValueGroup<*>

player

open val player: LocalPlayer

running

open override val running: Boolean

We check if the parent is active and if the mode is active, if so we handle the events.

syncOnStart

val syncOnStart: Boolean

tag

override val tag: String

tagAliases

override val tagAliases: List<String>

valueType

val valueType: ValueType

visibleCondition

var visibleCondition: BooleanSupplier

Hides the value from the GUI while false. Configs keep it either way.

world

open val world: ClientLevel

Functions

after

open fun after(ticks: Int, task: Runnable): AutoCloseable

Runs task once, ticks game ticks from now, unless this listener stops running first.

asRefreshable

fun Value<ClosedFloatingPointRange<Float>>.asRefreshable(): RefreshableFloatState

fun Value<IntRange>.asRefreshable(): RefreshableIntState

asStateFlow

fun asStateFlow(): StateFlow<MutableCollection<Value<*>>>

bind

@JvmOverloads

fun bind(name: String, default: Int = InputConstants.UNKNOWN.value): BindValue

fun bind(name: String, default: InputBind): BindValue

bind

fun Value<InputBind>.bind(name: String)

Binds to the given input name.

fun Value<InputBind>.bind(key: InputConstants.Key, action: InputBind.BindAction, modifiers: Set<InputBind.Modifier>)

Binds to the given input type and code.

block

fun block(name: String, default: Block): Value<Block>

blocks

fun <C : SequencedSet<Block>> blocks(name: String, default: C): RegistryListValue<C, Block>

boolean

@JvmName(name = "bool")

@JvmOverloads

fun boolean(name: String, default: Boolean, aliases: List<String> = emptyList()): Value<Boolean>

c2sPackets

fun <C : SequencedSet<Identifier>> c2sPackets(name: String, default: C): RegistryListValue<C, Identifier>

checkIfInclude

fun checkIfInclude(): Boolean

Checks if this value should be included in the public configuration based on its doNotInclude condition and inclusionGroup.

children

open fun children(): List<EventListener>

Children EventListener

collectValueGroupsRecursively

fun collectValueGroupsRecursively(prefix: String = ""): Sequence<ValueGroup>

collectValuesRecursively

fun collectValuesRecursively(prefix: String = ""): Sequence<Value<*>>

color

fun color(name: String, default: Color4b): Value<Color4b>

computedOn

inline fun <E : Event, V> EventListener.computedOn(initialValue: V, priority: Short = 0, crossinline accumulator: (event: E, prev: V) -> V): ReadWriteProperty<EventListener, V>

Returns computed ReadWriteProperty based on the accumulator of specific event.

createEventHook

open override fun <T : Event> EventListener.createEventHook(eventClass: Class<T>, wrappedContext: CoroutineContext, priority: Short, handler: SuspendableEventHandler<T>): EventHook<T>

curve

inline fun curve(name: String, block: CurveValue.Builder.() -> Unit): CurveValue

fun curve(name: String, default: MutableList<Vector2f>, xAxis: CurveValue.Axis, yAxis: CurveValue.Axis, tension: Float = CurveValue.DEFAULT_TENSION): CurveValue

debugGeometry

inline fun DebuggedOwner.debugGeometry(name: String, lazyGeometry: () -> ModuleDebug.DebuggedGeometry?)

debugParameter

inline fun DebuggedOwner.debugParameter(name: String, lazyValue: () -> Any?)

deserializeFrom

open fun deserializeFrom(gson: Gson, element: JsonElement)

Deserialize value from JSON

disable

open fun disable()

doNotIncludeAlways

fun doNotIncludeAlways(): Value<MutableCollection<Value<*>>>

doNotIncludeWhen

fun doNotIncludeWhen(condition: BooleanSupplier): Value<MutableCollection<Value<*>>>

drop

fun <T : ValueGroup> drop(valueGroup: T): T

easing

fun easing(name: String, default: Easing): ChoiceListValue<Easing>

enable

open fun enable()

enchantments

fun <C : SequencedSet<Identifier>> enchantments(name: String, default: C): RegistryListValue<C, Identifier>

EntityLookup

@JvmStatic

@JvmName(name = "create")

fun <T : Entity> EventListener.EntityLookup(collector: EntityLookup.Collector<T>): EntityLookup<T>

entityTypes

fun <C : SequencedSet<EntityType<*>>> entityTypes(name: String, default: C): RegistryListValue<C, EntityType<*>>

enumChoice

fun <T : Enum<T>, Tagged> enumChoice(name: String, default: T): ChoiceListValue<T>

For Java, which cannot call the reified overload.

inline fun <T : Enum<T>, Tagged> enumChoice(name: String, default: T, aliases: List<String> = emptyList()): ChoiceListValue<T>

@JvmOverloads

fun <T : Tagged> enumChoice(name: String, default: T, choices: Set<T>, aliases: List<String> = emptyList()): ChoiceListValue<T>

every

open fun every(ticks: Int, task: Runnable): AutoCloseable

Runs task every ticks game ticks while this listener is running, the first time after ticks.

ExpiringList

@JvmStatic

@JvmName(name = "create")

fun <E> EventListener.ExpiringList(): ExpiringList<E>

file

fun file(name: String, default: File? = null, dialogMode: FileDialogMode = FileDialogMode.OPEN_FILE, supportedExtensions: Set<String>? = null): FileValue

float

@JvmName(name = "floating")

@JvmOverloads

fun float(name: String, default: Float, min: Float, max: Float, suffix: String = ""): RangedValue<Float>

@JvmName(name = "floating")

@JvmOverloads

fun float(name: String, default: Float, range: ClosedFloatingPointRange<Float>, suffix: String = "", aliases: List<String> = emptyList()): RangedValue<Float>

floatRange

@JvmOverloads

fun floatRange(name: String, default: ClosedFloatingPointRange<Float>, range: ClosedFloatingPointRange<Float>, suffix: String = "", aliases: List<String> = emptyList()): RangedValue<ClosedFloatingPointRange<Float>>

get

fun get(): MutableCollection<Value<*>>

getBlockBreakingDelta

fun getBlockBreakingDelta(pos: BlockPos, state: BlockState, itemStack: ItemStack?): Float

getSlot

fun getSlot(state: BlockState): HotbarItemSlot?

getSwitchingMethod

open fun getSwitchingMethod(): SwitchMethod

getTagValue

@JvmName(name = "getTagValue")

fun getTagValue(): Any

getValue

@JvmName(name = "getValue")

fun getValue(): Any

operator fun getValue(u: Any?, property: KProperty<*>): MutableCollection<Value<*>>

Support for delegated properties example: var autoaim by boolean(name = "autoaim", default = true) if(!autoaim) autoaim = true

handler

inline fun <T : Event> EventListener.handler(priority: Short = 0, handler: Consumer<T>): EventHook<T>

fun <T : Event> EventListener.handler(eventClass: Class<T>, priority: Short = 0, handler: Consumer<T>): EventHook<T>

immutable

fun immutable(): Value<MutableCollection<Value<*>>>

inclusionGroup

open override fun inclusionGroup(group: OptionalInclusion): ValueGroup

independentDescription

fun independentDescription(): Value<MutableCollection<Value<*>>>

int

@JvmName(name = "integer")

@JvmOverloads

fun int(name: String, default: Int, min: Int, max: Int, suffix: String = ""): RangedValue<Int>

@JvmName(name = "integer")

@JvmOverloads

fun int(name: String, default: Int, range: IntRange, suffix: String = "", aliases: List<String> = emptyList()): RangedValue<Int>

intRange

@JvmOverloads

fun intRange(name: String, default: IntRange, range: IntRange, suffix: String = "", aliases: List<String> = emptyList()): RangedValue<IntRange>

item

fun item(name: String, default: Item): Value<Item>

itemList

fun <C : MutableList<Item>> itemList(name: String, default: C): RegistryMutableListValue<C, Item>

inline fun <T : MutableSet<E>, E> itemList(name: String, defaultValue: T, items: Set<ItemListValue.NamedItem<E>>, valueType: ValueType): ItemListValue<T, E>

fun <T : MutableSet<E>, E> itemList(name: String, defaultValue: T, items: Set<ItemListValue.NamedItem<E>>, valueType: ValueType, innerType: Class<E>): ItemListValue<T, E>

items

fun <C : SequencedSet<Item>> items(name: String, default: C): RegistryListValue<C, Item>

json

fun ValueGroup.json(valueObject: JsonObject)

Assigns the value of the settings to the component

key

@JvmOverloads

fun key(name: String, default: InputConstants.Key = InputConstants.UNKNOWN): Value<InputConstants.Key>

fun key(name: String, default: Int): Value<InputConstants.Key>

list

inline fun <T : MutableCollection<E>, E> list(name: String, defaultValue: T, valueType: ValueType): ListValue<T, E>

fun <T : MutableCollection<E>, E> list(name: String, defaultValue: T, valueType: ValueType, innerType: Class<E>): ListValue<T, E>

literalDescription

fun literalDescription(text: Supplier<String?>): Value<MutableCollection<Value<*>>>

Uses text instead of a translation key, for descriptions that come from outside LiquidBounce.

mapReadOnly

fun <T : Any, R> Value<T>.mapReadOnly(transform: (T) -> R): ReadOnlyProperty<Any?, R>

mobEffects

fun <C : SequencedSet<MobEffect>> mobEffects(name: String, default: C): RegistryListValue<C, MobEffect>

modes

fun <T : Mode> modes(eventListener: EventListener?, name: String, activeCallback: ToIntFunction<List<T>>, modesCallback: (ModeValueGroup<T>) -> Array<T>): ModeValueGroup<T>

multiEnumChoice

inline fun <T : Enum<T>, Tagged> multiEnumChoice(name: String, default: Iterable<T>, canBeNone: Boolean = true): MultiChoiceListValue<T?>

inline fun <T : Enum<T>, Tagged> multiEnumChoice(name: String, vararg default: T, canBeNone: Boolean = true): MultiChoiceListValue<T?>

inline fun <T : Enum<T>, Tagged> multiEnumChoice(name: String, default: EnumSet<T> = enumSetOf(), choices: EnumSet<T> = enumSetAllOf(), canBeNone: Boolean = true): MultiChoiceListValue<T?>

inline fun <T : Enum<T>, Tagged> multiEnumChoice(name: String, default: SequencedSet<T>, choices: EnumSet<T> = enumSetAllOf(), canBeNone: Boolean = true): MultiChoiceListValue<T?>

fun <T : Tagged> multiEnumChoice(name: String, default: MutableSet<T>, choices: Set<T>, canBeNone: Boolean, isOrderSensitive: Boolean): MultiChoiceListValue<T>

@JvmOverloads

fun <T : Enum<T>, Tagged> multiEnumChoice(name: String, type: Class<T>, default: Collection<T>, canBeNone: Boolean = true): MultiChoiceListValue<T>

For Java, which cannot call the reified overloads.

mutableList

inline fun <T : MutableCollection<E>, E> mutableList(name: String, defaultValue: T, valueType: ValueType): MutableListValue<T, E>

fun <T : MutableCollection<E>, E> mutableList(name: String, defaultValue: T, valueType: ValueType, innerType: Class<E>): MutableListValue<T, E>

newEventHook

inline fun <E : Event> EventListener.newEventHook(priority: Short = 0, handler: Consumer<E>): EventHook<E>

notAnOption

fun notAnOption(): Value<MutableCollection<Value<*>>>

notPersistent

fun notPersistent(): Value<MutableCollection<Value<*>>>

open fun <E : Event> on(type: Class<E>, handler: Consumer<E>): AutoCloseable

open fun <E : Event> on(type: Class<E>, priority: Short, handler: Consumer<E>): AutoCloseable

Calls handler for every type event while this listener is running. Higher priority runs first. Close the result to stop early; unregister does the same for all of them.

once

inline fun <T : Event> EventListener.once(priority: Short = 0, crossinline handler: (T) -> Unit): EventHook<T>

onChange

fun onChange(listener: ValueListener<MutableCollection<Value<*>>>): Value<MutableCollection<Value<*>>>

onChanged

fun onChanged(listener: ValueChangedListener<MutableCollection<Value<*>>>): Value<MutableCollection<Value<*>>>

onTick

open fun onTick(task: Runnable): AutoCloseable

task every game tick while this listener is running.

parent

open override fun parent(): EventListener?

Parent EventListener

percentageChance

fun ValueGroup.percentageChance(name: String, default: Float, range: ClosedFloatingPointRange<Float> = 0f..100f, randomGetter: Supplier<out RandomGenerator> = DEFAULT_RANDOM): PercentageChance<Float>

fun ValueGroup.percentageChance(name: String, default: Int, range: IntRange = 0..100, randomGetter: Supplier<out RandomGenerator> = DEFAULT_RANDOM): PercentageChance<Int>

prepareDeserialize

open fun prepareDeserialize(jsonObject: JsonObject)

Allows dynamic groups to create their children before stored values are applied.

regex

fun regex(name: String, default: Regex): Value<Regex>

regexList

fun <C : MutableCollection<Regex>> regexList(name: String, default: C): MutableListValue<C, Regex>

registryList

inline fun <T : SequencedSet<E>, E> registryList(name: String, defaultValue: T, valueType: ValueType): RegistryListValue<T, E>

fun <T : SequencedSet<E>, E> registryList(name: String, defaultValue: T, valueType: ValueType, innerType: Class<E>): RegistryListValue<T, E>

registryMutableList

inline fun <T : MutableList<E>, E> registryMutableList(name: String, defaultValue: T, valueType: ValueType): RegistryMutableListValue<T, E>

fun <T : MutableList<E>, E> registryMutableList(name: String, defaultValue: T, valueType: ValueType, innerType: Class<E>): RegistryMutableListValue<T, E>

removeEventListenerScope

fun EventListener.removeEventListenerScope()

Remove cached scope and cancel it.

repeated

inline fun <T : Event> EventListener.repeated(times: Int = 1, priority: Short = 1, crossinline handler: (T) -> Unit): EventHook<T>

restore

open override fun restore()

Restore all values to their default values

s2cPackets

fun <C : SequencedSet<Identifier>> s2cPackets(name: String, default: C): RegistryListValue<C, Identifier>

sequenceHandler

inline fun <T : Event> EventListener.sequenceHandler(priority: Short = 0, dispatcher: CoroutineDispatcher? = null, onCancellation: Runnable? = null, crossinline eventHandler: SuspendableEventHandler<T>): EventHook<T>

Registers an event hook for events of type T and launches a sequence

set

fun set(t: MutableCollection<Value<*>>)

fun set(t: MutableCollection<Value<*>>, apply: ValueChangedListener<MutableCollection<Value<*>>>)

setByString

open fun setByString(string: String)

setValue

operator fun setValue(u: Any?, property: KProperty<*>, t: MutableCollection<Value<*>>)

shouldSwitch

open override fun shouldSwitch(mineTarget: MineTarget): Boolean

sounds

fun <C : SequencedSet<SoundEvent>> sounds(name: String, default: C): RegistryListValue<C, SoundEvent>

suspendHandler

inline fun <T : Event> EventListener.suspendHandler(context: CoroutineContext = EmptyCoroutineContext, priority: Short = 0, behavior: SuspendHandlerBehavior = SuspendHandlerBehavior.Parallel.Default, noinline handler: SuspendableEventHandler<T>): EventHook<T>

Start a Job on event.

text

fun text(name: String, default: String): Value<String>

textList

fun <C : MutableCollection<String>> textList(name: String, default: C): MutableListValue<C, String>

tickHandler

inline fun EventListener.tickHandler(dispatcher: CoroutineDispatcher? = null, onCancellation: Runnable? = null, crossinline eventHandler: suspend CoroutineScope.() -> Unit): EventHook<GameTickEvent>

Registers a repeatable sequence which repeats the execution of code on GameTickEvent.

toString

open override fun toString(): String

tree

fun <T : ValueGroup> tree(valueGroup: T): T

treeAll

fun <T : ValueGroup> treeAll(vararg valueGroups: T)

type

fun type(): ValueType

unbind

fun Value<InputBind>.unbind()

Unbinds the key by setting it to UNKNOWN_KEY.

unregister

open fun unregister()

Unregisters the event handler from the manager. This decision is FINAL! After the class was unregistered we cannot restore the handlers.

until

inline fun <T : Event> EventListener.until(priority: Short = 0, crossinline handler: (T) -> Boolean): EventHook<T>

value

fun <V : Value<*>> value(value: V): V

fun <T : Any> value(name: String, defaultValue: T, valueType: ValueType = ValueType.INVALID, aliases: List<String> = emptyList()): Value<T>

vec2f

fun vec2f(name: String, default: Vector2fc): Value<Vector2fc>

vec3d

@JvmOverloads

fun vec3d(name: String, default: Vec3 = Vec3.ZERO, useLocateButton: Boolean = true, aliases: List<String> = emptyList()): Value<Vec3>

vec3i

@JvmOverloads

fun vec3i(name: String, default: Vec3i = Vec3i.ZERO, useLocateButton: Boolean = true, aliases: List<String> = emptyList()): Value<Vec3i>

visibleWhen

fun visibleWhen(condition: BooleanSupplier): Value<MutableCollection<Value<*>>>

waitMatches

inline suspend fun <T : Event> EventListener.waitMatches(priority: Short = 0, predicate: Predicate<T>): T

Wait an event of type T which matches given predicate.

suspend fun <T : Event> EventListener.waitMatches(eventClass: Class<T>, priority: Short, predicate: Predicate<T>): T

waitMatchesWithTimeout

inline suspend fun <T : Event> EventListener.waitMatchesWithTimeout(timeout: Duration, priority: Short = 0, predicate: Predicate<T>): T?

Wait an event of type T which matches given predicate. If the timeout is exceeded, return null.

walkInit

open fun walkInit()

walkKeyPath

fun walkKeyPath(previousBaseKey: String? = null)

Walks the path of the ValueGroup and its children

wrapContinuationInterceptor

fun EventListener.wrapContinuationInterceptor(original: ContinuationInterceptor? = null): ContinuationInterceptor

Wrap the original interceptor and make it auto-detect the listener's running state at suspension to determine whether to resume the continuation.