player

package
v0.0.5 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: May 30, 2021 License: MIT Imports: 39 Imported by: 190

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type Handler 

type Handler interface {
	// HandleMove handles the movement of a player. ctx.Cancel() may be called to cancel the movement event.
	// The new position, yaw and pitch are passed.
	HandleMove(ctx *event.Context, newPos mgl64.Vec3, newYaw, newPitch float64)
	// HandleTeleport handles the teleportation of a player. ctx.Cancel() may be called to cancel it.
	HandleTeleport(ctx *event.Context, pos mgl64.Vec3)
	// HandleChat handles a message sent in the chat by a player. ctx.Cancel() may be called to cancel the
	// message being sent in chat.
	// The message may be changed by assigning to *message.
	HandleChat(ctx *event.Context, message *string)
	// HandleFoodLoss handles the food bar of a player depleting naturally, for example because the player was
	// sprinting and jumping. ctx.Cancel() may be called to cancel the food points being lost.
	HandleFoodLoss(ctx *event.Context, from, to int)
	// HandleHeal handles the player being healed by a healing source. ctx.Cancel() may be called to cancel
	// the healing.
	// The health added may be changed by assigning to *health.
	HandleHeal(ctx *event.Context, health *float64, src healing.Source)
	// HandleHurt handles the player being hurt by any damage source. ctx.Cancel() may be called to cancel the
	// damage being dealt to the player.
	// The damage dealt to the player may be changed by assigning to *damage.
	HandleHurt(ctx *event.Context, damage *float64, src damage.Source)
	// HandleDeath handles the player dying to a particular damage cause.
	HandleDeath(src damage.Source)
	// HandleRespawn handles the respawning of the player in the world. The spawn position passed may be
	// changed by assigning to *pos.
	HandleRespawn(pos *mgl64.Vec3)
	// HandleStartBreak handles the player starting to break a block at the position passed. ctx.Cancel() may
	// be called to stop the player from breaking the block completely.
	HandleStartBreak(ctx *event.Context, pos cube.Pos)
	// HandleBlockBreak handles a block that is being broken by a player. ctx.Cancel() may be called to cancel
	// the block being broken.
	HandleBlockBreak(ctx *event.Context, pos cube.Pos)
	// HandleBlockPlace handles the player placing a specific block at a position in its world. ctx.Cancel()
	// may be called to cancel the block being placed.
	HandleBlockPlace(ctx *event.Context, pos cube.Pos, b world.Block)
	// HandleBlockPick handles the player picking a specific block at a position in its world. ctx.Cancel()
	// may be called to cancel the block being picked.
	HandleBlockPick(ctx *event.Context, pos cube.Pos, b world.Block)
	// HandleItemUse handles the player using an item in the air. It is called for each item, although most
	// will not actually do anything. Items such as snowballs may be thrown if HandleItemUse does not cancel
	// the context using ctx.Cancel(). It is not called if the player is holding no item.
	HandleItemUse(ctx *event.Context)
	// HandleItemUseOnBlock handles the player using the item held in its main hand on a block at the block
	// position passed. The face of the block clicked is also passed, along with the relative click position.
	// The click position has X, Y and Z values which are all in the range 0.0-1.0. It is also called if the
	// player is holding no item.
	HandleItemUseOnBlock(ctx *event.Context, pos cube.Pos, face cube.Face, clickPos mgl64.Vec3)
	// HandleItemUseOnEntity handles the player using the item held in its main hand on an entity passed to
	// the method.
	// HandleItemUseOnEntity is always called when a player uses an item on an entity, regardless of whether
	// the item actually does anything when used on an entity. It is also called if the player is holding no
	// item.
	HandleItemUseOnEntity(ctx *event.Context, e world.Entity)
	// HandleAttackEntity handles the player attacking an entity using the item held in its hand. ctx.Cancel()
	// may be called to cancel the attack, which will cancel damage dealt to the target and will stop the
	// entity from being knocked back.
	// The entity attacked may not be alive (implements entity.Living), in which case no damage will be dealt
	// and the target won't be knocked back.
	// The entity attacked may also be immune when this method is called, in which case no damage and knock-
	// back will be dealt.
	HandleAttackEntity(ctx *event.Context, e world.Entity)
	// HandleItemDamage handles the event wherein the item either held by the player or as armour takes
	// damage through usage.
	// The type of the item may be checked to determine whether it was armour or a tool used. The damage to
	// the item is passed.
	HandleItemDamage(ctx *event.Context, i item.Stack, damage int)
	// HandleItemPickup handles the player picking up an item from the ground. The item stack laying on the
	// ground is passed. ctx.Cancel() may be called to prevent the player from picking up the item.
	HandleItemPickup(ctx *event.Context, i item.Stack)
	// HandleItemDrop handles the player dropping an item on the ground. The dropped item entity is passed.
	// ctx.Cancel() may be called to prevent the player from dropping the entity.Item passed on the ground.
	// e.Item() may be called to obtain the item stack dropped.
	HandleItemDrop(ctx *event.Context, e *entity.Item)
	// HandleTransfer handles a player being transferred to another server. ctx.Cancel() may be called to
	// cancel the transfer.
	HandleTransfer(ctx *event.Context, addr *net.UDPAddr)
	// HandleCommandExecution handles the command execution of a player, who wrote a command in the chat.
	// ctx.Cancel() may be called to cancel the command execution.
	HandleCommandExecution(ctx *event.Context, command cmd.Command, args []string)
	// HandleQuit handles the closing of a player. It is always called when the player is disconnected,
	// regardless of the reason.
	HandleQuit()
}

