protocol

package
Version: v0.11.0 Latest Latest
Warning

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

Go to latest
Published: Jul 28, 2019 License: MIT Imports: 12 Imported by: 42

Documentation

Index

Constants

View Source
const (
	CommandArgValid    = 0x100000
	CommandArgEnum     = 0x200000
	CommandArgSuffixed = 0x1000000
	CommandArgSoftEnum = 0x4000000

	CommandArgTypeInt = iota + 1
	CommandArgTypeFloat
	CommandArgTypeValue
	CommandArgTypeWildcardInt
	CommandArgTypeOperator
	CommandArgTypeTarget

	CommandArgTypeFilepath = 0x0e
	CommandArgTypeString   = 0x1b
	CommandArgTypePosition = 0x1d
	CommandArgTypeMessage  = 0x20
	CommandArgTypeRawText  = 0x22
	CommandArgTypeJSON     = 0x25
	CommandArgTypeCommand  = 0x2c
)
View Source
const (
	CommandOriginPlayer = iota
	CommandOriginBlock
	CommandOriginMinecartBlock
	CommandOriginDevConsole
	CommandOriginTest
	CommandOriginAutomationPlayer
	CommandOriginClientAutomation
	CommandOriginDedicatedServer
	CommandOriginEntity
	CommandOriginVirtual
	CommandOriginGameArgument
	CommandOriginEntityServer
)
View Source
const (
	// EntityLinkRemove is set to remove the link between two entities.
	EntityLinkRemove = iota
	// EntityLinkRider is set for entities that have control over the entity they're riding, such as in a
	// minecart.
	EntityLinkRider
	// EntityLinkPassenger is set for entities being a passenger of a vehicle they enter, such as the back
	// sit of a boat.
	EntityLinkPassenger
)
View Source
const (
	EntityDataByte = iota
	EntityDataInt16
	EntityDataInt32
	EntityDataFloat32
	EntityDataString
	EntityDataItem
	EntityDataBlockPos
	EntityDataInt64
	EntityDataVec3
)
View Source
const (
	// CurrentProtocol is the current protocol version for the version below.
	CurrentProtocol = 361
	// CurrentVersion is the current version of Minecraft as supported by the `packet` package.
	CurrentVersion = "1.12.0"
)
View Source
const (
	InventoryActionSourceContainer    = 0
	InventoryActionSourceWorld        = 2
	InventoryActionSourceCreative     = 3
	InventoryActionSourceCraftingGrid = 100
	InventoryActionSourceTODO         = 99999
)
View Source
const (
	UseItemActionClickBlock = iota
	UseItemActionClickAir
	UseItemActionBreakBlock
)
View Source
const (
	UseItemOnEntityActionInteract = iota
	UseItemOnEntityActionAttack
)
View Source
const (
	ReleaseItemActionRelease = iota
	ReleaseItemActionConsume
)
View Source
const (
	MapObjectTypeEntity = iota
	MapObjectTypeBlock
)
View Source
const (
	RecipeShapeless = iota
	RecipeShaped
	RecipeFurnace
	RecipeFurnaceData
	RecipeMulti
	RecipeShulkerBox
	RecipeShapelessChemistry
	RecipeShapedChemistry
)
View Source
const (
	ScoreboardIdentityPlayer = iota + 1
	ScoreboardIdentityEntity
	ScoreboardIdentityFakePlayer
)
View Source
const (
	StructureMirrorNone = iota
	StructureMirrorLeftToRight
	StructureMirrorFrontToBack
)

Variables

This section is empty.

Functions

func Attributes added in v0.3.0

func Attributes(src *bytes.Buffer, attributes *[]Attribute) error

Attributes reads an Attribute slice from bytes.Buffer src and stores it in the pointer passed.

func Blob added in v0.9.2

func Blob(src *bytes.Buffer, x *CacheBlob) error

Blob reads a CacheBlob x from Buffer src.

func BlockPosition

func BlockPosition(src *bytes.Buffer, x *BlockPos) error

BlockPosition reads a BlockPos from Buffer src and stores it to the BlockPos pointer passed.

func ByteSlice added in v0.9.2

func ByteSlice(src *bytes.Buffer, x *[]byte) error

ByteSlice reads a []byte x from Buffer src, setting the result to the pointer passed. The []byte read is prefixed by its length.

func CommandData added in v0.9.1

func CommandData(src *bytes.Buffer, x *Command, enums []CommandEnum, suffixes []string) error

CommandData reads a Command x from Buffer src using the enums and suffixes passed to match indices with the values these slices hold.

func CommandMessage added in v0.9.1

func CommandMessage(src *bytes.Buffer, x *CommandOutputMessage) error

CommandMessage reads a CommandOutputMessage x from Buffer src.

func CommandOriginData added in v0.9.1

func CommandOriginData(src *bytes.Buffer, x *CommandOrigin) error

CommandOriginData reads a CommandOrigin x from Buffer src.

func CommandParam added in v0.9.1

func CommandParam(src *bytes.Buffer, x *CommandParameter, enums []CommandEnum, suffixes []string) error

CommandParam reads a CommandParam x from Buffer src using the enums and suffixes passed to translate offsets to their respective values. CommandParam does not handle soft/dynamic enums. The caller is responsible to do this itself.

func EntityLinkAction added in v0.3.0

func EntityLinkAction(src *bytes.Buffer, x *EntityLink) error

EntityLinkAction reads a single entity link (action) from buffer src.

func EntityLinks(src *bytes.Buffer, x *[]EntityLink) error

EntityLinks reads a list of entity links from buffer src that are currently active.

func EntityMetadata added in v0.3.0

func EntityMetadata(src *bytes.Buffer, x *map[uint32]interface{}) error

EntityMetadata reads an entity metadata list from buffer src into map x. The types in the map will be one of byte, int16, int32, float32, string, ItemStack, BlockPos, int64 or mgl32.Vec3.

func Float32

func Float32(src *bytes.Buffer, x *float32) error

