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

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>

enabledEffect

open suspend fun enabledEffect()

Launches an async task on eventListenerScope when module is turned on.

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<*>>

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>

message

fun message(key: String, vararg args: Any): MutableComponent

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>

modifyDrawSide

fun modifyDrawSide(blockState: BlockState, level: BlockGetter, blockPos: BlockPos, side: Direction, original: Boolean): Boolean

Keeps vanilla/Sodium face culling unless this is a whitelisted XRay block hidden behind another block.

modifyShouldRenderFace

fun modifyShouldRenderFace(original: Boolean, state: BlockState, otherState: BlockState, side: Direction): Boolean

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<*>>>

onDisabled

open override fun onDisabled()

Will be called when the state is toggled off.

onEnabled

open override fun onEnabled()

Will be called when the state is toggled on.

onEnabledValueRegistration

override fun onEnabledValueRegistration(value: Value<Boolean>): Value<Boolean>

onRegistration

open fun onRegistration()

Called when the module is registered in the module manager.

onTick

open fun onTick(task: Runnable): AutoCloseable

task every game tick while this listener is running.

onToggled

fun onToggled(state: Boolean, isParentUpdate: Boolean): Boolean

override fun onToggled(state: Boolean): Boolean

The listener that will be called when the state is toggled. By default, it will simply call onEnabled or onDisabled depending on the state.

parent

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.

renderActive

@JvmStatic

fun renderActive(): Boolean

Whether XRay applies here: the value captured by a meshing scope, or the live state outside a build. Sodium's face checks read their per block cache; this serves the fallback, vanilla and light paths.

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<*>>)

shouldRender

fun shouldRender(blockState: BlockState, blockPos: BlockPos): Boolean

Checks if the block should be rendered or not. This can be used to exclude blocks that should not be rendered. Also features an option to only render blocks that are exposed to air.

shouldRenderTransparentBackground

fun shouldRenderTransparentBackground(blockState: BlockState): Boolean

shouldSkipRender

fun shouldSkipRender(blockState: BlockState, blockPos: BlockPos): 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.

tagBy

fun tagBy(setting: Value<*>)

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

transparentBackgroundAlpha

fun transparentBackgroundAlpha(blockState: BlockState): Int

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>

verifyFallbackDescription

fun verifyFallbackDescription()

Warns when no module description is set in the main translation file.

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.