packet

type Animation ¶

type Animation struct {
	Entity    int32
	Animation int8 // (see proto/minecraft/constants#EntityAnimation)
}

Animation is a two-way packet. Total Size: 6 bytes

func (p Animation) Id() byte

func (p *Animation) ReadFrom(r io.Reader) (n int64, err error)

func (p *Animation) WriteTo(w io.Writer) (n int64, err error)

type BedUse ¶

type BedUse struct {
	Entity int32
	X      int32
	Y      int8
	Z      int32
}

BedUse is a server to client packet.

Note: This Packet is sent to all nearby players including the one sent to bed.

Total Size: 15 bytes

func (p BedUse) Id() byte

func (p *BedUse) ReadFrom(r io.Reader) (n int64, err error)

func (p *BedUse) WriteTo(w io.Writer) (n int64, err error)

type BlockAction ¶

type BlockAction struct {
	X            int32
	Y            int16
	Z            int32
	Byte1, Byte2 int8  // Varies depending on block (see Block_Actions)
	BlockId      int16 // The block id this action is set for
}

BlockAction is a server to client packet.

It is used for: - Chests opening and closing - Pistons pushing and pulling - Note blocks playing

Total Size: 15 bytes

func (p BlockAction) Id() byte

func (p *BlockAction) ReadFrom(r io.Reader) (n int64, err error)

func (p *BlockAction) WriteTo(w io.Writer) (n int64, err error)

type BlockBreakAnimation ¶

type BlockBreakAnimation struct {
	Entity  int32
	X, Y, Z int32 // Block position
	Damage  int8  // How far destroyed this block is
}

BlockBreakAnimation is a server to client packet. Total Size: 18 bytes

func (p BlockBreakAnimation) Id() byte

func (p *BlockBreakAnimation) ReadFrom(r io.Reader) (n int64, err error)

func (p *BlockBreakAnimation) WriteTo(w io.Writer) (n int64, err error)

type BlockChange ¶

type BlockChange struct {
	X         int32
	Y         byte
	Z         int32
	BlockType int16 // New block type for block
	BlockMeta int8  // New Metadata for block
}

BlockChange is a server to client packet. Total Size: 13 bytes

func (p BlockChange) Id() byte

func (p *BlockChange) ReadFrom(r io.Reader) (n int64, err error)

func (p *BlockChange) WriteTo(w io.Writer) (n int64, err error)

type BlockChangeMulti ¶

type BlockChangeMulti struct {
	X, Z   int32   // Chunk XZ Coordinate
	Count  int16   // len(Blocks)
	Length int32   // Length of payload
	Blocks []int32 // Coordinates, Type, and Metadata of blocks to change
}

BlockChangeMulti is a server to client packet. Total Size: 15 bytes + arrays

func (p BlockChangeMulti) Id() byte

func (p *BlockChangeMulti) ReadFrom(r io.Reader) (n int64, err error)

func (p *BlockChangeMulti) WriteTo(w io.Writer) (n int64, err error)

type ChatMessage ¶

type ChatMessage struct {
	Message string
}

ChatMessage is a two-way packet.

The default server will check the message to see if it begins with a '/'. If it doesn't, the username of the sender is prepended and sent to all other clients (including the original sender). If it does, the server assumes it to be a command and attempts to process it. A message longer than 100 characters will cause the server to kick the client.

Note: User input must be sanitized server-side

Total Size: 3 bytes + length of strings

func (p ChatMessage) Id() byte

func (p *ChatMessage) ReadFrom(r io.Reader) (n int64, err error)

func (p *ChatMessage) WriteTo(w io.Writer) (n int64, err error)

type ChunkData ¶

type ChunkData struct {
	X, Z           int32  // Chunk XZ Coordinate
	AllColSections bool   // true = all sections in this vertical column, where the primary bitmap specifies exactly which sections are included, and which are air.
	Primary        uint16 // Bitmask. 1 for every 16x16x16 section
	Add            uint16 // Bitmask. 1 for every 16x16x16 section ("add" on payload)
	// BUG(toqueteos): type should be proto/anvil/ChunkData instead of []byte
	ChunkData []byte // ZLib Deflate compressed chunk data
}

ChunkData is a server to client packet. Total Size: 18 bytes + len(ChunkData)

func (p ChunkData) Id() byte

func (p *ChunkData) ReadFrom(r io.Reader) (n int64, err error)

func (p *ChunkData) WriteTo(w io.Writer) (n int64, err error)

type ChunkMeta ¶

type ChunkMeta struct {
	X, Z    int32  // The XZ coordinate of the specific chunk
	Primary uint16 // Bitmap. Specifies which sections are not empty
	Add     uint16 // Bitmap. Specifies which sections need add information because of very high block ids
}

type ClientSettings ¶

type ClientSettings struct {
	Locale       string
	ViewDistance int8 // 0-3 for "far", "normal", "short", "tiny"
	ChatFlags    int8 // Chat settings
	Difficulty   int8 // Client-side difficulty from options.txt
	ShowCape     bool // Client-side "show cape" option
}

ClientSettings is a client to server packet. Total Size: 7 bytes + length of string

func (p ClientSettings) Id() byte

func (p *ClientSettings) ReadFrom(r io.Reader) (n int64, err error)

func (p *ClientSettings) WriteTo(w io.Writer) (n int64, err error)

type ClientStatuses ¶

type ClientStatuses struct {
	Payload int8 // Bit field. 0: Initial spawn, 1: Respawn after death
}

ClientStatuses is a client to server packet. Total Size: 2 bytes

