LiquidBounce/net.ccbluex.liquidbounce.features.command.commands.ingame.fakeplayer/FakePlayer

FakePlayer

open class FakePlayer(level: ClientLevel, gameProfile: GameProfile, var onRemoval: Consumer<in FakePlayer>? = null) : RemotePlayer, MinecraftShortcuts

This class represents a Fake Player implementing attackability and assured totem pops instead of death into RemotePlayer.

Inheritors

MovingFakePlayer

Constructors

FakePlayer

constructor(level: ClientLevel, gameProfile: GameProfile, onRemoval: Consumer<in FakePlayer>? = null)

Properties

abilities

open val abilities: Abilities

absorptionAmount

open var absorptionAmount: Float

activeEffects

open val activeEffects: Collection<MobEffectInstance>

activeEffectsMap

open val activeEffectsMap: Map<Holder<MobEffect>, MobEffectInstance>

activeItem

open val activeItem: ItemStack

ageScale

open val ageScale: Float

airSupply

open var airSupply: Int

armorCoverPercentage

open val armorCoverPercentage: Float

armorItems

val LivingEntity.armorItems: Array<ItemStack>

armorKnockbackResistance

val DataComponentGetter.armorKnockbackResistance: Double

armorToughness

val DataComponentGetter.armorToughness: Double

armorValue

open val armorValue: Int

armorValue

val DataComponentGetter.armorValue: Double

arrowCount

var arrowCount: Int

attachments

val attachments: EntityAttachments

attackAnim

var attackAnim: Float

attackStrengthTicker

var attackStrengthTicker: Int

attributes

open val attributes: AttributeMap

autoSpinAttackDmg

var autoSpinAttackDmg: Float

bbHeight

val bbHeight: Float

bbWidth

val bbWidth: Float

bedOrientation

open val bedOrientation: @Nullable Direction?

blockPosBelowThatAffectsMyMovement

open val blockPosBelowThatAffectsMyMovement: BlockPos

blocksAttacksComponent

val DataComponentGetter.blocksAttacksComponent: @Nullable BlocksAttacks?

blocksBuilding

var blocksBuilding: Boolean

blockSpeedFactor

open val blockSpeedFactor: Float

blockStateOn

open val blockStateOn: BlockState

val blockX: Int

val blockY: Int

val blockZ: Int

var boundingBox: AABB

box

val Entity.box: AABB

brain

open val brain: Brain<*>

combatTracker

open val combatTracker: CombatTracker

containerInteractionRange

open val containerInteractionRange: Double

containerMenu

var containerMenu: AbstractContainerMenu

controlledVehicle

open val controlledVehicle: @Nullable Entity?

controllingPassenger

open val controllingPassenger: @Nullable LivingEntity?

cooldowns

open val cooldowns: ItemCooldowns

currentExplosionCause

var currentExplosionCause: @Nullable Entity?

currentImpulseImpactPos

var currentImpulseImpactPos: @Nullable Vec3?

currentItemAttackStrengthDelay

open val currentItemAttackStrengthDelay: Float

customName

open var customName: @Nullable Component?

deathTime

var deathTime: Int

deltaMovement

open var deltaMovement: Vec3

dimensionChangingDelay

open val dimensionChangingDelay: Int

dimensions

var dimensions: EntityDimensions

direction

open val direction: Direction

dismountPoses

open val dismountPoses: ImmutableList<Pose>

displayName

open val displayName: Component

elytraAnimationState

val elytraAnimationState: ElytraAnimationState

enchantmentSeed

open val enchantmentSeed: Int

enderChestInventory

open val enderChestInventory: PlayerEnderChestContainer

entityData

open val entityData: SynchedEntityData

equipmentSlot

val DataComponentGetter.equipmentSlot: EquipmentSlot?

equippableComponent

val DataComponentGetter.equippableComponent: @Nullable Equippable?

experienceLevel

var experienceLevel: Int

experienceProgress

var experienceProgress: Float

eyeHeight

val eyeHeight: Float

eyePosition

val eyePosition: Vec3

eyeY

open val eyeY: Double

fallDistance

var fallDistance: Double

fallFlyingTicks

open val fallFlyingTicks: Int

fallSounds

open val fallSounds: LivingEntity.Fallsounds

feedbackDisplayName

open val feedbackDisplayName: Component

firstPassenger

open val firstPassenger: @Nullable Entity?

fishing

var fishing: @Nullable FishingHook?

fluidHeight

var fluidHeight: Object2DoubleMap<TagKey<Fluid>>

fluidJumpThreshold

open val fluidJumpThreshold: Double

fluidOnEyes

val fluidOnEyes: Set<TagKey<Fluid>>

flyDist

var flyDist: Float

foodComponent

val DataComponentGetter.foodComponent: FoodProperties?

foodData

open val foodData: FoodData

forward

open val forward: Vec3

gameProfile

open val gameProfile: GameProfile

gpuDevice

open val gpuDevice: GpuDevice

gravity

val gravity: Double

handItems

val LivingEntity.handItems: Array<ItemStack>

headLookAngle

open val headLookAngle: Vec3

health

open var health: Float

horizontalCollision

var horizontalCollision: Boolean

horizontalSpeed

val Entity.horizontalSpeed: Double

hurtDir

open val hurtDir: Float

hurtDuration

var hurtDuration: Int

hurtMarked

var hurtMarked: Boolean

hurtTime

var hurtTime: Int

open var id: Int

inBlockState

open val inBlockState: BlockState

indirectPassengers

open val indirectPassengers: Iterable<Entity>

interaction

open val interaction: MultiPlayerGameMode

interpolation

open val interpolation: InterpolationHandler

inventory

open val inventory: Inventory

inventoryMenu

val inventoryMenu: InventoryMenu

invulnerableTime

var invulnerableTime: Int

isAffectedByFluids

open val isAffectedByFluids: Boolean

isAffectedByPotions

open val isAffectedByPotions: Boolean

isAlive

open val isAlive: Boolean

isAlwaysTicking

open val isAlwaysTicking: Boolean

isAttackable

open val isAttackable: Boolean

isAutoSpinAttack

open val isAutoSpinAttack: Boolean

isBaby

open val isBaby: Boolean

isBlockAction

val Player.isBlockAction: Boolean

isBlocking

open val isBlocking: Boolean

isClientAuthoritative

open val isClientAuthoritative: Boolean

isCreative

open val isCreative: Boolean

isCrouching

open val isCrouching: Boolean

isCurrentlyGlowing

open val isCurrentlyGlowing: Boolean

isCustomNameVisible

open var isCustomNameVisible: Boolean

isDeadOrDying

open val isDeadOrDying: Boolean

isDescending

open val isDescending: Boolean

isDiscrete

open val isDiscrete: Boolean

