LiquidBounce/net.ccbluex.liquidbounce.features.marketplace.autoconfig/ConfigTracker

ConfigTracker

object ConfigTracker : Config, EventListener

Tracks the marketplace config the client runs.

A loaded config is State.TRACKED while the settings match what was loaded and State.EDITING once they differ. The settings from before the first load are kept as a backup until the user restores or detaches.

A config's config dependencies are applied before it, depth-first in their order, and its add-on and script dependencies are installed. The settings after the dependencies are its base: an overlay only publishes what differs from it.

Loading a local config over it stops tracking, unless the local config was saved from it; see loadedLocal.

Types

LoadResult

data class LoadResult(val installed: List<MarketplaceItem>, val restartRequired: Boolean, val unavailable: List<Unavailable>)

Dependencies load installed; restartRequired when one only works after a restart. unavailable are the ones left out since they or what they need do not load with this game.

State

enum State : Tagged, Enum<ConfigTracker.State>

Step

data class Step(val itemId: Int, val revisionId: Int)

Properties

address

val address: String

author/name of the tracked config, or its name while the author is unknown.

aliases

val aliases: List<String>

base

var base: ValueGroup?

Stores the ValueGroup in which the ValueGroup is included, can be null.

baseKey

open val baseKey: String

The base key used when base is null, otherwise the baseKey from base is used when its base is null and so on.

chain

val chain: List<ConfigTracker.Step>

Config dependencies applied before the tracked config, in order.

containedValues

@get:JvmName(name = "getContainedValues")

val containedValues: Array<Value<*>>

debugDisplayName

open override val debugDisplayName: FormattedCharSequence

debugOwnerId

open override val debugOwnerId: String

description

open var description: Supplier<String?>

descriptionKey

var descriptionKey: String?

doNotInclude

var doNotInclude: BooleanSupplier

If true, value will not be included in generated public config. Can be set using doNotIncludeWhen or doNotIncludeAlways.

eventListenerScope

val EventListener.eventListenerScope: CoroutineScope

Get the related CoroutineScope of receiver EventListener.

hasBackup

val hasBackup: Boolean

hasBase

val hasBase: Boolean

hasLiteralDescription

var hasLiteralDescription: Boolean

inclusionGroup

var inclusionGroup: OptionalInclusion?

Group for optional inclusion during configuration saving. Managed by AutoConfig.

independentDescription

var independentDescription: Boolean

If true, the description won't be bound to any net.ccbluex.liquidbounce.config.types.group.ValueGroup.

isImmutable

var isImmutable: Boolean

If true, value will always keep inner equals defaultValue.

isPersistent

var isPersistent: Boolean

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.

itemAuthor

var itemAuthor: String

var itemId: Int

var itemName: String

var itemUid: String

val jsonFile: File

val jsonTmpFile: File

We write to this temp file, we can safely rename jsonTmpFile to jsonFile, to eliminate any chances of data loss.

key

var key: String?

localName

var localName: String

The local config that last replaced the settings, until a marketplace config does.

name

@SerializedName(value = "name")

val name: String

notAnOption

var notAnOption: Boolean

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

revisionId

var revisionId: Int

running

open val running: Boolean

Returns whether the listenable is running or not, this is based on the parent listenable and if no parent is present, it will return the opposite of isDestructed.

state

var state: ConfigTracker.State

trackedItemId

val trackedItemId: Int?

Id of the tracked config, which a local config saved now keeps as its origin.

valueType

val valueType: ValueType

visibleCondition

var visibleCondition: BooleanSupplier

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

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.

create

suspend fun create(session: OAuthSession, name: String, description: String, details: MarketplaceApi.ItemDetails): MarketplaceItem

Publishes the current settings as a new config and tracks it.

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

delete

suspend fun delete(session: OAuthSession)

deserializeFrom

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

Deserialize value from JSON

detach

suspend fun detach()

Keeps the current settings and stops tracking.

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>

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

fork

suspend fun fork(session: OAuthSession, name: String, description: String, visibility: MarketplaceItemVisibility): MarketplaceItem

Publishes the edited settings as a new config that links back to the tracked revision.

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.

load

suspend fun load(item: MarketplaceItem, revisionId: Int, modules: Collection<ValueGroup> = emptyList()): ConfigTracker.LoadResult

Applies revisionId of item after its config dependencies and installs its add-on and script dependencies. A full load starts tracking it, a load restricted to modules only applies that slice of every step.

loadedLocal

fun loadedLocal(name: String, origin: Int?, partial: Boolean): String?

Settings of the local config name were applied, only some modules of it when partial. A partial load, or one of a config saved from the tracked one (origin is its trackedItemId), goes on as edits of the tracked config. Any other replaces it: tracking stops, the backup stays.

loadExternal

suspend fun loadExternal(source: String, modules: Collection<ValueGroup> = emptyList())

Applies a config that does not come from the marketplace. It stops tracking but keeps the backup.

loadFromDisk

fun loadFromDisk()

Re-reads the file, dropping unsaved changes.

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.

overlay

suspend fun overlay(session: OAuthSession, name: String, description: String, visibility: MarketplaceItemVisibility): MarketplaceItem

Publishes only what was changed on top of the tracked config, as a new config that depends on it, and tracks that.

parent

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

renamed

fun renamed(item: MarketplaceItem)

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

restoreBackup

suspend fun restoreBackup()

Returns to the settings from before the first marketplace load.

revert

suspend fun revert()

Re-applies the tracked revision and its config dependencies, dropping local edits.

s2cPackets

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

saveToDisk

fun saveToDisk()

Writes the file now; the client does so on exit anyway.

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

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>

update

suspend fun update(session: OAuthSession, changelog: String?): MarketplaceItemRevision

Uploads the edited settings as the tracked config's newest revision. With config dependencies, only what differs from them.

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.