Handler handles events that are called by a player. Implementations of Handler may be used to listen to specific events such as when a player chats or moves.

type NopHandler 

type NopHandler struct{}

NopHandler implements the Handler interface but does not execute any code when an event is called. The default handler of players is set to NopHandler. Users may embed NopHandler to avoid having to implement each method.

func (NopHandler) HandleAttackEntity 

func (NopHandler) HandleAttackEntity(*event.Context, world.Entity)

HandleAttackEntity ...

func (NopHandler) HandleBlockBreak 

func (NopHandler) HandleBlockBreak(*event.Context, cube.Pos)

HandleBlockBreak ...

func (NopHandler) HandleBlockPick 

func (NopHandler) HandleBlockPick(ctx *event.Context, pos cube.Pos, b world.Block)

HandleBlockPick ...

func (NopHandler) HandleBlockPlace 

func (NopHandler) HandleBlockPlace(*event.Context, cube.Pos, world.Block)

HandleBlockPlace ...

func (NopHandler) HandleChat 

func (NopHandler) HandleChat(*event.Context, *string)

HandleChat ...

func (NopHandler) HandleCommandExecution 

func (NopHandler) HandleCommandExecution(*event.Context, cmd.Command, []string)

HandleCommandExecution ...

func (NopHandler) HandleDeath 

func (NopHandler) HandleDeath(damage.Source)

HandleDeath ...

func (NopHandler) HandleFoodLoss 

func (NopHandler) HandleFoodLoss(*event.Context, int, int)

HandleFoodLoss ...

func (NopHandler) HandleHeal 

func (NopHandler) HandleHeal(*event.Context, *float64, healing.Source)

HandleHeal ...

func (NopHandler) HandleHurt 

func (NopHandler) HandleHurt(*event.Context, *float64, damage.Source)

HandleHurt ...

func (NopHandler) HandleItemDamage 

func (NopHandler) HandleItemDamage(*event.Context, item.Stack, int)

HandleItemDamage ...

func (NopHandler) HandleItemDrop 

func (NopHandler) HandleItemDrop(*event.Context, *entity.Item)

HandleItemDrop ...

func (NopHandler) HandleItemPickup 

func (NopHandler) HandleItemPickup(*event.Context, item.Stack)

HandleItemPickup ...

func (NopHandler) HandleItemUse 

func (NopHandler) HandleItemUse(*event.Context)

HandleItemUse ...

func (NopHandler) HandleItemUseOnBlock 

func (NopHandler) HandleItemUseOnBlock(*event.Context, cube.Pos, cube.Face, mgl64.Vec3)