isEffectiveAi

open val isEffectiveAi: Boolean

isFallFlying

open val isFallFlying: Boolean

isFlyingVehicle

open val isFlyingVehicle: Boolean

isFreezing

open val isFreezing: Boolean

isFullyFrozen

open val isFullyFrozen: Boolean

isHurt

open val isHurt: Boolean

isIgnoringBlockTriggers

open val isIgnoringBlockTriggers: Boolean

isIgnoringFallDamageFromCurrentImpulse

open val isIgnoringFallDamageFromCurrentImpulse: Boolean

isInClouds

open val isInClouds: Boolean

isInLava

open val isInLava: Boolean

isInLiquid

open val isInLiquid: Boolean

isInPostImpulseGraceTime

open val isInPostImpulseGraceTime: Boolean

isInPowderSnow

var isInPowderSnow: Boolean

isInShallowWater

open val isInShallowWater: Boolean

isInsideWaterOrBubbleColumn

val Entity.isInsideWaterOrBubbleColumn: Boolean

isInterpolating

val isInterpolating: Boolean

isInvertedHealAndHarm

open val isInvertedHealAndHarm: Boolean

isInvisible

open var isInvisible: Boolean

isInvulnerable

open var isInvulnerable: Boolean

isInWall

open val isInWall: Boolean

isInWater

open val isInWater: Boolean

isInWaterOrRain

open val isInWaterOrRain: Boolean

isJumping

open var isJumping: Boolean

isLocalInstanceAuthoritative

val isLocalInstanceAuthoritative: Boolean

isLocalPlayer

open val isLocalPlayer: Boolean

isMobilityRestricted

open val isMobilityRestricted: Boolean

isNoGravity

open var isNoGravity: Boolean

isOnFire

open val isOnFire: Boolean

isOnPortalCooldown

open val isOnPortalCooldown: Boolean

isOnRails

open val isOnRails: Boolean

isPassenger

open val isPassenger: Boolean

isPickable

open val isPickable: Boolean

isPushable

open val isPushable: Boolean

isPushedByFluid

open val isPushedByFluid: Boolean

isReducedDebugInfo

open var isReducedDebugInfo: Boolean

isRemoved

val isRemoved: Boolean

isScoping

open val isScoping: Boolean

isSecondaryUseActive

open val isSecondaryUseActive: Boolean

isSensitiveToWater

open val isSensitiveToWater: Boolean

isShiftKeyDown

open var isShiftKeyDown: Boolean

isSilent

open var isSilent: Boolean

isSleeping

open val isSleeping: Boolean

isSleepingLongEnough

open val isSleepingLongEnough: Boolean

isSlowDueToUsingItem

val Player.isSlowDueToUsingItem: Boolean

isSpectator

open val isSpectator: Boolean

isSprinting

open var isSprinting: Boolean

isSteppingCarefully

open val isSteppingCarefully: Boolean

isSuppressingBounce

open val isSuppressingBounce: Boolean

isSuppressingSlidingDownLadder

open val isSuppressingSlidingDownLadder: Boolean

isSwimming

open var isSwimming: Boolean

isTextFilteringEnabled

open val isTextFilteringEnabled: Boolean

isTransmittingWaypoint

open val isTransmittingWaypoint: Boolean

isUnderWater

open val isUnderWater: Boolean

isUsingItem

open val isUsingItem: Boolean

isVehicle

open val isVehicle: Boolean

isVisuallyCrawling

open val isVisuallyCrawling: Boolean

isVisuallySwimming

open val isVisuallySwimming: Boolean

itemBlockingWith

open val itemBlockingWith: @Nullable ItemStack?

jumpBoostPower

open val jumpBoostPower: Float

jumping

var jumping: Boolean

jumpPower

open val jumpPower: Float

killCredit

open val killCredit: @Nullable LivingEntity?

knownMovement

open val knownMovement: Vec3

knownSpeed

open val knownSpeed: Vec3

lastAttacker

open val lastAttacker: LivingEntity

lastClimbablePos

open val lastClimbablePos: Optional<BlockPos>

lastDamageSource

open val lastDamageSource: @Nullable DamageSource?

lastDeathLocation

open var lastDeathLocation: Optional<GlobalPos>

lastHurtByMob

open var lastHurtByMob: @Nullable LivingEntity?

lastHurtByMobTimestamp

open val lastHurtByMobTimestamp: Int

lastHurtByPlayer

open val lastHurtByPlayer: @Nullable Player?

lastHurtByPlayerMemoryTime

open val lastHurtByPlayerMemoryTime: Int

lastHurtMob

open val lastHurtMob: @Nullable LivingEntity?

lastHurtMobTimestamp

open val lastHurtMobTimestamp: Int

lastPos

val Entity.lastPos: Vec3

lightLevelDependentMagicValue

open val lightLevelDependentMagicValue: Float

livingEntity

open val livingEntity: LivingEntity

lookAngle

open val lookAngle: Vec3

lootTable

open val lootTable: Optional<ResourceKey<LootTable>>

lootTableSeed

open val lootTableSeed: Long

luck

open val luck: Float

mainArm

open var mainArm: HumanoidArm

mainHandItem

open val mainHandItem: ItemStack

mainSupportingBlockPos

var mainSupportingBlockPos: Optional<BlockPos>

maxAbsorption

val maxAbsorption: Float

maxAirSupply

open val maxAirSupply: Int

maxFallDistance

open val maxFallDistance: Int

maxHealth

val maxHealth: Float

open val mc: Minecraft

minorHorizontalCollision

var minorHorizontalCollision: Boolean

motionDirection

open val motionDirection: Direction

moveDist

var moveDist: Float

name

open val name: Component

nearestViewDirection

open val nearestViewDirection: Direction

needsSync

var needsSync: Boolean

netherPosition

val Entity.netherPosition: Vec3

network

open val network: ClientPacketListener

noActionTime

open var noActionTime: Int

noJumpDelay

var noJumpDelay: Int

noPhysics

var noPhysics: Boolean

oAttackAnim

var oAttackAnim: Float

offhandItem

open val offhandItem: ItemStack

onPos

open val onPos: BlockPos

onPosLegacy

open val onPosLegacy: BlockPos

onRemoval

var onRemoval: Consumer<in FakePlayer>?

passengers

val passengers: List<Entity>

passengersAndSelf

open val passengersAndSelf: Stream<Entity>

percentFrozen

open val percentFrozen: Float

pickRadius

open val pickRadius: Float

pickResult

open val pickResult: @Nullable ItemStack?

ping

val Player.ping: Int

pistonPushReaction

open val pistonPushReaction: PushReaction

plainTextName

open val plainTextName: String

player

open val player: LocalPlayer

playerInfo

open val playerInfo: @Nullable PlayerInfo?

