LiquidBounce/net.ccbluex.liquidbounce.utils.entity

Package-level declarations

Types

class CachedPlayerSimulation(val simulatedPlayer: SimulatedPlayerCache) : PlayerSimulation

Yes, this name sucks as SimulatedPlayerCache already exists, but I don't know a better name :/

class FallingPlayer(player: LocalPlayer, var x: Double, var y: Double, var z: Double, motionX: Double, motionY: Double, motionZ: Double, yRot: Float)

LinearPositionExtrapolation

class LinearPositionExtrapolation(basePosition: Vec3, velocity: Vec3) : PositionExtrapolation

A utility class which assumes that the subject is moving at a specified speed.

PlayerSimulation

interface PlayerSimulation

PlayerSimulationCache

object PlayerSimulationCache : EventListener

PlayerSimulationExtrapolation

class PlayerSimulationExtrapolation(simulation: SimulatedPlayerCache) : PositionExtrapolation

PositionExtrapolation

fun interface PositionExtrapolation

A utility which predicts the position of something in n ticks.

RenderedEntities

object RenderedEntities : Collection<LivingEntity> , EventListener

A readonly Collection containing all LivingEntity instances that meet the shouldBeShown condition.

SimulatedArrow

class SimulatedArrow(val level: Level, var pos: Vec3, var velocity: Vec3, collideEntities: Boolean = true)

SimulatedPlayer

class SimulatedPlayer(player: Player, var input: SimulatedPlayer.SimulatedPlayerInput, var pos: Vec3, var deltaMovement: Vec3, var boundingBox: AABB, var yRot: Float, var xRot: Float, var isSprinting: Boolean, var fallDistance: Double, jumpTriggerTime: Int, jumping: Boolean, fallFlying: Boolean, var onGround: Boolean, var horizontalCollision: Boolean, verticalCollision: Boolean, wasTouchingWater: Boolean, isSwimming: Boolean, wasUnderwater: Boolean, fluidHeight: Object2DoubleMap<TagKey<Fluid>>, eyeFluidTags: HashSet<TagKey<Fluid>>) : PlayerSimulation

SimulatedPlayerCache

class SimulatedPlayerCache(simulatedPlayer: SimulatedPlayer)

SimulatedPlayerSnapshot

data class SimulatedPlayerSnapshot(val pos: Vec3, val fallDistance: Double, val velocity: Vec3, val onGround: Boolean, val clipLedged: Boolean)

StrictInteractionResult

@JvmRecord

data class StrictInteractionResult(val hand: InteractionHand, val source: StrictInteractionSource, val result: InteractionResult) : Record

Strict means to 1:1 simulate net.minecraft.client.Minecraft.startUseItem logic: Try interact/useItemOn then useItem with each hand (main hand -> offhand).

StrictInteractionSource

enum StrictInteractionSource : Enum<StrictInteractionSource>

If the effective hand (item) is offhand, the packets are doubled (main hand -> offhand).

Properties

airTicks

val LocalPlayer.airTicks: Int

anyHorizontal

val Input.anyHorizontal: Boolean

armorItems

val LivingEntity.armorItems: Array<ItemStack>

box

val Entity.box: AABB

direction

val LocalPlayer.direction: Float

handItems

val LivingEntity.handItems: Array<ItemStack>

hasCooldown

val LocalPlayer.hasCooldown: Boolean

Check if the attack speed is below 1 tick. If so, we have a cooldown.

horizontalSpeed

val Entity.horizontalSpeed: Double

immuneToMagmaBlocks

val LocalPlayer.immuneToMagmaBlocks: Boolean

initial

val ClientInput.initial: Input

isBlockAction

val Player.isBlockAction: Boolean

isInsideWaterOrBubbleColumn

val Entity.isInsideWaterOrBubbleColumn: Boolean

isSlowDueToUsingItem

val Player.isSlowDueToUsingItem: Boolean

lastPos

val Entity.lastPos: Vec3

lastRotation

val LocalPlayer.lastRotation: Rotation

movementForward

var ClientInput.movementForward: Float

movementSideways

var ClientInput.movementSideways: Float

moving

val LocalPlayer.moving: Boolean