HandleItemUseOnBlock ...

func (NopHandler) HandleItemUseOnEntity 

func (NopHandler) HandleItemUseOnEntity(*event.Context, world.Entity)

HandleItemUseOnEntity ...

func (NopHandler) HandleMove 

func (NopHandler) HandleMove(*event.Context, mgl64.Vec3, float64, float64)

HandleMove ...

func (NopHandler) HandleQuit 

func (NopHandler) HandleQuit()

HandleQuit ...

func (NopHandler) HandleRespawn 

func (NopHandler) HandleRespawn(*mgl64.Vec3)

HandleRespawn ...

func (NopHandler) HandleStartBreak 

func (NopHandler) HandleStartBreak(*event.Context, cube.Pos)

HandleStartBreak ...

func (NopHandler) HandleTeleport 

func (NopHandler) HandleTeleport(*event.Context, mgl64.Vec3)

HandleTeleport ...

func (NopHandler) HandleTransfer 

func (NopHandler) HandleTransfer(*event.Context, *net.UDPAddr)

HandleTransfer ...

type Player 

type Player struct {
	// contains filtered or unexported fields
}

Player is an implementation of a player entity. It has methods that implement the behaviour that players need to play in the world.

func New 

func New(name string, skin skin.Skin, pos mgl64.Vec3) *Player

New returns a new initialised player. A random UUID is generated for the player, so that it may be identified over network.

func NewWithSession 

func NewWithSession(name, xuid string, uuid uuid.UUID, skin skin.Skin, s *session.Session, pos mgl64.Vec3) *Player

NewWithSession returns a new player for a network session, so that the network session can control the player. A set of additional fields must be provided to initialise the player with the client's data, such as the name and the skin of the player.

func (*Player) AABB 

func (p *Player) AABB() physics.AABB

AABB returns the axis aligned bounding box of the player.

func (*Player) AbortBreaking 

func (p *Player) AbortBreaking()

AbortBreaking makes the player stop breaking the block it is currently breaking, or returns immediately if the player isn't breaking anything. Unlike FinishBreaking, AbortBreaking does not stop the animation.

func (*Player) AddEffect 

func (p *Player) AddEffect(e effect.Effect)

AddEffect adds an entity.Effect to the Player. If the effect is instant, it is applied to the Player immediately. If not, the effect is applied to the player every time the Tick method is called. AddEffect will overwrite any effects present if the level of the effect is higher than the existing one, or if the effects' levels are equal and the new effect has a longer duration.

func (*Player) AddFood 

func (p *Player) AddFood(points int)

AddFood adds a number of points to the food level of the player. If the new food level is negative or if it exceeds 20, it will be set to 0 or 20 respectively.

func (*Player) Addr 

func (p *Player) Addr() net.Addr

Addr returns the net.Addr of the Player. If the Player is not connected to a network session, nil is returned.

func (*Player) Armour 

func (p *Player) Armour() item.ArmourContainer

Armour returns the armour inventory of the player. This inventory yields 4 slots, for the helmet, chestplate, leggings and boots respectively.

func (*Player) AttackEntity 

func (p *Player) AttackEntity(e world.Entity)

AttackEntity uses the item held in the main hand of the player to attack the entity passed, provided it is within range of the player. The damage dealt to the entity will depend on the item held by the player and any effects the player may have. If the player cannot reach the entity at its position, the method returns immediately.

func (*Player) AttackImmune 

func (p *Player) AttackImmune() bool

AttackImmune checks if the player is currently immune to entity attacks, meaning it was recently attacked.

func (*Player) BeaconAffected 

func (*Player) BeaconAffected() bool

BeaconAffected ...

func (*Player) BreakBlock 

func (p *Player) BreakBlock(pos cube.Pos)

BreakBlock makes the player break a block in the world at a position passed. If the player is unable to reach the block passed, the method returns immediately.

func (*Player) Chat 

func (p *Player) Chat(msg ...interface{})

Chat writes a message in the global chat (chat.Global). The message is prefixed with the name of the player and is formatted following the rules of fmt.Sprintln.