func (p ClientStatuses) Id() byte

func (p *ClientStatuses) ReadFrom(r io.Reader) (n int64, err error)

func (p *ClientStatuses) WriteTo(w io.Writer) (n int64, err error)

type ConfirmTransaction ¶

type ConfirmTransaction struct {
	WindowId int8
	Action   int16 // Unique number
	Accepted bool
}

ConfirmTransaction is a two-way packet. Total Size: 5 bytes

func (p ConfirmTransaction) Id() byte

func (p *ConfirmTransaction) ReadFrom(r io.Reader) (n int64, err error)

func (p *ConfirmTransaction) WriteTo(w io.Writer) (n int64, err error)

type CreativeInventoryAction ¶

type CreativeInventoryAction struct {
	Slot int16
	Item *mct.Slot
}

CreativeInventoryAction is a two-way packet. Total Size: 3 bytes + slot data

func (p CreativeInventoryAction) Id() byte

func (p *CreativeInventoryAction) ReadFrom(r io.Reader) (n int64, err error)

func (p *CreativeInventoryAction) WriteTo(w io.Writer) (n int64, err error)

type Disconnect ¶

type Disconnect struct {
	Reason string // Displayed to the client when the connection terminates
}

Disconnect is a two-way packet. Total Size: 3 bytes + length of strings

func (p Disconnect) Id() byte

func (p *Disconnect) ReadFrom(r io.Reader) (n int64, err error)

func (p *Disconnect) WriteTo(w io.Writer) (n int64, err error)

type EnchantItem ¶

type EnchantItem struct {
	WindowId int8
	Position int8 // 0~2 from top to bottom
}

EnchantItem is a client to server packet.

While the user is in the standard inventory (i.e., not a crafting bench) on a creative-mode server then the server will send this packet: - If an item is dropped into the quick bar. - If an item is picked up from the quick bar (item id is -1)..

Total Size: 3 bytes

func (p EnchantItem) Id() byte

func (p *EnchantItem) ReadFrom(r io.Reader) (n int64, err error)

func (p *EnchantItem) WriteTo(w io.Writer) (n int64, err error)

type EncryptionKeyRequest ¶

type EncryptionKeyRequest struct {
	ServerId         string
	PublicKey, Token []byte
}

EncryptionKeyRequest is a server to client packet. Total Size: 7 bytes + len(ServerId) + len(PublicKey) + len(Token)

func (p EncryptionKeyRequest) Id() byte

func (p *EncryptionKeyRequest) ReadFrom(r io.Reader) (n int64, err error)

func (p *EncryptionKeyRequest) WriteTo(w io.Writer) (n int64, err error)

type EncryptionKeyResponse ¶

type EncryptionKeyResponse struct {
	Secret, Token []byte
}

EncryptionKeyResponse is a two-way packet. Total Size: 5 bytes + len(Secret) + len(Token)

func (p EncryptionKeyResponse) Id() byte

func (p *EncryptionKeyResponse) ReadFrom(r io.Reader) (n int64, err error)

func (p *EncryptionKeyResponse) WriteTo(w io.Writer) (n int64, err error)

type Entity ¶

type Entity struct {
	Entity int32
}

Entity is a server to client packet.

Sent every game tick.

Entity did not move/look since the last PlayerPos/Look packet.

Total Size: 5 bytes

func (p Entity) Id() byte

func (p *Entity) ReadFrom(r io.Reader) (n int64, err error)

func (p *Entity) WriteTo(w io.Writer) (n int64, err error)

type EntityAction ¶

type EntityAction struct {
	Entity int32
	Action int8 // (see proto/minecraft/constants#EntityAction)
}

EntityAction is a client to server packet. Total Size: 6 bytes

func (p EntityAction) Id() byte

func (p *EntityAction) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityAction) WriteTo(w io.Writer) (n int64, err error)

type EntityAttach ¶

type EntityAttach struct {
	Entity    int32
	VehicleId int32 // The vehicle entity Id attached to (-1 for unattaching)
}

EntityAttach is a server to client packet.

Sent when an entity is attached to an entity (Minecart).

Total Size: 9 bytes

func (p EntityAttach) Id() byte

func (p *EntityAttach) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityAttach) WriteTo(w io.Writer) (n int64, err error)

type EntityDestroy ¶

type EntityDestroy struct {
	Count    int8
	Entities []int32
}

EntityDestroy is a server to client packet. Total Size: 2 + (entity count * 4) bytes

func (p EntityDestroy) Id() byte

func (p *EntityDestroy) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityDestroy) WriteTo(w io.Writer) (n int64, err error)

type EntityEffect ¶

type EntityEffect struct {
	Entity    int32
	Effect    int8 // (see PotionEffect)
	Amplifier int8
	Duration  int16
}

EntityEffect is a server to client packet. Total Size: 9 bytes

func (p EntityEffect) Id() byte

func (p *EntityEffect) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityEffect) WriteTo(w io.Writer) (n int64, err error)

type EntityEffectRemove ¶

type EntityEffectRemove struct {
	Entity int32
	Effect int8 // (see PotionEffect)
}

EntityEffectRemove is a server to client packet. Total Size: 6 bytes

func (p EntityEffectRemove) Id() byte

func (p *EntityEffectRemove) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityEffectRemove) WriteTo(w io.Writer) (n int64, err error)

type EntityEquipment ¶

type EntityEquipment struct {
	Entity int32
	Slot   int16     // Equipment slot: 0=held, 1-4=armor slot
	Item   *mct.Slot // Item in slot format
}