netherPosition

val Entity.netherPosition: Vec3

onGroundTicks

val LocalPlayer.onGroundTicks: Int

ping

val Player.ping: Int

rotation

val Entity.rotation: Rotation

untransformed

val ClientInput.untransformed: Input

wouldBlockHit

val LivingEntity.wouldBlockHit: Boolean

Functions

blockedByShield

fun LivingEntity.blockedByShield(source: DamageSource): Boolean

boxedDistanceTo

fun Entity.boxedDistanceTo(entity: Entity): Double

Allows to calculate the distance between the current entity and entity from the nearest corner of the bounding box

cameraDistance

fun Position.cameraDistance(): Double

cameraDistanceSq

fun Position.cameraDistanceSq(): Double

fun Vec3i.cameraDistanceSq(): Double

canStep

fun LocalPlayer.canStep(height: Double = 1.0): Boolean

Check if the player can step up by height blocks.

copy

inline fun Input.copy(forward: Boolean = this.forward, backward: Boolean = this.backward, left: Boolean = this.left, right: Boolean = this.right, jump: Boolean = this.jump, sneak: Boolean = this.shift, sprint: Boolean = this.sprint): Input

doesCollideAt

fun Entity.doesCollideAt(pos: Vec3 = player.position()): Boolean

Check if the entity box collides with any block in the world at the given pos.

doesNotCollideBelow

fun Entity.doesNotCollideBelow(until: Double = -64.0): Boolean

Check if the entity collides with anything below his bounding box.

getActualHealth

fun LivingEntity.getActualHealth(fromScoreboard: Boolean = true): Float

Sometimes the server does not publish the actual entity health with its metadata. This function incorporates other sources to get the actual value.

getBoundingBoxAt

fun Entity.getBoundingBoxAt(pos: Vec3): AABB

getDamageFromExplosion

fun LivingEntity.getDamageFromExplosion(pos: Vec3, power: Float = 6.0f, explosionRange: Float = power * 2f, damageDistance: Float = explosionRange * explosionRange, exclude: Array<BlockPos>? = null, include: BlockPos? = null, maxBlastResistance: Float? = null, entityBoundingBox: AABB? = null): Float

See ExplosionDamageCalculator.getEntityDamageAmount.

getEffectiveDamage

fun LivingEntity.getEffectiveDamage(source: DamageSource, damage: Float, ignoreShield: Boolean = false): Float

Applies armor, enchantments, effects, etc. to the damage and returns the damage that is actually applied. This function is so damn ugly that I turned off code smell analysis for it.

getExplosionDamageFromEntity

fun LivingEntity.getExplosionDamageFromEntity(entity: Entity): Float

getExposureToExplosion

fun LivingEntity.getExposureToExplosion(source: Vec3, exclude: Array<BlockPos>?, include: BlockPos?, maxBlastResistance: Float?, entityBoundingBox: AABB?): Float

Basically ServerExplosion.getSeenPercent but this method allows us to exclude blocks using exclude.

getFeetBlockPos

fun LocalPlayer.getFeetBlockPos(): BlockPos

getMovementDirectionOfInput

fun getMovementDirectionOfInput(facingYaw: Float, input: DirectionalInput = DirectionalInput(player.input)): Float

getMovementDirectionOfInput

@JvmOverloads

fun LocalPlayer.getMovementDirectionOfInput(input: DirectionalInput = DirectionalInput(this.input)): Float

hasHealthScoreboard

fun LivingEntity.hasHealthScoreboard(): Boolean

interactBlock

fun interactBlock(hitResult: BlockHitResult, hand: InteractionHand = InteractionHand.MAIN_HAND, swingMode: SwingMode = SwingMode.DO_NOT_HIDE): InteractionResult

Simulated net.minecraft.world.phys.HitResult.Type.BLOCK branch in vanilla No fallback MultiPlayerGameMode.useItem call

interactBlockLikeVanilla

fun interactBlockLikeVanilla(hitResult: BlockHitResult, swingMode: SwingMode = SwingMode.DO_NOT_HIDE, rotation: Rotation = RotationManager.currentRotation ?: player.rotation): StrictInteractionResult?

interactEntity

