LiquidBounce/net.ccbluex.liquidbounce.utils.block.placer/BlockPlacer

BlockPlacer

class BlockPlacer(name: String, val module: ClientModule, val priority: Priority, val slotFinder: Function<BlockPos?, HotbarItemSlot?>, allowSupportPlacements: Boolean = true) : ValueGroup, EventListener

Constructors

BlockPlacer

constructor(name: String, module: ClientModule, priority: Priority, slotFinder: Function<BlockPos?, HotbarItemSlot?>, allowSupportPlacements: Boolean = true)

Properties

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.

blocks

val blocks: Long2BooleanLinkedOpenHashMap

Stores all block positions where blocks should be placed paired with a boolean that is true if the position was added by support.

constructFailResult

val constructFailResult: Boolean

Construct a hit result at the point selected by target finding when the raytrace result is invalid. This can make the module rotations wrong as well as place a bit outside the range, but it makes the placements a lot more reliable and works on most servers.

containedValues

@get:JvmName(name = "getContainedValues")

val containedValues: Array<Value<*>>

cooldown

val cooldown: IntRange

crystalDestroyer

val crystalDestroyer: CrystalDestroyFeature

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.

hasLiteralDescription

var hasLiteralDescription: Boolean

ignoreOpenInventory

val ignoreOpenInventory: Boolean

ignoreUsingItem

val ignoreUsingItem: 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.

key

var key: String?

module

val module: ClientModule

name

@SerializedName(value = "name")

val name: String

notAnOption

var notAnOption: Boolean

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

placedRenderer

val placedRenderer: PlacementRenderer

Renders all placements.

priority

val priority: Priority

ranAction

var ranAction: Boolean

range

val range: Float

rotationMode

val rotationMode: ModeValueGroup<BlockPlacerRotationMode>

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.

slotFinder

val slotFinder: Function<BlockPos?, HotbarItemSlot?>

slotResetDelay

val slotResetDelay: IntRange

support

val support: SupportFeature

swingMode

val swingMode: SwingMode

targetRenderer

val targetRenderer: PlacementRenderer

Renders all tracked positions that are queued to be placed.

ticksToWait

var ticksToWait: Int

valueType

val valueType: ValueType

visibleCondition

var visibleCondition: BooleanSupplier

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

wallRange

val wallRange: Float

worldChangeHandler

val worldChangeHandler: EventHook<WorldChangeEvent>

Functions

addToQueue

fun addToQueue(pos: BlockPos, update: Boolean = true, isSupport: Boolean = false)

Adds a block to be placed.

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>

canClickPlace

fun canClickPlace(pos: BlockPos): Boolean

Checks whether the player can currently click-place a block at pos from their position.

canReach

fun canReach(pos: BlockPos, rotation: Rotation): Boolean

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

clear

fun clear()

Discards all blocks.

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

fun disable()

This should be called when the module using this placer is disabled.

doNotIncludeAlways

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

doNotIncludeWhen

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

doPlacement

fun doPlacement(isSupport: Boolean, pos: BlockPos, placementTarget: BlockPlacementTarget): Boolean

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

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>

isDone

fun isDone(): Boolean

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>

placeInstantOnBlockUpdate

fun BlockPlacer.placeInstantOnBlockUpdate(event: PacketEvent)

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.

removeFromQueue

fun removeFromQueue(pos: BlockPos)

Removes a block from the queue.

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

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

fun update(positions: Collection<BlockPos>)

Removes all positions that are not in positions and adds all that are not in the queue.

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.