Float32 reads a float32 from Buffer src, setting the result to the pointer to a float32 passed.

func GameRules

func GameRules(src *bytes.Buffer, x *map[string]interface{}) error

GameRules reads a map of game rules from Buffer src. It sets one of the types 'bool', 'float32' or 'uint32' to the map x, with the key being the name of the game rule.

func InitialAttributes added in v0.3.0

func InitialAttributes(src *bytes.Buffer, attributes *[]Attribute) error

InitialAttributes reads an Attribute slice from bytes.Buffer src and stores it in the pointer passed. InitialAttributes is used when reading the attributes of a new entity. (AddEntity packet)

func InvAction added in v0.4.0

func InvAction(src *bytes.Buffer, action *InventoryAction) error

InvAction reads an inventory action from buffer src.

func Item added in v0.3.0

func Item(src *bytes.Buffer, x *ItemStack) error

Item reads an item stack from buffer src and stores it into item stack x.

func MapDeco added in v0.7.0

func MapDeco(buf *bytes.Buffer, x *MapDecoration) error

MapDeco reads a MapDecoration from buf into x.

func MapTrackedObj added in v0.7.0

func MapTrackedObj(buf *bytes.Buffer, x *MapTrackedObject) error

MapTrackedObj reads a MapTrackedObject from buf into x.

func RecipeIngredient added in v0.9.2

func RecipeIngredient(src *bytes.Buffer, x *ItemStack) error

RecipeIngredient reads an ItemStack x as a recipe ingredient from Buffer src.

func Rotation added in v0.3.0

func Rotation(src *bytes.Buffer, x *mgl32.Vec3) error

Rotation reads a rotation object from buffer src and stores it in Vec3 x. The rotation object exists out of 3 bytes.

func ScoreEntry added in v0.9.1

func ScoreEntry(src *bytes.Buffer, x *ScoreboardEntry, modify bool) error

ScoreEntry reads a ScoreboardEntry x from Buffer src. It reads the display information if modify is true, as expected when the SetScore packet is sent to modify entries.

func String

func String(src *bytes.Buffer, x *string) error

String reads a string from Buffer src, setting the result to the pointer to a string passed. The string read is prefixed by a varuint32.

func StructSettings added in v0.9.2

func StructSettings(src *bytes.Buffer, x *StructureSettings) error

StructSettings reads StructureSettings x from Buffer src.

func UBlockPosition

func UBlockPosition(src *bytes.Buffer, x *BlockPos) error

UBlockPosition reads an unsigned BlockPos from Buffer src and stores it to the BlockPos pointer passed. The difference between this and BlockPosition is that the Y coordinate is read as a varuint32.

func UUID added in v0.3.0

func UUID(src *bytes.Buffer, id *uuid.UUID) error

UUID reads a little endian UUID from buffer src into UUID id.

func VarRGBA added in v0.7.0

func VarRGBA(buf *bytes.Buffer, x *color.RGBA) error

VarRGBA reads an RGBA value from buf into x packed into a varuint32.

func Varint32

func Varint32(src *bytes.Buffer, x *int32) error

Varint32 reads up to 5 bytes from the source buffer passed and sets the integer produced to a pointer.

func Varint64

func Varint64(src *bytes.Buffer, x *int64) error

Varint64 reads up to 10 bytes from the source buffer passed and sets the integer produced to a pointer.

func Varuint32

func Varuint32(src *bytes.Buffer, x *uint32) error

Varuint32 reads up to 5 bytes from the source buffer passed and sets the integer produced to a pointer.

func Varuint64

func Varuint64(src *bytes.Buffer, x *uint64) error

Varuint64 reads up to 10 bytes from the source buffer passed and sets the integer produced to a pointer.

func Vec2 added in v0.7.0

func Vec2(src *bytes.Buffer, x *mgl32.Vec2) error

Vec2 reads an mgl32.Vec2 (float32 vector) from Buffer src, setting the result to the pointer to an mgl32.Vec2 passed.

func Vec3

func Vec3(src *bytes.Buffer, x *mgl32.Vec3) error

Vec3 reads an mgl32.Vec3 (float32 vector) from Buffer src, setting the result to the pointer to an mgl32.Vec3 passed.

func WriteAttributes added in v0.3.0

func WriteAttributes(dst *bytes.Buffer, x []Attribute) error

WriteAttributes writes a slice of Attributes x to buffer dst.

func WriteBlob added in v0.9.2

func WriteBlob(dst *bytes.Buffer, x CacheBlob) error

WriteBlob writes a CacheBlob x to Buffer dst.

func WriteBlockPosition

func WriteBlockPosition(dst *bytes.Buffer, x BlockPos) error

WriteBlockPosition writes a BlockPos x to Buffer dst, composed of 3 varint32s.

func WriteByteSlice added in v0.9.2

func WriteByteSlice(dst *bytes.Buffer, x []byte) error

WriteByteSlice writes a []byte x to Buffer dst. The []byte is prefixed by a varuint32 holding its length.

func WriteCommandData added in v0.9.1

func WriteCommandData(dst *bytes.Buffer, x Command, enumIndices map[string]int, suffixIndices map[string]int, dynamicEnumIndices map[string]int) error

WriteCommandData writes a Command x to Buffer dst, using the enum indices and suffix indices passed to translate enums and suffixes to the indices that they're written in in the buffer.

func WriteCommandMessage added in v0.9.1

func WriteCommandMessage(dst *bytes.Buffer, x CommandOutputMessage) error

WriteCommandMessage writes a CommandOutputMessage x to Buffer dst.

func WriteCommandOriginData added in v0.9.1

func WriteCommandOriginData(dst *bytes.Buffer, x CommandOrigin) error

WriteCommandOriginData writes a CommandOrigin x to Buffer dst.

func WriteCommandParam added in v0.9.1

func WriteCommandParam(dst *bytes.Buffer, x CommandParameter, enumIndices map[string]int, suffixIndices map[string]int, dynamicEnumIndices map[string]int) error