EntityEquipment is a server to client packet. Total Size: 7 bytes + slot data

func (p EntityEquipment) Id() byte

func (p *EntityEquipment) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityEquipment) WriteTo(w io.Writer) (n int64, err error)

type EntityGlobalSpawn ¶

type EntityGlobalSpawn struct {
	Entity  int32
	Type    int8  // Global entity type, currently always 1 for thunderbolt.
	X, Y, Z int32 // Thunderbolt XYZ as Absolute Integer
}

EntityGlobalSpawn is a server to client packet. Total Size: 18 bytes

func (p EntityGlobalSpawn) Id() byte

func (p *EntityGlobalSpawn) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityGlobalSpawn) WriteTo(w io.Writer) (n int64, err error)

type EntityHeadLook ¶

type EntityHeadLook struct {
	Entity  int32
	HeadYaw float32 // Head yaw in steps of 2p/256
}

EntityHeadLook is a server to client packet. Total Size: 6 bytes

func (p EntityHeadLook) Id() byte

func (p *EntityHeadLook) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityHeadLook) WriteTo(w io.Writer) (n int64, err error)

type EntityInteract ¶

type EntityInteract struct {
	From, To    int32
	MouseButton bool // true=left click, false=right click
}

EntityInteract is a client to server packet.

Sent when an entity attacks or right-clicks another entity.

NMS: accept iff entity being attacked/used is visible without obstruction and within a 4-unit radius of the player's position.

Total Size: 10 bytes

func (p EntityInteract) Id() byte

func (p *EntityInteract) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityInteract) WriteTo(w io.Writer) (n int64, err error)

type EntityLook ¶

type EntityLook struct {
	Entity     int32
	Yaw, Pitch float32 // The X & Y Axis rotation as a fraction of 360
}

EntityLook is a server to client packet.

Sent when an entity rotates.

Total Size: 7 bytes

func (p EntityLook) Id() byte

func (p *EntityLook) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityLook) WriteTo(w io.Writer) (n int64, err error)

type EntityLookRelMove ¶

type EntityLookRelMove struct {
	Entity     int32
	X, Y, Z    int8 // Axis Relative movement as an Absolute Integer
	Yaw, Pitch int8 // The X & Y Axis rotation as a fraction of 360
}

EntityLookRelMove is a server to client packet.

Mix of 0x1F + 0x20.

Total Size: 10 bytes

func (p EntityLookRelMove) Id() byte

func (p *EntityLookRelMove) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityLookRelMove) WriteTo(w io.Writer) (n int64, err error)

type EntityMetadata ¶

type EntityMetadata struct {
	Entity int32
	Meta   mct.Metadata // (see Entities)
}

EntityMetadata is a server to client packet. Total Size: 5 bytes + Metadata

func (p EntityMetadata) Id() byte

func (p *EntityMetadata) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityMetadata) WriteTo(w io.Writer) (n int64, err error)

type EntityNamedSpawn ¶

type EntityNamedSpawn struct {
	Entity     int32
	Name       string  // Max length: 16
	X, Y, Z    float64 // Absolute Integer
	Yaw, Pitch float32 // Packed float
	Item       int16   // Item currently holding. 0: no item
	Metadata   mct.Metadata
}

EntityNamedSpawn is a server to client packet.

Note: sent when a player comes into visible range, not when it player joins.

Note: Item <= 0 crashes clients.

Total Size: 22 bytes + length of strings + metadata (at least 1)

func (p EntityNamedSpawn) Id() byte

func (p *EntityNamedSpawn) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityNamedSpawn) WriteTo(w io.Writer) (n int64, err error)

type EntityRelMove ¶

type EntityRelMove struct {
	Entity  int32
	X, Y, Z int8 // Axis Relative movement as an Absolute Integer
}

EntityRelMove is a server to client packet.

Sent when an entity moves less than 4 blocks, otherwise use 0x22.

Total Size: 8 bytes

func (p EntityRelMove) Id() byte

func (p *EntityRelMove) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityRelMove) WriteTo(w io.Writer) (n int64, err error)

type EntityStatus ¶

type EntityStatus struct {
	Entity int32
	Status int8 // (see proto/minecraft/constants#EntityStatus)
}

EntityStatus is a server to client packet. Total Size: 6 bytes

func (p EntityStatus) Id() byte

func (p *EntityStatus) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityStatus) WriteTo(w io.Writer) (n int64, err error)

type EntityTeleport ¶

type EntityTeleport struct {
	Entity     int32
	X, Y, Z    float64 // Position as an Absolute Integer
	Yaw, Pitch float32 // The X & Y Axis rotation as a fraction of 360
}

EntityTeleport is a server to client packet.

Complementary of 0x1F. Sent when an entity moves more than 4 blocks.

Total Size: 19 bytes

func (p EntityTeleport) Id() byte

func (p *EntityTeleport) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityTeleport) WriteTo(w io.Writer) (n int64, err error)

type EntityVelocity ¶

type EntityVelocity struct {
	Entity           int32
	VelX, VelY, VelZ int16 // (Protocol#Entity Velocity (0x1C))
}

EntityVelocity is a server to client packet.

Velocity is believed to be in units of 1/8000 of a block per server tick (50ms).

Example: -1343 would move (-1343 / 8000) = −0.167875 blocks per tick (or −3,3575 blocks per second).

Total Size: 11 bytes

func (p EntityVelocity) Id() byte

func (p *EntityVelocity) ReadFrom(r io.Reader) (n int64, err error)