func (*Player) Close 

func (p *Player) Close() error

Close closes the player and removes it from the world. Close disconnects the player with a 'Connection closed.' message. Disconnect should be used to disconnect a player with a custom message.

func (*Player) Collect 

func (p *Player) Collect(s item.Stack) (n int)

Collect makes the player collect the item stack passed, adding it to the inventory.

func (*Player) ContinueBreaking 

func (p *Player) ContinueBreaking(face cube.Face)

ContinueBreaking makes the player continue breaking the block it started breaking after a call to Player.StartBreaking(). The face passed is used to display particles on the side of the block broken.

func (*Player) Dead 

func (p *Player) Dead() bool

Dead checks if the player is considered dead. True is returned if the health of the player is equal to or lower than 0.

func (*Player) Disconnect 

func (p *Player) Disconnect(msg ...interface{})

Disconnect closes the player and removes it from the world. Disconnect, unlike Close, allows a custom message to be passed to show to the player when it is disconnected. The message is formatted following the rules of fmt.Sprintln without a newline at the end.

func (*Player) Drop 

func (p *Player) Drop(s item.Stack) (n int)

Drop makes the player drop the item.Stack passed as an entity.Item, so that it may be picked up from the ground. The dropped item entity has a pickup delay of 2 seconds. The number of items that was dropped in the end is returned. It is generally the count of the stack passed or 0 if dropping the item.Stack was cancelled.

func (*Player) Effects 

func (p *Player) Effects() []effect.Effect

Effects returns any effect currently applied to the entity. The returned effects are guaranteed not to have expired when returned.

func (*Player) EncodeEntity 

func (p *Player) EncodeEntity() string

EncodeEntity ...

func (*Player) ExecuteCommand 

func (p *Player) ExecuteCommand(commandLine string)

ExecuteCommand executes a command passed as the player. If the command could not be found, or if the usage was incorrect, an error message is sent to the player.

func (*Player) Exhaust 

func (p *Player) Exhaust(points float64)

Exhaust exhausts the player by the amount of points passed if the player is in survival mode. If the total exhaustion level exceeds 4, a saturation point, or food point, if saturation is 0, will be subtracted.

func (*Player) Extinguish 

func (p *Player) Extinguish()

Extinguish ...

func (*Player) EyeHeight 

func (p *Player) EyeHeight() float64

EyeHeight returns the eye height of the player: 1.62, or 0.52 if the player is swimming.

func (*Player) Facing 

func (p *Player) Facing() cube.Direction

Facing returns the horizontal direction that the player is facing.

func (*Player) FinalDamageFrom 

func (p *Player) FinalDamageFrom(dmg float64, src damage.Source) float64

FinalDamageFrom resolves the final damage received by the player if it is attacked by the source passed with the damage passed. FinalDamageFrom takes into account things such as the armour worn and the enchantments on the individual pieces. The damage returned will be at the least 0.

func (*Player) FinishBreaking 

func (p *Player) FinishBreaking()

FinishBreaking makes the player finish breaking the block it is currently breaking, or returns immediately if the player isn't breaking anything. FinishBreaking will stop the animation and break the block.

func (*Player) Food 

func (p *Player) Food() int

Food returns the current food level of a player. The level returned is guaranteed to always be between 0 and 20. Every half drumstick is one level.

func (*Player) GameMode 

func (p *Player) GameMode() world.GameMode

GameMode returns the current game mode assigned to the player. If not changed, the game mode returned will be the same as that of the world that the player spawns in. The game mode may be changed using Player.SetGameMode().

func (*Player) Handle 

func (p *Player) Handle(h Handler)

Handle changes the current handler of the player. As a result, events called by the player will call handlers of the Handler passed. Handle sets the player's handler to NopHandler if nil is passed.

func (*Player) Heal 

func (p *Player) Heal(health float64, source healing.Source)

Heal heals the entity for a given amount of health. The source passed represents the cause of the healing, for example healing.SourceFood if the entity healed by having a full food bar. If the health added to the original health exceeds the entity's max health, Heal will not add the full amount. If the health passed is negative, Heal will not do anything.