portalCooldown

open var portalCooldown: Int

portalProcess

var portalProcess: @Nullable PortalProcessor?

pose

open var pose: Pose

positionCodec

open val positionCodec: VecDeltaCodec

quadLeashHolderOffsets

open val quadLeashHolderOffsets: Array<out Vec3>

random

open val random: RandomSource

randomY

open val randomY: Double

remainingFireTicks

open var remainingFireTicks: Int

removalReason

open val removalReason: Entity.RemovalReason

removeArrowTime

var removeArrowTime: Int

removeStingerTime

var removeStingerTime: Int

requiresPrecisePosition

open var requiresPrecisePosition: Boolean

rootVehicle

open val rootVehicle: Entity

rotation

val Entity.rotation: Rotation

rotationVector

open val rotationVector: Vec2

scale

val scale: Float

score

open var score: Int

scoreboardName

open val scoreboardName: String

secondsToDisableBlocking

open val secondsToDisableBlocking: Float

selfAndPassengers

open val selfAndPassengers: Stream<Entity>

shoulderParrotLeft

open var shoulderParrotLeft: Optional<Parrot.Variant>

shoulderParrotRight

open var shoulderParrotRight: Optional<Parrot.Variant>

skin

open val skin: PlayerSkin

sleepingPos

open val sleepingPos: Optional<BlockPos>

sleepTimer

open val sleepTimer: Int

soundSource

open val soundSource: SoundSource

speed

open var speed: Float

stingerCount

var stingerCount: Int

stringUUID

open val stringUUID: String

swinging

var swinging: Boolean

swingingArm

var swingingArm: InteractionHand

swingTime

var swingTime: Int

Functions

absSnapRotationTo

open fun absSnapRotationTo(yRot: Float, xRot: Float)

absSnapTo

open fun absSnapTo(x: Double, y: Double, z: Double)

open fun absSnapTo(x: Double, y: Double, z: Double, yRot: Float, xRot: Float)

activeLocationDependentEnchantments

open fun activeLocationDependentEnchantments(slot: EquipmentSlot): Map<Enchantment, Set<EnchantmentLocationBasedEffect>>

addDeltaMovement

open fun addDeltaMovement(addend: Vec3)

addEffect

fun addEffect(effectInstance: MobEffectInstance): Boolean

open fun addEffect(effectInstance: MobEffectInstance, entity: @Nullable Entity?): Boolean

addItem

open fun addItem(stack: ItemStack): Boolean

addTag

open fun addTag(tag: String): Boolean

adjustSpawnLocation

open fun adjustSpawnLocation(level: ServerLevel, pos: BlockPos): BlockPos

aiStep

open fun aiStep()

animateHurt

open fun animateHurt(yaw: Float)

applyComponentsFromItemStack

fun applyComponentsFromItemStack(stack: ItemStack)

applyEffectsFromBlocks

open fun applyEffectsFromBlocks(oldPosition: Vec3, position: Vec3)

applyItemBlocking

open fun applyItemBlocking(level: ServerLevel, damageSource: DamageSource, damageAmount: Float): Float

applyPostImpulseGraceTime

open fun applyPostImpulseGraceTime(ticks: Int)

asLivingEntity

open fun asLivingEntity(): @Nullable LivingEntity?

attack

open fun attack(target: Entity)

attackable

open fun attackable(): Boolean

avatarState

open fun avatarState(): ClientAvatarState

awardKillScore

open fun awardKillScore(entity: Entity, damageSource: DamageSource)

awardRecipes

open fun awardRecipes(recipes: Collection<RecipeHolder<*>>): Int

awardRecipesByKey

open fun awardRecipesByKey(recipes: List<ResourceKey<Recipe<*>>>)

awardStat

open fun awardStat(statKey: Identifier)

open fun awardStat(stat: Stat<*>)

open fun awardStat(stat: Identifier, increment: Int)

open fun awardStat(stat: Stat<*>, increment: Int)

baseTick

open fun baseTick()

belowNameDisplay

open fun belowNameDisplay(): @Nullable Component?

blockActionRestricted

open fun blockActionRestricted(level: Level, pos: BlockPos, gameMode: GameType): Boolean

blockedByShield

fun LivingEntity.blockedByShield(source: DamageSource): Boolean

blockInteractionRange

open fun blockInteractionRange(): Double

blockPosition

open fun blockPosition(): BlockPos

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

broadcastToPlayer

open fun broadcastToPlayer(player: ServerPlayer): Boolean

calculateEntityAnimation

open fun calculateEntityAnimation(includeHeight: Boolean)

calculateFallDamage

open fun calculateFallDamage(fallDistance: Double, damageMultiplier: Float): Int

calculateViewVector

fun calculateViewVector(xRot: Float, yRot: Float): Vec3

canAddPassenger

open fun canAddPassenger(passenger: Entity): Boolean

canAttack

open fun canAttack(target: LivingEntity): Boolean

canAttackType

open fun canAttackType(entityType: EntityType<*>): Boolean

canBeAffected

open fun canBeAffected(effectInstance: MobEffectInstance): Boolean

canBeCollidedWith

open fun canBeCollidedWith(entity: @Nullable Entity?): Boolean

canBeHitByProjectile

open fun canBeHitByProjectile(): Boolean

canBeSeenAsEnemy

open fun canBeSeenAsEnemy(): Boolean

canBeSeenByAnyone

open fun canBeSeenByAnyone(): Boolean

canBreatheUnderwater

open fun canBreatheUnderwater(): Boolean

canCollideWith

open fun canCollideWith(entity: Entity): Boolean

canControlVehicle

open fun canControlVehicle(): Boolean

canDropItems

open fun canDropItems(): Boolean

canEat

open fun canEat(canAlwaysEat: Boolean): Boolean

canEquipWithDispenser

fun canEquipWithDispenser(stack: ItemStack): Boolean

canFreeze

open fun canFreeze(): Boolean

canHarmPlayer

open fun canHarmPlayer(other: Player): Boolean

canInteractWithLevel

open fun canInteractWithLevel(): Boolean

cannotAttackWithItem

open fun cannotAttackWithItem(stack: ItemStack, adjustTicks: Int): Boolean

canPickUpLoot

open fun canPickUpLoot(): Boolean

canSimulateMovement

open fun canSimulateMovement(): Boolean

canSpawnSprintParticle

open fun canSpawnSprintParticle(): Boolean

canSprint

open fun canSprint(): Boolean

canStandOnFluid

open fun canStandOnFluid(fluidState: FluidState): Boolean

canTeleport

open fun canTeleport(fromLevel: Level, toLevel: Level): Boolean

canUseGameMasterBlocks

open fun canUseGameMasterBlocks(): Boolean

canUsePortal

open fun canUsePortal(allowPassengers: Boolean): Boolean