func (p *EntityVelocity) WriteTo(w io.Writer) (n int64, err error)

type Explosion ¶

type Explosion struct {
	X, Y, Z                   float64
	Radius                    float32 // NMC: Unused
	Count                     int32
	Blocks                    [][3]int8 // len(BlockPos) == Blocks * 3
	PlayerX, PlayerY, PlayerZ float32   // XYZ velocity of the player being pushed
}

Explosion is a server to client packet. Total Size: 45 bytes + 3*(Record count) bytes

func (p Explosion) Id() byte

func (p *Explosion) ReadFrom(r io.Reader) (n int64, err error)

func (p *Explosion) WriteTo(w io.Writer) (n int64, err error)

type GameStateChange ¶

type GameStateChange struct {
	Reason   int8
	GameMode int8 // Reason == 3 then 0=survival, 1=creative
}

GameStateChange is a server to client packet. Total Size: 3 bytes

func (p GameStateChange) Id() byte

func (p *GameStateChange) ReadFrom(r io.Reader) (n int64, err error)

func (p *GameStateChange) WriteTo(w io.Writer) (n int64, err error)

type Handshake ¶

type Handshake struct {
	Version  int8
	Username string // Player attempting to connect
	Host     string
	Port     int32
}

Handshake is a client to server packet.

Total Size: 10 bytes + length of strings

func (p Handshake) Id() byte

func (p *Handshake) ReadFrom(r io.Reader) (n int64, err error)

func (p *Handshake) WriteTo(w io.Writer) (n int64, err error)

type HealthUpdate ¶

type HealthUpdate struct {
	Health     int16   // <=0: dead, 20: full HP
	Food       int16   // 0~20
	Saturation float32 // 0.0~5.0, integer increments
}

HealthUpdate is a server to client packet.

Updates a player's health. Starts at 5.0.

Food won't decrease while saturation is over zero. Eating increases food and saturation.

Total Size: 9 bytes

func (p HealthUpdate) Id() byte

func (p *HealthUpdate) ReadFrom(r io.Reader) (n int64, err error)

func (p *HealthUpdate) WriteTo(w io.Writer) (n int64, err error)

type Id ¶

type Id byte

func (i *Id) ReadFrom(r io.Reader) (n int64, err error)

func (i *Id) WriteTo(w io.Writer) (n int64, err error)

type ItemCollect ¶

type ItemCollect struct {
	WhatId, WhoId int32
}

ItemCollect is a server to client packet.

Note: Server checks items to be picked up after each PlayerPos and PlayerPosLook packet sent.

Total Size: 9 bytes

func (p ItemCollect) Id() byte

func (p *ItemCollect) ReadFrom(r io.Reader) (n int64, err error)

func (p *ItemCollect) WriteTo(w io.Writer) (n int64, err error)

type ItemData ¶

type ItemData struct {
	Type   int16
	ItemId int16  // Damage value
	Length int16  // len(Text)
	Text   []byte // ASCII text
}

ItemData is a server to client packet.

Specifies complex data on an item; currently used only for maps.

Maps If the first byte of the text is 0, the next two bytes are X start and Y start and the rest of the bytes are the colors in that column.

If the first byte of the text is 1, the rest of the bytes are in groups of three: (data, x, y). The lower half of the data is the type (always 0 under vanilla) and the upper half is the direction.

Total Size: 7 bytes + Text length

func (p ItemData) Id() byte

func (p *ItemData) ReadFrom(r io.Reader) (n int64, err error)

func (p *ItemData) WriteTo(w io.Writer) (n int64, err error)

type ItemHeldChange ¶

type ItemHeldChange struct {
	SlotId int16 // The slot which the player has selected (0-8)
}

ItemHeldChange is a two-way packet. Total Size: 3 bytes

func (p ItemHeldChange) Id() byte

func (p *ItemHeldChange) ReadFrom(r io.Reader) (n int64, err error)

func (p *ItemHeldChange) WriteTo(w io.Writer) (n int64, err error)

type KeepAlive ¶

type KeepAlive struct {
	RandomId int32
}

KeepAlive is a two-way packet.

The server will frequently send out a keep-alive, each containing a random ID. The client must respond with the same packet.

Total Size: 5 bytes

func (p KeepAlive) Id() byte

func (p *KeepAlive) ReadFrom(r io.Reader) (n int64, err error)

func (p *KeepAlive) WriteTo(w io.Writer) (n int64, err error)

type LoginInfo ¶

type LoginInfo struct {
	Entity     int32
	LevelType  string // level-type in server.properties
	GameMode   int8   // 0: survival, 1: creative, 2: adventure. Bit 3 (0x8) is the hardcore flag
	Dimension  int8   // -1: nether, 0: overworld, 1: end
	Difficulty int8   // 0~3 for Peaceful, Easy, Normal, Hard
	// _WorldHeight int8 // NMS: always 0
	MaxPlayers int8 // Used by the client to draw the player list
}

LoginInfo is a server to client packet.

Total Size: 12 bytes + length of strings

func (p LoginInfo) Id() byte

func (p *LoginInfo) ReadFrom(r io.Reader) (n int64, err error)

func (p *LoginInfo) WriteTo(w io.Writer) (n int64, err error)

type MapChunkBulk ¶

type MapChunkBulk struct {
	// Count  int16 // len(ChunkMeta)
	// Length int32 // len(ChunkData)
	SkylightSent bool   // Chunk data contains a light nibble array? true for overworld, false otherwise
	ChunkData    []byte // Compressed chunk data
	ChunkMeta    []ChunkMeta
}

