Class Player

java.lang.Object
net.minestom.server.entity.Entity
net.minestom.server.entity.LivingEntity
net.minestom.server.entity.Player
All Implemented Interfaces:
Audience, Identified, Pointered, Sound.Emitter, HoverEventSource<HoverEvent.ShowEntity>, Shape, CommandSender, DataComponent.Holder, EventHandler<EntityEvent>, EquipmentHandler, Snapshotable, Taggable, TagReadable, TagWritable, AcquirableSource<Entity>, Tickable, Schedulable, NamedAndIdentified, Viewable
public class Player extends LivingEntity implements CommandSender, HoverEventSource<HoverEvent.ShowEntity>, NamedAndIdentified
Those are the major actors of the server

You can easily create your own implementation of this and use it with ConnectionManager.setPlayerProvider(PlayerProvider).

  • Field Details

  • Constructor Details

  • Method Details

    • setPendingOptions

      @Internal public void setPendingOptions(Instance pendingInstance, boolean hardcore)

    • UNSAFE_init

      @Internal public CompletableFuture<Void> UNSAFE_init()
      Used when the player is created. Init the player and spawn him.

      WARNING: executed in the main update thread UNSAFE: Only meant to be used when a socket player connects through the server.

    • startConfigurationPhase

      public void startConfigurationPhase()
      Moves the player to the configuration state at the end of the current tick.

      The player is automatically moved to configuration upon finishing login, this method can be used to move them back to configuration after entering the play state.

      This will result in them being removed from the current instance, player list, etc.

    • playerConnectionInit

      protected void playerConnectionInit()
      Used to initialize the player connection

    • update

      public void update(long time)
      Description copied from class: Entity
      Called each tick.
      Overrides:
      update in class LivingEntity
      Parameters:
      time - time of the update in milliseconds. This may only be used as a delta and has no meaning in the real world

    • kill

      public void kill()
      Description copied from class: LivingEntity
      Kills the entity, trigger the EntityDeathEvent event.
      Overrides:
      kill in class LivingEntity

    • respawn

      public void respawn()
      Respawns the player by sending a RespawnPacket to the player and teleporting him to getRespawnPoint(). It also resets fire and health.

    • refreshCommands

      public void refreshCommands()
      Refreshes the command list for this player. This checks the CommandConditions again, and any changes will be visible to the player.

    • refreshRecipes

      public void refreshRecipes()
      Refreshes the recipes and recipe book for this player, testing recipe predicates again.

    • isOnGround

      public boolean isOnGround()
      Overrides:
      isOnGround in class Entity

    • remove

      public void remove(boolean permanent)
      Overrides:
      remove in class Entity

    • sendPacketToViewersAndSelf

      public void sendPacketToViewersAndSelf(SendablePacket packet)
      Description copied from interface: Viewable
      Sends a packet to all viewers and the viewable element if it is a player.

      If 'this' isn't a player, then only Viewable.sendPacketToViewers(SendablePacket) is called.

      Specified by:
      sendPacketToViewersAndSelf in interface Viewable
      Parameters:
      packet - the packet to send

    • setInstance

      public CompletableFuture<Void> setInstance(Instance instance, Pos spawnPosition)
      Changes the player instance and load surrounding chunks if needed.

      Be aware that because chunk operations are expensive, it is possible for this method to be non-blocking when retrieving chunks is required.

      Overrides:
      setInstance in class Entity
      Parameters:
      instance - the new player instance
      spawnPosition - the new position of the player
      Returns:
      a future called once the player instance changed

    • setInstance

      public CompletableFuture<Void> setInstance(Instance instance)
      Changes the player instance without changing its position (defaulted to getRespawnPoint() if the player is not in any instance).
      Overrides:
      setInstance in class Entity
      Parameters:
      instance - the new player instance
      Returns:
      a CompletableFuture called once the entity's instance has been set, this is due to chunks needing to load for players
      See Also:

    • onChunkBatchReceived

      @Internal public void onChunkBatchReceived(float newTargetChunksPerTick)

    • sendChunk

      public void sendChunk(Chunk chunk)
      Queues the given chunk to be sent to the player.
      Parameters:
      chunk - The chunk to send

    • updatePose

      protected void updatePose()
      Overrides:
      updatePose in class Entity

    • sendMessage

      public void sendMessage(Identity source, Component message, MessageType type)
      Specified by:
      sendMessage in interface Audience

    • sendPluginMessage

      public void sendPluginMessage(String channel, byte[] data)
      Sends a plugin message to the player.
      Parameters:
      channel - the message channel
      data - the message data

    • sendPluginMessage

      public void sendPluginMessage(String channel, String message)
      Sends a plugin message to the player.

      Message encoded to UTF-8.

      Parameters:
      channel - the message channel
      message - the message

    • playSound

      public void playSound(Sound sound)
      Specified by:
      playSound in interface Audience

    • playSound

      public void playSound(Sound sound, Point point)

    • playSound

      public void playSound(Sound sound, double x, double y, double z)
      Specified by:
      playSound in interface Audience

    • playSound

      public void playSound(Sound sound, Sound.Emitter emitter)
      Specified by:
      playSound in interface Audience

    • stopSound

      public void stopSound(SoundStop stop)
      Specified by:
      stopSound in interface Audience

    • playEffect

      public void playEffect(WorldEvent worldEvent, int x, int y, int z, int data, boolean disableRelativeVolume)
      Plays a given worldEvent at the given position for this player.
      Parameters:
      worldEvent - the worldEvent to play
      x - x position of the worldEvent
      y - y position of the worldEvent
      z - z position of the worldEvent
      data - data for the worldEvent
      disableRelativeVolume - disable volume scaling based on distance

    • sendPlayerListHeaderAndFooter

      public void sendPlayerListHeaderAndFooter(Component header, Component footer)
      Specified by:
      sendPlayerListHeaderAndFooter in interface Audience

    • sendTitlePart

      public <T> void sendTitlePart(TitlePart<T> part, T value)
      Specified by:
      sendTitlePart in interface Audience

    • sendActionBar

      public void sendActionBar(Component message)
      Specified by:
      sendActionBar in interface Audience

    • resetTitle

      public void resetTitle()
      Specified by:
      resetTitle in interface Audience

    • clearTitle

      public void clearTitle()
      Specified by:
      clearTitle in interface Audience

    • showBossBar

      public void showBossBar(BossBar bar)
      Specified by:
      showBossBar in interface Audience

    • hideBossBar

      public void hideBossBar(BossBar bar)
      Specified by:
      hideBossBar in interface Audience

    • openBook

      public void openBook(Book book)
      Specified by:
      openBook in interface Audience

    • showDialog

      public void showDialog(DialogLike dialog)
      Specified by:
      showDialog in interface Audience

    • closeDialog

      public void closeDialog()
      Specified by:
      closeDialog in interface Audience

    • setHealth

      public void setHealth(float health)
      Description copied from class: LivingEntity
      Changes the entity health, kill it if health is <= 0 and is not dead yet.
      Overrides:
      setHealth in class LivingEntity
      Parameters:
      health - the new entity health

    • getPlayerMeta

      public PlayerMeta getPlayerMeta()
      Gets the entity meta for the player.

      Note that this method will throw an exception if the player's entity type has been changed with Entity.switchEntityType(EntityType). It is wise to check Entity.getEntityType() first.

    • getAdditionalHearts

      public float getAdditionalHearts()
      Gets the player additional hearts.

      Note that this function is uncallable if the player has their entity type switched with Entity.switchEntityType(EntityType).

      Returns:
      the player additional hearts

    • setAdditionalHearts

      public void setAdditionalHearts(float additionalHearts)
      Changes the amount of additional hearts shown.

      Note that this function is uncallable if the player has their entity type switched with Entity.switchEntityType(EntityType).

      Parameters:
      additionalHearts - the count of additional hearts

    • getFood

      public int getFood()
      Gets the player food.
      Returns:
      the player food

    • setFood

      public void setFood(int food)
      Sets and refresh client food bar.
      Parameters:
      food - the new food value
      Throws:
      IllegalArgumentException - if food is not between 0 and 20

    • getFoodSaturation

      public float getFoodSaturation()

    • setFoodSaturation

      public void setFoodSaturation(float foodSaturation)
      Sets and refresh client food saturation.
      Parameters:
      foodSaturation - the food saturation
      Throws:
      IllegalArgumentException - if foodSaturation is not between 0 and 20

    • isEating

      public boolean isEating()
      Gets if the player is eating.
      Returns:
      true if the player is eating, false otherwise

    • isUsingItem

      public boolean isUsingItem()
      Gets if the player is using an item.
      Returns:
      true if the player is using an item, false otherwise

    • getItemUseHand

      @Nullable public @Nullable PlayerHand getItemUseHand()
      Gets the hand which the player is using an item from.
      Returns:
      the item use hand, null if none

    • getCurrentItemUseTime

      public long getCurrentItemUseTime()
      Gets the amount of ticks which have passed since the player started using an item.
      Returns:
      the amount of ticks which have passed, or zero if the player is not using an item

    • getEyeHeight

      public double getEyeHeight()
      Description copied from class: Entity
      Gets the entity eye height.
      Overrides:
      getEyeHeight in class Entity
      Returns:
      the entity eye height

    • getDisplayName

      @Nullable public @Nullable Component getDisplayName()
      Gets the player display name in the tab-list.
      Returns:
      the player display name, null means that getUsername() is displayed

    • setDisplayName

      public void setDisplayName(@Nullable @Nullable Component displayName)
      Changes the player display name in the tab-list.

      Sets to null to show the player username.

      Parameters:
      displayName - the display name, null to display the username

    • getSkin

      @Nullable public @Nullable PlayerSkin getSkin()
      Gets the player skin.
      Returns:
      the player skin object, null means that the player has his Entity.getUuid() default skin

    • setSkin

      public void setSkin(@Nullable @Nullable PlayerSkin skin)
      Changes the player skin.

      This does remove the player for all viewers to spawn it again with the correct new skin.

      Parameters:
      skin - the player skin, null to reset it to his Entity.getUuid() default skin
      See Also:

    • setDeathLocation

      public void setDeathLocation(Pos position)

    • setDeathLocation

      public void setDeathLocation(String dimension, Pos position)

    • getDeathLocation

      @Nullable public @Nullable WorldPos getDeathLocation()

    • isEnableRespawnScreen

      public boolean isEnableRespawnScreen()
      Gets if the player has the respawn screen enabled or disabled.
      Returns:
      true if the player has the respawn screen, false if he didn't

    • setEnableRespawnScreen

      public void setEnableRespawnScreen(boolean enableRespawnScreen)
      Enables or disable the respawn screen.
      Parameters:
      enableRespawnScreen - true to enable the respawn screen, false to disable it

    • getName

      public Component getName()
      Gets the player's name as a component. This will either return the display name (if set) or a component holding the username.
      Specified by:
      getName in interface NamedAndIdentified
      Returns:
      the name

    • getUsername

      public String getUsername()
      Gets the player's username.
      Returns:
      the player's username

    • dropItem

      public boolean dropItem(ItemStack item)
      Calls an ItemDropEvent with a specified item.

      Returns false if item is air.

      Parameters:
      item - the item to drop
      Returns:
      true if player can drop the item (event not cancelled), false otherwise

    • sendResourcePacks

      public void sendResourcePacks(ResourcePackRequest request)
      Specified by:
      sendResourcePacks in interface Audience

    • removeResourcePacks

      public void removeResourcePacks(UUID id, UUID... others)
      Specified by:
      removeResourcePacks in interface Audience

    • clearResourcePacks

      public void clearResourcePacks()
      Specified by:
      clearResourcePacks in interface Audience

    • getResourcePackFuture

      @Internal @Nullable public @Nullable CompletableFuture<Void> getResourcePackFuture()
      If there are resource packs in-flight, a future is returned which will be completed when all resource packs have been responded to by the client. Otherwise null is returned.

    • onResourcePackStatus

      @Internal public void onResourcePackStatus(UUID id, ResourcePackStatus status)

    • facePosition

      public void facePosition(Player.FacePoint facePoint, Point targetPosition)
      Rotates the player to face targetPosition.
      Parameters:
      facePoint - the point from where the player should aim
      targetPosition - the target position to face

    • facePosition

      public void facePosition(Player.FacePoint facePoint, Entity entity, Player.FacePoint targetPoint)
      Rotates the player to face entity.
      Parameters:
      facePoint - the point from where the player should aim
      entity - the entity to face
      targetPoint - the point to aim at entity position

    • spectate

      public void spectate(Entity entity)
      Sets the camera at entity eyes.
      Parameters:
      entity - the entity to spectate

    • stopSpectating

      public void stopSpectating()
      Resets the camera at the player.

    • getRespawnPoint

      public Pos getRespawnPoint()
      Used to retrieve the default spawn point.

      Can be altered by the PlayerRespawnEvent.setRespawnPosition(Pos).

      Returns:
      a copy of the default respawn point

    • setRespawnPoint

      public void setRespawnPoint(Pos respawnPoint)
      Changes the default spawn point.
      Parameters:
      respawnPoint - the player respawn point

    • refreshAfterTeleport

      protected void refreshAfterTeleport()
      Called after the player teleportation to refresh his position and send data to his new viewers.

    • refreshHealth

      protected void refreshHealth()
      Sets the player food and health values to their maximum.

    • getExp

      public float getExp()
      Gets the percentage displayed in the experience bar.
      Returns:
      the exp percentage 0-1

    • setExp

      public void setExp(float exp)
      Used to change the percentage experience bar. This cannot change the displayed level, see setLevel(int).
      Parameters:
      exp - a percentage between 0 and 1
      Throws:
      IllegalArgumentException - if exp is not between 0 and 1

    • getLevel

      public int getLevel()
      Gets the level of the player displayed in the experience bar.
      Returns:
      the player level

    • setLevel

      public void setLevel(int level)
      Used to change the level of the player This cannot change the displayed percentage bar see setExp(float)
      Parameters:
      level - the new level of the player

    • getPortalCooldown

      public int getPortalCooldown()

    • setPortalCooldown

      public void setPortalCooldown(int portalCooldown)

    • getPlayerConnection

      public PlayerConnection getPlayerConnection()
      Gets the player connection.

      Used to send packets and get stuff related to the connection.

      Returns:
      the player connection

    • sendPacket

      public void sendPacket(SendablePacket packet)
      Shortcut for PlayerConnection.sendPacket(SendablePacket).
      Parameters:
      packet - the packet to send

    • sendPackets

      public void sendPackets(SendablePacket... packets)

    • sendPackets

      public void sendPackets(Collection<SendablePacket> packets)

    • isOnline

      public boolean isOnline()
      Gets if the player is online or not.
      Returns:
      true if the player is online, false otherwise

    • getSettings

      public ClientSettings getSettings()
      Gets the player settings.
      Returns:
      the player settings

    • refreshSettings

      public void refreshSettings(ClientSettings settings)
      Changes the player settings internally.

      WARNING: the player will not be noticed by this change, probably unsafe.

    • getDimensionType

      public DimensionType getDimensionType()
      Gets the player dimension.
      Returns:
      the player current dimension

    • getInventory

      public PlayerInventory getInventory()

    • getLatency

      public int getLatency()
      Used to get the player latency, computed by seeing how long it takes the client to answer the KeepAlivePacket packet.
      Returns:
      the player latency

    • getGameMode

      public GameMode getGameMode()
      Gets the player GameMode.
      Returns:
      the player current gamemode

    • setGameMode

      public boolean setGameMode(GameMode gameMode)
      Changes the player GameMode
      Parameters:
      gameMode - the new player GameMode
      Returns:
      true if the gamemode was changed successfully, false otherwise (cancelled by event)

    • sendDimension

      protected void sendDimension(RegistryKey<DimensionType> dimensionType, String dimensionName)
      Changes the dimension of the player. Mostly unsafe since it requires sending chunks after.
      Parameters:
      dimensionType - the new player dimension

    • kick

      public void kick(Component component)
      Kicks the player with a reason.
      Parameters:
      component - the reason

    • kick

      public void kick(String message)
      Kicks the player with a reason.
      Parameters:
      message - the kick reason

    • setHeldItemSlot

      public void setHeldItemSlot(byte slot)
      Changes the current held slot for the player.
      Parameters:
      slot - the slot that the player has to held
      Throws:
      IllegalArgumentException - if slot is not between 0 and 8

    • getHeldSlot

      public byte getHeldSlot()
      Gets the player held slot (0-8).
      Returns:
      the current held slot for the player

    • setBelowNameTag

      public void setBelowNameTag(BelowNameTag belowNameTag)
      Changes the tag below the name.
      Parameters:
      belowNameTag - The new below name tag

    • getClickPreprocessor

      public ClickPreprocessor getClickPreprocessor()

    • getOpenInventory

      @Nullable public @Nullable AbstractInventory getOpenInventory()
      Gets the player open inventory.
      Returns:
      the currently open inventory, null if there is not (player inventory is not detected)

    • openInventory

      public boolean openInventory(Inventory inventory)
      Opens the specified Inventory, close the previous inventory if existing.
      Parameters:
      inventory - the inventory to open
      Returns:
      true if the inventory has been opened/sent to the player, false otherwise (cancelled by event)

    • closeInventory

      public void closeInventory()
      Closes the current inventory if there is any. It closes the player inventory (when opened) if getOpenInventory() returns null.

    • closeInventory

      @Internal public void closeInventory(boolean fromClient, byte windowId)

    • didCloseInventory

      public boolean didCloseInventory()
      Used internally to determine when sending the close inventory packet should be skipped.

    • UNSAFE_changeDidCloseInventory

      @Internal public void UNSAFE_changeDidCloseInventory(boolean didCloseInventory)
      Used internally to reset the skipClosePacket field, which determines when sending the close inventory packet should be skipped.

      Shouldn't be used externally without proper understanding of its consequence.

      Parameters:
      didCloseInventory - the new didCloseInventory field

    • getNextTeleportId

      public int getNextTeleportId()

    • getLastSentTeleportId

      public int getLastSentTeleportId()

    • getLastReceivedTeleportId

      public int getLastReceivedTeleportId()

    • refreshReceivedTeleportId

      public void refreshReceivedTeleportId(int receivedTeleportId)

    • setView

      public void setView(float yaw, float pitch)
      Forces the player's client to look towards the target yaw/pitch
      Overrides:
      setView in class Entity
      Parameters:
      yaw - the new yaw
      pitch - the new pitch

    • lookAt

      public void lookAt(Point point)
      Forces the player's client to look towards the specified point

      Note: the player's position is not updated on the server until the client receives this packet

      Overrides:
      lookAt in class Entity
      Parameters:
      point - the point to look at

    • lookAt

      public void lookAt(Entity entity)
      Forces the player's client to look towards the specified entity

      Note: the player's position is not updated on the server until the client receives this packet

      Overrides:
      lookAt in class Entity
      Parameters:
      entity - the entity to look at

    • getPermissionLevel

      public int getPermissionLevel()
      Gets the player permission level.
      Returns:
      the player permission level

    • setPermissionLevel

      public void setPermissionLevel(int permissionLevel)
      Changes the player permission level.
      Parameters:
      permissionLevel - the new player permission level
      Throws:
      IllegalArgumentException - if permissionLevel is not between 0 and 4

    • setReducedDebugScreenInformation

      public void setReducedDebugScreenInformation(boolean reduced)
      Sets or remove the reduced debug screen.
      Parameters:
      reduced - should the player has the reduced debug screen

    • hasReducedDebugScreenInformation

      public boolean hasReducedDebugScreenInformation()
      Gets if the player has the reduced debug screen.
      Returns:
      true if the player has the reduced debug screen, false otherwise

    • setInvulnerable

      public void setInvulnerable(boolean invulnerable)
      This do update the invulnerable field in the packet PlayerAbilitiesPacket and prevent the player from receiving damage.
      Overrides:
      setInvulnerable in class LivingEntity
      Parameters:
      invulnerable - should the player be invulnerable

    • setSneaking

      public void setSneaking(boolean sneaking)
      Description copied from class: Entity
      Makes the entity sneak.

      WARNING: this will not work for the client itself.

      Overrides:
      setSneaking in class Entity
      Parameters:
      sneaking - true to make the entity sneak

    • isFlying

      public boolean isFlying()
      Gets if the player is currently flying.
      Returns:
      true if the player if flying, false otherwise

    • setFlying

      public void setFlying(boolean flying)
      Sets the player flying.
      Parameters:
      flying - should the player fly

    • refreshFlying

      public void refreshFlying(boolean flying)
      Updates the internal flying field.

      Mostly unsafe since there is nothing to backup the value, used internally for creative players.

      Parameters:
      flying - the new flying field
      See Also:

    • isAllowFlying

      public boolean isAllowFlying()
      Gets if the player is allowed to fly.
      Returns:
      true if the player if allowed to fly, false otherwise

    • setAllowFlying

      public void setAllowFlying(boolean allowFlying)
      Allows or forbid the player to fly.
      Parameters:
      allowFlying - should the player be allowed to fly

    • isInstantBreak

      public boolean isInstantBreak()

    • setInstantBreak

      public void setInstantBreak(boolean instantBreak)
      Changes the player ability "Creative Mode".
      Parameters:
      instantBreak - true to allow instant break
      See Also:

    • getFlyingSpeed

      public float getFlyingSpeed()
      Gets the player flying speed.
      Returns:
      the flying speed of the player

    • setFlyingSpeed

      public void setFlyingSpeed(float flyingSpeed)
      Updates the internal field and send a PlayerAbilitiesPacket with the new flying speed.
      Parameters:
      flyingSpeed - the new flying speed of the player

    • getFieldViewModifier

      public float getFieldViewModifier()

    • setFieldViewModifier

      public void setFieldViewModifier(float fieldViewModifier)

    • getStatisticValueMap

      public Map<PlayerStatistic, Integer> getStatisticValueMap()
      This is the map used to send the statistic packet. It is possible to add/remove/change statistic value directly into it.
      Returns:
      the modifiable statistic map

    • inputs

      public PlayerInputs inputs()
      Gets the last reported set of player inputs.

      This information comes from the client so should be considered as such.

    • refreshAbilities

      protected void refreshAbilities()
      Sends to the player a PlayerAbilitiesPacket with all the updated fields.

    • addPacketToQueue

      public void addPacketToQueue(ClientPacket packet)
      All packets in the queue are executed in the update(long) method It is used internally to add all received packet from the client. Could be used to "simulate" a received packet, but to use at your own risk.
      Parameters:
      packet - the packet to add in the queue

    • interpretPacketQueue

      @Internal public void interpretPacketQueue()

    • refreshLatency

      public void refreshLatency(int latency)
      Changes the storage player latency and update its tab value.
      Parameters:
      latency - the new player latency

    • refreshOnGround

      public void refreshOnGround(boolean onGround)

    • refreshKeepAlive

      public void refreshKeepAlive(long lastKeepAlive)
      Used to change internally the last sent last keep alive id.

      Warning: could lead to have the player kicked because of a wrong keep alive packet.

      Parameters:
      lastKeepAlive - the new lastKeepAlive id

    • didAnswerKeepAlive

      public boolean didAnswerKeepAlive()

    • refreshAnswerKeepAlive

      public void refreshAnswerKeepAlive(boolean answerKeepAlive)

    • refreshHeldSlot

      public void refreshHeldSlot(byte slot)
      Changes the held item for the player viewers Also cancel item usage if isUsingItem() was true.

      Warning: the player will not be noticed by this chance, only his viewers, see instead: setHeldItemSlot(byte).

      Parameters:
      slot - the new held slot

    • refreshItemUse

      public void refreshItemUse(@Nullable @Nullable PlayerHand itemUseHand, long itemUseTimeTicks)

    • clearItemUse

      public void clearItemUse()

    • refreshInput

      public void refreshInput(boolean forward, boolean backward, boolean left, boolean right, boolean jump, boolean shift, boolean sprint)

    • getLastKeepAlive

      public long getLastKeepAlive()
      Gets the last sent keep alive id.
      Returns:
      the last keep alive id sent to the player

    • asHoverEvent

      public HoverEvent<HoverEvent.ShowEntity> asHoverEvent(UnaryOperator<HoverEvent.ShowEntity> op)
      Specified by:
      asHoverEvent in interface HoverEventSource<HoverEvent.ShowEntity>
      Overrides:
      asHoverEvent in class Entity

    • getAddPlayerToList

      protected PlayerInfoUpdatePacket getAddPlayerToList()
      Gets the packet to add the player from the tab-list.
      Returns:
      a PlayerInfoUpdatePacket to add the player

    • getRemovePlayerToList

      protected PlayerInfoRemovePacket getRemovePlayerToList()
      Gets the packet to remove the player from the tab-list.
      Returns:
      a PlayerInfoRemovePacket to remove the player

    • showPlayer

      protected void showPlayer(PlayerConnection connection)
      Sends all the related packet to have the player sent to another with related data (create player, spawn position, velocity, metadata, equipments, passengers, team).

      WARNING: this alone does not sync the player, please use Entity.addViewer(Player).

      Parameters:
      connection - the connection to show the player to

    • getEquipment

      public ItemStack getEquipment(EquipmentSlot slot)
      Description copied from interface: EquipmentHandler
      Gets the equipment in a specific slot.
      Specified by:
      getEquipment in interface EquipmentHandler
      Overrides:
      getEquipment in class LivingEntity
      Parameters:
      slot - the equipment to get the item from
      Returns:
      the equipment ItemStack

    • setEquipment

      public void setEquipment(EquipmentSlot slot, ItemStack itemStack)
      Specified by:
      setEquipment in interface EquipmentHandler
      Overrides:
      setEquipment in class LivingEntity

    • updateSnapshot

      public PlayerSnapshot updateSnapshot(SnapshotUpdater updater)
      Description copied from interface: Snapshotable
      Updates the currently cached snapshot if required. The updater can be used to retrieve references to other snapshots while avoiding circular dependency. Be careful to do not store updater anywhere as its data will change when building requested references.

      This method is not thread-safe, and targeted at internal use since its execution rely on safe-points (e.g. end of ticks)

      Specified by:
      updateSnapshot in interface Snapshotable
      Overrides:
      updateSnapshot in class Entity
      Parameters:
      updater - the snapshot updater/context
      Returns:
      the updated snapshot

    • getLocale

      public Locale getLocale()

    • setLocale

      public void setLocale(Locale locale)
      Sets the player's locale. This will only set the locale of the player as it is stored in the server. This will also be reset if the settings are refreshed.
      Parameters:
      locale - the new locale

    • pointers

      @Contract(pure=true) public Pointers pointers()
      Specified by:
      pointers in interface Pointered
      Overrides:
      pointers in class Entity

    • updateCollisions

      protected void updateCollisions()
      Overrides:
      updateCollisions in class Entity

    • sendChunkUpdates

      protected void sendChunkUpdates(Chunk newChunk)

    • teleport

      public CompletableFuture<Void> teleport(Pos position, long @Nullable [] chunks, int flags)
      Overrides:
      teleport in class Entity
      See Also:

    • sendNotification

      public void sendNotification(Notification notification)
      Send a Notification to the player.
      Parameters:
      notification - the Notification to send

    • leaveBed

      public void leaveBed()
      Sends a EntityAnimationPacket to clear remove the sleep darkness.
      Overrides:
      leaveBed in class LivingEntity

    • effectiveViewDistance

      public int effectiveViewDistance()
      Gets the client's 'effective' view distance, which is the minimum of the client's view distance settings, and the local instance settings, plus one
      Returns:
      The effective chunk view distance range of the client

    • acquirable

      @Experimental public Acquirable<? extends Player> acquirable()
      Description copied from interface: AcquirableSource
      Obtains an Acquirable. To safely perform operations on this object, the user must call Acquirable.sync(Consumer), Acquirable.applySync(Function), or Acquirable.lock() (followed by a subsequent unlock) on the Acquirable instance.
      Specified by:
      acquirable in interface AcquirableSource<Entity>
      Overrides:
      acquirable in class LivingEntity
      Returns:
      an Acquirable which can be used to synchronize access to this object