canUseSlot

open fun canUseSlot(slot: EquipmentSlot): Boolean

categorize

@JvmStatic

fun Entity?.categorize(): ModuleStorageESP.ChestType?

causeExtraKnockback

open fun causeExtraKnockback(entity: Entity, knockback: Float, deltaMovement: Vec3)

causeFallDamage

open fun causeFallDamage(fallDistance: Double, damageMultiplier: Float, damageSource: DamageSource): Boolean

causeFoodExhaustion

open fun causeFoodExhaustion(exhaustion: Float)

checkBelowWorld

open fun checkBelowWorld()

checkDespawn

open fun checkDespawn()

checkFallDistanceAccumulation

open fun checkFallDistanceAccumulation()

chunkPosition

open fun chunkPosition(): ChunkPos

clearFire

open fun clearFire()

clearFreeze

open fun clearFreeze()

clearSleepingPos

open fun clearSleepingPos()

closerThan

open fun closerThan(entity: Entity, distance: Double): Boolean

open fun closerThan(entity: Entity, horizontalDistance: Double, verticalDistance: Double): Boolean

collidedWithFluid

open fun collidedWithFluid(fluid: FluidState, pos: BlockPos, from: Vec3, to: Vec3): Boolean

collidedWithShapeMovingFrom

open fun collidedWithShapeMovingFrom(from: Vec3, to: Vec3, boxes: List<AABB>): Boolean

copyPosition

open fun copyPosition(entity: Entity)

countPlayerPassengers

open fun countPlayerPassengers(): Int

createCommandSourceStackForNameResolution

open fun createCommandSourceStackForNameResolution(level: ServerLevel): CommandSourceStack

crit

open fun crit(entityHit: Entity)

damageSources

open fun damageSources(): DamageSources

dampensVibrations

open fun dampensVibrations(): Boolean

debugInfo

open fun debugInfo(): String

deflection

open fun deflection(projectile: Projectile): ProjectileDeflection

die

open fun die(damageSource: DamageSource)

discard

fun discard()

dismountsUnderwater

open fun dismountsUnderwater(): Boolean

dismountTo

open fun dismountTo(x: Double, y: Double, z: Double)

displayClientMessage

open fun displayClientMessage(chatComponent: Component, actionBar: Boolean)

displayFireAnimation

open fun displayFireAnimation(): Boolean

distanceTo

open fun distanceTo(entity: Entity): Float

distanceToSqr

open fun distanceToSqr(entity: Entity): Double

open fun distanceToSqr(vec: Vec3): Double

open fun distanceToSqr(x: Double, y: Double, z: Double): Double

doCheckFallDamage

fun doCheckFallDamage(x: Double, y: Double, z: Double, onGround: Boolean)

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.

doHurtTarget

open fun doHurtTarget(level: ServerLevel, source: Entity): Boolean

drop

open fun drop(stack: ItemStack, randomizeMotion: Boolean, includeThrower: Boolean): @Nullable ItemEntity?

open fun drop(itemStack: ItemStack, includeThrowerName: Boolean): @Nullable ItemEntity?

dropAllLeashConnections

open fun dropAllLeashConnections(player: @Nullable Player?): Boolean

dropFromEntityInteractLootTable

open fun dropFromEntityInteractLootTable(level: ServerLevel, lootTable: ResourceKey<LootTable>, entity: @Nullable Entity?, tool: ItemStack, dropConsumer: BiConsumer<ServerLevel, ItemStack>): Boolean

dropFromGiftLootTable

open fun dropFromGiftLootTable(level: ServerLevel, lootTable: ResourceKey<LootTable>, dropConsumer: BiConsumer<ServerLevel, ItemStack>): Boolean

dropFromLootTable

open fun dropFromLootTable(level: ServerLevel, damageSource: DamageSource, playerKill: Boolean, lootTable: ResourceKey<LootTable>)

open fun dropFromLootTable(level: ServerLevel, damageSource: DamageSource, playerKill: Boolean, lootTable: ResourceKey<LootTable>, dropConsumer: Consumer<ItemStack>)

ejectPassengers

open fun ejectPassengers()

entityAttackRange

open fun entityAttackRange(): AttackRange

entityInteractionRange

open fun entityInteractionRange(): Double

equipmentHasChanged

open fun equipmentHasChanged(oldItem: ItemStack, newItem: ItemStack): Boolean

extinguishFire

open fun extinguishFire()

fillCrashReportCategory

open fun fillCrashReportCategory(category: CrashReportCategory)

findEntityInCrosshair

fun Entity.findEntityInCrosshair(range: Double, rotation: Rotation, predicate: Predicate<Entity>? = null): EntityHitResult?

fireImmune

open fun fireImmune(): Boolean

forceAddEffect

open fun forceAddEffect(instance: MobEffectInstance, entity: @Nullable Entity?)

forceSetRotation

open fun forceSetRotation(yRot: Float, yRelative: Boolean, xRot: Float, xRelative: Boolean)

fudgePositionAfterSizeChange

open fun fudgePositionAfterSizeChange(dimensions: EntityDimensions): Boolean

gameEvent

open fun gameEvent(gameEvent: Holder<GameEvent>)

open fun gameEvent(gameEvent: Holder<GameEvent>, entity: @Nullable Entity?)

gameMode

open fun gameMode(): @Nullable GameType?

get

open operator fun <T : Any> get(component: DataComponentType<out T>): @Nullable T?

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.

getAddEntityPacket

open fun getAddEntityPacket(entity: ServerEntity): Packet<ClientGamePacketListener>

getAttached

open fun <A : Any> getAttached(type: AttachmentType<A>): @Nullable A?

getAttachedOrCreate

open fun <A : Any> getAttachedOrCreate(type: AttachmentType<A>): A

open fun <A : Any> getAttachedOrCreate(type: AttachmentType<A>, initializer: Supplier<A>): A

getAttachedOrElse

@Contract(value = "_, !null -> !null")

open fun <A : Any> getAttachedOrElse(type: AttachmentType<A>, defaultValue: @Nullable A?): A

getAttachedOrGet

open fun <A : Any> getAttachedOrGet(type: AttachmentType<A>, defaultValue: Supplier<A>): A

getAttachedOrSet

open fun <A : Any> getAttachedOrSet(type: AttachmentType<A>, defaultValue: A): A

getAttachedOrThrow

open fun <A : Any> getAttachedOrThrow(type: AttachmentType<A>): A

getAttackAnim

open fun getAttackAnim(partialTick: Float): Float

getAttackStrengthScale

open fun getAttackStrengthScale(adjustTicks: Float): Float

getAttribute

open fun getAttribute(attribute: Holder<Attribute>): @Nullable AttributeInstance?

getAttributeBaseValue