MapChunkBulk is a server to client packet. Total Size: 8 + (DataLength) + 12 * (Count) bytes

func (p MapChunkBulk) Id() byte

func (p *MapChunkBulk) ReadFrom(r io.Reader) (n int64, err error)

func (p *MapChunkBulk) WriteTo(w io.Writer) (n int64, err error)

type MustReadWriter ¶

type MustReadWriter struct {
	must.ReadWriter
}

MustReadWriter handles error handling while reading common types present in packets. It keeps a counter of bytes read and errors out on the first error.

func (rw MustReadWriter) ReadBool(r io.Reader) (res bool)

func (rw MustReadWriter) ReadMetadata(r io.Reader) (res mct.Metadata)

func (rw MustReadWriter) ReadObjectData(r io.Reader) (res *mct.ObjectData)

func (rw MustReadWriter) ReadSlot(r io.Reader) (res *mct.Slot)

func (rw MustReadWriter) ReadString(r io.Reader) (res string)

func (rw MustReadWriter) WriteBool(w io.Writer, value bool)

func (rw MustReadWriter) WriteMetadata(w io.Writer, value mct.Metadata)

func (rw MustReadWriter) WriteObjectData(w io.Writer, value *mct.ObjectData)

func (rw MustReadWriter) WriteSlot(w io.Writer, value *mct.Slot)

func (rw MustReadWriter) WriteString(w io.Writer, value string)

type Packet ¶

type Packet interface {
	Id() byte
	io.ReaderFrom
	io.WriterTo
}

type Particle ¶

type Particle struct {
	Name                      string
	X, Y, Z                   float32
	OffsetX, OffsetY, OffsetZ float32 // Added to XYZ after multiplication by random.nextGaussian()
	Speed                     float32
	Number                    int32
}

Particle is a server to client packet. Total Size: 34 bytes + length of string

func (p Particle) Id() byte

func (p *Particle) ReadFrom(r io.Reader) (n int64, err error)

func (p *Particle) WriteTo(w io.Writer) (n int64, err error)

type Player ¶

type Player struct {
	OnGround bool // true if the client is on the ground, false otherwise
}

Player is a client to server packet.

Fall damage is applied when this state goes from false to true and player is 4+ blocks high from ground.

Total Size: 2 bytes

func (p Player) Id() byte

func (p *Player) ReadFrom(r io.Reader) (n int64, err error)

func (p *Player) WriteTo(w io.Writer) (n int64, err error)

type PlayerAbilities ¶

type PlayerAbilities struct {
	GodMode, CanFly, Flying, Creative bool // Sent as byte
	FlyingSpeed                       int8
	WalkingSpeed                      int8
}

Total Size: 4 bytes

func (p PlayerAbilities) Id() byte

func (p *PlayerAbilities) ReadFrom(r io.Reader) (n int64, err error)

func (p *PlayerAbilities) WriteTo(w io.Writer) (n int64, err error)

type PlayerAction ¶

type PlayerAction struct {
	Action int8 // (see proto/minecraft/constants#PlayerAction)
	X      int32
	Y      int8
	Z      int32
	Face   int8 // (see proto/minecraft/constants#BlockDirection)
}

PlayerAction client to server packet.

NMS: accepts packet iff coordinates within a 6-unit radius from player's position.

Actions: 0: start dig. 1: cancel dig. 2: finish dig. 3: drop full stack (all other values set to 0). 4: drop single item from stack (all other values set to 0). 5: shoot arrow / finish eating (face: 0xff, all other values set to 0).

Total Size: 12 bytes

func (p PlayerAction) Id() byte

func (p *PlayerAction) ReadFrom(r io.Reader) (n int64, err error)

func (p *PlayerAction) WriteTo(w io.Writer) (n int64, err error)

type PlayerBlockPlace ¶

type PlayerBlockPlace struct {
	X             int32
	Y             byte
	Z             int32
	Direction     int8 // (see proto/minecraft/constants#BlockDirection)
	HeldItem      *mct.Slot
	ChX, ChY, ChZ int8 // The position of the crosshair on the block
}

PlayerBlockPlace client to server packet.

Iff XYZ + Direction == -1 currently held item should have its state updated (eating food, shooting bows, using buckets, etc...)

Note: NMC might send two packets when using buckets, first a normal and then a special case. First a normal packet is sent when you're looking at a block, it does nothing on NMS. Second packet performs the action (based on current pos/look and with a distance check, see next note).

Note: buckets can only be used within a radius of 6 units.

Total Size: 14 bytes + slot data

func (p PlayerBlockPlace) Id() byte

func (p *PlayerBlockPlace) ReadFrom(r io.Reader) (n int64, err error)

func (p *PlayerBlockPlace) WriteTo(w io.Writer) (n int64, err error)

type PlayerLook ¶

type PlayerLook struct {
	Yaw, Pitch float32 // Absolute rotation on the XY Axis (degrees)
	OnGround   bool    // Same as 0x0A
}

PlayerLook client to server packet.

Updates the direction the player is looking in.

Yaw is measured in degrees, and does not follow classical trigonometry rules. The unit circle of yaw on the xz-plane starts at (0, 1) and turns backwards towards (-1, 0), or in other words, it turns clockwise instead of counterclockwise. Additionally, yaw is not clamped to between 0 and 360 degrees; any number is valid, including negative numbers and numbers greater than 360.

Pitch is measured in degrees, where 0 is looking straight ahead, -90 is looking straight up, and 90 is looking straight down.

Total Size: 10 bytes

func (p PlayerLook) Id() byte