func (*Player) Health 

func (p *Player) Health() float64

Health returns the current health of the player. It will always be lower than Player.MaxHealth().

func (*Player) HeldItems 

func (p *Player) HeldItems() (mainHand, offHand item.Stack)

HeldItems returns the items currently held in the hands of the player. The first item stack returned is the one held in the main hand, the second is held in the off-hand. If no item was held in a hand, the stack returned has a count of 0. Stack.Empty() may be used to check if the hand held anything.

func (*Player) HideCoordinates 

func (p *Player) HideCoordinates()

HideCoordinates disables the vanilla coordinates for the player.

func (*Player) Hurt 

func (p *Player) Hurt(dmg float64, source damage.Source)

Hurt hurts the player for a given amount of damage. The source passed represents the cause of the damage, for example damage.SourceEntityAttack if the player is attacked by another entity. If the final damage exceeds the health that the player currently has, the player is killed and will have to respawn. If the damage passed is negative, Hurt will not do anything.

func (*Player) Inventory 

func (p *Player) Inventory() *inventory.Inventory

Inventory returns the inventory of the player. This inventory holds the items stored in the normal part of the inventory and the hotbar. It also includes the item in the main hand as returned by Player.HeldItems().

func (*Player) KnockBack 

func (p *Player) KnockBack(src mgl64.Vec3, force, height float64)

KnockBack knocks the player back with a given force and height. A source is passed which indicates the source of the velocity, typically the position of an attacking entity. The source is used to calculate the direction which the entity should be knocked back in.

func (*Player) Latency 

func (p *Player) Latency() time.Duration

Latency returns a rolling average of latency between the sending and the receiving end of the connection of the player. The latency returned is updated continuously and is half the round trip time (RTT). If the Player does not have a session associated with it, Latency returns 0.

func (*Player) Locale 

func (p *Player) Locale() language.Tag

Locale returns the language and locale of the Player, as selected in the Player's settings.

func (*Player) MaxHealth 

func (p *Player) MaxHealth() float64

MaxHealth returns the maximum amount of health that a player may have. The MaxHealth will always be higher than Player.Health().

func (*Player) Message 

func (p *Player) Message(a ...interface{})

Message sends a formatted message to the player. The message is formatted following the rules of fmt.Sprintln, however the newline at the end is not written.

func (*Player) Messagef 

func (p *Player) Messagef(f string, a ...interface{})

Messagef sends a formatted message using a specific format to the player. The message is formatted according to the fmt.Sprintf formatting rules.

func (*Player) Move 

func (p *Player) Move(deltaPos mgl64.Vec3)

Move moves the player from one position to another in the world, by adding the delta passed to the current position of the player.

func (*Player) Name 

func (p *Player) Name() string

Name returns the username of the player. If the player is controlled by a client, it is the username of the client. (Typically the XBOX Live name)

func (*Player) OnFireDuration 

func (p *Player) OnFireDuration() time.Duration

OnFireDuration ...

func (*Player) OnGround 

func (p *Player) OnGround() bool

OnGround checks if the player is considered to be on the ground.

func (*Player) OpenBlockContainer 

func (p *Player) OpenBlockContainer(pos cube.Pos)

OpenBlockContainer opens a block container, such as a chest, at the position passed. If no container was present at that location, OpenBlockContainer does nothing. OpenBlockContainer will also do nothing if the player has no session connected to it.

func (*Player) PickBlock 

func (p *Player) PickBlock(pos cube.Pos)

PickBlock makes the player pick a block in the world at a position passed. If the player is unable to pick the block, the method returns immediately.

func (*Player) Pitch 

func (p *Player) Pitch() float64

Pitch returns the pitch of the entity. This is vertical rotation (rotation around the horizontal axis), and is 0 when the entity faces forward.

func (*Player) PlaceBlock 

func (p *Player) PlaceBlock(pos cube.Pos, b world.Block, ctx *item.UseContext)

PlaceBlock makes the player place the block passed at the position passed, granted it is within the range of the player. A use context may be passed to obtain information on if the block placement was successful. (SubCount will be incremented). Nil may also be passed for the context parameter.