open fun getAttributeBaseValue(attribute: Holder<Attribute>): Double

getAttributeValue

open fun getAttributeValue(attribute: Holder<Attribute>): Double

getAttributeValue

@JvmOverloads

fun DataComponentGetter.getAttributeValue(attribute: Holder<Attribute>, slot: EquipmentSlot? = null, baseValue: Double = attribute.value().defaultValue): Double

getAvailableSpaceBelow

open fun getAvailableSpaceBelow(distance: Double): Double

getBlockExplosionResistance

open fun getBlockExplosionResistance(explosion: Explosion, level: BlockGetter, pos: BlockPos, blockState: BlockState, fluidState: FluidState, explosionPower: Float): Float

getBoundingBoxAt

fun Entity.getBoundingBoxAt(pos: Vec3): AABB

getDamageAfterArmorAbsorb

open fun getDamageAfterArmorAbsorb(damageSource: DamageSource, damageAmount: Float): Float

getDamageAfterMagicAbsorb

open fun getDamageAfterMagicAbsorb(damageSource: DamageSource, damageAmount: Float): Float

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.

getDefaultDimensions

open fun getDefaultDimensions(pose: Pose): EntityDimensions

getDestroySpeed

open fun getDestroySpeed(state: BlockState): Float

getDimensions

fun getDimensions(pose: Pose): EntityDimensions

getDismountLocationForPassenger

open fun getDismountLocationForPassenger(passenger: LivingEntity): Vec3

getEffect

open fun getEffect(effect: Holder<MobEffect>): @Nullable MobEffectInstance?

getEffectBlendFactor

open fun getEffectBlendFactor(effect: Holder<MobEffect>, partialTick: Float): Float

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.

getEnchantedDamage

open fun getEnchantedDamage(entity: Entity, damage: Float, damageSource: DamageSource): Float

getEquipmentSlotForItem

fun getEquipmentSlotForItem(stack: ItemStack): EquipmentSlot

getExperienceReward

fun getExperienceReward(level: ServerLevel, killer: @Nullable Entity?): Int

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.

getFieldOfViewModifier

open fun getFieldOfViewModifier(isFirstPerson: Boolean, fovEffectScale: Float): Float

getFluidFallingAdjustedMovement

open fun getFluidFallingAdjustedMovement(gravity: Double, isFalling: Boolean, deltaMovement: Vec3): Vec3

getFluidHeight

open fun getFluidHeight(fluidTag: TagKey<Fluid>): Double

getHandHoldingItemAngle

open fun getHandHoldingItemAngle(item: Item): Vec3

getItemBySlot

open fun getItemBySlot(slot: EquipmentSlot): ItemStack

getItemHeldByArm

open fun getItemHeldByArm(arm: HumanoidArm): ItemStack

getItemInHand

open fun getItemInHand(hand: InteractionHand): ItemStack

getItemSwapScale

open fun getItemSwapScale(adjustTicks: Float): Float

getLightProbePosition

open fun getLightProbePosition(partialTick: Float): Vec3

getLocalBoundsForPose

open fun getLocalBoundsForPose(pose: Pose): AABB

getOrDefault

open fun <T : Any> getOrDefault(component: DataComponentType<out T>, defaultValue: T): T

getParrotVariantOnShoulder

open fun getParrotVariantOnShoulder(left: Boolean): Parrot.Variant

getPassengerRidingPosition

open fun getPassengerRidingPosition(entity: Entity): Vec3

getPosition

fun getPosition(partialTick: Float): Vec3

getPreciseBodyRotation

open fun getPreciseBodyRotation(partialTick: Float): Float

getProjectile

open fun getProjectile(weaponStack: ItemStack): ItemStack

getRandomX

open fun getRandomX(scale: Double): Double

getRandomZ

open fun getRandomZ(scale: Double): Double

getRelativePortalPosition

open fun getRelativePortalPosition(axis: Direction.Axis, rectangle: BlockUtil.FoundRectangle): Vec3

getRopeHoldPosition

open fun getRopeHoldPosition(partialTicks: Float): Vec3

getSlot

open fun getSlot(index: Int): @Nullable SlotAccess?

getSlotsFromRange

open fun getSlotsFromRange(range: IntList): SlotCollection

getSwimAmount

open fun getSwimAmount(partialTicks: Float): Float

getTicksSinceLastKineticHitFeedback

open fun getTicksSinceLastKineticHitFeedback(partialTick: Float): Float

getTyped

open fun <T : Any> getTyped(component: DataComponentType<T>): @Nullable TypedDataComponent<T>?

getUpVector

fun getUpVector(partialTick: Float): Vec3

getVehicleAttachmentPoint

open fun getVehicleAttachmentPoint(entity: Entity): Vec3

getViewVector

fun getViewVector(partialTick: Float): Vec3

getViewXRot

open fun getViewXRot(partialTick: Float): Float

getViewYRot

open fun getViewYRot(partialTick: Float): Float

getVisibilityPercent

open fun getVisibilityPercent(lookingEntity: @Nullable Entity?): Double

giveExperienceLevels

open fun giveExperienceLevels(levels: Int)

giveExperiencePoints

open fun giveExperiencePoints(xpPoints: Int)

handleCreativeModeItemDrop

open fun handleCreativeModeItemDrop(stack: ItemStack)

handleDamageEvent

open fun handleDamageEvent(damageSource: DamageSource)

handleEntityEvent

open fun handleEntityEvent(id: Byte)

handleExtraItemsCreatedOnUse

open fun handleExtraItemsCreatedOnUse(stack: ItemStack)

handleShoulderEntities

open fun handleShoulderEntities()

hasAttached

open fun hasAttached(type: AttachmentType<*>): Boolean

hasContainerOpen

open fun hasContainerOpen(openCounter: ContainerOpenersCounter, pos: BlockPos): Boolean

open fun hasContainerOpen(): Boolean

hasControllingPassenger

fun hasControllingPassenger(): Boolean

hasCorrectToolForDrops

open fun hasCorrectToolForDrops(state: BlockState): Boolean

hasCustomName

open fun hasCustomName(): Boolean

hasEffect

open fun hasEffect(effect: Holder<MobEffect>): Boolean

hasExactlyOnePlayerPassenger

open fun hasExactlyOnePlayerPassenger(): Boolean

hasGlowingTag

fun hasGlowingTag(): Boolean

hasHealthScoreboard

fun LivingEntity.hasHealthScoreboard(): Boolean

hasIndirectPassenger

open fun hasIndirectPassenger(entity: Entity): Boolean

hasInfiniteMaterials

open fun hasInfiniteMaterials(): Boolean

hasItemInSlot

open fun hasItemInSlot(slot: EquipmentSlot): Boolean

hasLandedInLiquid

open fun hasLandedInLiquid(): Boolean

