rebar/io.github.pylonmc.rebar.util

Package-level declarations

Types

ConfettiParticle

class ConfettiParticle

MachineUpdateReason

class MachineUpdateReason : UpdateReason

Indicates a machine has updated an inventory slot.

enum MiningLevel : Enum<MiningLevel>

Represents the blocks that a tool made of some material is allowed to break.

open class Octree<N>(maxDepth: Int = DEFAULT_MAX_DEPTH, maxEntries: Int = DEFAULT_MAX_ENTRIES, bounds: BoundingBox, depth: Int, entryStrategy: (N) -> BoundingBox, storeOutOfBoundsEntries: Boolean = false) : Iterable<N>

RandomizedSound

data class RandomizedSound(val keys: Collection<Key>, val source: Sound.Source, val volume: Pair<Double, Double>, val pitch: Pair<Double, Double>)

class WeightedSet<E> @JvmOverloads constructor(innerSet: MutableSet<WeightedSet.Element<E>> = mutableSetOf()) : AbstractMutableSet<WeightedSet.Element<E>>

A set containing elements with associated weights. You can retrieve either a specified subset or a single element randomly, with the probability of each element being chosen proportional to its weight.

Properties

val CARDINAL_FACES: Array<BlockFace>

BlockFace.NORTH, BlockFace.EAST, BlockFace.SOUTH, BlockFace.WEST

DISALLOW_PLAYERS_FROM_ADDING_ITEMS_HANDLER

val DISALLOW_PLAYERS_FROM_ADDING_ITEMS_HANDLER: Consumer<ItemPreUpdateEvent>

A shorthand for a commonly used VirtualInventory handler which prevents players from removing items from it.

const val FLUID_EPSILON: Double = 1.0E-6

IMMEDIATE_FACES

val IMMEDIATE_FACES: Array<BlockFace>

BlockFace.UP, BlockFace.DOWN, BlockFace.EAST, BlockFace.WEST, BlockFace.SOUTH, BlockFace.NORTH

IMMEDIATE_FACES_WITH_DIAGONALS

val IMMEDIATE_FACES_WITH_DIAGONALS: Array<BlockFace>

Same as IMMEDIATE_FACES but includes diagonal faces, not including the vertical directions.

val Player.pdc: PersistentDataContainer

val Component.plainText: String

replaceableOrAir

val Block.replaceableOrAir: Boolean

Functions

fun axeMineable(): Tag<BlockType>

fun blocksBetween(from: BlockPosition, to: BlockPosition): List<Block>

fun blocksOnPath(from: BlockPosition, to: BlockPosition): List<Block>

Does not include first or last block

fun blocksWithin(world: World, boundingBox: BoundingBox): List<Block>

createChildContext

fun CoroutineContext.createChildContext(): CoroutineContext

Creates a CoroutineContext for a child coroutine, with a Job that is a child of the current context's Job

fun damageItem(itemStack: ItemStack, amount: Int, world: World, onBreak: (Material) -> Unit = {}, force: Boolean = false)

fun damageItem(itemStack: ItemStack, amount: Int, entity: LivingEntity, slot: EquipmentSlot, force: Boolean = false)

suspend fun delayTicks(ticks: Long)

inline fun <T : Any> ItemStack.editData(type: DataComponentType.Valued<T>, block: (T) -> T): ItemStack

editDataOrDefault

inline fun <T : Any> ItemStack.editDataOrDefault(type: DataComponentType.Valued<T>, block: (T) -> T): ItemStack

inline fun <T : Any> ItemStack.editDataOrSet(type: DataComponentType.Valued<T>, block: (T?) -> T): ItemStack

fun faceToYaw(face: BlockFace): Double

Returns the yaw (in radians) that a face has, starting at NORTH and going counterclockwise.

findClosestDistanceBetweenLineAndPoint

fun findClosestDistanceBetweenLineAndPoint(p: Vector3f, p1: Vector3f, d1: Vector3f): Float