WriteCommandParam writes a CommandParameter x to Buffer dst, using the enum indices and suffix indices to translate the respective values to the offset in the buffer.

func WriteEntityLinkAction added in v0.3.0

func WriteEntityLinkAction(dst *bytes.Buffer, x EntityLink) error

WriteEntityLinkAction writes a single entity link x to buffer dst.

func WriteEntityLinks(dst *bytes.Buffer, x []EntityLink) error

WriteEntityLinks writes a list of entity links currently active to buffer dst.

func WriteEntityMetadata added in v0.3.0

func WriteEntityMetadata(dst *bytes.Buffer, x map[uint32]interface{}) error

WriteEntityMetadata writes an entity metadata list x to buffer dst. The types held by the map must be one of byte, int16, int32, float32, string, ItemStack, BlockPos, int64 or mgl32.Vec3. The function will panic if a different type is encountered.

func WriteFloat32

func WriteFloat32(dst *bytes.Buffer, x float32) error

WriteFloat32 writes a float32 to Buffer dst, by first converting it to a uint32.

func WriteGameRules

func WriteGameRules(dst *bytes.Buffer, x map[string]interface{}) error

WriteGameRules writes a map of game rules x, indexed by their names to Buffer dst. The types of the map values must be either 'bool', 'float32' or 'uint32'. If one of the values has a different type, the function will panic.

func WriteInitialAttributes added in v0.3.0

func WriteInitialAttributes(dst *bytes.Buffer, x []Attribute) error

WriteInitialAttributes writes a slice of Attributes x to buffer dst. WriteInitialAttributes is used when writing the attributes of a new entity. (AddEntity packet)

func WriteInvAction added in v0.4.0

func WriteInvAction(dst *bytes.Buffer, action InventoryAction) error

WriteInvAction writes an inventory action to buffer dst.

func WriteItem added in v0.3.0

func WriteItem(dst *bytes.Buffer, x ItemStack) error

WriteItem writes an item stack x to buffer dst.

func WriteMapDeco added in v0.7.0

func WriteMapDeco(buf *bytes.Buffer, x MapDecoration) error

WriteMapDeco writes a MapDecoration x to buf.

func WriteMapTrackedObj added in v0.7.0

func WriteMapTrackedObj(buf *bytes.Buffer, x MapTrackedObject) error

WriteMapTrackedObj writes a MapTrackedObject xx to buf.

func WriteRecipeIngredient added in v0.9.2

func WriteRecipeIngredient(dst *bytes.Buffer, x ItemStack) error

WriteRecipeIngredient writes an ItemStack x as a recipe ingredient to Buffer dst.

func WriteRotation added in v0.3.0

func WriteRotation(dst *bytes.Buffer, x mgl32.Vec3) error

WriteRotation writes a rotation Vec3 to buffer dst as 3 bytes.

func WriteScoreEntry added in v0.9.1

func WriteScoreEntry(dst *bytes.Buffer, x ScoreboardEntry, modify bool) error

WriteScoreEntry writes a ScoreboardEntry x to Buffer dst. If modify is set to true, the display information of the entry is written. If not, it is ignored, as expected when the SetScore packet is sent to modify entries.

func WriteString

func WriteString(dst *bytes.Buffer, x string) error

WriteString writes a string x to Buffer dst. The string is a slice of bytes prefixed by a varuint32 specifying its length.

func WriteStructSettings added in v0.9.2

func WriteStructSettings(dst *bytes.Buffer, x StructureSettings) error

WriteStructSettings writes StructureSettings x to Buffer dst.

func WriteUBlockPosition

func WriteUBlockPosition(dst *bytes.Buffer, x BlockPos) error

WriteUBlockPosition writes an unsigned BlockPos x to Buffer dst, composed of a varint32, varuint32 and a varint32.

func WriteUUID added in v0.3.0

func WriteUUID(dst *bytes.Buffer, id uuid.UUID) error

WriteUUID writes a little endian UUID id to buffer dst.

func WriteVarRGBA added in v0.7.0

func WriteVarRGBA(buf *bytes.Buffer, x color.RGBA) error

WriteVarRGBA writes an RGBA value to buf by packing it into a varuint32.

func WriteVarint32

func WriteVarint32(dst *bytes.Buffer, x int32) error

WriteVarint32 writes an int32 to the destination buffer passed with a size of 1-5 bytes.

func WriteVarint64

func WriteVarint64(dst *bytes.Buffer, x int64) error

WriteVarint64 writes an int64 to the destination buffer passed with a size of 1-10 bytes.

func WriteVaruint32

func WriteVaruint32(dst *bytes.Buffer, x uint32) error

WriteVaruint32 writes a uint32 to the destination buffer passed with a size of 1-5 bytes.

func WriteVaruint64

func WriteVaruint64(dst *bytes.Buffer, x uint64) error

WriteVaruint64 writes a uint64 to the destination buffer passed with a size of 1-10 bytes.

func WriteVec2 added in v0.7.0

func WriteVec2(dst *bytes.Buffer, x mgl32.Vec2) error

WriteVec2 writes an mgl32.Vec2 (float32 vector) to Buffer dst, writing each of the float32s separately.

func WriteVec3

func WriteVec3(dst *bytes.Buffer, x mgl32.Vec3) error

WriteVec3 writes an mgl32.Vec3 (float32 vector) to Buffer dst, writing each of the float32s separately.

Types

type Attribute added in v0.3.0

type Attribute struct {
	// Name is the name of the attribute, for example 'minecraft:health'. These names must be identical to
	// the ones defined client-side.
	Name string
	// Value is the current value of the attribute. This value will be applied to the entity when sent in a
	// packet.
	Value float32
	// Max and Min specify the boundaries within the value of the attribute must be. The definition of these
	// fields differ per attribute. The maximum health of an entity may be changed, whereas the maximum
	// movement speed for example may not be.
	Max, Min float32
	// Default is the default value of the attribute. It's not clear why this field must be sent to the
	// client, but it is required regardless.
	Default float32
}

