rebar

1.0.0-SNAPSHOT

rebar/io.github.pylonmc.rebar.util

Package-level declarations

Types

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.

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 blocksOnPath(from: BlockPosition, to: BlockPosition): List<Block>

Does not include first or last block

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)

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

findRebarItemInInventory

fun findRebarItemInInventory(inventory: Inventory, targetItem: RebarItem): Int?

Finds a Rebar item in an inventory. Use this to find Rebar items instead of traditional find methods, because this will compare 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): <Error class: unknown class>

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

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): <Error class: unknown class>

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>

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.