Documentation
¶
Index ¶
- Constants
- func Attributes(src *bytes.Buffer, attributes *[]Attribute) error
- func Blob(src *bytes.Buffer, x *CacheBlob) error
- func BlockPosition(src *bytes.Buffer, x *BlockPos) error
- func ByteSlice(src *bytes.Buffer, x *[]byte) error
- func CommandData(src *bytes.Buffer, x *Command, enums []CommandEnum, suffixes []string) error
- func CommandMessage(src *bytes.Buffer, x *CommandOutputMessage) error
- func CommandOriginData(src *bytes.Buffer, x *CommandOrigin) error
- func CommandParam(src *bytes.Buffer, x *CommandParameter, enums []CommandEnum, suffixes []string) error
- func EntityLinkAction(src *bytes.Buffer, x *EntityLink) error
- func EntityLinks(src *bytes.Buffer, x *[]EntityLink) error
- func EntityMetadata(src *bytes.Buffer, x *map[uint32]interface{}) error
- func Float32(src *bytes.Buffer, x *float32) error
- func GameRules(src *bytes.Buffer, x *map[string]interface{}) error
- func InitialAttributes(src *bytes.Buffer, attributes *[]Attribute) error
- func InvAction(src *bytes.Buffer, action *InventoryAction) error
- func Item(src *bytes.Buffer, x *ItemStack) error
- func MapDeco(buf *bytes.Buffer, x *MapDecoration) error
- func MapTrackedObj(buf *bytes.Buffer, x *MapTrackedObject) error
- func RecipeIngredient(src *bytes.Buffer, x *ItemStack) error
- func Rotation(src *bytes.Buffer, x *mgl32.Vec3) error
- func ScoreEntry(src *bytes.Buffer, x *ScoreboardEntry, modify bool) error
- func String(src *bytes.Buffer, x *string) error
- func StructSettings(src *bytes.Buffer, x *StructureSettings) error
- func UBlockPosition(src *bytes.Buffer, x *BlockPos) error
- func UUID(src *bytes.Buffer, id *uuid.UUID) error
- func VarRGBA(buf *bytes.Buffer, x *color.RGBA) error
- func Varint32(src *bytes.Buffer, x *int32) error
- func Varint64(src *bytes.Buffer, x *int64) error
- func Varuint32(src *bytes.Buffer, x *uint32) error
- func Varuint64(src *bytes.Buffer, x *uint64) error
- func Vec2(src *bytes.Buffer, x *mgl32.Vec2) error
- func Vec3(src *bytes.Buffer, x *mgl32.Vec3) error
- func WriteAttributes(dst *bytes.Buffer, x []Attribute) error
- func WriteBlob(dst *bytes.Buffer, x CacheBlob) error
- func WriteBlockPosition(dst *bytes.Buffer, x BlockPos) error
- func WriteByteSlice(dst *bytes.Buffer, x []byte) error
- func WriteCommandData(dst *bytes.Buffer, x Command, enumIndices map[string]int, ...) error
- func WriteCommandMessage(dst *bytes.Buffer, x CommandOutputMessage) error
- func WriteCommandOriginData(dst *bytes.Buffer, x CommandOrigin) error
- func WriteCommandParam(dst *bytes.Buffer, x CommandParameter, enumIndices map[string]int, ...) error
- func WriteEntityLinkAction(dst *bytes.Buffer, x EntityLink) error
- func WriteEntityLinks(dst *bytes.Buffer, x []EntityLink) error
- func WriteEntityMetadata(dst *bytes.Buffer, x map[uint32]interface{}) error
- func WriteFloat32(dst *bytes.Buffer, x float32) error
- func WriteGameRules(dst *bytes.Buffer, x map[string]interface{}) error
- func WriteInitialAttributes(dst *bytes.Buffer, x []Attribute) error
- func WriteInvAction(dst *bytes.Buffer, action InventoryAction) error
- func WriteItem(dst *bytes.Buffer, x ItemStack) error
- func WriteMapDeco(buf *bytes.Buffer, x MapDecoration) error
- func WriteMapTrackedObj(buf *bytes.Buffer, x MapTrackedObject) error
- func WriteRecipeIngredient(dst *bytes.Buffer, x ItemStack) error
- func WriteRotation(dst *bytes.Buffer, x mgl32.Vec3) error
- func WriteScoreEntry(dst *bytes.Buffer, x ScoreboardEntry, modify bool) error
- func WriteString(dst *bytes.Buffer, x string) error
- func WriteStructSettings(dst *bytes.Buffer, x StructureSettings) error
- func WriteUBlockPosition(dst *bytes.Buffer, x BlockPos) error
- func WriteUUID(dst *bytes.Buffer, id uuid.UUID) error
- func WriteVarRGBA(buf *bytes.Buffer, x color.RGBA) error
- func WriteVarint32(dst *bytes.Buffer, x int32) error
- func WriteVarint64(dst *bytes.Buffer, x int64) error
- func WriteVaruint32(dst *bytes.Buffer, x uint32) error
- func WriteVaruint64(dst *bytes.Buffer, x uint64) error
- func WriteVec2(dst *bytes.Buffer, x mgl32.Vec2) error
- func WriteVec3(dst *bytes.Buffer, x mgl32.Vec3) error
- type Attribute
- type BlockEntry
- type BlockPos
- type CacheBlob
- type Command
- type CommandEnum
- type CommandOrigin
- type CommandOutputMessage
- type CommandOverload
- type CommandParameter
- type EntityLink
- type FurnaceDataRecipe
- type FurnaceRecipe
- type InventoryAction
- type InventoryTransactionData
- type ItemEntry
- type ItemStack
- type ItemType
- type LimitHitError
- type MapDecoration
- type MapTrackedObject
- type MismatchTransactionData
- type MultiRecipe
- type NegativeCountError
- type NormalTransactionData
- type Recipe
- type ReleaseItemTransactionData
- type ScoreboardEntry
- type ScoreboardIdentityEntry
- type ShapedChemistryRecipe
- type ShapedRecipe
- type ShapelessChemistryRecipe
- type ShapelessRecipe
- type ShulkerBoxRecipe
- type StructureSettings
- type UseItemOnEntityTransactionData
- type UseItemTransactionData
Constants ¶
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 )
const ( CommandOriginPlayer = iota CommandOriginBlock CommandOriginMinecartBlock CommandOriginDevConsole CommandOriginTest CommandOriginAutomationPlayer CommandOriginClientAutomation CommandOriginDedicatedServer CommandOriginEntity CommandOriginVirtual CommandOriginGameArgument CommandOriginEntityServer )
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 )
const ( EntityDataByte = iota EntityDataInt16 EntityDataInt32 EntityDataFloat32 EntityDataString EntityDataItem EntityDataBlockPos EntityDataInt64 EntityDataVec3 )
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" )
const ( InventoryActionSourceContainer = 0 InventoryActionSourceWorld = 2 InventoryActionSourceCreative = 3 InventoryActionSourceCraftingGrid = 100 InventoryActionSourceTODO = 99999 )
const ( UseItemActionClickBlock = iota UseItemActionClickAir UseItemActionBreakBlock )
const ( UseItemOnEntityActionInteract = iota UseItemOnEntityActionAttack )
const ( ReleaseItemActionRelease = iota ReleaseItemActionConsume )
const ( MapObjectTypeEntity = iota MapObjectTypeBlock )
const ( RecipeShapeless = iota RecipeShaped RecipeFurnace RecipeFurnaceData RecipeMulti RecipeShulkerBox RecipeShapelessChemistry RecipeShapedChemistry )
const ( ScoreboardIdentityPlayer = iota + 1 ScoreboardIdentityEntity ScoreboardIdentityFakePlayer )
const ( StructureMirrorNone = iota StructureMirrorLeftToRight StructureMirrorFrontToBack )
Variables ¶
This section is empty.
Functions ¶
func Attributes ¶ added in v0.3.0
Attributes reads an Attribute slice from bytes.Buffer src and stores it in the pointer passed.
func BlockPosition ¶ added in v0.1.0
BlockPosition reads a BlockPos from Buffer src and stores it to the BlockPos pointer passed.
func ByteSlice ¶ added in v0.9.2
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 ¶
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 ¶
func CommandOriginData(src *bytes.Buffer, x *CommandOrigin) error
CommandOriginData reads a CommandOrigin x from Buffer src.
func CommandParam ¶
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 ¶ added in v0.3.0
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
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 ¶ added in v0.1.0
Float32 reads a float32 from Buffer src, setting the result to the pointer to a float32 passed.
func GameRules ¶ added in v0.1.0
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
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
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
RecipeIngredient reads an ItemStack x as a recipe ingredient from Buffer src.
func Rotation ¶ added in v0.3.0
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 ¶ added in v0.1.0
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 ¶
func StructSettings(src *bytes.Buffer, x *StructureSettings) error
StructSettings reads StructureSettings x from Buffer src.
func UBlockPosition ¶ added in v0.1.0
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 Varint32 ¶
Varint32 reads up to 5 bytes from the source buffer passed and sets the integer produced to a pointer.
func Varint64 ¶
Varint64 reads up to 10 bytes from the source buffer passed and sets the integer produced to a pointer.
func Varuint32 ¶
Varuint32 reads up to 5 bytes from the source buffer passed and sets the integer produced to a pointer.
func Varuint64 ¶
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
Vec2 reads an mgl32.Vec2 (float32 vector) from Buffer src, setting the result to the pointer to an mgl32.Vec2 passed.
func Vec3 ¶ added in v0.1.0
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
WriteAttributes writes a slice of Attributes x to buffer dst.
func WriteBlockPosition ¶ added in v0.1.0
WriteBlockPosition writes a BlockPos x to Buffer dst, composed of 3 varint32s.
func WriteByteSlice ¶ added in v0.9.2
WriteByteSlice writes a []byte x to Buffer dst. The []byte is prefixed by a varuint32 holding its length.
func WriteCommandData ¶
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 ¶
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 ¶ added in v0.3.0
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
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 ¶ added in v0.1.0
WriteFloat32 writes a float32 to Buffer dst, by first converting it to a uint32.
func WriteGameRules ¶ added in v0.1.0
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
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 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
WriteRecipeIngredient writes an ItemStack x as a recipe ingredient to Buffer dst.
func WriteRotation ¶ added in v0.3.0
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 ¶ added in v0.1.0
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 ¶ added in v0.1.0
WriteUBlockPosition writes an unsigned BlockPos x to Buffer dst, composed of a varint32, varuint32 and a varint32.
func WriteVarRGBA ¶ added in v0.7.0
WriteVarRGBA writes an RGBA value to buf by packing it into a varuint32.
func WriteVarint32 ¶
WriteVarint32 writes an int32 to the destination buffer passed with a size of 1-5 bytes.
func WriteVarint64 ¶
WriteVarint64 writes an int64 to the destination buffer passed with a size of 1-10 bytes.
func WriteVaruint32 ¶
WriteVaruint32 writes a uint32 to the destination buffer passed with a size of 1-5 bytes.
func WriteVaruint64 ¶
WriteVaruint64 writes a uint64 to the destination buffer passed with a size of 1-10 bytes.
Types ¶
type Attribute ¶
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 ¶
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 ¶
X returns the X coordinate of the block position. It is equivalent to BlockPos[0].
type CacheBlob ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
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 ¶
func (recipe *FurnaceDataRecipe) Marshal(buf *bytes.Buffer)
Marshal ...
type FurnaceRecipe ¶
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.
type InventoryAction ¶
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 ¶
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 ¶
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 ¶
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 ¶
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
LimitHitError is returned by a reading operation if it hits the limit of the maximum amount of elements in an array.
type MapDecoration ¶
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 ¶
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 ¶
type MismatchTransactionData struct{}
MismatchTransactionData represents a mismatched inventory transaction's data object.
func (*MismatchTransactionData) Marshal ¶
func (*MismatchTransactionData) Marshal(buf *bytes.Buffer)
Marshal ...
type MultiRecipe ¶
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.
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 ¶
type NormalTransactionData struct{}
NormalTransactionData represents an inventory transaction data object for normal transactions, such as crafting. It has no content.
func (*NormalTransactionData) Marshal ¶
func (*NormalTransactionData) Marshal(buf *bytes.Buffer)
Marshal ...
type Recipe ¶
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 ¶
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 ¶
func (data *ReleaseItemTransactionData) Marshal(buf *bytes.Buffer)
Marshal ...
type ScoreboardEntry ¶
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 ¶
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 ¶
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 ¶
func (recipe *ShapedChemistryRecipe) Marshal(buf *bytes.Buffer)
Marshal ...
type ShapedRecipe ¶
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.
type ShapelessChemistryRecipe ¶
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 ¶
func (recipe *ShapelessChemistryRecipe) Marshal(buf *bytes.Buffer)
Marshal ...
type ShapelessRecipe ¶
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 ¶
func (recipe *ShapelessRecipe) Marshal(buf *bytes.Buffer)
Marshal ...
type ShulkerBoxRecipe ¶
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 ¶
func (recipe *ShulkerBoxRecipe) Marshal(buf *bytes.Buffer)
Marshal ...
type StructureSettings ¶
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 ¶
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 ¶
func (data *UseItemOnEntityTransactionData) Marshal(buf *bytes.Buffer)
Marshal ...
type UseItemTransactionData ¶
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 ¶
func (data *UseItemTransactionData) Marshal(buf *bytes.Buffer)
Marshal ...
Source Files
Directories