hasLineOfSight

open fun hasLineOfSight(entity: Entity): Boolean

open fun hasLineOfSight(entity: Entity, block: ClipContext.Block, fluid: ClipContext.Fluid, y: Double): Boolean

hasMovedHorizontallyRecently

open fun hasMovedHorizontallyRecently(): Boolean

hasPassenger

open fun hasPassenger(predicate: Predicate<Entity>): Boolean

open fun hasPassenger(entity: Entity): Boolean

hasPose

open fun hasPose(pose: Pose): Boolean

heal

open fun heal(healAmount: Float)

hurt

fun ~~hurt~~(damageSource: DamageSource, amount: Float)

hurtClient

open fun hurtClient(damageSource: DamageSource): Boolean

hurtOrSimulate

fun ~~hurtOrSimulate~~(damageSource: DamageSource, amount: Float): Boolean

hurtServer

open fun hurtServer(level: ServerLevel, damageSource: DamageSource, amount: Float): Boolean

igniteForSeconds

fun igniteForSeconds(seconds: Float)

igniteForTicks

open fun igniteForTicks(ticks: Int)

ignoreExplosion

open fun ignoreExplosion(explosion: Explosion): Boolean

increaseScore

open fun increaseScore(score: Int)

indicateDamage

open fun indicateDamage(xDistance: Double, zDistance: Double)

interact

open fun interact(player: Player, hand: InteractionHand): InteractionResult

interactAt

open fun interactAt(player: Player, vec: Vec3, hand: InteractionHand): InteractionResult

interactOn

open fun interactOn(entityToInteractOn: Entity, hand: InteractionHand): InteractionResult

interpolateCurrentPosition

fun Entity.interpolateCurrentPosition(tickDelta: Float): Vec3

interpolateCurrentRotation

fun Entity.interpolateCurrentRotation(tickDelta: Float): Rotation

open fun is(entity: Entity): Boolean

isAlliedTo

fun isAlliedTo(entity: @Nullable Entity?): Boolean

open fun isAlliedTo(team: @Nullable Team?): Boolean

isColliding

open fun isColliding(pos: BlockPos, state: BlockState): Boolean

isEquippableInSlot

fun isEquippableInSlot(stack: ItemStack, slot: EquipmentSlot): Boolean

isEyeInFluid

open fun isEyeInFluid(fluidTag: TagKey<Fluid>): Boolean

isFacingBlock

fun Entity.isFacingBlock(eyes: Vec3 = this.eyePosition, targetPoint: Vec3, blockPos: BlockPos, expectedSide: Direction? = null, expectedMaxRange: Double? = null): Boolean

Allows you to check if a point is behind a wall

isFree

open fun isFree(x: Double, y: Double, z: Double): Boolean

isHolding

open fun isHolding(predicate: Predicate<ItemStack>): Boolean

open fun isHolding(item: Item): Boolean

isInvisibleTo

open fun isInvisibleTo(player: Player): Boolean

isInvulnerableTo

open fun isInvulnerableTo(level: ServerLevel, damageSource: DamageSource): Boolean

isInvulnerableToBase

fun isInvulnerableToBase(damageSource: DamageSource): Boolean

isLookingAtMe

open fun isLookingAtMe(entity: LivingEntity, tolerance: Double, scaleByDistance: Boolean, visual: Boolean, vararg yValues: Double): Boolean

isModelPartShown

open fun isModelPartShown(part: PlayerModelPart): Boolean

isPassengerOfSameVehicle

open fun isPassengerOfSameVehicle(entity: Entity): Boolean

isSupportedBy

open fun isSupportedBy(pos: BlockPos): Boolean

isWithinAttackRange

open fun isWithinAttackRange(box: AABB, range: Double): Boolean

isWithinBlockInteractionRange

open fun isWithinBlockInteractionRange(pos: BlockPos, range: Double): Boolean

isWithinEntityInteractionRange

open fun isWithinEntityInteractionRange(entity: Entity, range: Double): Boolean

open fun isWithinEntityInteractionRange(box: AABB, range: Double): Boolean

jumpFromGround

open fun jumpFromGround()

kill

open fun kill(level: ServerLevel)

killedEntity

open fun killedEntity(level: ServerLevel, entity: LivingEntity, damageSource: DamageSource): Boolean

knockback

open override fun knockback(strength: Double, x: Double, z: Double)

The fake player takes no knockback.

lastRenderPos

fun Entity.lastRenderPos(): Vec3

lavaHurt

open fun lavaHurt()

lavaIgnite

open fun lavaIgnite()

lerpHeadTo

open fun lerpHeadTo(yaw: Float, pitch: Int)

lerpMotion

open fun lerpMotion(deltaMovement: Vec3)

level

open fun level(): Level

load

open fun load(input: ValueInput)

loadAttributes

fun loadAttributes(snapshot: PosPoseSnapshot)

Loads the attributes from the player into the fake player.

lookAt

open fun lookAt(anchor: EntityAnchorArgument.Anchor, target: Vec3)

lungeForwardMaybe

open fun lungeForwardMaybe()

magicCrit

open fun magicCrit(entityHit: Entity)

makePoofParticles

open fun makePoofParticles()

makeSound

open fun makeSound(sound: @Nullable SoundEvent?)

makeStuckInBlock

open fun makeStuckInBlock(state: BlockState, motionMultiplier: Vec3)

makeWaypointConnectionWith

open fun makeWaypointConnectionWith(player: ServerPlayer): Optional<WaypointTransmitter.Connection>

maxUpStep

open fun maxUpStep(): Float

mayBuild

open fun mayBuild(): Boolean

mayInteract

open fun mayInteract(level: ServerLevel, pos: BlockPos): Boolean

mayUseItemAt

open fun mayUseItemAt(pos: BlockPos, facing: Direction, stack: ItemStack): Boolean

mirror

open fun mirror(transformMirror: Mirror): Float

modifyAttached

open fun <A : Any> modifyAttached(type: AttachmentType<A>, modifier: UnaryOperator<A>): @Nullable A?

move

open fun move(type: MoverType, movement: Vec3)

moveOrInterpolateTo

fun moveOrInterpolateTo(pos: Vec3)

fun moveOrInterpolateTo(yRot: Float, xRot: Float)

fun moveOrInterpolateTo(pos: Optional<Vec3>, yRot: Optional<Float>, xRot: Optional<Float>)

fun moveOrInterpolateTo(pos: Vec3, yRot: Float, xRot: Float)

moveRelative

open fun moveRelative(amount: Float, relative: Vec3)

nameAndId

open fun nameAndId(): NameAndId

notifyLeasheeRemoved

open fun notifyLeasheeRemoved(leashHolder: Leashable)

notifyLeashHolder

open fun notifyLeashHolder(leashHolder: Leashable)