func (*Player) PlaySound 

func (p *Player) PlaySound(sound world.Sound)

PlaySound plays a world.Sound that only this Player can hear. Unlike World.PlaySound, it is not broadcast to players around it.

func (*Player) Position 

func (p *Player) Position() mgl64.Vec3

Position returns the current position of the player. It may be changed as the player moves or is moved around the world.

func (*Player) ReleaseItem 

func (p *Player) ReleaseItem()

ReleaseItem makes the Player release the item it is currently using. This is only applicable for items that implement the item.Consumable interface. If the Player is not currently using any item, ReleaseItem returns immediately. ReleaseItem either aborts the using of the item or finished it, depending on the time that elapsed since the item started being used.

func (*Player) RemoveBossBar 

func (p *Player) RemoveBossBar()

RemoveBossBar removes any boss bar currently active on the player's screen. If no boss bar is currently present, nothing happens.

func (*Player) RemoveEffect 

func (p *Player) RemoveEffect(e effect.Effect)

RemoveEffect removes any effect that might currently be active on the Player.

func (*Player) RemoveScoreboard 

func (p *Player) RemoveScoreboard()

RemoveScoreboard removes any scoreboard currently present on the screen of the player. Nothing happens if the player has no scoreboard currently active.

func (*Player) ResetFallDistance 

func (p *Player) ResetFallDistance()

ResetFallDistance resets the player's fall distance.

func (*Player) Respawn 

func (p *Player) Respawn()

Respawn spawns the player after it dies, so that its health is replenished and it is spawned in the world again. Nothing will happen if the player does not have a session connected to it.

func (*Player) Rotate 

func (p *Player) Rotate(deltaYaw, deltaPitch float64)

Rotate rotates the player, adding deltaYaw and deltaPitch to the respective values.

func (*Player) Saturate 

func (p *Player) Saturate(food int, saturation float64)

Saturate saturates the player's food bar with the amount of food points and saturation points passed. The total saturation of the player will never exceed its total food level.

func (*Player) Scale 

func (p *Player) Scale() float64

Scale returns the scale modifier of the Player. The default value for a normal scale is 1. A scale of 0 will make the Player completely invisible.

func (*Player) SendBossBar 

func (p *Player) SendBossBar(bar bossbar.BossBar)

SendBossBar sends a boss bar to the player, so that it will be shown indefinitely at the top of the player's screen. The boss bar may be removed by calling Player.RemoveBossBar().

func (*Player) SendCommandOutput 

func (p *Player) SendCommandOutput(output *cmd.Output)

SendCommandOutput sends the output of a command to the player.

func (*Player) SendForm 

func (p *Player) SendForm(f form.Form)

SendForm sends a form to the player for the client to fill out. Once the client fills it out, the Submit method of the form will be called. Note that the client may also close the form instead of filling it out, which will result in the form not having its Submit method called at all. Forms should never depend on the player actually filling out the form.

func (*Player) SendPopup 

func (p *Player) SendPopup(a ...interface{})

SendPopup sends a formatted popup to the player. The popup is shown above the hotbar of the player and overwrites/is overwritten by the name of the item equipped. The popup is formatted following the rules of fmt.Sprintln without a newline at the end.

func (*Player) SendScoreboard 

func (p *Player) SendScoreboard(scoreboard *scoreboard.Scoreboard)

SendScoreboard sends a scoreboard to the player. The scoreboard will be present indefinitely until removed by the caller. SendScoreboard may be called at any time to change the scoreboard of the player.

func (*Player) SendTip 

func (p *Player) SendTip(a ...interface{})

SendTip sends a tip to the player. The tip is shown in the middle of the screen of the player. The tip is formatted following the rules of fmt.Sprintln without a newline at the end.

func (*Player) SendTitle 

func (p *Player) SendTitle(t title.Title)

SendTitle sends a title to the player. The title may be configured to change the duration it is displayed and the text it shows. If non-empty, the subtitle is shown in a smaller font below the title. The same counts for the action text of the title, which is shown in a font similar to that of a tip/popup.