fun interactEntity(entity: Entity, hitResult: EntityHitResult = EntityHitResult(entity), hand: InteractionHand = InteractionHand.MAIN_HAND, swingMode: SwingMode = SwingMode.DO_NOT_HIDE): InteractionResult?

Simulated net.minecraft.world.phys.HitResult.Type.ENTITY branch in vanilla No fallback MultiPlayerGameMode.useItem call

interactEntityLikeVanilla

fun interactEntityLikeVanilla(entity: Entity, hitResult: EntityHitResult = EntityHitResult(entity), swingMode: SwingMode = SwingMode.DO_NOT_HIDE, rotation: Rotation = RotationManager.currentRotation ?: player.rotation): StrictInteractionResult?

interpolateCurrentPosition

fun Entity.interpolateCurrentPosition(tickDelta: Float): Vec3

interpolateCurrentRotation

fun Entity.interpolateCurrentRotation(tickDelta: Float): Rotation

isBurrowed

fun LocalPlayer.isBurrowed(): Boolean

isCloseToEdge

fun LocalPlayer.isCloseToEdge(directionalInput: DirectionalInput = DirectionalInput(this.input), distance: Double = 0.1, pos: Vec3 = this.position()): Boolean

isInHole

fun LocalPlayer.isInHole(feetBlockPos: BlockPos = getFeetBlockPos()): Boolean

isOnMagmaBlock

fun AABB.isOnMagmaBlock(): Boolean

lastRenderPos

fun Entity.lastRenderPos(): Vec3

linePointDistanceSquared

fun linePointDistanceSquared(l1: Vec3, l2: Vec3, p: Vec3): Double

Determines the squared distance between the line defined by l1 and l2 the point p

set

inline fun ClientInput.set(forward: Boolean = keyPresses.forward, backward: Boolean = keyPresses.backward, left: Boolean = keyPresses.left, right: Boolean = keyPresses.right, jump: Boolean = keyPresses.jump, sneak: Boolean = keyPresses.shift, sprint: Boolean = keyPresses.sprint)

setDeltaMovement

inline fun LocalPlayer.setDeltaMovement(block: (Vec3) -> Vec3)

shouldSwingHand

fun InteractionResult.shouldSwingHand(): Boolean

squareBoxedDistanceTo

fun Entity.squareBoxedDistanceTo(entity: Entity, offsetPos: Vec3): Double

squaredBoxedDistanceTo

fun Entity.squaredBoxedDistanceTo(entity: Entity): Double

fun Entity.squaredBoxedDistanceTo(otherPos: Vec3): Double

straightLinePointDistanceSquared

fun straightLinePointDistanceSquared(s: Vec3, r: Vec3, p: Vec3): Double

Determines the squared distance between the straight light defined by the base vector s and the direction vector r the point p

useItem

@JvmOverloads

fun useItem(hand: InteractionHand, yRot: Float = RotationManager.currentRotation?.yRot ?: player.yRot, xRot: Float = RotationManager.currentRotation?.xRot ?: player.xRot, swingMode: SwingMode = SwingMode.DO_NOT_HIDE): InteractionResult

useItemStrict

fun useItemStrict(yRot: Float = RotationManager.currentRotation?.yRot ?: player.yRot, xRot: Float = RotationManager.currentRotation?.xRot ?: player.xRot, swingMode: SwingMode = SwingMode.DO_NOT_HIDE): StrictInteractionResult?

warp

fun LocalPlayer.warp(pos: Vec3? = null, onGround: Boolean = false)

withStrafe

fun Vec3.withStrafe(speed: Double = horizontalDistance(), strength: Double = 1.0, input: DirectionalInput? = DirectionalInput(player.input), yaw: Float = player.getMovementDirectionOfInput(input ?: DirectionalInput(player.input))): Vec3

wouldBeCloseToFallOff

fun Player.wouldBeCloseToFallOff(position: Vec3): Boolean

wouldFallIntoVoid

fun Entity.wouldFallIntoVoid(pos: Vec3, voidLevel: Double = -64.0, safetyExpand: Double = 0.0): Boolean

Check if the entity is likely falling to the void based on the given position and bounding box.