oldPosition

fun oldPosition(): Vec3

onAboveBubbleColumn

open fun onAboveBubbleColumn(downwards: Boolean, pos: BlockPos)

onAttachedSet

open fun <A : Any> onAttachedSet(type: AttachmentType<A>): Event<AttachmentTarget.OnAttachedSet<A>>

onAttack

open fun onAttack()

onClientRemoval

open fun onClientRemoval()

onClimbable

open fun onClimbable(): Boolean

onEnchantmentPerformed

open fun onEnchantmentPerformed(enchantedItem: ItemStack, levelCost: Int)

onEnterCombat

open fun onEnterCombat()

onEquipItem

open fun onEquipItem(slot: EquipmentSlot, oldItem: ItemStack, newItem: ItemStack)

onEquippedItemBroken

open fun onEquippedItemBroken(item: Item, slot: EquipmentSlot)

onExplosionHit

open fun onExplosionHit(entity: @Nullable Entity?)

onGround

open fun onGround(): Boolean

onInsideBubbleColumn

open fun onInsideBubbleColumn(downwards: Boolean)

onItemPickup

open fun onItemPickup(itemEntity: ItemEntity)

onLeaveCombat

open fun onLeaveCombat()

onPassengerTurned

open fun onPassengerTurned(entityToUpdate: Entity)

onRemoval

open fun onRemoval(reason: Entity.RemovalReason)

onSyncedDataUpdated

open fun onSyncedDataUpdated(newData: List<SynchedEntityData.DataValue<*>>)

open fun onSyncedDataUpdated(dataAccessor: EntityDataAccessor<*>)

onUpdateAbilities

open fun onUpdateAbilities()

openCommandBlock

open fun openCommandBlock(commandBlockEntity: CommandBlockEntity)

openDialog

open fun openDialog(dialog: Holder<Dialog>)

openHorseInventory

open fun openHorseInventory(horse: AbstractHorse, inventory: Container)

openItemGui

open fun openItemGui(stack: ItemStack, hand: InteractionHand)

openJigsawBlock

open fun openJigsawBlock(jigsawBlockEntity: JigsawBlockEntity)

openMenu

open fun openMenu(menu: @Nullable MenuProvider?): OptionalInt

openMinecartCommandBlock

open fun openMinecartCommandBlock(commandBlock: MinecartCommandBlock)

openNautilusInventory

open fun openNautilusInventory(nautilus: AbstractNautilus, inventory: Container)

openStructureBlock

open fun openStructureBlock(structureEntity: StructureBlockEntity)

openTestBlock

open fun openTestBlock(testBlockEntity: TestBlockEntity)

openTestInstanceBlock

open fun openTestInstanceBlock(testInstanceBlockEntity: TestInstanceBlockEntity)

openTextEdit

open fun openTextEdit(signEntity: SignBlockEntity, isFrontText: Boolean)

permissions

open fun permissions(): PermissionSet

pick

open fun pick(hitDistance: Double, partialTick: Float, hitFluids: Boolean): HitResult

placePortalTicket

open fun placePortalTicket(pos: BlockPos)

playerTouch

open fun playerTouch(player: Player)

playSound

open fun playSound(sound: SoundEvent)

open fun playSound(sound: SoundEvent, volume: Float, pitch: Float)

position

open fun position(): Vec3

positionRider

fun positionRider(passenger: Entity)

preventsBlockDrops

open fun preventsBlockDrops(): Boolean

problemPath

open fun problemPath(): ProblemReporter.PathElement

push

open fun push(entity: Entity)

open fun push(vector: Vec3)

open fun push(x: Double, y: Double, z: Double)

randomTeleport

open fun randomTeleport(x: Double, y: Double, z: Double, broadcastTeleport: Boolean): Boolean

recreateFromPacket

open fun recreateFromPacket(packet: ClientboundAddEntityPacket)

refreshDimensions

open fun refreshDimensions()

registerDebugValues

open fun registerDebugValues(level: ServerLevel, registration: DebugValueSource.Registration)

registryAccess

open fun registryAccess(): RegistryAccess

releaseUsingItem

open fun releaseUsingItem()

rememberStabbedEntity

open fun rememberStabbedEntity(entity: Entity)

remove

open override fun remove(reason: Entity.RemovalReason)

removeAllEffects

open fun removeAllEffects(): Boolean

removeAttached

open fun <A : Any> removeAttached(type: AttachmentType<A>): @Nullable A?

removeEffect

open fun removeEffect(effect: Holder<MobEffect>): Boolean

removeEffectNoUpdate

fun removeEffectNoUpdate(effect: Holder<MobEffect>): @Nullable MobEffectInstance?

removeLatestMovementRecording

open fun removeLatestMovementRecording()

removeTag

open fun removeTag(tag: String): Boolean

removeVehicle

open fun removeVehicle()

resetAttackStrengthTicker

open fun resetAttackStrengthTicker()

resetCurrentImpulseContext

open fun resetCurrentImpulseContext()

resetFallDistance

open fun resetFallDistance()

resetOnlyAttackStrengthTicker

open fun resetOnlyAttackStrengthTicker()

resetRecipes

open fun resetRecipes(recipes: Collection<RecipeHolder<*>>): Int

resetStat

open fun resetStat(stat: Stat<*>)

restoreFrom

open fun restoreFrom(entity: Entity)

rideTick

open fun rideTick()

rotate

open fun rotate(transformRotation: Rotation): Float

save

open fun save(output: ValueOutput): Boolean

saveAsPassenger

open fun saveAsPassenger(output: ValueOutput): Boolean

saveWithoutId

open fun saveWithoutId(output: ValueOutput)

sendEffectToPassengers

open fun sendEffectToPassengers(effectInstance: MobEffectInstance)

sendMerchantOffers

open fun sendMerchantOffers(containerId: Int, offers: MerchantOffers, villagerLevel: Int, villagerXp: Int, showProgress: Boolean, canRestock: Boolean)

setAsInsidePortal

open fun setAsInsidePortal(portal: Portal, pos: BlockPos)

setAttached

open fun <A : Any> setAttached(type: AttachmentType<A>, value: @Nullable A?): @Nullable A?

setComponent

open fun <T : Any> setComponent(component: DataComponentType<T>, value: T)

setDiscardFriction

open fun setDiscardFriction(discardFriction: Boolean)

setGlowingTag

fun setGlowingTag(hasGlowingTag: Boolean)

setHealth

open override fun setHealth(health: Float)

setIgnoreFallDamageFromCurrentImpulse

open fun setIgnoreFallDamageFromCurrentImpulse(ignoreFallDamageFromCurrentImpulse: Boolean)

setIsInPowderSnow

open fun setIsInPowderSnow(isInPowderSnow: Boolean)