func (*Player) SetAbsorption 

func (p *Player) SetAbsorption(health float64)

SetAbsorption sets the absorption health of a player. This extra health shows as golden hearts and do not actually increase the maximum health. Once the hearts are lost, they will not regenerate. Nothing happens if a negative number is passed.

func (*Player) SetFood 

func (p *Player) SetFood(level int)

SetFood sets the food level of a player. The level passed must be in a range of 0-20. If the level passed is negative, the food level will be set to 0. If the level exceeds 20, the food level will be set to 20.

func (*Player) SetGameMode 

func (p *Player) SetGameMode(mode world.GameMode)

SetGameMode sets the game mode of a player. The game mode specifies the way that the player can interact with the world that it is in.

func (*Player) SetHeldItems 

func (p *Player) SetHeldItems(mainHand, offHand item.Stack)

SetHeldItems sets items to the main hand and the off-hand of the player. The Stacks passed may be empty (Stack.Empty()) to clear the held item.

func (*Player) SetImmobile 

func (p *Player) SetImmobile()

SetImmobile prevents the player from moving around, but still allows them to look around.

func (*Player) SetInvisible 

func (p *Player) SetInvisible()

SetInvisible sets the player invisible, so that other players will not be able to see it.

func (*Player) SetMaxHealth 

func (p *Player) SetMaxHealth(health float64)

SetMaxHealth sets the maximum health of the player. If the current health of the player is higher than the new maximum health, the health is set to the new maximum. SetMaxHealth panics if the max health passed is 0 or lower.

func (*Player) SetMobile 

func (p *Player) SetMobile()

SetMobile allows the player to freely move around again after being immobile.

func (*Player) SetNameTag 

func (p *Player) SetNameTag(name string)

SetNameTag changes the name tag displayed over the player in-game. Changing the name tag does not change the player's name in, for example, the player list or the chat.

func (*Player) SetOnFire 

func (p *Player) SetOnFire(duration time.Duration)

SetOnFire ...

func (*Player) SetScale 

func (p *Player) SetScale(s float64)

SetScale changes the scale modifier of the Player. The default value for a normal scale is 1. A scale of 0 will make the Player completely invisible.

func (*Player) SetSpeed 

func (p *Player) SetSpeed(speed float64)

SetSpeed sets the speed of the player. The value passed is the blocks/tick speed that the player will then obtain.

func (*Player) SetVelocity 

func (p *Player) SetVelocity(v mgl64.Vec3)

SetVelocity sets the velocity of the player.

func (*Player) SetVisible 

func (p *Player) SetVisible()

SetVisible sets the player visible again, so that other players can see it again. If the player was already visible, or if the player is in spectator mode, nothing happens.

func (*Player) ShowCoordinates 

func (p *Player) ShowCoordinates()

ShowCoordinates enables the vanilla coordinates for the player.

func (*Player) Skin 

func (p *Player) Skin() skin.Skin

Skin returns the skin that a player joined with. This skin will be visible to other players that the player is shown to. If the player was not connected to a network session, a default skin will be set.

func (*Player) Sneaking 

func (p *Player) Sneaking() bool

Sneaking checks if the player is currently sneaking.

func (*Player) Speed 

func (p *Player) Speed() float64

Speed returns the speed of the player, returning a value that indicates the blocks/tick speed. The default speed of a player is 0.1.

func (*Player) Sprinting 

func (p *Player) Sprinting() bool

Sprinting checks if the player is currently sprinting.

func (*Player) StartBreaking 

func (p *Player) StartBreaking(pos cube.Pos, face cube.Face)

StartBreaking makes the player start breaking the block at the position passed using the item currently held in its main hand. If no block is present at the position, or if the block is out of range, StartBreaking will return immediately and the block will not be broken. StartBreaking will stop the breaking of any block that the player might be breaking before this method is called.

func (*Player) StartSneaking 

func (p *Player) StartSneaking()

StartSneaking makes a player start sneaking. If the player is already sneaking, StartSneaking will not do anything. If the player is sprinting while StartSneaking is called, the sprinting is stopped.

