Documentation
¶
Index ¶
- type AddActor
- type AddPlayer
- type AddVolumeEntity
- type CommandRequest
- type ItemStackRequest
- type ModalFormResponse
- type NetworkChunkPublisherUpdate
- type PlayerAction
- type PlayerAuthInput
- type PlayerList
- type PlayerSkin
- type RemoveVolumeEntity
- type RequestChunkRadius
- type SetActorData
- type SpawnParticleEffect
- type StartGame
- type StructureBlockUpdate
- type StructureTemplateDataRequest
- type UpdateAttributes
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
This section is empty.
Types ¶
type AddActor ¶
type AddActor struct {
// EntityUniqueID is the unique ID of the entity. The unique ID is a value that remains consistent across
// different sessions of the same world, but most servers simply fill the runtime ID of the entity out for
// this field.
EntityUniqueID int64
// EntityRuntimeID is the runtime ID of the entity. The runtime ID is unique for each world session, and
// entities are generally identified in packets using this runtime ID.
EntityRuntimeID uint64
// EntityType is the string entity type of the entity, for example 'minecraft:skeleton'. A list of these
// entities may be found online.
EntityType string
// Position is the position to spawn the entity on. If the entity is on a distance that the player cannot
// see it, the entity will still show up if the player moves closer.
Position mgl32.Vec3
// Velocity is the initial velocity the entity spawns with. This velocity will initiate client side
// movement of the entity.
Velocity mgl32.Vec3
// Pitch is the vertical rotation of the entity. Facing straight forward yields a pitch of 0. Pitch is
// measured in degrees.
Pitch float32
// Yaw is the horizontal rotation of the entity. Yaw is also measured in degrees.
Yaw float32
// HeadYaw is the same as Yaw, except that it applies specifically to the head of the entity. A different value for
// HeadYaw than Yaw means that the entity will have its head turned.
HeadYaw float32
// Attributes is a slice of attributes that the entity has. It includes attributes such as its health,
// movement speed, etc.
Attributes []protocol.AttributeValue
// EntityMetadata is a map of entity metadata, which includes flags and data properties that alter in
// particular the way the entity looks. Flags include ones such as 'on fire' and 'sprinting'.
// The metadata values are indexed by their property key.
EntityMetadata map[uint32]any
// EntityLinks is a list of entity links that are currently active on the entity. These links alter the
// way the entity shows up when first spawned in terms of it shown as riding an entity. Setting these
// links is important for new viewers to see the entity is riding another entity.
EntityLinks []protocol.EntityLink
}
AddActor is sent by the server to the client to spawn an entity to the player. It is used for every entity except other players, for which the AddPlayer packet is used.
type AddPlayer ¶
type AddPlayer struct {
// UUID is the UUID of the player. It is the same UUID that the client sent in the Login packet at the
// start of the session. A player with this UUID must exist in the player list (built up using the
// PlayerList packet), for it to show up in-game.
UUID uuid.UUID
// Username is the name of the player. This username is the username that will be set as the initial
// name tag of the player.
Username string
// EntityUniqueID is the unique ID of the entity. The unique ID is a value that remains consistent across
// different sessions of the same world, but most servers simply fill the runtime ID of the entity out for
// this field.
EntityUniqueID int64
// EntityRuntimeID is the runtime ID of the player. The runtime ID is unique for each world session, and
// entities are generally identified in packets using this runtime ID.
EntityRuntimeID uint64
// PlatformChatID is an identifier only set for particular platforms when chatting (presumably only for
// Nintendo Switch). It is otherwise an empty string, and is used to decide which players are able to
// chat with each other.
PlatformChatID string
// Position is the position to spawn the player on. If the player is on a distance that the viewer cannot
// see it, the player will still show up if the viewer moves closer.
Position mgl32.Vec3
// Velocity is the initial velocity the player spawns with. This velocity will initiate client side
// movement of the player.
Velocity mgl32.Vec3
// Pitch is the vertical rotation of the player. Facing straight forward yields a pitch of 0. Pitch is
// measured in degrees.
Pitch float32
// Yaw is the horizontal rotation of the player. Yaw is also measured in degrees.
Yaw float32
// HeadYaw is the same as Yaw, except that it applies specifically to the head of the player. A different
// value for HeadYaw than Yaw means that the player will have its head turned.
HeadYaw float32
// HeldItem is the item that the player is holding. The item is shown to the viewer as soon as the player
// itself shows up. Needless to say that this field is rather pointless, as additional packets still must
// be sent for armour to show up.
HeldItem protocol.ItemInstance
// EntityMetadata is a map of entity metadata, which includes flags and data properties that alter in
// particular the way the player looks. Flags include ones such as 'on fire' and 'sprinting'.
// The metadata values are indexed by their property key.
EntityMetadata map[uint32]any
// AdventureSettings represents various data about the abilities of a player, such as ability layers or permissions.
AdventureSettings packet.AdventureSettings
// EntityLinks is a list of entity links that are currently active on the player. These links alter the
// way the player shows up when first spawned in terms of it shown as riding an entity. Setting these
// links is important for new viewers to see the player is riding another entity.
EntityLinks []protocol.EntityLink
// DeviceID is the device ID set in one of the files found in the storage of the device of the player. It
// may be changed freely, so it should not be relied on for anything.
DeviceID string
// BuildPlatform is the build platform/device OS of the player that is about to be added, as it sent in
// the Login packet when joining.
BuildPlatform int32
}
AddPlayer is sent by the server to the client to make a player entity show up client-side. It is one of the few entities that cannot be sent using the AddActor packet.
type AddVolumeEntity ¶
type AddVolumeEntity struct {
// EntityRuntimeID is the runtime ID of the volume. The runtime ID is unique for each world session, and
// entities are generally identified in packets using this runtime ID.
EntityRuntimeID uint64
// EntityMetadata is a map of entity metadata, which includes flags and data properties that alter in
// particular the way the volume functions or looks.
EntityMetadata map[string]any
// EncodingIdentifier is the unique identifier for the volume. It must be of the form 'namespace:name', where
// namespace cannot be 'minecraft'.
EncodingIdentifier string
// InstanceIdentifier is the identifier of a fog definition.
InstanceIdentifier string
// EngineVersion is the engine version the entity is using, for example, '1.17.0'.
EngineVersion string
}
AddVolumeEntity sends a volume entity's definition and metadata from server to client.
func (*AddVolumeEntity) Marshal ¶
func (pk *AddVolumeEntity) Marshal(r protocol.IO)
type CommandRequest ¶
type CommandRequest struct {
// CommandLine is the raw entered command line. The client does no parsing of the command line by itself
// (unlike it did in the early stages), but lets the server do that.
CommandLine string
// CommandOrigin is the data specifying the origin of the command. In other words, the source that the
// command was from, such as the player itself or a websocket server.
CommandOrigin protocol.CommandOrigin
// Internal specifies if the command request internal. Setting it to false seems to work and the usage of
// this field is not known.
Internal bool
}
CommandRequest is sent by the client to request the execution of a server-side command. Although some servers support sending commands using the Text packet, this packet is guaranteed to have the correct result.
func (*CommandRequest) Marshal ¶
func (pk *CommandRequest) Marshal(io protocol.IO)
type ItemStackRequest ¶
type ItemStackRequest struct {
// Requests holds a list of item stack requests. These requests are all separate, but the client buffers
// the requests, so you might find multiple unrelated requests in this packet.
Requests []types.ItemStackRequest
}
ItemStackRequest is sent by the client to change item stacks in an inventory. It is essentially a replacement of the InventoryTransaction packet added in 1.16 for inventory specific actions, such as moving items around or crafting. The InventoryTransaction packet is still used for actions such as placing blocks and interacting with entities.
func (*ItemStackRequest) Marshal ¶
func (pk *ItemStackRequest) Marshal(io protocol.IO)
type ModalFormResponse ¶
type ModalFormResponse struct {
// FormID is the form ID of the form the client has responded to. It is the same as the ID sent in the
// ModalFormRequest, and may be used to identify which form was submitted.
FormID uint32
// ResponseData is a JSON encoded value representing the response of the player. If the form was
// cancelled, a JSON encoded 'null' is in the response. For a modal form, the response is either true or
// false, for a menu form, the response is an integer specifying the index of the button clicked, and for
// a custom form, the response is an array containing a value for each element.
ResponseData []byte
}
ModalFormResponse is sent by the client in response to a ModalFormRequest, after the player has submitted the form sent. It contains the options/properties selected by the player, or a JSON encoded 'null' if the form was closed by clicking the X in the top right corner of the form.
type NetworkChunkPublisherUpdate ¶
type NetworkChunkPublisherUpdate struct {
// Position is the block position around which chunks loaded will remain shown to the client. Most servers
// set this position to the position of the player itself.
Position protocol.BlockPos
// Radius is the radius in blocks around Position that chunks sent show up in and will remain loaded in.
// Unlike the RequestChunkRadius and ChunkRadiusUpdated packets, this radius is in blocks rather than
// chunks, so the chunk radius needs to be multiplied by 16. (Or shifted to the left by 4.)
Radius uint32
}
NetworkChunkPublisherUpdate is sent by the server to change the point around which chunks are and remain loaded. This is useful for mini-game servers, where only one area is ever loaded, in which case the NetworkChunkPublisherUpdate packet can be sent in the middle of it, so that no chunks ever need to be additionally sent during the course of the game. In reality, the packet is not extraordinarily useful, and most servers just send it constantly at the position of the player. If the packet is not sent at all, no chunks will be shown to the player, regardless of where they are sent.
func (*NetworkChunkPublisherUpdate) Marshal ¶
func (pk *NetworkChunkPublisherUpdate) Marshal(r protocol.IO)
Marshal ...
type PlayerAction ¶
type PlayerAction struct {
// EntityRuntimeID is the runtime ID of the player. The runtime ID is unique for each world session, and
// entities are generally identified in packets using this runtime ID.
EntityRuntimeID uint64
// ActionType is the ID of the action that was executed by the player. It is one of the constants that may
// be found in protocol/player.go.
ActionType int32
// BlockPosition is the position of the target block, if the action with the ActionType set concerned a
// block. If that is not the case, the block position will be zero.
BlockPosition protocol.BlockPos
// BlockFace is the face of the target block that was touched. If the action with the ActionType set
// concerned a block. If not, the face is always 0.
BlockFace int32
}
PlayerAction is sent by the client when it executes any action, for example starting to sprint, swim, starting the breaking of a block, dropping an item, etc.
func (*PlayerAction) Marshal ¶
func (pk *PlayerAction) Marshal(io protocol.IO)
type PlayerAuthInput ¶
type PlayerAuthInput struct {
// Pitch and Yaw hold the rotation that the player reports it has.
Pitch, Yaw float32
// Position holds the position that the player reports it has.
Position mgl32.Vec3
// MoveVector is a Vec2 that specifies the direction in which the player moved, as a combination of X/Z
// values which are created using the WASD/controller stick state.
MoveVector mgl32.Vec2
// HeadYaw is the horizontal rotation of the head that the player reports it has.
HeadYaw float32
// InputData is a combination of bit flags that together specify the way the player moved last tick. It
// is a combination of the flags above.
InputData uint64
// InputMode specifies the way that the client inputs data to the screen. It is one of the constants that
// may be found above.
InputMode uint32
// PlayMode specifies the way that the player is playing. The values it holds, which are rather random,
// may be found above.
PlayMode uint32
// GazeDirection is the direction in which the player is gazing, when the PlayMode is PlayModeReality: In
// other words, when the player is playing in virtual reality.
GazeDirection mgl32.Vec3
// Tick is the server tick at which the packet was sent. It is used in relation to
// CorrectPlayerMovePrediction.
Tick uint64
// Delta was the delta between the old and the new position. There isn't any practical use for this field
// as it can be calculated by the server itself.
Delta mgl32.Vec3
// ItemInteractionData is the transaction data if the InputData includes an item interaction.
ItemInteractionData protocol.UseItemTransactionData
// ItemStackRequest is sent by the client to change an item in their inventory.
ItemStackRequest types.ItemStackRequest
// BlockActions is a slice of block actions that the client has interacted with.
BlockActions []protocol.PlayerBlockAction
}
PlayerAuthInput is sent by the client to allow for server authoritative movement. It is used to synchronise the player input with the position server-side. The client sends this packet when the ServerAuthoritativeMovementMode field in the StartGame packet is set to true, instead of the MovePlayer packet. The client will send this packet once every tick.
func (*PlayerAuthInput) Marshal ¶
func (pk *PlayerAuthInput) Marshal(io protocol.IO)
type PlayerList ¶
type PlayerList struct {
// ActionType is the action to execute upon the player list. The entries that follow specify which entries
// are added or removed from the player list.
ActionType byte
// Entries is a list of all player list entries that should be added/removed from the player list,
// depending on the ActionType set.
Entries []types.PlayerListEntry
}
PlayerList is sent by the server to update the client-side player list in the in-game menu screen. It shows the icon of each player if the correct XUID is written in the packet. Sending the PlayerList packet is obligatory when sending an AddPlayer packet. The added player will not show up to a client if it has not been added to the player list, because several properties of the player are obtained from the player list, such as the skin.
func (*PlayerList) Marshal ¶
func (pk *PlayerList) Marshal(io protocol.IO)
type PlayerSkin ¶
type PlayerSkin struct {
// UUID is the UUID of the player as sent in the Login packet when the client joined the server. It must
// match this UUID exactly for the skin to show up on the player.
UUID uuid.UUID
// Skin is the new skin to be applied on the player with the UUID in the field above. The skin, including
// its animations, will be shown after sending it.
Skin types.Skin
// NewSkinName no longer has a function: The field can be left empty at all times.
NewSkinName string
// OldSkinName no longer has a function: The field can be left empty at all times.
OldSkinName string
}
PlayerSkin is sent by the client to the server when it updates its own skin using the in-game skin picker. It is relayed by the server, or sent if the server changes the skin of a player on its own accord. Note that the packet can only be sent for players that are in the player list at the time of sending.
func (*PlayerSkin) Marshal ¶
func (pk *PlayerSkin) Marshal(io protocol.IO)
type RemoveVolumeEntity ¶
type RemoveVolumeEntity struct {
// EntityRuntimeID ...
EntityRuntimeID uint64
}
RemoveVolumeEntity indicates a volume entity to be removed from server to client.
func (*RemoveVolumeEntity) Marshal ¶
func (pk *RemoveVolumeEntity) Marshal(r protocol.IO)
type RequestChunkRadius ¶
type RequestChunkRadius struct {
// ChunkRadius is the requested chunk radius. This value is always the value set in the settings of the
// player.
ChunkRadius int32
}
RequestChunkRadius is sent by the client to the server to update the server on the chunk view radius that it has set in the settings. The server may respond with a ChunkRadiusUpdated packet with either the chunk radius requested, or a different chunk radius if the server chooses so.
func (*RequestChunkRadius) Marshal ¶
func (pk *RequestChunkRadius) Marshal(io protocol.IO)
type SetActorData ¶
type SetActorData struct {
// EntityRuntimeID is the runtime ID of the entity. The runtime ID is unique for each world session, and
// entities are generally identified in packets using this runtime ID.
EntityRuntimeID uint64
// EntityMetadata is a map of entity metadata, which includes flags and data properties that alter in
// particular the way the entity looks. Flags include ones such as 'on fire' and 'sprinting'.
// The metadata values are indexed by their property key.
EntityMetadata map[uint32]any
// Tick is the server tick at which the packet was sent. It is used in relation to CorrectPlayerMovePrediction.
Tick uint64
}
SetActorData is sent by the server to update the entity metadata of an entity. It includes flags such as if the entity is on fire, but also properties such as the air it has left until it starts drowning.
func (*SetActorData) Marshal ¶
func (pk *SetActorData) Marshal(io protocol.IO)
type SpawnParticleEffect ¶
type SpawnParticleEffect struct {
// Dimension is the dimension that the particle is spawned in. Its exact usage is not clear, as the
// dimension has no direct effect on the particle.
Dimension byte
// EntityUniqueID is the unique ID of the entity that the spawned particle may be attached to. If this ID
// is not -1, the Position below will be interpreted as relative to the position of the entity associated
// with this unique ID.
EntityUniqueID int64
// Position is the position that the particle should be spawned at. If the position is too far away from
// the player, it will not show up.
// If EntityUniqueID is not -1, the position will be relative to the position of the entity.
Position mgl32.Vec3
// ParticleName is the name of the particle that should be shown. This name may point to a particle effect
// that is built-in, or to one implemented by behaviour packs.
ParticleName string
}
SpawnParticleEffect is sent by the server to spawn a particle effect client-side. Unlike other packets that result in the appearing of particles, this packet can show particles that are not hardcoded in the client. They can be added and changed through behaviour packs to implement custom particles.
func (*SpawnParticleEffect) Marshal ¶
func (pk *SpawnParticleEffect) Marshal(r protocol.IO)
type StartGame ¶
type StartGame struct {
// EntityUniqueID is the unique ID of the player. The unique ID is a value that remains consistent across
// different sessions of the same world, but most servers simply fill the runtime ID of the entity out for
// this field.
EntityUniqueID int64
// EntityRuntimeID is the runtime ID of the player. The runtime ID is unique for each world session, and
// entities are generally identified in packets using this runtime ID.
EntityRuntimeID uint64
// PlayerGameMode is the game mode the player currently has. It is a value from 0-4, with 0 being
// survival mode, 1 being creative mode, 2 being adventure mode, 3 being survival spectator and 4 being
// creative spectator.
// This field may be set to 5 to make the client fall back to the game mode set in the WorldGameMode
// field.
PlayerGameMode int32
// PlayerPosition is the spawn position of the player in the world. In servers this is often the same as
// the world's spawn position found below.
PlayerPosition mgl32.Vec3
// Pitch is the vertical rotation of the player. Facing straight forward yields a pitch of 0. Pitch is
// measured in degrees.
Pitch float32
// Yaw is the horizontal rotation of the player. Yaw is also measured in degrees.
Yaw float32
// WorldSeed is the seed used to generate the world. Unlike in PC edition, the seed is a 32bit integer
// here.
WorldSeed int32
// SpawnBiomeType specifies if the biome that the player spawns in is user defined (through behaviour
// packs) or builtin. See the constants above.
SpawnBiomeType int16
// UserDefinedBiomeName is a readable name of the biome that the player spawned in, such as 'plains'. This
// might be a custom biome name if any custom biomes are present through behaviour packs.
UserDefinedBiomeName string
// Dimension is the ID of the dimension that the player spawns in. It is a value from 0-2, with 0 being
// the overworld, 1 being the nether and 2 being the end.
Dimension int32
// Generator is the generator used for the world. It is a value from 0-4, with 0 being old limited worlds,
// 1 being infinite worlds, 2 being flat worlds, 3 being nether worlds and 4 being end worlds. A value of
// 0 will actually make the client stop rendering chunks you send beyond the world limit.
Generator int32
// WorldGameMode is the game mode that a player gets when it first spawns in the world. It is shown in the
// settings and is used if the PlayerGameMode is set to 5.
WorldGameMode int32
// Difficulty is the difficulty of the world. It is a value from 0-3, with 0 being peaceful, 1 being easy,
// 2 being normal and 3 being hard.
Difficulty int32
// WorldSpawn is the block on which the world spawn of the world. This coordinate has no effect on the
// place that the client spawns, but it does have an effect on the direction that a compass points.
WorldSpawn protocol.BlockPos
// AchievementsDisabled defines if achievements are disabled in the world. The client crashes if this
// value is set to true while the player's or the world's game mode is creative, and it's recommended to
// simply always set this to false as a server.
AchievementsDisabled bool
// DayCycleLockTime is the time at which the day cycle was locked if the day cycle is disabled using the
// respective game rule. The client will maintain this time as long as the day cycle is disabled.
DayCycleLockTime int32
// EducationEditionOffer is some Minecraft: Education Edition field that specifies what 'region' the world
// was from, with 0 being None, 1 being RestOfWorld, and 2 being China.
// The actual use of this field is unknown.
EducationEditionOffer int32
// EducationFeaturesEnabled specifies if the world has education edition features enabled, such as the
// blocks or entities specific to education edition.
EducationFeaturesEnabled bool
// EducationProductID is a UUID used to identify the education edition server instance. It is generally
// unique for education edition servers.
EducationProductID string
// RainLevel is the level specifying the intensity of the rain falling. When set to 0, no rain falls at
// all.
RainLevel float32
// LightningLevel is the level specifying the intensity of the thunder. This may actually be set
// independently from the RainLevel, meaning dark clouds can be produced without rain.
LightningLevel float32
// ConfirmedPlatformLockedContent ...
ConfirmedPlatformLockedContent bool
// MultiPlayerGame specifies if the world is a multi-player game. This should always be set to true for
// servers.
MultiPlayerGame bool
// LANBroadcastEnabled specifies if LAN broadcast was intended to be enabled for the world.
LANBroadcastEnabled bool
// XBLBroadcastMode is the mode used to broadcast the joined game across XBOX Live.
XBLBroadcastMode int32
// PlatformBroadcastMode is the mode used to broadcast the joined game across the platform.
PlatformBroadcastMode int32
// CommandsEnabled specifies if commands are enabled for the player. It is recommended to always set this
// to true on the server, as setting it to false means the player cannot, under any circumstance, use a
// command.
CommandsEnabled bool
// TexturePackRequired specifies if the texture pack the world might hold is required, meaning the client
// was forced to download it before joining.
TexturePackRequired bool
// GameRules defines game rules currently active with their respective values. The value of these game
// rules may be either 'bool', 'int32' or 'float32'. Some game rules are server side only, and don't
// necessarily need to be sent to the client.
GameRules []protocol.GameRule
// Experiments holds a list of experiments that are either enabled or disabled in the world that the
// player spawns in.
Experiments []protocol.ExperimentData
// ExperimentsPreviouslyToggled specifies if any experiments were previously toggled in this world. It is
// probably used for some kind of metrics.
ExperimentsPreviouslyToggled bool
// BonusChestEnabled specifies if the world had the bonus map setting enabled when generating it. It does
// not have any effect client-side.
BonusChestEnabled bool
// StartWithMapEnabled specifies if the world has the start with map setting enabled, meaning each joining
// player obtains a map. This should always be set to false, because the client obtains a map all on its
// own accord if this is set to true.
StartWithMapEnabled bool
// PlayerPermissions is the permission level of the player. It is a value from 0-3, with 0 being visitor,
// 1 being member, 2 being operator and 3 being custom.
PlayerPermissions int32
// ServerChunkTickRadius is the radius around the player in which chunks are ticked. Most servers set this
// value to a fixed number, as it does not necessarily affect anything client-side.
ServerChunkTickRadius int32
// HasLockedBehaviourPack specifies if the behaviour pack of the world is locked, meaning it cannot be
// disabled from the world. This is typically set for worlds on the marketplace that have a dedicated
// behaviour pack.
HasLockedBehaviourPack bool
// HasLockedTexturePack specifies if the texture pack of the world is locked, meaning it cannot be
// disabled from the world. This is typically set for worlds on the marketplace that have a dedicated
// texture pack.
HasLockedTexturePack bool
// FromLockedWorldTemplate specifies if the world from the server was from a locked world template. For
// servers this should always be set to false.
FromLockedWorldTemplate bool
// MSAGamerTagsOnly ..
MSAGamerTagsOnly bool
// FromWorldTemplate specifies if the world from the server was from a world template. For servers this
// should always be set to false.
FromWorldTemplate bool
// WorldTemplateSettingsLocked specifies if the world was a template that locks all settings that change
// properties above in the settings GUI. It is recommended to set this to true for servers that do not
// allow things such as setting game rules through the GUI.
WorldTemplateSettingsLocked bool
// OnlySpawnV1Villagers is a hack that Mojang put in place to preserve backwards compatibility with old
// villagers. The bool is never actually read though, so it has no functionality.
OnlySpawnV1Villagers bool
// BaseGameVersion is the version of the game from which Vanilla features will be used. The exact function
// of this field isn't clear.
BaseGameVersion string
// LimitedWorldWidth and LimitedWorldDepth are the dimensions of the world if the world is a limited
// world. For unlimited worlds, these may simply be left as 0.
LimitedWorldWidth, LimitedWorldDepth int32
// NewNether specifies if the server runs with the new nether introduced in the 1.16 update.
NewNether bool
EducationSharedResourceURI protocol.EducationSharedResourceURI
// ForceExperimentalGameplay specifies if experimental gameplay should be force enabled. For servers this
// should always be set to false.
ForceExperimentalGameplay bool
// LevelID is a base64 encoded world ID that is used to identify the world.
LevelID string
// WorldName is the name of the world that the player is joining. Note that this field shows up above the
// player list for the rest of the game session, and cannot be changed. Setting the server name to this
// field is recommended.
WorldName string
// TemplateContentIdentity is a UUID specific to the premium world template that might have been used to
// generate the world. Servers should always fill out an empty string for this.
TemplateContentIdentity string
// Trial specifies if the world was a trial world, meaning features are limited and there is a time limit
// on the world.
Trial bool
// PlayerMovementSettings ...
PlayerMovementSettings protocol.PlayerMovementSettings
// Time is the total time that has elapsed since the start of the world.
Time int64
// EnchantmentSeed is the seed used to seed the random used to produce enchantments in the enchantment
// table. Note that the exact correct random implementation must be used to produce the correct results
// both client- and server-side.
EnchantmentSeed int32
// Blocks is a list of all custom blocks registered on the server.
Blocks []protocol.BlockEntry
// Items is a list of all items with their legacy IDs which are available in the game. Failing to send any
// of the items that are in the game will crash mobile clients.
Items []protocol.ItemEntry
// MultiPlayerCorrelationID is a unique ID specifying the multi-player session of the player. A random
// UUID should be filled out for this field.
MultiPlayerCorrelationID string
// ServerAuthoritativeInventory specifies if the server authoritative inventory system is enabled. This
// is a new system introduced in 1.16. Backwards compatibility with the inventory transactions has to
// some extent been preserved, but will eventually be removed.
ServerAuthoritativeInventory bool
// GameVersion is the version of the game the server is running. The exact function of this field isn't clear.
GameVersion string
// ServerBlockStateChecksum is a checksum to ensure block states between the server and client match.
// This can simply be left empty, and the client will avoid trying to verify it.
ServerBlockStateChecksum uint64
}
StartGame is sent by the server to send information about the world the player will be spawned in. It contains information about the position the player spawns in, and information about the world in general such as its game rules.
type StructureBlockUpdate ¶
type StructureBlockUpdate struct {
// Position is the position of the structure block that is updated.
Position protocol.BlockPos
// StructureName is the name of the structure that was set in the structure block's UI. This is the name
// used to export the structure to a file.
StructureName string
// DataField is the name of a function to run, usually used during natural generation. A description can
// be found here: https://minecraft.gamepedia.com/Structure_Block#Data.
DataField string
// IncludePlayers specifies if the 'Include Players' toggle has been enabled, meaning players are also
// exported by the structure block.
IncludePlayers bool
// ShowBoundingBox specifies if the structure block should have its bounds outlined. A thin line will
// encapsulate the bounds of the structure if set to true.
ShowBoundingBox bool
// StructureBlockType is the type of the structure block updated. A list of structure block types that
// will be used can be found in the constants above.
StructureBlockType int32
// Settings is a struct of settings that should be used for exporting the structure. These settings are
// identical to the last sent in the StructureBlockUpdate packet by the client.
Settings types.StructureSettings
// RedstoneSaveMode is the mode that should be used to save the structure when used with redstone. In
// Java Edition, this is always stored in memory, but in Bedrock Edition it can be stored either to disk
// or memory. See the constants above for the options.
RedstoneSaveMode int32
// ShouldTrigger specifies if the structure block should be triggered immediately after this packet
// reaches the server.
ShouldTrigger bool
// Waterlogged specifies if non-air blocks replace water or combine with water.
Waterlogged bool
}
StructureBlockUpdate is sent by the client when it updates a structure block using the in-game UI. The data it contains depends on the type of structure block that it is. In Minecraft Bedrock Edition v1.11, there is only the Export structure block type, but in v1.13 the ones present in Java Edition will, according to the wiki, be added too.
func (*StructureBlockUpdate) Marshal ¶
func (pk *StructureBlockUpdate) Marshal(io protocol.IO)
type StructureTemplateDataRequest ¶
type StructureTemplateDataRequest struct {
// StructureName is the name of the structure that was set in the structure block's UI. This is the name
// used to export the structure to a file.
StructureName string
// Position is the position of the structure block that has its template data requested.
Position protocol.BlockPos
// Settings is a struct of settings that should be used for exporting the structure. These settings are
// identical to the last sent in the StructureBlockUpdate packet by the client.
Settings types.StructureSettings
// RequestType specifies the type of template data request that the player sent. It is one of the
// constants found above.
RequestType byte
}
StructureTemplateDataRequest is sent by the client to request data of a structure.
func (*StructureTemplateDataRequest) Marshal ¶
func (pk *StructureTemplateDataRequest) Marshal(io protocol.IO)
type UpdateAttributes ¶
type UpdateAttributes struct {
// EntityRuntimeID is the runtime ID of the entity. The runtime ID is unique for each world session, and
// entities are generally identified in packets using this runtime ID.
EntityRuntimeID uint64
// Attributes is a slice of new attributes that the entity gets. It includes attributes such as its
// health, movement speed, etc. Note that only changed attributes have to be sent in this packet. It is
// not required to send attributes that did not have their values changed.
Attributes []types.Attribute
// Tick is the server tick at which the packet was sent. It is used in relation to CorrectPlayerMovePrediction.
Tick uint64
}
UpdateAttributes is sent by the server to update an amount of attributes of any entity in the world. These attributes include ones such as the health or the movement speed of the entity.
func (*UpdateAttributes) Marshal ¶
func (pk *UpdateAttributes) Marshal(io protocol.IO)
Source Files
¶
- add_actor.go
- add_player.go
- add_volume_entity.go
- command_request.go
- item_stack_request.go
- modal_form_response.go
- network_chunk_publisher_update.go
- player_action.go
- player_auth_input.go
- player_list.go
- player_skin.go
- remove_volume_entity.go
- request_chunk_radius.go
- set_actor_data.go
- spawn_particle_effect.go
- start_game.go
- structure_block_update.go
- structure_template_data_request.go
- update_attributes.go
Click to show internal directories.
Click to hide internal directories.