Attribute is an entity attribute, that holds specific data such as the health of the entity. Each attribute holds a default value, maximum and minimum value, name and its current value.

type BlockEntry added in v0.9.2

type BlockEntry struct {
	// Name is the name of the block. It looks like 'minecraft:stone'.
	Name string
	// RawPayload is the metadata value of the block. A lot of blocks only have 0 as data value, but some blocks
	// carry specific variants or properties encoded in the metadata.
	Data int16
	// LegacyID is the legacy, numerical ID of the block.
	LegacyID int16
}

BlockEntry is a block sent in the StartGame packet block runtime ID table. It holds a name and a metadata value of a block.

type BlockPos

type BlockPos [3]int32

BlockPos is the position of a block. It is composed of three integers, and is typically written as either 3 varint32s or a varint32, varuint32 and varint32.

func (BlockPos) X

func (pos BlockPos) X() int32

X returns the X coordinate of the block position. It is equivalent to BlockPos[0].

func (BlockPos) Y

func (pos BlockPos) Y() int32

Y returns the Y coordinate of the block position. It is equivalent to BlockPos[1].

func (BlockPos) Z

func (pos BlockPos) Z() int32

Z returns the Z coordinate of the block position. It is equivalent to BlockPos[2].

type CacheBlob added in v0.9.2

type CacheBlob struct {
	// Hash is the hash of the blob. The hash is computed using xxHash, and must be deterministic for the same
	// chunk data.
	Hash int64
	// Payload is the data of the blob. When sent, the client will associate the Hash of the blob with the
	// Payload in it.
	Payload []byte
}

CacheBlob represents a blob as used in the client side blob cache protocol. It holds a hash of its data and the full data of it.

type Command added in v0.9.1

type Command struct {
	// Name is the name of the command. The command may be executed using this name, and will be shown in the
	// /help list with it. It currently seems that the client crashes if the Name contains uppercase letters.
	Name string
	// Description is the description of the command. It is shown in the /help list and when starting to write
	// a command.
	Description string
	// Flags is a combination of flags not currently known. Leaving the Flags field empty appears to work.
	Flags byte
	// PermissionLevel is the command permission level that the player required to execute this command. The
	// field no longer seems to serve a purpose, as the client does not handle the execution of commands
	// anymore: The permissions should be checked server-side.
	PermissionLevel byte
	// Aliases is a list of aliases of the command name, that may alternatively be used to execute the command
	// in the same way.
	Aliases []string
	// Overloads is a list of command overloads that specify the ways in which a command may be executed. The
	// overloads may be completely different.
	Overloads []CommandOverload
}

Command holds the data that a command requires to be shown to a player client-side. The command is shown in the /help command and auto-completed using this data.

type CommandEnum added in v0.9.1

type CommandEnum struct {
	// Type is the type of the command enum. The type will show up in the command usage as the type of the
	// argument if it has a certain amount of arguments, or when CollapseEnumOptions is set to true in the
	// command holding the enum.
	Type string
	// Options is a list of options that are valid for the client to submit to the command. They will be able
	// to be auto-completed and show up as options client-side.
	Options []string
	// Dynamic specifies if the command enum is considered dynamic. If set to true, it is written differently
	// and may be updated during runtime as a result using the UpdateSoftEnum packet.
	Dynamic bool
}

CommandEnum represents an enum in a command usage. The enum typically has a type and a set of options that are valid. A value that is not one of the options results in a failure during execution.

type CommandOrigin added in v0.9.1

type CommandOrigin struct {
	// Origin is one of the values above that specifies the origin of the command. The origin may change,
	// depending on what part of the client actually called the command. The command may be issued by a
	// websocket server, for example.
	Origin uint32
	// UUID is the UUID of the command called. This UUID is a bit odd as it is not specified by the server. It
	// is not clear what exactly this UUID is meant to identify, but it is unique for each command called.
	UUID uuid.UUID
	// RequestID is an ID that identifies the request of the client. The server should send a CommandOrigin
	// with the same request ID to ensure it can be matched with the request by the caller of the command.
	// This is especially important for websocket servers and it seems that this field is only non-empty for
	// these websocket servers.
	RequestID string
	// PlayerUniqueID is an ID that identifies the player, the same as the one found in the AdventureSettings
	// packet. Filling it out with 0 seems to work.
	// PlayerUniqueID is only written if Origin is CommandOriginDevConsole or CommandOriginTest.
	PlayerUniqueID int64
}

CommandOrigin holds data that identifies the origin of the requesting of a command. It holds several fields that may be used to get specific information. When sent in a CommandRequest packet, the same CommandOrigin should be sent in a CommandOutput packet.

type CommandOutputMessage added in v0.9.1

type CommandOutputMessage struct {
	// Success indicates if the output message was one of a successful command execution. If set to true, the
	// output message is by default coloured white, whereas if set to false, the message is by default
	// coloured red.
	Success bool
	// Message is the message that is sent to the client in the chat window. It may either be simply a
	// message or a translated built-in string like 'commands.tp.success.coordinates', combined with specific
	// parameters below.
	Message string
	// Parameters is a list of parameters that serve to supply the message sent with additional information,
	// such as the position that a player was teleported to or the effect that was applied to an entity.
	// These parameters only apply for the Minecraft built-in command output.
	Parameters []string
}

CommandOutputMessage represents a message sent by a command that holds the output of one of the commands executed.

type CommandOverload added in v0.9.1

type CommandOverload struct {
	// Parameters is a list of command parameters that are part of the overload. These parameters specify the
	// usage of the command when this overload is applied.
	Parameters []CommandParameter
}

CommandOverload represents an overload of a command. This overload can be compared to function overloading in languages such as java. It represents a single usage of the command. A command may have multiple different overloads, which are handled differently.

type CommandParameter added in v0.9.1