func (*Player) StartSprinting 

func (p *Player) StartSprinting()

StartSprinting makes a player start sprinting, increasing the speed of the player by 30% and making particles show up under the feet. The player will only start sprinting if its food level is high enough. If the player is sneaking when calling StartSprinting, it is stopped from sneaking.

func (*Player) StartSwimming 

func (p *Player) StartSwimming()

StartSwimming makes the player start swimming if it is not currently doing so. If the player is sneaking while StartSwimming is called, the sneaking is stopped.

func (*Player) State 

func (p *Player) State() (s []state.State)

State returns the current state of the player. Types from the `entity/state` package are returned depending on what the player is currently doing.

func (*Player) StopSneaking 

func (p *Player) StopSneaking()

StopSneaking makes a player stop sneaking if it currently is. If the player is not sneaking, StopSneaking will not do anything.

func (*Player) StopSprinting 

func (p *Player) StopSprinting()

StopSprinting makes a player stop sprinting, setting back the speed of the player to its original value.

func (*Player) StopSwimming 

func (p *Player) StopSwimming()

StopSwimming makes the player stop swimming if it is currently doing so.

func (*Player) Swimming 

func (p *Player) Swimming() bool

Swimming checks if the player is currently swimming.

func (*Player) SwingArm 

func (p *Player) SwingArm()

SwingArm makes the player swing its arm.

func (*Player) Teleport 

func (p *Player) Teleport(pos mgl64.Vec3)

Teleport teleports the player to a target position in the world. Unlike Move, it immediately changes the position of the player, rather than showing an animation.

func (*Player) Tick 

func (p *Player) Tick(current int64)

Tick ticks the entity, performing actions such as checking if the player is still breaking a block.

func (*Player) Transfer 

func (p *Player) Transfer(address string) (err error)

Transfer transfers the player to a server at the address passed. If the address could not be resolved, an error is returned. If it is returned, the player is closed and transferred to the server.

func (*Player) UUID 

func (p *Player) UUID() uuid.UUID

UUID returns the UUID of the player. This UUID will remain consistent with an XBOX Live account, and will, unlike the name of the player, never change. It is therefore recommended to use the UUID over the name of the player. Additionally, it is recommended to use the UUID over the XUID because of its standard format.

func (*Player) UseItem 

func (p *Player) UseItem()

UseItem uses the item currently held in the player's main hand in the air. Generally, nothing happens, unless the held item implements the item.Usable interface, in which case it will be activated. This generally happens for items such as throwable items like snowballs.

func (*Player) UseItemOnBlock 

func (p *Player) UseItemOnBlock(pos cube.Pos, face cube.Face, clickPos mgl64.Vec3)

UseItemOnBlock uses the item held in the main hand of the player on a block at the position passed. The player is assumed to have clicked the face passed with the relative click position clickPos. If the item could not be used successfully, for example when the position is out of range, the method returns immediately.

func (*Player) UseItemOnEntity 

func (p *Player) UseItemOnEntity(e world.Entity)

UseItemOnEntity uses the item held in the main hand of the player on the entity passed, provided it is within range of the player. If the item held in the main hand of the player does nothing when used on an entity, nothing will happen.

func (*Player) Velocity 

func (p *Player) Velocity() mgl64.Vec3

Velocity returns the current velocity of the player.

func (*Player) World 

func (p *Player) World() *world.World

World returns the world that the player is currently in.

func (*Player) XUID 

func (p *Player) XUID() string

XUID returns the XBOX Live user ID of the player. It will remain consistent with the XBOX Live account, and will not change in the lifetime of an account. The XUID is a number that can be parsed as an int64. No more information on what it represents is available, and the UUID should be preferred. The XUID returned is empty if the Player is not connected to a network session or if the Player is not authenticated with XBOX Live.

func (*Player) Yaw 

func (p *Player) Yaw() float64

Yaw returns the yaw of the entity. This is horizontal rotation (rotation around the vertical axis), and is 0 when the entity faces forward.

Source Files

View all Source files

Directories

Path Synopsis

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.