func (p *PlayerLook) ReadFrom(r io.Reader) (n int64, err error)

func (p *PlayerLook) WriteTo(w io.Writer) (n int64, err error)

type PlayerPos ¶

type PlayerPos struct {
	X, Y, Z  float64 // Absolute position
	Stance   float64 // Modifies players' bounding box while on stairs, crouching, etc...
	OnGround bool    // Same as 0x0A
}

PlayerPos client to server packet.

Updates the players XYZ position on the server.

If Stance - Y is less than 0.1 or greater than 1.65, the stance is illegal and the client will be kicked with the message “Illegal Stance”.

If the distance between the last known position of the player on the server and the new position set by this packet is greater than 100 units will result in the client being kicked for "You moved too quickly :( (Hacking?)".

Also if the absolute number of X or Z is set greater than 3.2E7D the client will be kicked for "Illegal position".

Total Size: 34 bytes

func (p PlayerPos) Id() byte

func (p *PlayerPos) ReadFrom(r io.Reader) (n int64, err error)

func (p *PlayerPos) WriteTo(w io.Writer) (n int64, err error)

type PlayerPosLook ¶

type PlayerPosLook struct {
	X, Y, Z    float64 // Absolute position
	Stance     float64 // Modifies players' bounding box while on stairs, crouching, etc...
	Yaw, Pitch float32 // Absolute rotation on the XY Axis (degrees)
	OnGround   bool    // Same as 0x0A
}

PlayerPosLook is a two-way packet.

Note: When this packet is sent from the server, the Y and Stance fields are swapped.

Total Size: 42 bytes

func (p PlayerPosLook) Id() byte

func (p *PlayerPosLook) ReadFrom(r io.Reader) (n int64, err error)

func (p *PlayerPosLook) WriteTo(w io.Writer) (n int64, err error)

type PlayerTabListPing ¶

type PlayerTabListPing struct {
	Name   string // Supports chat colouring, max 16 chars
	Online bool   // false = client will remove user from player list
	Ping   int16  // Ping, presumably in ms
}

PlayerTabListPing is a server to client packet.

NMS: sends one packet per user per tick (amounting to 20 packets/s for 1 online user).

Total Size: 6 bytes + length of string

func (p PlayerTabListPing) Id() byte

func (p *PlayerTabListPing) ReadFrom(r io.Reader) (n int64, err error)

func (p *PlayerTabListPing) WriteTo(w io.Writer) (n int64, err error)

type PluginMessage ¶

type PluginMessage struct {
	Name string
	// Length  int16 // len(Payload)
	Payload []byte
}

PluginMessage is a two-way packet. Total Size: 5 bytes + len(Name) + len(Payload)

func (p PluginMessage) Id() byte

func (p *PluginMessage) ReadFrom(r io.Reader) (n int64, err error)

func (p *PluginMessage) WriteTo(w io.Writer) (n int64, err error)

type Respawn ¶

type Respawn struct {
	Dimension   int32  // -1: The Nether, 0: The Overworld, 1: The End
	Difficulty  int8   // 0~3: Peaceful, Easy, Normal, Hard.
	GameMode    int8   // 0: survival, 1: creative, 2: adventure. Hardcore flag not included
	WorldHeight int16  // Defaults to 256
	LevelType   string // See 0x01 login
}

Respawn is a server to client packet.

NMC: 1 is always sent c->s

Total Size: 11 bytes + length of string

func (p Respawn) Id() byte

func (p *Respawn) ReadFrom(r io.Reader) (n int64, err error)

func (p *Respawn) WriteTo(w io.Writer) (n int64, err error)

type ScoreDisplay ¶

type ScoreDisplay struct {
	Position    int8   // 0 = list, 1 = sidebar, 2 = belowName
	DisplayName string // Unique name for the scoreboard to be displayed.
}

ScoreDisplay is a server to client packet. Total Size: 4 bytes + length of string

func (p ScoreDisplay) Id() byte

func (p *ScoreDisplay) ReadFrom(r io.Reader) (n int64, err error)

func (p *ScoreDisplay) WriteTo(w io.Writer) (n int64, err error)

type ScoreObjective ¶

type ScoreObjective struct {
	Name   string // Unique name
	Value  string // The text to be displayed for the score
	Action int8   // 0 = create, 1 = remove, 2 = update display text
}

ScoreObjective is a server to client packet. Total Size: 6 bytes + length of string

func (p ScoreObjective) Id() byte

func (p *ScoreObjective) ReadFrom(r io.Reader) (n int64, err error)

func (p *ScoreObjective) WriteTo(w io.Writer) (n int64, err error)

type ScoreTeams ¶

type ScoreTeams struct {
	Name                        string   // Unique, shared with scoreboard
	Mode                        int8     // 0: create, 1: remove, 2: update, 3: player join, 4: player leave
	DisplayName, Prefix, Suffix string   // iff Mode == (0 | 2)
	FriendlyFire                int8     // iff Mode == (0 | 2); 0: off, 1: on, 3: see friendly invisibles
	Count                       int16    // iff Mode == (0 | 3 | 4)
	Players                     []string // iff Mode == (0 | 3 | 4)
}

ScoreTeams is a server to client packet. Total Size: Variable

func (p ScoreTeams) Id() byte

func (p *ScoreTeams) ReadFrom(r io.Reader) (n int64, err error)

func (p *ScoreTeams) WriteTo(w io.Writer) (n int64, err error)

type ScoreUpdate ¶