type CommandParameter struct {
	// Name is the name of the command parameter. It shows up in the usage like <$Name: $Type>, with the
	// exception of enum types, which show up simply as a list of options if the list is short enough and
	// CollapseEnumOptions is set to false.
	Name string
	// Type is a rather odd combination of type(flag)s that result in a certain parameter type to show up
	// client-side. It is a combination of the flags above. The basic types must be combined with the
	// ArgumentTypeFlagBasic flag (and integers with a suffix ArgumentTypeFlagSuffixed), whereas enums are
	// combined with the ArgumentTypeFlagEnum flag.
	Type uint32
	// Optional specifies if the command parameter is optional to enter. Note that no non-optional parameter
	// should ever be present in a command overload after an optional parameter. When optional, the parameter
	// shows up like so: [$Name: $Type], whereas when mandatory, it shows up like so: <$Name: $Type>.
	Optional bool
	// CollapseEnumOptions specifies if the enum (only if the Type is actually an enum type. If not, setting
	// this to true has no effect) should be collapsed. This means that the options of the enum are never
	// shown in the actual usage of the command, but only as auto-completion, like it automatically does with
	// enums that have a big amount of options. To illustrate, it can make <false|true|yes|no> <$Name: bool>.
	CollapseEnumOptions bool

	// Enum is the enum of the parameter if it should be of the type enum. If non-empty, the parameter will
	// be treated as an enum and show up as such client-side.
	Enum CommandEnum
	// Suffix is the suffix of the parameter if it should receive one. Note that only integer argument types
	// are able to receive a suffix, and so the type, if Suffix is a non-empty string, will always be an
	// integer.
	Suffix string
}

CommandParameter represents a single parameter of a command overload, which accepts a certain type of input values. It has a name and a type which show up client-side when a player is entering the command.

type EntityLink struct {
	// RiddenEntityUniqueID is the entity unique ID of the entity that is being ridden. For a player sitting
	// in a boat, this is the unique ID of the boat.
	RiddenEntityUniqueID int64
	// RiderEntityUniqueID is the entity unique ID of the entity that is riding. For a player sitting in a
	// boat, this is the unique ID of the player.
	RiderEntityUniqueID int64
	// Type is one of the types above. It specifies the way the entity is linked to another entity.
	Type byte
	// Immediate is set to immediately dismount an entity from another. This should be set when the mount of
	// an entity is killed.
	Immediate bool
}

EntityLink is a link between two entities, typically being one entity riding another.

type FurnaceDataRecipe added in v0.7.0

type FurnaceDataRecipe FurnaceRecipe

FurnaceDataRecipe is a recipe specifically used for furnace-type crafting stations. It is equal to FurnaceRecipe, except it has an input item with a specific metadata value, instead of any metadata value.

func (*FurnaceDataRecipe) Marshal added in v0.7.0

func (recipe *FurnaceDataRecipe) Marshal(buf *bytes.Buffer)

Marshal ...

func (*FurnaceDataRecipe) Unmarshal added in v0.7.0

func (recipe *FurnaceDataRecipe) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type FurnaceRecipe added in v0.7.0

type FurnaceRecipe struct {
	// InputType is the item type of the input item. The metadata value of the item is not used in the
	// FurnaceRecipe. Use FurnaceDataRecipe to allow an item with only one metadata value.
	InputType ItemType
	// Output is the item that is created as a result of smelting/cooking an item in the furnace.
	Output ItemStack
	// Block is the block name that is required to create the output of the recipe. The block is not prefixed
	// with 'minecraft:', so it will look like 'furnace' as an example.
	Block string
}

FurnaceRecipe is a recipe that is specifically used for all kinds of furnaces. These recipes don't just apply to furnaces, but also blast furnaces and smokers.

func (*FurnaceRecipe) Marshal added in v0.7.0

func (recipe *FurnaceRecipe) Marshal(buf *bytes.Buffer)

Marshal ...

func (*FurnaceRecipe) Unmarshal added in v0.7.0

func (recipe *FurnaceRecipe) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type InventoryAction added in v0.4.0

type InventoryAction struct {
	// SourceType is the source type of the inventory action. It is one of the constants above.
	SourceType uint32
	// WindowID is the ID of the window that the client has opened. The window ID is not set if the SourceType
	// is InventoryActionSourceWorld.
	WindowID int32
	// SourceFlags is a combination of flags that is only set if the SourceType is InventoryActionSourceWorld.
	SourceFlags uint32
	// InventorySlot is the slot in which the action took place. Each action only describes the change of item
	// in a single slot.
	InventorySlot uint32
	// OldItem is the item that was present in the slot before the inventory action. It should be checked by
	// the server to ensure the inventories were not out of sync.
	OldItem ItemStack
	// NewItem is the new item that was put in the InventorySlot that the OldItem was in. It must be checked
	// in combination with other inventory actions to ensure that the transaction is balanced.
	NewItem ItemStack
}

InventoryAction represents a single action that took place during an inventory transaction. On itself, this inventory action is always unbalanced: It must be combined with other actions in an inventory transaction to form a balanced transaction.

type InventoryTransactionData added in v0.4.0

type InventoryTransactionData interface {
	// Marshal encodes the inventory transaction data to its binary representation into buf.
	Marshal(buf *bytes.Buffer)
	// Unmarshal decodes a serialised inventory transaction data object in buf into the
	// InventoryTransactionData instance.
	Unmarshal(buf *bytes.Buffer) error
}

InventoryTransactionData represents an object that holds data specific to an inventory transaction type. The data it holds depends on the type.

type ItemEntry added in v0.9.2

type ItemEntry struct {
	// Name if the name of the item, which is a name like 'minecraft:stick'.
	Name string
	// LegacyID is the legacy ID of the item. It must point to either an existing item ID or a new one if it
	// seeks to implement a new item.
	LegacyID int16
}

ItemEntry is an item sent in the StartGame item table. It holds a name and a legacy ID, which is used to point back to that name.