Unidirectional, meaning if the closest point is 'behind' the starting point, returns the distance from the starting point.

findClosestPointBetweenSkewLines

fun findClosestPointBetweenSkewLines(p1: Vector3f, d1: Vector3f, p2: Vector3f, d2: Vector3f): Float

findClosestPointToOtherPointOnLine

fun findClosestPointToOtherPointOnLine(p: Vector3f, p1: Vector3f, d1: Vector3f): Float

fun Inventory.findRebar(targetItem: RebarItemSchema): Int?

Finds a Rebar item in this inventory. Use this to find Rebar items instead of traditional find methods, because this will compare Rebar IDs.

fun Inventory.findType(targetType: ItemTypeWrapper): Int?

Finds an item of the right type in this inventory. Use this to find items purely based on Vanilla / Rebar IDs.

fromMiniMessage

fun fromMiniMessage(string: String): Component

Small helper function to convert a minimessage string (eg: 'bruh') into a component

fun getAddon(key: NamespacedKey): RebarAddon

getBlockBreakTicks

fun getBlockBreakTicks(tool: ItemStack, block: Block): Float

fun Block.getRelative(vector: Vector3i): @NotNull Block

fun Entity.hasTracker(): Boolean

fun hoeMineable(): Tag<BlockType>

isCardinalDirection

fun isCardinalDirection(vector: Vector3f): Boolean

fun isCardinalDirection(vector: Vector3i): Boolean

fun isFakeEvent(event: Event): Boolean

(Heuristically) checks whether an event is 'fake' (by checking if it has 'Fake' in its name)

@JvmName(name = "isKeyFromAddon")

fun NamespacedKey.isFromAddon(addon: RebarAddon): Boolean

Checks whether a NamespacedKey is from addon

isRebarAndIsNot

inline fun <T> ItemStack?.isRebarAndIsNot(): Boolean

fun Class<*>.isSubclassOf(other: Class<*>): Boolean

perpendicularImmediateFaces

fun perpendicularImmediateFaces(face: BlockFace): List<BlockFace>

Returns all the immediate faces that are perpendicular to the given face

fun <T> persistentData(key: NamespacedKey, type: PersistentDataType<*, T & Any>, default: T): ReadWriteProperty<PersistentDataHolder, T>

Same as persistentData but with a default value that is constant

inline fun <T> persistentData(key: NamespacedKey, type: PersistentDataType<*, T & Any>, crossinline default: () -> T): ReadWriteProperty<PersistentDataHolder, T>

Acts as a property delegate for stuff contained inside a PersistentDataContainer For example:

pickaxeMineable

fun pickaxeMineable(): Tag<BlockType>

rotateFaceToReference

fun rotateFaceToReference(referenceFace: BlockFace, face: BlockFace): BlockFace

Rotates face to be relative to referenceFace.

rotateVectorToFace

fun rotateVectorToFace(vector: Vector3d, face: BlockFace): Vector3d

fun rotateVectorToFace(vector: Vector3i, face: BlockFace): Vector3i

Rotates vector to face a direction

fun Entity.scheduleRemove(): @NotNull BukkitTask

Schedules the entity to be removed next tick

fun <P, C> PersistentDataContainer.setNullable(key: NamespacedKey, type: PersistentDataType<P, C>, value: C?)

Wrapper around PersistentDataContainer.set that allows nullable values to be passed

fun shovelMineable(): Tag<BlockType>

fun Inventory.swapItem(from: Int, to: Int)

vanillaDisplayName

fun ItemStack.vanillaDisplayName(): Component

vectorToBlockFace

fun vectorToBlockFace(vector: Vector): BlockFace

fun vectorToBlockFace(vector: Vector3d): BlockFace

fun vectorToBlockFace(vector: Vector3f): BlockFace

fun vectorToBlockFace(vector: Vector3i): BlockFace

Converts an orthogonal vector to a BlockFace

@JvmName(name = "attachArguments")

fun Component.withArguments(args: List<TranslationArgumentLike>): Component

Attaches arguments to a component and all its children.