type ScoreUpdate struct {
	EntityName string // Unique name to be displayed in the list.
	Action     int8   // 0 = create/update item, 1 = remove item
	Objetive   string // Unique name. Sent iff Action != 1
	Value      int32  // Sent iff Action != 1
}

ScoreUpdate is a server to client packet. Total Size: 9 bytes + length of strings

func (p ScoreUpdate) Id() byte

func (p *ScoreUpdate) ReadFrom(r io.Reader) (n int64, err error)

func (p *ScoreUpdate) WriteTo(w io.Writer) (n int64, err error)

type ServerListPing ¶

type ServerListPing struct {
	Magic int8 // always 1
}

ServerListPing is a client to server packet. Total Size: 2 bytes

func (p ServerListPing) Id() byte

func (p *ServerListPing) ReadFrom(r io.Reader) (n int64, err error)

func (p *ServerListPing) WriteTo(w io.Writer) (n int64, err error)

type SetExperience ¶

type SetExperience struct {
	Xp      float32
	Level   int16
	TotalXp int16
}

SetExperience is a server to client packet. Total Size: 9 bytes

func (p SetExperience) Id() byte

func (p *SetExperience) ReadFrom(r io.Reader) (n int64, err error)

func (p *SetExperience) WriteTo(w io.Writer) (n int64, err error)

type SignUpdate ¶

type SignUpdate struct {
	X     int32
	Y     int16
	Z     int32
	Lines [4]string
}

SignUpdate is a two-way packet.

S->C: sent whenever a sign is discovered or created. C->S: sent when the "Done" button is pushed after placing a sign.

Note: Not sent when a sign is destroyed or unloaded.

Total Size: 11 bytes + 4 strings

func (p SignUpdate) Id() byte

func (p *SignUpdate) ReadFrom(r io.Reader) (n int64, err error)

func (p *SignUpdate) WriteTo(w io.Writer) (n int64, err error)

type SoundEffect ¶

type SoundEffect struct {
	EffectId         int32
	X                int32
	Y                int8
	Z                int32
	Data             int32 // Extra data for certain effects, see below.
	DisableRelVolume bool  // Ignored by client for all but mob.wither.spawn (1013)
}

SoundEffect is a server to client packet.

NMC: volume of sound effects is adjusted based on distance.

Total Size: 19 bytes

func (p SoundEffect) Id() byte

func (p *SoundEffect) ReadFrom(r io.Reader) (n int64, err error)

func (p *SoundEffect) WriteTo(w io.Writer) (n int64, err error)

type SoundEffectNamed ¶

type SoundEffectNamed struct {
	Name    string  // 250
	X, Y, Z int32   // XYZ, multiplied by 8
	Volume  float32 // 1 is 100%, can be more
	Pitch   int8    // 63 is 100%, can be more
}

SoundEffectNamed is a server to client packet. Total Size: 20 bytes + length of string

func (p SoundEffectNamed) Id() byte

func (p *SoundEffectNamed) ReadFrom(r io.Reader) (n int64, err error)

func (p *SoundEffectNamed) WriteTo(w io.Writer) (n int64, err error)

type SpawnExperienceOrb ¶

type SpawnExperienceOrb struct {
	Entity  int32
	X, Y, Z int32 // Absolute
	Count   int16
}

SpawnExperienceOrb is a server to client packet. Total Size: 19 bytes

func (p SpawnExperienceOrb) Id() byte

func (p *SpawnExperienceOrb) ReadFrom(r io.Reader) (n int64, err error)

func (p *SpawnExperienceOrb) WriteTo(w io.Writer) (n int64, err error)

type SpawnMob ¶

type SpawnMob struct {
	Entity                int32
	Type                  int8  // The type of object (see Entities#Objects)
	X, Y, Z               int32 // Absolute Integer Position of the object
	Pitch, HeadPitch, Yaw int8  // Yaw in steps of 2p/256
	VelX, VelY, VelZ      int16
	Metadata              mct.Metadata // Varies by mob (see Entities)
}

SpawnMob is a server to client packet. Total Size: 27 bytes + Metadata (3+ bytes)

func (p SpawnMob) Id() byte

func (p *SpawnMob) ReadFrom(r io.Reader) (n int64, err error)

func (p *SpawnMob) WriteTo(w io.Writer) (n int64, err error)

type SpawnObjectVehicle ¶

type SpawnObjectVehicle struct {
	Entity     int32
	Type       int8            // The type of object (see Entities#Objects)
	X, Y, Z    int32           // Absolute Integer Position of the object
	Pitch, Yaw int8            // In steps of 2p/256
	ObjectData *mct.ObjectData // (see Object Data)
}

SpawnObjectVehicle is a server to client packet. Total Size: 23 or 29 bytes

func (p SpawnObjectVehicle) Id() byte

func (p *SpawnObjectVehicle) ReadFrom(r io.Reader) (n int64, err error)

func (p *SpawnObjectVehicle) WriteTo(w io.Writer) (n int64, err error)

type SpawnPainting ¶

type SpawnPainting struct {
	Entity    int32
	Title     string
	X, Y, Z   int32
	Direction int32 // Direction the painting faces (0: -z, 1: -x, 2: +z, 3: +x)
}

SpawnPainting is a server to client packet.

Note: Title's max length is 13.

Total Size: 23 bytes + length of string

func (p SpawnPainting) Id() byte

func (p *SpawnPainting) ReadFrom(r io.Reader) (n int64, err error)

func (p *SpawnPainting) WriteTo(w io.Writer) (n int64, err error)

type SpawnPosition ¶

type SpawnPosition struct {
	X, Y, Z int32 // Spawn X, Y, Z in block coordinates
}