type ItemStack added in v0.3.0

type ItemStack struct {
	ItemType
	// Count is the count of items that the item stack holds.
	Count int16
	// NBTData is a map that is serialised to its NBT representation when sent in a packet.
	NBTData map[string]interface{}
	// CanBePlacedOn is a list of block identifiers like 'minecraft:stone' which the item, if it is an item
	// that can be placed, can be placed on top of.
	CanBePlacedOn []string
	// CanBreak is a list of block identifiers like 'minecraft:dirt' that the item is able to break.
	CanBreak []string
}

ItemStack represents an item instance/stack over network. It has a network ID and a metadata value that define its type.

type ItemType added in v0.7.0

type ItemType struct {
	// NetworkID is the numerical network ID of the item. This is sometimes a positive ID, and sometimes a
	// negative ID, depending on what item it concerns.
	NetworkID int32
	// MetadataValue is the metadata value of the item. For some items, this is the damage value, whereas for
	// other items it is simply an identifier of a variant of the item.
	MetadataValue int16
}

ItemType represents a consistent combination of network ID and metadata value of an item. It cannot usually be changed unless a new item is obtained.

type LimitHitError added in v0.7.0

type LimitHitError struct {
	Limit int
	Type  string
}

LimitHitError is returned by a reading operation if it hits the limit of the maximum amount of elements in an array.

func (LimitHitError) Error added in v0.7.0

func (err LimitHitError) Error() string

Error ...

type MapDecoration added in v0.7.0

type MapDecoration struct {
	// Type is the type of the map decoration. The type specifies the shape (and sometimes the colour) that
	// the map decoration gets.
	Type byte
	// Rotation is the rotation of the map decoration. It is byte due to the 16 fixed directions that the
	// map decoration may face.
	Rotation byte
	// X is the offset on the X axis in pixels of the decoration.
	X byte
	// Y is the offset on the Y axis in pixels of the decoration.
	Y byte
	// Label is the name of the map decoration. This name may be of any value.
	Label string
	// Colour is the colour of the map decoration. Some map decoration types have a specific colour set
	// automatically, whereas others may be changed.
	Colour color.RGBA
}

MapDecoration is a fixed decoration on a map: Its position or other properties do not change automatically client-side.

type MapTrackedObject added in v0.7.0

type MapTrackedObject struct {
	// Type is the type of the tracked object. It is either MapObjectTypeEntity or MapObjectTypeBlock.
	Type int32
	// EntityUniqueID is the unique ID of the entity, if the tracked object was an entity. It needs not to be
	// filled out if Type is not MapObjectTypeEntity.
	EntityUniqueID int64
	// BlockPosition is the position of the block, if the tracked object was a block. It needs not to be
	// filled out if Type is not MapObjectTypeBlock.
	BlockPosition BlockPos
}

MapTrackedObject is an object on a map that is 'tracked' by the client, such as an entity or a block. This object may move, which is handled client-side.

type MismatchTransactionData added in v0.4.0

type MismatchTransactionData struct{}

MismatchTransactionData represents a mismatched inventory transaction's data object.

func (*MismatchTransactionData) Marshal added in v0.4.0

func (*MismatchTransactionData) Marshal(buf *bytes.Buffer)

Marshal ...

func (*MismatchTransactionData) Unmarshal added in v0.4.0

func (*MismatchTransactionData) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type MultiRecipe added in v0.7.0

type MultiRecipe struct {
	// UUID is a UUID identifying the recipe. This can actually be set to an empty UUID if the CraftingEvent
	// packet is not used.
	UUID uuid.UUID
}

MultiRecipe serves as an 'enable' switch for multi-shape recipes.

func (*MultiRecipe) Marshal added in v0.7.0

func (recipe *MultiRecipe) Marshal(buf *bytes.Buffer)

Marshal ...

func (*MultiRecipe) Unmarshal added in v0.7.0

func (recipe *MultiRecipe) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type NegativeCountError added in v0.7.0

type NegativeCountError struct {
	Type string
}

NegativeCountError is returned when a count prefix of an array-type structure is a negative number. Most types only have unsigned count prefixes, but some do not and may return this error.

func (NegativeCountError) Error added in v0.7.0

func (err NegativeCountError) Error() string

Error ...

type NormalTransactionData added in v0.4.0

type NormalTransactionData struct{}

NormalTransactionData represents an inventory transaction data object for normal transactions, such as crafting. It has no content.

func (*NormalTransactionData) Marshal added in v0.4.0

func (*NormalTransactionData) Marshal(buf *bytes.Buffer)

Marshal ...

func (*NormalTransactionData) Unmarshal added in v0.4.0

func (*NormalTransactionData) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type Recipe added in v0.7.0

type Recipe interface {
	// Marshal encodes the recipe data to its binary representation into buf.
	Marshal(buf *bytes.Buffer)
	// Unmarshal decodes a serialised recipe in buf into the recipe instance.
	Unmarshal(buf *bytes.Buffer) error
}

Recipe represents a recipe that may be sent in a CraftingData packet to let the client know what recipes are available server-side.

type ReleaseItemTransactionData added in v0.4.0

type ReleaseItemTransactionData struct {
	// ActionType is the type of the ReleaseItem inventory transaction. It is one of the action types found
	// in the constants above, and specifies the way the item was released.
	ActionType uint32
	// HotBarSlot is the hot bar slot that the player was holding while releasing the item. It should be used
	// to ensure that the hot bar slot and held item are correctly synchronised with the server.
	HotBarSlot int32
	// HeldItem is the item that was released. The server should check if this item is actually present in the
	// HotBarSlot.
	HeldItem ItemStack
	// HeadPosition is the position of the player's head at the time of releasing the item. This is used
	// mainly for purposes such as spawning eating particles at that position.
	HeadPosition mgl32.Vec3
}

ReleaseItemTransactionData represents an inventory transaction data object sent when the client releases the item it was using, for example when stopping while eating or stopping the charging of a bow.