setItemInHand

open fun setItemInHand(hand: InteractionHand, stack: ItemStack)

setItemSlot

open fun setItemSlot(slot: EquipmentSlot, stack: ItemStack)

setLastHurtByPlayer

open fun setLastHurtByPlayer(uuid: UUID, memoryTime: Int)

open fun setLastHurtByPlayer(player: Player, memoryTime: Int)

setLastHurtMob

open fun setLastHurtMob(entity: Entity)

setLevelCallback

open fun setLevelCallback(levelCallback: EntityInLevelCallback)

setOldPosAndRot

fun setOldPosAndRot()

fun setOldPosAndRot(pos: Vec3, yRot: Float, xRot: Float)

setOldRot

open fun setOldRot()

setOnGround

open fun setOnGround(onGround: Boolean)

setOnGroundWithMovement

open fun setOnGroundWithMovement(onGround: Boolean, movement: Vec3)

open fun setOnGroundWithMovement(onGround: Boolean, horizontalCollision: Boolean, movement: Vec3)

setPos

fun setPos(pos: Vec3)

open fun setPos(x: Double, y: Double, z: Double)

setPosRaw

fun setPosRaw(x: Double, y: Double, z: Double)

setRecordPlayingNearby

open fun setRecordPlayingNearby(jukebox: BlockPos, partyParrot: Boolean)

setRemoved

fun setRemoved(removalReason: Entity.RemovalReason)

setSharedFlagOnFire

open fun setSharedFlagOnFire(isOnFire: Boolean)

setSleepingPos

open fun setSleepingPos(pos: BlockPos)

setYBodyRot

open fun setYBodyRot(yBodyRot: Float)

shearOffAllLeashConnections

open fun shearOffAllLeashConnections(player: @Nullable Player?): Boolean

shouldBeAttacked

@JvmOverloads

fun Entity?.shouldBeAttacked(enemyConf: Set<Targets> = GlobalSettingsTarget.combat): Boolean

shouldBeSaved

open fun shouldBeSaved(): Boolean

shouldBeShown

@JvmOverloads

fun Entity.shouldBeShown(enemyConf: Set<Targets> = GlobalSettingsTarget.visual): Boolean

shouldBlockExplode

open fun shouldBlockExplode(explosion: Explosion, level: BlockGetter, pos: BlockPos, blockState: BlockState, explosionPower: Float): Boolean

shouldDiscardFriction

open fun shouldDiscardFriction(): Boolean

shouldDropExperience

open fun shouldDropExperience(): Boolean

shouldRender

open fun shouldRender(x: Double, y: Double, z: Double): Boolean

shouldRenderAtSqrDistance

open fun shouldRenderAtSqrDistance(distance: Double): Boolean

shouldRotateWithMinecart

open fun shouldRotateWithMinecart(): Boolean

shouldShowName

open fun shouldShowName(): Boolean

showExtraEars

open fun showExtraEars(): Boolean

showVehicleHealth

open fun showVehicleHealth(): Boolean

skipAttackInteraction

open fun skipAttackInteraction(entity: Entity): Boolean

skipDropExperience

open fun skipDropExperience()

snapTo

open fun snapTo(pos: Vec3)

open fun snapTo(x: Double, y: Double, z: Double)

open fun snapTo(pos: BlockPos, yRot: Float, xRot: Float)

open fun snapTo(pos: Vec3, yRot: Float, xRot: Float)

open fun snapTo(x: Double, y: Double, z: Double, yRot: Float, xRot: Float)

spawnAtLocation

open fun spawnAtLocation(level: ServerLevel, stack: ItemStack): @Nullable ItemEntity?

open fun spawnAtLocation(level: ServerLevel, item: ItemLike): @Nullable ItemEntity?

open fun spawnAtLocation(level: ServerLevel, stack: ItemStack, yOffset: Float): @Nullable ItemEntity?

open fun spawnAtLocation(level: ServerLevel, stack: ItemStack, offset: Vec3): @Nullable ItemEntity?

spawnItemParticles

open fun spawnItemParticles(stack: ItemStack, amount: Int)

squareBoxedDistanceTo

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

squaredBoxedDistanceTo

fun Entity.squaredBoxedDistanceTo(entity: Entity): Double

fun Entity.squaredBoxedDistanceTo(otherPos: Vec3): Double

stabAttack

open fun stabAttack(slot: EquipmentSlot, entity: Entity, damageAmount: Float, damage: Boolean, knockback: Boolean, dismount: Boolean): Boolean

stabbedEntities

open fun stabbedEntities(predicate: Predicate<Entity>): Int

startAutoSpinAttack

open fun startAutoSpinAttack(ticks: Int, damage: Float, itemStack: ItemStack)

startFallFlying

open fun startFallFlying()

startRiding

fun startRiding(vehicle: Entity): Boolean

open fun startRiding(vehicle: Entity, force: Boolean, sendGameEvent: Boolean): Boolean

startSeenByPlayer

open fun startSeenByPlayer(serverPlayer: ServerPlayer)

startSleepInBed

open fun startSleepInBed(bedPos: BlockPos): Either<Player.BedSleepingProblem, Unit>

startSleeping

open fun startSleeping(pos: BlockPos)

startUsingItem

open fun startUsingItem(hand: InteractionHand)

stopFallFlying

open fun stopFallFlying()

stopRiding

open fun stopRiding()

stopSeenByPlayer

open fun stopSeenByPlayer(serverPlayer: ServerPlayer)

stopSleepInBed

open fun stopSleepInBed(wakeImmediately: Boolean, updateLevelForSleepingPlayers: Boolean)

stopSleeping

open fun stopSleeping()

stopUsingItem

open fun stopUsingItem()

supportQuadLeashAsHolder

open fun supportQuadLeashAsHolder(): Boolean

swing

open fun swing(hand: InteractionHand)

open fun swing(hand: InteractionHand, updateSelf: Boolean)

syncPacketPositionCodec

open fun syncPacketPositionCodec(x: Double, y: Double, z: Double)

take

open fun take(entity: Entity, amount: Int)

teleport

open fun teleport(teleportTransition: TeleportTransition): @Nullable Entity?

teleportRelative

open fun teleportRelative(dx: Double, dy: Double, dz: Double)

teleportSetPosition

open fun teleportSetPosition(positionMovementRotation: PositionMoveRotation, relatives: Set<Relative>)

open fun teleportSetPosition(from: PositionMoveRotation, to: PositionMoveRotation, relatives: Set<Relative>)

teleportTo

open fun teleportTo(x: Double, y: Double, z: Double)

open fun teleportTo(level: ServerLevel, x: Double, y: Double, z: Double, relativeMovements: Set<Relative>, yaw: Float, pitch: Float, setCamera: Boolean): Boolean

thunderHit