SpawnPosition is a server to client packet.

Sent by the server after login to specify the coordinates of the spawn point. It can be sent at any time to update the point compasses point at.

Total Size: 13 bytes

func (p SpawnPosition) Id() byte

func (p *SpawnPosition) ReadFrom(r io.Reader) (n int64, err error)

func (p *SpawnPosition) WriteTo(w io.Writer) (n int64, err error)

type StatIncrement ¶

type StatIncrement struct {
	StatId int32
	Amount int8
}

StatIncrement is a server to client packet. Total Size: 6 bytes

func (p StatIncrement) Id() byte

func (p *StatIncrement) ReadFrom(r io.Reader) (n int64, err error)

func (p *StatIncrement) WriteTo(w io.Writer) (n int64, err error)

type TabComplete ¶

type TabComplete struct {
	Text string
}

TabComplete is a two-way packet. Total Size: 3 bytes + length of string

func (p TabComplete) Id() byte

func (p *TabComplete) ReadFrom(r io.Reader) (n int64, err error)

func (p *TabComplete) WriteTo(w io.Writer) (n int64, err error)

type TileEntityUpdate ¶

type TileEntityUpdate struct {
	X      int32
	Y      int16
	Z      int32
	Action int8 // 1: set mob displayed inside mob spawner
	// Length int16 // Hidden in slice
	Data []byte // NBT Byte Array; iff Length > 0
}

TileEntityUpdate is a server to client packet. Total Size: 12 + itemstack bytes

func (p TileEntityUpdate) Id() byte

func (p *TileEntityUpdate) ReadFrom(r io.Reader) (n int64, err error)

func (p *TileEntityUpdate) WriteTo(w io.Writer) (n int64, err error)

type TimeUpdate ¶

type TimeUpdate struct {
	WorldAge, Time int64
}

TimeUpdate is a server to client packet.

Time is based on ticks, exactly 20 ticks per second. There are 24000 ticks in a day, making Minecraft days exactly 20 minutes long.

NOTES: Time = Time + 20 % 24000

Total Size: 17 Bytes

func (p TimeUpdate) Id() byte

func (p *TimeUpdate) ReadFrom(r io.Reader) (n int64, err error)

func (p *TimeUpdate) WriteTo(w io.Writer) (n int64, err error)

type WindowClick ¶

type WindowClick struct {
	WindowId int8      // 0: inventory
	Slot     int16     //
	Button   int8      // 0: left, 1: right, 3: middle ("Mode" set to 3)
	Action   int16     // Unique number for the action, used for transaction handling
	Mode     int8      // 0: regular, 1: shift + click, 5: "painting" mode, 6: double-click
	Item     *mct.Slot // Clicked item
}

WindowClick is a client to server packet. Total Size: 8 bytes + slot data

func (p WindowClick) Id() byte

func (p *WindowClick) ReadFrom(r io.Reader) (n int64, err error)

func (p *WindowClick) WriteTo(w io.Writer) (n int64, err error)

type WindowClose ¶

type WindowClose struct {
	WindowId int8 // 0 = inventory
}

WindowClose is a two-way packet. Total Size: 2 bytes

func (p WindowClose) Id() byte

func (p *WindowClose) ReadFrom(r io.Reader) (n int64, err error)

func (p *WindowClose) WriteTo(w io.Writer) (n int64, err error)

type WindowOpen ¶

type WindowOpen struct {
	WindowId         int8   // Unique Window Id number. NMS: counter, starting at 1.
	InventoryType    int8   // The window type to use for display. Check below
	WindowTitle      string // The title of the window.
	Slots            int8   // Slots in window excluding player inventory slots
	UseProvidedTitle bool   // true: client uses what the server provides, false: client will look up a string
}

WindowOpen is a server to client packet.

Sent when NMC should open an inventory (chest, workbench, furnace, etc...). Not sent when client opens his inventory.

Total Size: 7 bytes + length of string

func (p WindowOpen) Id() byte

func (p *WindowOpen) ReadFrom(r io.Reader) (n int64, err error)

func (p *WindowOpen) WriteTo(w io.Writer) (n int64, err error)

type WindowSetItems ¶

type WindowSetItems struct {
	WindowId int8 // 0 = inventory
	Count    int16
	SlotData []*mct.Slot
}

WindowSetItems is a server to client packet. Total Size: 4 bytes + size of slot data array

func (p WindowSetItems) Id() byte

func (p *WindowSetItems) ReadFrom(r io.Reader) (n int64, err error)

func (p *WindowSetItems) WriteTo(w io.Writer) (n int64, err error)

type WindowSlotSet ¶

type WindowSlotSet struct {
	WindowId int8 // 0 = inventory
	Slot     int16
	Data     *mct.Slot
}

WindowSlotSet is a server to client packet. Total Size: 4 bytes + slot data

func (p WindowSlotSet) Id() byte

func (p *WindowSlotSet) ReadFrom(r io.Reader) (n int64, err error)

func (p *WindowSlotSet) WriteTo(w io.Writer) (n int64, err error)

type WindowUpdateProperty ¶

type WindowUpdateProperty struct {
	WindowId int8 // 0 = inventory
	Property int16
	Value    int16
}

WindowUpdateProperty is a server to client packet. Total Size: 6 bytes

func (p WindowUpdateProperty) Id() byte

func (p *WindowUpdateProperty) ReadFrom(r io.Reader) (n int64, err error)

func (p *WindowUpdateProperty) WriteTo(w io.Writer) (n int64, err error)