func (*ReleaseItemTransactionData) Marshal added in v0.4.0

func (data *ReleaseItemTransactionData) Marshal(buf *bytes.Buffer)

Marshal ...

func (*ReleaseItemTransactionData) Unmarshal added in v0.4.0

func (data *ReleaseItemTransactionData) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type ScoreboardEntry added in v0.9.1

type ScoreboardEntry struct {
	// EntryID is a unique identifier of this entry. Each entry that represents a different value should get
	// its own entry ID. When modifying a scoreboard, entries that represent the same line should have the
	// same entry ID.
	EntryID int64
	// ObjectiveName is the name of the objective that this scoreboard entry is for. It must be identical to
	// the one set in the SetDisplayObjective packet previously sent.
	ObjectiveName string
	// Score is the score that the entry represents. Scoreboard entries are ordered using this score, so in
	// order to get the scoreboard to be ordered as expected when trying to write non-score related text on
	// a scoreboard, this score should be incremented for each entry.
	Score int32
	// IdentityType is the identity type of the scoreboard entry. The entry may represent an entity, player or
	// a fake player, as the constants above indicate.
	// In order to write plain text to the scoreboard, ScoreboardIdentityFakePlayer should always be used, in
	// combination with the DisplayName field. A different identity type will use the name of the entity.
	IdentityType byte
	// EntityUniqueID is the unique ID of either the player or the entity represented by the scoreboard entry.
	// This field is only used if IdentityType is either ScoreboardIdentityEntity or ScoreboardIdentityPlayer.
	EntityUniqueID int64
	// DisplayName is the custom name of the scoreboard entry. This field is only used if IdentityType is
	// ScoreboardIdentityFakePlayer. If this identity type is not used, the name of the entity/player will be
	// shown instead.
	DisplayName string
}

ScoreboardEntry represents a single entry that may be found on a scoreboard. These entries represent a line on the scoreboard each.

type ScoreboardIdentityEntry added in v0.9.1

type ScoreboardIdentityEntry struct {
	// EntryID is the unique identifier of the entry that the identity should be associated with, or that
	// associations should be cleared from.
	EntryID int64
	// EntityUniqueID is the unique ID that the entry should be associated with. It is empty if the
	// SetScoreboardIdentity packet is sent to remove associations with identities.
	EntityUniqueID int64
}

ScoreboardIdentityEntry holds an entry to either associate an identity with one of the entries in a scoreboard, or to remove associations.

type ShapedChemistryRecipe added in v0.7.0

type ShapedChemistryRecipe ShapedRecipe

ShapedChemistryRecipe is a recipe specifically made for chemistry related features, which exist only in the Education Edition. It functions the same as a normal ShapedRecipe.

func (*ShapedChemistryRecipe) Marshal added in v0.7.0

func (recipe *ShapedChemistryRecipe) Marshal(buf *bytes.Buffer)

Marshal ...

func (*ShapedChemistryRecipe) Unmarshal added in v0.7.0

func (recipe *ShapedChemistryRecipe) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type ShapedRecipe added in v0.7.0

type ShapedRecipe struct {
	// RecipeID is a unique ID of the recipe. This ID must be unique amongst all other types of recipes too,
	// but its functionality is not exactly known.
	RecipeID string
	// Width is the width of the recipe's shape.
	Width int32
	// Height is the height of the recipe's shape.
	Height int32
	// Input is a list of items that serve as the input of the shapeless recipe. These items are the items
	// required to craft the output. The amount of input items must be exactly equal to Width * Height.
	Input []ItemStack
	// Output is a list of items that are created as a result of crafting the recipe.
	Output []ItemStack
	// UUID is a UUID identifying the recipe. This can actually be set to an empty UUID if the CraftingEvent
	// packet is not used.
	UUID uuid.UUID
	// Block is the block name that is required to craft the output of the recipe. The block is not prefixed
	// with 'minecraft:', so it will look like 'crafting_table' as an example.
	Block string
	// Priority ...
	Priority int32
}

ShapedRecipe is a recipe that has a specific shape that must be used to craft the output of the recipe. Trying to craft the item in any other shape will not work. The ShapedRecipe is of the same structure as the ShapedChemistryRecipe.

func (*ShapedRecipe) Marshal added in v0.7.0

func (recipe *ShapedRecipe) Marshal(buf *bytes.Buffer)

Marshal ...

func (*ShapedRecipe) Unmarshal added in v0.7.0

func (recipe *ShapedRecipe) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type ShapelessChemistryRecipe added in v0.7.0

type ShapelessChemistryRecipe ShapelessRecipe

ShapelessChemistryRecipe is a recipe specifically made for chemistry related features, which exist only in the Education Edition. They function the same as shapeless recipes do.

func (*ShapelessChemistryRecipe) Marshal added in v0.7.0

func (recipe *ShapelessChemistryRecipe) Marshal(buf *bytes.Buffer)

Marshal ...

func (*ShapelessChemistryRecipe) Unmarshal added in v0.7.0

func (recipe *ShapelessChemistryRecipe) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type ShapelessRecipe added in v0.7.0

type ShapelessRecipe struct {
	// RecipeID is a unique ID of the recipe. This ID must be unique amongst all other types of recipes too,
	// but its functionality is not exactly known.
	RecipeID string
	// Input is a list of items that serve as the input of the shapeless recipe. These items are the items
	// required to craft the output.
	Input []ItemStack
	// Output is a list of items that are created as a result of crafting the recipe.
	Output []ItemStack
	// UUID is a UUID identifying the recipe. This can actually be set to an empty UUID if the CraftingEvent
	// packet is not used.
	UUID uuid.UUID
	// Block is the block name that is required to craft the output of the recipe. The block is not prefixed
	// with 'minecraft:', so it will look like 'crafting_table' as an example.
	Block string
	// Priority ...
	Priority int32
}

ShapelessRecipe is a recipe that has no particular shape. Its functionality is shared with the RecipeShulkerBox and RecipeShapelessChemistry types.

func (*ShapelessRecipe) Marshal added in v0.7.0

func (recipe *ShapelessRecipe) Marshal(buf *bytes.Buffer)

Marshal ...

func (*ShapelessRecipe) Unmarshal added in v0.7.0

func (recipe *ShapelessRecipe) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type ShulkerBoxRecipe added in v0.7.0

type ShulkerBoxRecipe ShapelessRecipe

ShulkerBoxRecipe is a shapeless recipe made specifically for shulker box crafting, so that they don't lose their user data when dyeing a shulker box.

func (*ShulkerBoxRecipe) Marshal added in v0.7.0

func (recipe *ShulkerBoxRecipe) Marshal(buf *bytes.Buffer)

Marshal ...

func (*ShulkerBoxRecipe) Unmarshal added in v0.7.0

func (recipe *ShulkerBoxRecipe) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type StructureSettings added in v0.9.2

type StructureSettings struct {
	// PaletteName is the name of the palette used in the structure. Currently, it seems that this field is
	// always 'default'.
	PaletteName string
	// IgnoreEntities specifies if the structure should ignore entities or include them. If set to false,
	// entities will also show up in the exported structure.
	IgnoreEntities bool
	// IgnoreBlocks specifies if the structure should ignore blocks or include them. If set to false, blocks
	// will show up in the exported structure.
	IgnoreBlocks bool

	// Size is the size of the area that is about to be exported. The area exported will start at the
	// Position + Offset, and will extend as far as Size specifies.
	Size BlockPos
	// Offset is the offset position that was set in the structure block. The area exported is offset by this
	// position.
	Offset BlockPos
	// LastTouchedByPlayerUniqueID is the unique ID of the player that last touched the structure block that
	// these settings concern.
	LastTouchedByPlayerUniqueID int64

	// Rotation is the rotation that the structure block should obtain.
	Rotation byte
	// Mirror specifies the way the structure should be mirrored. It is either no mirror at all, left to
	// right mirror or front to back, as the constants above specify.
	Mirror byte
	// Integrity is usually 1, but may be set to a number between 0 and 1 to omit blocks randomly, using
	// the Seed that follows.
	Integrity float32
	// Seed is the seed used to omit blocks if Integrity is not equal to one. If the Seed is 0, a random
	// seed is selected to omit blocks.
	Seed uint32
}

StructureSettings is a struct holding settings of a structure block. Its fields may be changed using the in-game UI on the client-side.

type UseItemOnEntityTransactionData added in v0.4.0

type UseItemOnEntityTransactionData struct {
	// TargetEntityRuntimeID is the entity runtime ID of the target that was clicked. It is the runtime ID
	// that was assigned to it in the AddEntity packet.
	TargetEntityRuntimeID uint64
	// ActionType is the type of the UseItemOnEntity inventory transaction. It is one of the action types
	// found in the constants above, and specifies the way the player interacted with the entity.
	ActionType uint32
	// HotBarSlot is the hot bar slot that the player was holding while clicking the entity. It should be used
	// to ensure that the hot bar slot and held item are correctly synchronised with the server.
	HotBarSlot int32
	// HeldItem is the item that was held to interact with the entity. The server should check if this item
	// is actually present in the HotBarSlot.
	HeldItem ItemStack
	// Position is the position of the player at the time of clicking the entity.
	Position mgl32.Vec3
	// ClickedPosition is the position that was clicked relative to the entity's base coordinate. It can be
	// used to find out exactly where a player clicked the entity.
	ClickedPosition mgl32.Vec3
}

UseItemOnEntityTransactionData represents an inventory transaction data object sent when the client uses an item on an entity.

func (*UseItemOnEntityTransactionData) Marshal added in v0.4.0

func (data *UseItemOnEntityTransactionData) Marshal(buf *bytes.Buffer)

Marshal ...

func (*UseItemOnEntityTransactionData) Unmarshal added in v0.4.0

func (data *UseItemOnEntityTransactionData) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

type UseItemTransactionData added in v0.4.0

type UseItemTransactionData struct {
	// ActionType is the type of the UseItem inventory transaction. It is one of the action types found above,
	// and specifies the way the player interacted with the block.
	ActionType uint32
	// BlockPosition is the position of the block that was interacted with. This is only really a correct
	// block position if ActionType is not UseItemActionClickAir.
	BlockPosition BlockPos
	// BlockFace is the face of the block that was interacted with. When clicking the block, it is the face
	// clicked. When breaking the block, it is the face that was last being hit until the block broke.
	BlockFace int32
	// HotBarSlot is the hot bar slot that the player was holding while clicking the block. It should be used
	// to ensure that the hot bar slot and held item are correctly synchronised with the server.
	HotBarSlot int32
	// HeldItem is the item that was held to interact with the block. The server should check if this item
	// is actually present in the HotBarSlot.
	HeldItem ItemStack
	// Position is the position of the player at the time of interaction. For clicking a block, this is the
	// position at that time, whereas for breaking the block it is the position at the time of breaking.
	Position mgl32.Vec3
	// ClickedPosition is the position that was clicked relative to the block's base coordinate. It can be
	// used to find out exactly where a player clicked the block.
	ClickedPosition mgl32.Vec3
	// BlockRuntimeID is the runtime ID of the block that was clicked. It may be used by the server to verify
	// that the player's world client-side is synchronised with the server's.
	BlockRuntimeID uint32
}

UseItemTransactionData represents an inventory transaction data object sent when the client uses an item on a block.

func (*UseItemTransactionData) Marshal added in v0.4.0

func (data *UseItemTransactionData) Marshal(buf *bytes.Buffer)

Marshal ...

func (*UseItemTransactionData) Unmarshal added in v0.4.0

func (data *UseItemTransactionData) Unmarshal(buf *bytes.Buffer) error

Unmarshal ...

Directories

Path Synopsis
jwt

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL