codePugHacKEr/bedrock-protocol
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
bedrock-protocol/data/latest/proto.yml
extremeheat d3723ef42a
 1.16.220 support (#66) 
* 1.16.220 initial support

* 1.16.220 fixes, electron gcm

* 1.16.220 item stack fix
2021-04-16 16:40:38 -04:00

2502 lines
No EOL
92 KiB
YAML
Raw Blame History

# Created from MiNET and gophertunnel docs
# The version below is the latest version this protocol schema was updated for.
# The output protocol.json will be in the folder for the version
!version: 1.16.220
# Some ProtoDef aliases
string: ["pstring",{"countType":"varint"}]
ByteArray: ["buffer",{"countType":"varint"}]
SignedByteArray: ["buffer",{"countType":"zigzag32"}]
LittleString: ["pstring",{"countType":"li32"}]
ShortArray: ["buffer",{"countType":"li16"}]
varint32: varint
bool: native
zigzag32: native
zigzag64: native
uuid: native
byterot: native
MapInfo: native
nbt: native
# load the packet map file
!import: packet_map.yml
#todo: docs
!StartDocs: Packets
# # Login Sequence
# The login process is as follows:
#
# C→S: [Login](#packet_login)
# S→C: [Server To Client Handshake](#packet_server_to_client_handshake)
# C→S: [Client To Server Handshake](#packet_client_to_server_handshake)
# S→C: [Play Status (Login success)](#packet_play_status)
# To spawn, the following packets should be sent, in order, after the ones above:
#
# S→C: [Resource Packs Info](#packet_resource_packs_info)
# C→S: [Resource Pack Client Response](#packet_resource_pack_client_response)
# S→C: [Resource Pack Stack](#packet_resource_pack_stack)
# C→S: [Resource Pack Client Response](#packet_resource_pack_client_response)
# S→C: [Start Game](#packet_start_game)
# S→C: [Creative Content](#packet_creative_content)
# S→C: [Biome Definition List](#packet_biome_definition_list)
# S→C: [Chunks](#packet_level_chunk)
# S→C: [Play Status (Player spawn)](#packet_play_status)
# If there are no resource packs being sent, a Resource Pack Stack can be sent directly
# after Resource Packs Info to avoid the client responses.
packet_login:
!id: 0x01
!bound: server
# Protocol version (Big Endian!)
protocol_version: i32
# The combined size of the `chain` and `client_data`
payload_size: varint
# JSON array of JWT data: contains the display name, UUID and XUID
# It should be signed by the Mojang public key
chain: LittleString
# Skin related data
client_data: LittleString
packet_play_status:
!id: 0x02
!bound: client
status: i32 =>
# Sent after Login has been successfully decoded and the player has logged in
0: login_success
# Displays "Could not connect: Outdated client!"
1: failed_client
# Displays "Could not connect: Outdated server!"
2: failed_spawn
# Sent after world data to spawn the player
3: player_spawn
# Displays "Unable to connect to world. Your school does not have access to this server."
4: failed_invalid_tenant
# Displays "The server is not running Minecraft: Education Edition. Failed to connect."
5: failed_vanilla_edu
# Displays "The server is running an incompatible edition of Minecraft. Failed to connect."
6: failed_edu_vanilla
# Displays "Wow this server is popular! Check back later to see if space opens up. Server Full"
7: failed_server_full
packet_server_to_client_handshake:
!id: 0x03
!bound: client
# Contains the salt to complete the Diffie-Hellman key exchange
token: string
# Sent by the client in response to a Server To Client Handshake packet
# sent by the server. It is the first encrypted packet in the login handshake
# and serves as a confirmation that encryption is correctly initialized client side.
# It has no fields.
packet_client_to_server_handshake:
!id: 0x04
!bound: server
# Sent by the server to disconnect a client.
packet_disconnect:
!id: 0x05
!bound: client
# Specifies if the disconnection screen should be hidden when the client is disconnected,
# meaning it will be sent directly to the main menu.
hide_disconnect_reason: bool
# An optional message to show when disconnected.
message: string
packet_resource_packs_info:
!id: 0x06
!bound: client
# If the resource pack requires the client accept it.
must_accept: bool
# If scripting is enabled.
has_scripts: bool
# A list of behaviour packs that the client needs to download before joining the server.
# All of these behaviour packs will be applied together.
behaviour_packs: BehaviourPackInfos
# A list of resource packs that the client needs to download before joining the server.
# The order of these resource packs is not relevant in this packet. It is however important in the Resource Pack Stack packet.
texture_packs: TexturePackInfos
packet_resource_pack_stack:
!id: 0x07
!bound: client
# If the resource pack must be accepted for the player to join the server.
must_accept: bool
# [inline]
behavior_packs: ResourcePackIdVersions
# [inline]
resource_packs: ResourcePackIdVersions
game_version: string
experiments: Experiments # ??? such random fields
experiments_previously_used: bool
packet_resource_pack_client_response:
!id: 0x08
!bound: server
response_status: u8 =>
0: none
1: refused
2: send_packs
3: have_all_packs
4: completed
# All of the pack IDs.
resourcepackids: ResourcePackIds
# Sent by the client to the server to send chat messages, and by the server to the client
# to forward or send messages, which may be chat, popups, tips etc.
## https://github.com/pmmp/PocketMine-MP/blob/a43b46a93cb127f037c879b5d8c29cda251dd60c/src/pocketmine/network/mcpe/protocol/TextPacket.php
## https://github.com/Sandertv/gophertunnel/blob/05ac3f843dd60d48b9ca0ab275cda8d9e85d8c43/minecraft/protocol/packet/text.go
packet_text:
!id: 0x09
!bound: both
# TextType is the type of the text sent. When a client sends this to the server, it should always be
# TextTypeChat. If the server sends it, it may be one of the other text types above.
type: u8 =>
0: raw
1: chat
2: translation
3: popup
4: jukebox_popup
5: tip
6: system
7: whisper
8: announcement
9: json_whisper
10: json
# NeedsTranslation specifies if any of the messages need to be translated. It seems that where % is found
# in translatable text types, these are translated regardless of this bool. Translatable text types
# include TextTypeTip, TextTypePopup and TextTypeJukeboxPopup.
needs_translation: bool
_: type?
if chat or whisper or announcement:
source_name: string
message: string
if raw or tip or system or json_whisper or json:
message: string
if translation or popup or jukebox_popup:
message: string
paramaters: string[]varint
# The XUID of the player who sent this message.
xuid: string
# PlatformChatID is an identifier only set for particular platforms when chatting (presumably only for
# Nintendo Switch). It is otherwise an empty string, and is used to decide which players are able to
# chat with each other.
platform_chat_id: string
# For additional information and examples of all the chat types above, see here: https://imgur.com/a/KhcFscg
# Sent by the server to update the current time client-side. The client actually advances time
# client-side by itself, so this packet does not need to be sent each tick. It is merely a means
# of synchronizing time between server and client.
packet_set_time:
!id: 0x0a
!bound: client
# Time is the current time. The time is not limited to 24000 (time of day), but continues
# progressing after that.
time: zigzag32
# Sent by the server to send information about the world the player will be spawned in.
packet_start_game:
!id: 0x0b
!bound: client
# The unique ID of the player. The unique ID is a value that remains consistent across
# different sessions of the same world, but most unofficial servers simply fill the
# runtime ID of the entity out for this field.
entity_id: zigzag64
# The runtime ID of the player. The runtime ID is unique for each world session,
# and entities are generally identified in packets using this runtime ID.
runtime_entity_id: varint64
# PlayerGameMode is the game mode the player currently has. It is a value from 0-4, with 0 being
# survival mode, 1 being creative mode, 2 being adventure mode, 3 being survival spectator and 4 being
# creative spectator.
# This field may be set to 5 to make the client fall back to the game mode set in the WorldGameMode
# field.
player_gamemode: GameMode
# The spawn position of the player in the world. In servers this is often the same as the
# world's spawn position found below.
player_position: vec3f
# The pitch and yaw of the player
rotation: vec2f
# The seed used to generate the world. Unlike in Java edition, the seed is a 32bit Integer here.
seed: zigzag32
biome_type: li16
biome_name: string
# Dimension is the ID of the dimension that the player spawns in. It is a value from 0-2,
# with 0 being the overworld, 1 being the nether and 2 being the end.
dimension: zigzag32
# Generator is the generator used for the world. It is a value from 0-4, with 0 being old
# limited worlds, 1 being infinite worlds, 2 being flat worlds, 3 being nether worlds and
# 4 being end worlds. A value of 0 will actually make the client stop rendering chunks you
# send beyond the world limit.
generator: zigzag32
# The world game mode that a player gets when it first spawns in the world. It is shown in the
# settings and is used if the Player Gamemode is set to 5.
world_gamemode: GameMode
# Difficulty is the difficulty of the world. It is a value from 0-3, with 0 being peaceful,
# 1 being easy, 2 being normal and 3 being hard.
difficulty: zigzag32
# The block on which the world spawn of the world. This coordinate has no effect on the place
# that the client spawns, but it does have an effect on the direction that a compass poInts.
spawn_position: BlockCoordinates
# Defines if achievements are disabled in the world. The client crashes if this value is set
# to true while the player's or the world's game mode is creative, and it's recommended to simply
# always set this to false as a server.
achievements_disabled: bool
# The time at which the day cycle was locked if the day cycle is disabled using the respective
# game rule. The client will maIntain this time as Boolean as the day cycle is disabled.
day_cycle_stop_time: zigzag32
# Some Minecraft: Education Edition field that specifies what 'region' the world was from,
# with 0 being None, 1 being RestOfWorld, and 2 being China. The actual use of this field is unknown.
edu_offer: zigzag32
# Specifies if the world has education edition features enabled, such as the blocks or entities
# specific to education edition.
edu_features_enabled: bool
edu_product_uuid: string
# The level specifying the Intensity of the rain falling. When set to 0, no rain falls at all.
rain_level: lf32
lightning_level: lf32
# The level specifying the Intensity of the thunder. This may actually be set independently
# from the rain level, meaning dark clouds can be produced without rain.
has_confirmed_platform_locked_content: bool
# Specifies if the world is a multi-player game. This should always be set to true for servers.
is_multiplayer: bool
# Specifies if LAN broadcast was Intended to be enabled for the world.
broadcast_to_lan: bool
# The mode used to broadcast the joined game across XBOX Live.
xbox_live_broadcast_mode: varint
# The mode used to broadcast the joined game across the platform.
platform_broadcast_mode: varint
# If commands are enabled for the player. It is recommended to always set this to true on the
# server, as setting it to false means the player cannot, under any circumstance, use a command.
enable_commands: bool
# Specifies if the texture pack the world might hold is required, meaning the client was
# forced to download it before joining.
is_texturepacks_required: bool
# Defines game rules currently active with their respective values. The value of these game
# rules may be either 'bool', 'Int32' or 'Float32'. Some game rules are server side only,
# and don't necessarily need to be sent to the client.
gamerules: GameRules
experiments: Experiments
experiments_previously_used: bool
# Specifies if the world had the bonus map setting enabled when generating it.
# It does not have any effect client-side.
bonus_chest: bool
# Specifies if the world has the start with map setting enabled, meaning each
# joining player obtains a map. This should always be set to false, because the
# client obtains a map all on its own accord if this is set to true.
map_enabled: bool
# The permission level of the player. It is a value from 0-3, with 0 being visitor,
# 1 being member, 2 being operator and 3 being custom.
permission_level: zigzag32
# The radius around the player in which chunks are ticked. Most servers set this value
# to a fixed number, as it does not necessarily affect anything client-side.
server_chunk_tick_range: li32
# Specifies if the texture pack of the world is locked, meaning it cannot be disabled
# from the world. This is typically set for worlds on the marketplace that have a dedicated
# texture pack.
has_locked_behavior_pack: bool
# Specifies if the texture pack of the world is locked, meaning it cannot be disabled from the
# world. This is typically set for worlds on the marketplace that have a dedicated texture pack.
has_locked_resource_pack: bool
# Specifies if the world from the server was from a locked world template.
# For servers this should always be set to false.
is_from_locked_world_template: bool
msa_gamertags_only: bool
# Specifies if the world from the server was from a locked world template.
# For servers this should always be set to false.
is_from_world_template: bool
# Specifies if the world was a template that locks all settings that change properties
# above in the settings GUI. It is recommended to set this to true for servers that
# do not allow things such as setting game rules through the GUI.
is_world_template_option_locked: bool
# A hack that Mojang put in place to preserve backwards compatibility with old villagers.
# The his never actually read though, so it has no functionality.
only_spawn_v1_villagers: bool
# The version of the game from which Vanilla features will be used.
# The exact function of this field isn't clear.
game_version: string
limited_world_width: li32
limited_world_length: li32
is_new_nether: bool
experimental_gameplay_override: bool
# A base64 encoded world ID that is used to identify the world.
level_id: string
# The name of the world that the player is joining. Note that this field shows up
# above the player list for the rest of the game session, and cannot be changed.
# Setting the server name to this field is recommended.
world_name: string
# A UUID specific to the premium world template that might have been used to
# generate the world. Servers should always fill out an empty String for this.
premium_world_template_id: string
# Specifies if the world was a trial world, meaning features are limited and there
# is a time limit on the world.
is_trial: bool
# MovementType specifies the way the server handles player movement. Available options are
# packet.AuthoritativeMovementModeClient, packet.AuthoritativeMovementModeServer and
# packet.AuthoritativeMovementModeServerWithRewind, where server the server authoritative types result
# in the client sending PlayerAuthInput packets instead of MovePlayer packets and the rewind mode
# requires sending the tick of movement and several actions.
#
# Specifies if the client or server is authoritative over the movement of the player,
# meaning it controls the movement of it.
## https://github.com/pmmp/PocketMine-MP/blob/a43b46a93cb127f037c879b5d8c29cda251dd60c/src/pocketmine/network/mcpe/protocol/types/PlayerMovementType.php#L26
movement_authority: zigzag32 =>
0: client
1: server
# PlayerAuthInputPacket + a bunch of junk that solves a nonexisting problem
2: server_with_rewind
# RewindHistorySize is the amount of history to keep at maximum if MovementType is
# packet.AuthoritativeMovementModeServerWithRewind.
rewind_history_size: zigzag32
# ServerAuthoritativeBlockBreaking specifies if block breaking should be sent through
# packet.PlayerAuthInput or not. This field is somewhat redundant as it is always enabled if
# MovementType is packet.AuthoritativeMovementModeServer or
# packet.AuthoritativeMovementModeServerWithRewind
server_authoritative_block_breaking: bool
# The total time in ticks that has elapsed since the start of the world.
current_tick: li64
# The seed used to seed the random used to produce enchantments in the enchantment table.
# Note that the exact correct random implementation must be used to produce the correct
# results both client- and server-side.
enchantment_seed: zigzag32
## This is not sent anymore in protocol versions > 419 (Bedrock Edition v1.16.100)
## A list of all blocks registered on the server.
block_palette: BlockPalette
# A list of all items with their legacy IDs which are available in the game.
# Failing to send any of the items that are in the game will crash mobile clients.
itemstates: Itemstates
# A unique ID specifying the multi-player session of the player.
# A random UUID should be filled out for this field.
multiplayer_correlation_id: string
server_authoritative_inventory: bool
packet_add_player:
!id: 0x0c
!bound: client
# UUID is the UUID of the player. It is the same UUID that the client sent in the
# Login packet at the start of the session. A player with this UUID must exist
# in the player list (built up using the Player List packet) for it to show up in-game.
uuid: uuid
# Username is the name of the player. This username is the username that will be
# set as the initial name tag of the player.
username: string
# The unique ID of the player. The unique ID is a value that remains consistent
# across different sessions of the same world, but most unoffical servers simply
# fill the runtime ID of the player out for this field.
entity_id_self: zigzag64
# The runtime ID of the player. The runtime ID is unique for each world session,
# and entities are generally identified in packets using this runtime ID.
runtime_entity_id: varint64
# An identifier only set for particular platforms when chatting (presumably only for
# Nintendo Switch). It is otherwise an empty string, and is used to decide which players
# are able to chat with each other.
platform_chat_id: string
x: lf32
y: lf32
z: lf32
speed_x: lf32
speed_y: lf32
speed_z: lf32
pitch: lf32
yaw: lf32
head_yaw: lf32
held_item: Item
metadata: MetadataDictionary
flags: varint
command_permission: varint
action_permissions: varint
permission_level: varint
custom_stored_permissions: varint
user_id: li64
links: Links
device_id: string
device_os: li32
packet_add_entity:
!id: 0x0d
!bound: client
entity_id_self: zigzag64
runtime_entity_id: varint64
entity_type: string
x: lf32
y: lf32
z: lf32
speed_x: lf32
speed_y: lf32
speed_z: lf32
pitch: lf32
yaw: lf32
head_yaw: lf32
attributes: EntityAttributes
metadata: MetadataDictionary
links: Links
packet_remove_entity:
!id: 0x0e
!bound: client
entity_id_self: zigzag64
packet_add_item_entity:
!id: 0x0f
!bound: client
entity_id_self: zigzag64
runtime_entity_id: varint64
item: Item
x: lf32
y: lf32
z: lf32
speed_x: lf32
speed_y: lf32
speed_z: lf32
metadata: MetadataDictionary
is_from_fishing: bool
packet_take_item_entity:
!id: 0x11
!bound: client
runtime_entity_id: varint64
target: varint
packet_move_entity:
!id: 0x12
!bound: both
runtime_entity_id: varint64
flags: u8
position: vec3f
rotation: Rotation
# MovePlayer is sent by players to send their movement to the server, and by the server to update the
# movement of player entities to other players.
packet_move_player:
!id: 0x13
!bound: both
# EntityRuntimeID is the runtime ID of the player. The runtime ID is unique for each world session, and
# entities are generally identified in packets using this runtime ID.
runtime_id: varint
# Position is the position to spawn the player on. If the player is on a distance that the viewer cannot
# see it, the player will still show up if the viewer moves closer.
position: vec3f
# Pitch is the vertical rotation of the player. Facing straight forward yields a pitch of 0. Pitch is
# measured in degrees.
pitch: lf32
# Yaw is the horizontal rotation of the player. Yaw is also measured in degrees
yaw: lf32
# HeadYaw is the same as Yaw, except that it applies specifically to the head of the player. A different
# value for HeadYaw than Yaw means that the player will have its head turned
head_yaw: lf32
# Mode is the mode of the movement. It specifies the way the player's movement should be shown to other
# players. It is one of the constants below.
mode: u8 =>
0: normal
1: reset
2: teleport
3: rotation
# OnGround specifies if the player is considered on the ground. Note that proxies or hacked clients could
# fake this to always be true, so it should not be taken for granted.
on_ground: bool
# RiddenEntityRuntimeID is the runtime ID of the entity that the player might currently be riding. If not
# riding, this should be left 0.
ridden_runtime_id: varint
teleport: mode ?
if teleport:
# TeleportCause is written only if Mode is MoveModeTeleport. It specifies the cause of the teleportation,
# which is one of the constants above.
cause: li32 =>
0: unknown
1: projectile
2: chorus_fruit
3: command
4: behavior
# TeleportSourceEntityType is the entity type that caused the teleportation, for example an ender pearl.
# TODO: is this still a integer and not a string?
source_entity_type: LegacyEntityType
tick: varint64
packet_rider_jump:
!id: 0x14
!bound: both
jump_strength: zigzag32
# UpdateBlock is sent by the server to update a block client-side, without resending the entire chunk that
# the block is located in. It is particularly useful for small modifications like block breaking/placing.
packet_update_block:
!id: 0x15
!bound: client
# Position is the block position at which a block is updated.
position: BlockCoordinates
# NewBlockRuntimeID is the runtime ID of the block that is placed at Position after sending the packet
# to the client.
block_runtime_id: varint
# Flags is a combination of flags that specify the way the block is updated client-side. It is a
# combination of the flags above, but typically sending only the BlockUpdateNetwork flag is sufficient.
flags: UpdateBlockFlags
# Layer is the world layer on which the block is updated. For most blocks, this is the first layer, as
# that layer is the default layer to place blocks on, but for blocks inside of each other, this differs.
layer: varint
UpdateBlockFlags: [ "bitflags",
{
"type": "varint",
"flags": {
"neighbors": 1,
"network": 2,
"no_graphic": 0b100,
"unused": 0b1000,
"priority": 0b10000,
}
}
]
packet_add_painting:
!id: 0x16
!bound: client
entity_id_self: zigzag64
runtime_entity_id: varint64
coordinates: BlockCoordinates
direction: zigzag32
title: string
# TickSync is sent by the client and the server to maintain a synchronized, server-authoritative tick between
# the client and the server. The client sends this packet first, and the server should reply with another one
# of these packets, including the response time.
packet_tick_sync:
!id: 0x17
!bound: both
# ClientRequestTimestamp is the timestamp on which the client sent this packet to the server. The server
# should fill out that same value when replying.
# The ClientRequestTimestamp is always 0
request_time: li64
# ServerReceptionTimestamp is the timestamp on which the server received the packet sent by the client.
# When the packet is sent by the client, this value is 0.
# ServerReceptionTimestamp is generally the current tick of the server. It isn't an actual timestamp, as
# the field implies
response_time: li64
packet_level_sound_event_old:
!id: 0x18
!bound: both
sound_id: u8
position: vec3f
block_id: zigzag32
entity_type: zigzag32
is_baby_mob: bool
is_global: bool
packet_level_event:
!id: 0x19
!bound: client
event: zigzag32 =>
1000: sound_click
1001: sound_click_fail
1002: sound_shoot
1003: sound_door
1004: sound_fizz
1005: sound_ignite
1007: sound_ghast
1008: sound_ghast_shoot
1009: sound_blaze_shoot
1010: sound_door_bump
1012: sound_door_crash
1018: sound_enderman_teleport
1020: sound_anvil_break
1021: sound_anvil_use
1022: sound_anvil_fall
1030: sound_pop
1032: sound_portal
1040: sound_itemframe_add_item
1041: sound_itemframe_remove
1042: sound_itemframe_place
1043: sound_itemframe_remove_item
1044: sound_itemframe_rotate_item
1050: sound_camera
1051: sound_orb
1052: sound_totem
1060: sound_armor_stand_break
1061: sound_armor_stand_hit
1062: sound_armor_stand_fall
1063: sound_armor_stand_place
1064: pointed_dripstone_land
1065: dye_used
1066: ink_sack_used
2000: particle_shoot #TODO: check 2000-2017
2001: particle_destroy
2002: particle_splash
2003: particle_eye_despawn
2004: particle_spawn
2005: particle_crop_growth
2006: particle_guardian_curse
2007: particle_death_smoke
2008: particle_block_force_field
2009: particle_projectile_hit
2010: particle_dragon_egg_teleport
2011: particle_crop_eaten
2012: particle_critical
2013: particle_enderman_teleport
2014: particle_punch_block
2015: particle_bubble
2016: particle_evaporate
2017: particle_destroy_armor_stand
2018: particle_breaking_egg
2019: particle_destroy_egg
2020: particle_evaporate_water
2021: particle_destroy_block_no_sound
2022: particle_knockback_roar
2023: particle_teleport_trail
2024: particle_point_cloud
2025: particle_explosion
2026: particle_block_explosion
2027: particle_vibration_signal
2028: particle_dripstone_drip
2029: particle_fizz_effect
2030: particle_wax_on
2031: particle_wax_off
2032: particle_scrape
2033: particle_electric_spark
3001: start_rain
3002: start_thunder
3003: stop_rain
3004: stop_thunder
3005: pause_game #data: 1 to pause, 0 to resume
3006: pause_game_no_screen #data: 1 to pause, 0 to resume - same effect as normal pause but without screen
3007: set_game_speed #x coordinate of pos = scale factor (default 1.0)
3500: redstone_trigger
3501: cauldron_explode
3502: cauldron_dye_armor
3503: cauldron_clean_armor
3504: cauldron_fill_potion
3505: cauldron_take_potion
3506: cauldron_fill_water
3507: cauldron_take_water
3508: cauldron_add_dye
3509: cauldron_clean_banner
3600: block_start_break
3601: block_stop_break
4000: set_data
9800: players_sleeping
0x4000: add_particle_mask
position: vec3f
data: zigzag32
packet_block_event:
!id: 0x1a
!bound: client
# Position is the position of the block that an event occurred at.
position: BlockCoordinates
# EventType is the type of the block event.
# The event type decides the way the event data that follows is used
type: zigzag32 =>
0: sound
1: change_state
# EventData holds event type specific data. For chests for example,
# opening the chest means the data must be 1
data: zigzag32
packet_entity_event:
!id: 0x1b
!bound: both
runtime_entity_id: varint64
event_id: u8 =>
1: jump
2: hurt_animation
3: death_animation
4: arm_swing
5: stop_attack
6: tame_fail
7: tame_success
8: shake_wet
9: use_item
10: eat_grass_animation
11: fish_hook_bubble
12: fish_hook_position
13: fish_hook_hook
14: fish_hook_tease
15: squid_ink_cloud
16: zombie_villager_cure
18: respawn
19: iron_golem_offer_flower
20: iron_golem_withdraw_flower
21: love_particles #breeding
22: villager_angry
23: villager_happy
24: witch_spell_particles
25: firework_particles
26: in_love_particles
27: silverfish_spawn_animation
28: guardian_attack
29: witch_drink_potion
30: witch_throw_potion
31: minecart_tnt_prime_fuse
32: creeper_prime_fuse
33: air_supply_expired
34: player_add_xp_levels
35: elder_guardian_curse
36: agent_arm_swing
37: ender_dragon_death
38: dust_particles #not sure what this is
39: arrow_shake
57: eating_item
60: baby_animal_feed #green particles, like bonemeal on crops
61: death_smoke_cloud
62: complete_trade
63: remove_leash #data 1 = cut leash
65: consume_totem
66: player_check_treasure_hunter_achievement #mojang...
67: entity_spawn #used for MinecraftEventing stuff, not needed
68: dragon_puke #they call this puke particles
69: item_entity_merge
70: start_swim
71: balloon_pop
72: treasure_hunt
73: agent_summon
74: charged_crossbow
75: fall
data: zigzag32
packet_mob_effect:
!id: 0x1c
!bound: client
runtime_entity_id: varint64
event_id: u8
effect_id: zigzag32
amplifier: zigzag32
particles: bool
duration: zigzag32
packet_update_attributes:
!id: 0x1d
!bound: client
runtime_entity_id: varint64
attributes: PlayerAttributes
tick: varint64
# InventoryTransaction is a packet sent by the client. It essentially exists out of multiple sub-packets,
# each of which have something to do with the inventory in one way or another. Some of these sub-packets
# directly relate to the inventory, others relate to interaction with the world, that could potentially
# result in a change in the inventory.
packet_inventory_transaction:
!id: 0x1e
!bound: both
transaction: Transaction
packet_mob_equipment:
!id: 0x1f
!bound: both
runtime_entity_id: varint64
item: Item
slot: u8
selected_slot: u8
window_id: WindowID
packet_mob_armor_equipment:
!id: 0x20
!bound: both
runtime_entity_id: varint64
helmet: Item
chestplate: Item
leggings: Item
boots: Item
# Interact is sent by the client when it interacts with another entity in some way. It used to be used for
# normal entity and block interaction, but this is no longer the case now.
packet_interact:
!id: 0x21
!bound: both
# Action type is the ID of the action that was executed by the player. It is one of the constants that
# may be found above.
action_id: u8 =>
3: leave_vehicle
4: mouse_over_entity
6: open_inventory
# TargetEntityRuntimeID is the runtime ID of the entity that the player interacted with. This is empty
# for the InteractActionOpenInventory action type.
target_entity_id: varint64
# Position associated with the ActionType above. For the InteractActionMouseOverEntity, this is the
# position relative to the entity moused over over which the player hovered with its mouse/touch. For the
# InteractActionLeaveVehicle, this is the position that the player spawns at after leaving the vehicle.
position: action_id ?
if mouse_over_entity or leave_vehicle: vec3f
packet_block_pick_request:
!id: 0x22
!bound: server
x: zigzag32
y: zigzag32
z: zigzag32
add_user_data: bool
selected_slot: u8
packet_entity_pick_request:
!id: 0x23
!bound: server
runtime_entity_id: lu64
selected_slot: u8
# PlayerAction is sent by the client when it executes any action, for example starting to sprint, swim,
# starting the breaking of a block, dropping an item, etc.
packet_player_action:
!id: 0x24
!bound: server
# EntityRuntimeID is the runtime ID of the player. The runtime ID is unique for each world session, and
# entities are generally identified in packets using this runtime ID.
runtime_entity_id: varint64
# ActionType is the ID of the action that was executed by the player. It is one of the constants that may
# be found above.
action: Action
# BlockPosition is the position of the target block, if the action with the ActionType set concerned a
# block. If that is not the case, the block position will be zero.
position: BlockCoordinates
# BlockFace is the face of the target block that was touched. If the action with the ActionType set
# concerned a block. If not, the face is always 0.
face: zigzag32
packet_hurt_armor:
!id: 0x26
!bound: client
health: zigzag32
packet_set_entity_data:
!id: 0x27
!bound: both
runtime_entity_id: varint64
metadata: MetadataDictionary
tick: varint
# SetActorMotion is sent by the server to change the client-side velocity of an entity. It is usually used
# in combination with server-side movement calculation.
packet_set_entity_motion:
!id: 0x28
!bound: both
# EntityRuntimeID is the runtime ID of the entity. The runtime ID is unique for each world session, and
# entities are generally identified in packets using this runtime ID.
runtime_entity_id: varint64
# Velocity is the new velocity the entity gets. This velocity will initiate the client-side movement of
# the entity.
velocity: vec3f
# SetActorLink is sent by the server to initiate an entity link client-side, meaning one entity will start
# riding another.
packet_set_entity_link:
!id: 0x29
!bound: client
link: Link
packet_set_health:
!id: 0x2a
!bound: client
health: zigzag32
packet_set_spawn_position:
!id: 0x2b
!bound: client
spawn_type: zigzag32 =>
0: player
1: world
player_position: BlockCoordinates
dimension: zigzag32
world_position: BlockCoordinates
packet_animate:
!id: 0x2c
!bound: both
action_id: zigzag32
runtime_entity_id: varint64
packet_respawn:
!id: 0x2d
!bound: both
x: lf32
y: lf32
z: lf32
state: u8
runtime_entity_id: varint64
# ContainerOpen is sent by the server to open a container client-side. This container must be physically
# present in the world, for the packet to have any effect. Unlike Java Edition, Bedrock Edition requires that
# chests for example must be present and in range to open its inventory.
packet_container_open:
!id: 0x2e
!bound: client
# WindowID is the ID representing the window that is being opened. It may be used later to close the
# container using a ContainerClose packet.
window_id: WindowID
# ContainerType is the type ID of the container that is being opened when opening the container at the
# position of the packet. It depends on the block/entity, and could, for example, be the window type of
# a chest or a hopper, but also a horse inventory.
window_type: WindowType
# ContainerPosition is the position of the container opened. The position must point to a block entity
# that actually has a container. If that is not the case, the window will not be opened and the packet
# will be ignored, if a valid ContainerEntityUniqueID has not also been provided.
coordinates: BlockCoordinates
# ContainerEntityUniqueID is the unique ID of the entity container that was opened. It is only used if
# the ContainerType is one that points to an entity, for example a horse.
runtime_entity_id: zigzag64
# ContainerClose is sent by the server to close a container the player currently has opened, which was opened
# using the ContainerOpen packet, or by the client to tell the server it closed a particular container, such
# as the crafting grid.
packet_container_close:
!id: 0x2f
!bound: both
# WindowID is the ID representing the window of the container that should be closed. It must be equal to
# the one sent in the ContainerOpen packet to close the designated window.
window_id: WindowID
# ServerSide determines whether or not the container was force-closed by the server. If this value is
# not set correctly, the client may ignore the packet and respond with a PacketViolationWarning.
server: bool
# PlayerHotBar is sent by the server to the client. It used to be used to link hot bar slots of the player to
# actual slots in the inventory, but as of 1.2, this was changed and hot bar slots are no longer a free
# floating part of the inventory.
# Since 1.2, the packet has been re-purposed, but its new functionality is not clear.
packet_player_hotbar:
!id: 0x30
!bound: both
selected_slot: varint
window_id: WindowID
select_slot: bool
# InventoryContent is sent by the server to update the full content of a particular inventory. It is usually
# sent for the main inventory of the player, but also works for other inventories that are currently opened
# by the player.
packet_inventory_content:
!id: 0x31
!bound: both
# WindowID is the ID that identifies one of the windows that the client currently has opened, or one of
# the consistent windows such as the main inventory.
window_id: WindowIDVarint
# Content is the new content of the inventory. The length of this slice must be equal to the full size of
# the inventory window updated.
input: ItemStacks
# InventorySlot is sent by the server to update a single slot in one of the inventory windows that the client
# currently has opened. Usually this is the main inventory, but it may also be the off hand or, for example,
# a chest inventory.
packet_inventory_slot:
!id: 0x32
!bound: both
# WindowID is the ID of the window that the packet modifies. It must point to one of the windows that the
# client currently has opened.
window_id: WindowIDVarint
# Slot is the index of the slot that the packet modifies. The new item will be set to the slot at this
# index.
slot: varint
# NewItem is the item to be put in the slot at Slot. It will overwrite any item that may currently
# be present in that slot.
item: Item
# ContainerSetData is sent by the server to update specific data of a single container, meaning a block such
# as a furnace or a brewing stand. This data is usually used by the client to display certain features
# client-side.
packet_container_set_data:
!id: 0x33
!bound: client
# WindowID is the ID of the window that should have its data set. The player must have a window open with
# the window ID passed, or nothing will happen.
window_id: WindowID
# Key is the key of the property. It is one of the constants that can be found above. Multiple properties
# share the same key, but the functionality depends on the type of the container that the data is set to.
property: zigzag32
# Value is the value of the property. Its use differs per property.
value: zigzag32
packet_crafting_data:
!id: 0x34
!bound: client
recipes: Recipes
potion_type_recipes: PotionTypeRecipes
potion_container_recipes: PotionContainerChangeRecipes
is_clean: bool
# CraftingEvent is sent by the client when it crafts a particular item. Note that this packet may be fully
# ignored, as the InventoryTransaction packet provides all the information required.
packet_crafting_event:
!id: 0x35
!bound: both
# WindowID is the ID representing the window that the player crafted in.
window_id: WindowID
# CraftingType is a type that indicates the way the crafting was done, for example if a crafting table
# was used.
recipe_type: zigzag32 =>
0: inventory
1: crafting
2: workbench
# RecipeUUID is the UUID of the recipe that was crafted. It points to the UUID of the recipe that was
# sent earlier in the CraftingData packet.
recipe_id: uuid
# Input is a list of items that the player put into the recipe so that it could create the Output items.
# These items are consumed in the process.
input: Item[]varint
# Output is a list of items that were obtained as a result of crafting the recipe.
result: Item[]varint
# GUIDataPickItem is sent by the server to make the client 'select' a hot bar slot. It currently appears to
# be broken however, and does not actually set the selected slot to the hot bar slot set in the packet.
packet_gui_data_pick_item:
!id: 0x36
!bound: client
# ItemName is the name of the item that shows up in the top part of the popup that shows up when
# selecting an item. It is shown as if an item was selected by the player itself.
item_name: string
# ItemEffects is the line under the ItemName, where the effects of the item are usually situated.
item_effects: string
# HotBarSlot is the hot bar slot to be selected/picked. This does not currently work, so it does not
# matter what number this is.
hotbar_slot: li32
# AdventureSettings is sent by the server to update game-play related features, in particular permissions to
# access these features for the client. It includes allowing the player to fly, build and mine, and attack
# entities. Most of these flags should be checked server-side instead of using this packet only.
# The client may also send this packet to the server when it updates one of these settings through the
# in-game settings interface. The server should verify if the player actually has permission to update those
# settings.
packet_adventure_settings:
!id: 0x37
!bound: both
# Flags is a set of flags that specify certain properties of the player, such as whether or not it can
# fly and/or move through blocks. It is one of the AdventureFlag constants above.
flags: AdventureFlags
# CommandPermissionLevel is a permission level that specifies the kind of commands that the player is
# allowed to use.
command_permission: varint32 =>
0: normal
1: operator
2: host
3: automation
4: admin
# ActionPermissions is, much like Flags, a set of flags that specify actions that the player is allowed
# to undertake, such as whether it is allowed to edit blocks, open doors etc. It is a combination of the
# ActionPermission constants above.
action_permissions: ActionPermissions
# PermissionLevel is the permission level of the player as it shows up in the player list built up using
# the PlayerList packet. It is one of the PermissionLevel constants above.
permission_level: varint =>
0: visitor
1: member
2: operator
3: custom
# Custom permissions
custom_stored_permissions: varint
# PlayerUniqueID is a unique identifier of the player. It appears it is not required to fill this field
# out with a correct value. Simply writing 0 seems to work.
user_id: li64
AdventureFlags: [ "bitflags",
{
"type": "varint",
"flags": {
"world_immutable": 1,
"no_pvp": 2,
"auto_jump": 0x20,
"allow_flight": 0x40,
"no_clip": 0x80,
"world_builder": 0x100,
"flying": 0x200,
"muted": 0x400
}
}
]
ActionPermissions: [ "bitflags",
{
"type": "varint",
"flags": {
"mine": 0x10001,
"doors_and_switches": 0x10002,
"open_containers": 0x10004,
"attack_players": 0x10008,
"attack_mobs": 0x10010,
"operator": 0x10020,
"teleport": 0x10080,
"build": 0x10100,
"default": 0x10200
}
}
]
packet_block_entity_data:
!id: 0x38
!bound: both
position: BlockCoordinates
nbt: nbt
packet_player_input:
!id: 0x39
!bound: server
motion_x: lf32
motion_z: lf32
jumping: bool
sneaking: bool
# LevelChunk is sent by the server to provide the client with a chunk of a world data (16xYx16 blocks).
# Typically a certain amount of chunks is sent to the client before sending it the spawn PlayStatus packet,
# so that the client spawns in a loaded world.
packet_level_chunk:
!id: 0x3a
!bound: client
# ChunkX is the X coordinate of the chunk sent. (To translate a block's X to a chunk's X: x >> 4)
x: zigzag32
# ChunkZ is the Z coordinate of the chunk sent. (To translate a block's Z to a chunk's Z: z >> 4)
z: zigzag32
# SubChunkCount is the amount of sub chunks that are part of the chunk sent. Depending on if the cache
# is enabled, a list of blob hashes will be sent, or, if disabled, the sub chunk data.
sub_chunk_count: varint
# CacheEnabled specifies if the client blob cache should be enabled. This system is based on hashes of
# blobs which are consistent and saved by the client in combination with that blob, so that the server
# does not have to send the same chunk multiple times. If the client does not yet have a blob with the hash sent,
# it will send a ClientCacheBlobStatus packet containing the hashes is does not have the data of.
cache_enabled: bool
blobs: cache_enabled?
if true:
# BlobHashes is a list of all blob hashes used in the chunk. It is composed of SubChunkCount + 1 hashes,
# with the first SubChunkCount hashes being those of the sub chunks and the last one that of the biome
# of the chunk.
# If CacheEnabled is set to false, BlobHashes can be left empty.
hashes: lu64[]varint
# RawPayload is a serialised string of chunk data. The data held depends on if CacheEnabled is set to
# true. If set to false, the payload is composed of multiple sub-chunks, each of which carry a version
# which indicates the way they are serialised, followed by biomes, border blocks and tile entities. If
# CacheEnabled is true, the payload consists out of the border blocks and tile entities only.
payload: ByteArray
packet_set_commands_enabled:
!id: 0x3b
!bound: client
enabled: bool
packet_set_difficulty:
!id: 0x3c
!bound: client
difficulty: varint
packet_change_dimension:
!id: 0x3d
!bound: client
dimension: zigzag32
position: vec3f
respawn: bool
# SetPlayerGameType is sent by the server to update the game type (game mode) of the player
packet_set_player_game_type:
!id: 0x3e
!bound: both
# The new gamemode for the player.
# Some of these game types require additional flags to be set in an AdventureSettings packet for
# the game mode to obtain its full functionality.
gamemode: GameMode
packet_player_list:
!id: 0x3f
!bound: client
records: PlayerRecords
packet_simple_event:
!id: 0x40
!bound: client
event_type: lu16
# Event is sent by the server to send an event with additional data. It is typically sent to the client for
# telemetry reasons, much like the SimpleEvent packet.
packet_event:
!id: 0x41
!bound: client
runtime_id: varint64
event_type: zigzag32 =>
0: achievement_awarded
1: entity_interact
2: portal_built
3: portal_used
4: mob_killed
5: cauldron_used
6: player_death
7: boss_killed
8: agent_command
9: agent_created
10: banner_pattern_removed
11: commaned_executed
12: fish_bucketed
13: mob_born
14: pet_died
15: cauldron_block_used
16: composter_block_used
17: bell_block_used
18: actor_definition
19: raid_update
20: player_movement_anomaly
21: player_moement_corrected
22: honey_harvested
23: target_block_hit
24: piglin_barter
use_player_id: u8
event_data: restBuffer # Unknown data, TODO: add
packet_spawn_experience_orb:
!id: 0x42
!bound: client
position: vec3f
count: zigzag32
packet_clientbound_map_item_data:
!id: 0x43
!bound: client
mapinfo: MapInfo
packet_map_info_request:
!id: 0x44
!bound: both
map_id: zigzag64
packet_request_chunk_radius:
!id: 0x45
!bound: both
chunk_radius: zigzag32
packet_chunk_radius_update:
!id: 0x46
!bound: client
chunk_radius: zigzag32
packet_item_frame_drop_item:
!id: 0x47
!bound: both
coordinates: BlockCoordinates
packet_game_rules_changed:
!id: 0x48
!bound: client
rules: GameRules
# Camera is sent by the server to use an Education Edition camera on a player. It produces an image
# client-side.
packet_camera:
!id: 0x49
!bound: client
# CameraEntityUniqueID is the unique ID of the camera entity from which the picture was taken.
camera_entity_unique_id: zigzag64
# TargetPlayerUniqueID is the unique ID of the target player. The unique ID is a value that remains
# consistent across different sessions of the same world, but most servers simply fill the runtime ID of
# the player out for this field.
target_player_unique_id: zigzag64
packet_boss_event:
!id: 0x4a
!bound: both
boss_entity_id: zigzag64
type: varint =>
# S2C: Shows the boss-bar to the player.
0: show_bar
# C2S: Registers a player to a boss fight.
1: register_player
# S2C: Removes the boss-bar from the client.
2: hide_bar
# C2S: Unregisters a player from a boss fight.
3: unregister_player
# S2C: Sets the bar percentage.
4: set_bar_progress
# S2C: Sets title of the bar.
5: set_bar_title
# S2C: darkens the sky
6: update_properties
# S2C: Not implemented :( Intended to alter bar appearance, but these currently produce no effect on client-side whatsoever.
7: texture
_: type?
if register_player or unregister_player:
player_id: zigzag64
if show:
title: string
bar_progress: lf32
if update_properties:
darkness_factor: li16
if texture:
color: varint
overlay: varint
if set_bar_progress:
bar_progress: lf32
if set_bar_title:
title: string
packet_show_credits:
!id: 0x4b
!bound: client
runtime_entity_id: varint64
status: zigzag32
# This packet sends a list of commands to the client. Commands can have
# arguments, and some of those arguments can have 'enum' values, which are a list of possible
# values for the argument. The serialization is rather complex and involves palettes like chunks.
## In bedrock-protocol, listen to on('client.commands') for a simpler representation
packet_available_commands:
!id: 0x4c
!bound: client
# The length of the enums for all the command paramaters in this packet
values_len: varint
# Not read from stream: instead calculated from the `values_len` field
# If the values_len < 0xff => byte
# If the values_len < 0xffff => short
# If the values_len < 0xffffff => int
_enum_type: '["enum_size_based_on_values_len"]'
# Here all the enum values for all of the possible commands are stored to one array palette
enum_values: string[]$values_len
# Integer paramaters may sometimes have a prefix, such as the XP command:
# /xp <amount: int> [player: target] <- here, the xp command gives experience points
# /xp <amount: int>L [player: target] <- here, the xp command gives experience levels
# This is the palette of suffixes
suffixes: string[]varint
# The list of enum objects
enums: []varint
# The name of the enum
name: string
# The values in the enum
values: []varint
# The indexes to value in the palette
_: ../_enum_type?
if byte: u8
if short: lu16
if int: lu32
command_data: []varint
name: string
description: string
flags: u8
permission_level: u8
alias: li32
# The list of overload paramaters for this command
overloads: []varint
# Each of the paramaters gets an array of posible overloads
_: []varint
# The name of the paramater shown to the user (the `amount` in `/xp <amount: int>`)
paramater_name: string
value_type: lu16 =>
1: int
2: float
3: value
4: wildcard_int
5: operator
6: target
16: file_path
32: string
40: position
44: message
46: raw_text
50: json
63: command
# In MC, this + prior field are combined to one 32bit bitfield
enum_type: lu16 =>
0x10: valid
0x20: enum
0x100: suffixed
0x400: soft_enum
# Is this paramater required?
optional: bool
# Additinal options for this command (thanks macroshaft...)
options: CommandFlags
# There are two types of enums: static enums which cannot be changed after sending AvaliableCommands,
# (unless you resend the whole packet) and 'soft' or 'dynamic' enums like below which is an array
# that can be updated with the UpdateSoftEnum packet
dynamic_enums: []varint
name: string
values: string[]varint
enum_constraints: []varint
value_index: li32
enum_index: li32
constraints: []varint
constraint: u8 =>
0: cheats_enabled
1: operator_permissions
2: host_permissions
# ParamOptionCollapseEnum 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>.
CommandFlags: [ "bitfield", [
{ "name": "unused", "size": 6, "signed": false }, # 6 unused upper bits
{ "name": "has_semantic_constraint", "size": 1, "signed": false },
{ "name": "collapse_enum", "size": 1, "signed": false }
]]
# enum_size_based_on_values_len: native
# CommandRequest is sent by the client to request the execution of a server-side command. Although some
# servers support sending commands using the Text packet, this packet is guaranteed to have the correct
# result.
packet_command_request:
!id: 0x4d
!bound: server
# CommandLine is the raw entered command line. The client does no parsing of the command line by itself
# (unlike it did in the early stages), but lets the server do that.
command: string
# Origin holds information about the command sender that will be returnd back in the command response
origin: CommandOrigin
# Internal specifies if the command request internal. Setting it to false seems to work and the usage of
# this field is not known.
interval: bool
packet_command_block_update:
!id: 0x4e
!bound: server
is_block: bool
packet_command_output:
!id: 0x4f
!bound: client
# CommandOrigin is the data specifying the origin of the command. In other words, the source that the
# command request was from, such as the player itself or a websocket server. The client forwards the
# messages in this packet to the right origin, depending on what is sent here.
origin: CommandOrigin
# OutputType specifies the type of output that is sent.
output_type: i8 =>
1: last
2: silent
3: all
4: data_set
# SuccessCount is the amount of times that a command was executed successfully as a result of the command
# that was requested. For servers, this is usually a rather meaningless fields, but for vanilla, this is
# applicable for commands created with Functions.
success_count: varint
# OutputMessages is a list of all output messages that should be sent to the player. Whether they are
# shown or not, depends on the type of the messages.
output: []varint
# 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_id: 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.
paramaters: string[]varint
data_set: output_type ?
if data_set: string
default: void
# UpdateTrade is sent by the server to update the trades offered by a villager to a player. It is sent at the
# moment that a player interacts with a villager.
packet_update_trade:
!id: 0x50
!bound: client
# WindowID is the ID that identifies the trading window that the client currently has opened.
window_id: WindowID
# WindowType is an identifier specifying the type of the window opened. In vanilla, it appears this is
# always filled out with 15.
window_type: WindowType
# Size is the amount of trading options that the villager has.
size: varint
# TradeTier is the tier of the villager that the player is trading with. The tier starts at 0 with a
# first two offers being available, after which two additional offers are unlocked each time the tier
# becomes one higher.
trade_tier: varint
# VillagerUniqueID is the unique ID of the villager entity that the player is trading with. The
# TradeTier sent above applies to this villager.
villager_unique_id: varint64
# EntityUniqueID is the unique ID of the entity (usually a player) for which the trades are updated. The
# updated trades may apply only to this entity.
entity_unique_id: varint64
# DisplayName is the name displayed at the top of the trading UI. It is usually used to represent the
# profession of the villager in the UI.
display_name: string
# NewTradeUI specifies if the villager should be using the new trade UI (The one added in 1.11.) rather
# than the old one. This should usually be set to true.
new_trading_ui: bool
# Trading based on Minecraft economy - specifies if the prices of the villager's offers are modified by an increase in
# demand for the item. (A mechanic added in 1.11.) Buying more of the same item will increase the price
# of that particular item.
# https://minecraft.gamepedia.com/Trading#Economics
economic_trades: bool
# NBT serialised compound of offers that the villager has.
offers: nbt
# UpdateEquip is sent by the server to the client upon opening a horse inventory. It is used to set the
# content of the inventory and specify additional properties, such as the items that are allowed to be put
# in slots of the inventory.
packet_update_equipment:
!id: 0x51
!bound: client
# WindowID is the identifier associated with the window that the UpdateEquip packet concerns. It is the
# ID sent for the horse inventory that was opened before this packet was sent.
window_id: WindowID
# WindowType is the type of the window that was opened. Generally, this is the type of a horse inventory,
# as the packet is specifically made for that.
window_type: WindowType
# Size is the size of the horse inventory that should be opened. A bigger size does, in fact, change the
# amount of slots displayed.
size: u8
# EntityUniqueID is the unique ID of the entity whose equipment was 'updated' to the player. It is
# typically the horse entity that had its inventory opened.
entity_id: zigzag64
# `inventory` is a network NBT serialised compound holding the content of the inventory of
# the entity (the equipment) and additional data such as the allowed items for a particular slot, used to
# make sure only saddles can be put in the saddle slot etc.
inventory: nbt
packet_resource_pack_data_info:
!id: 0x52
!bound: client
package_id: string
max_chunk_size: lu32
chunk_count: lu32
compressed_package_size: lu64
hash: ByteArray
is_premium: bool
pack_type: u8
packet_resource_pack_chunk_data:
!id: 0x53
!bound: client
package_id: string
chunk_index: lu32
progress: lu64
payload: ByteArray
packet_resource_pack_chunk_request:
!id: 0x54
!bound: server
package_id: string
chunk_index: lu32
packet_transfer:
!id: 0x55
!bound: client
server_address: string
port: lu16
packet_play_sound:
!id: 0x56
!bound: client
name: string
coordinates: BlockCoordinates
volume: lf32
pitch: lf32
packet_stop_sound:
!id: 0x57
!bound: client
name: string
stop_all: bool
# SetTitle is sent by the server to make a title, subtitle or action bar shown to a player. It has several
# fields that allow setting the duration of the titles.
packet_set_title:
!id: 0x58
!bound: client
# ActionType is the type of the action that should be executed upon the title of a player. It is one of
# the constants above and specifies the response of the client to the packet.
type: zigzag32 =>
0: clear
1: reset
2: set_title
3: set_subtitle
4: action_bar_message
5: set_durations
6: set_title_json
7: set_subtitle_json
8: action_bar_message_json
# Text is the text of the title, which has a different meaning depending on the ActionType that the
# packet has. The text is the text of a title, subtitle or action bar, depending on the type set.
text: string
# FadeInDuration is the duration that the title takes to fade in on the screen of the player. It is
# measured in 20ths of a second (AKA in ticks).
fade_in_time: zigzag32
# RemainDuration is the duration that the title remains on the screen of the player. It is measured in
# 20ths of a second (AKA in ticks).
stay_time: zigzag32
# FadeOutDuration is the duration that the title takes to fade out of the screen of the player. It is
# measured in 20ths of a second (AKA in ticks).
fade_out_time: zigzag32
packet_add_behavior_tree:
!id: 0x59
!bound: client
behaviortree: string
packet_structure_block_update:
!id: 0x5a
!bound: client
packet_show_store_offer:
!id: 0x5b
!bound: client
unknown0: string
unknown1: bool
packet_purchase_receipt:
!id: 0x5c
!bound: server
packet_player_skin:
!id: 0x5d
!bound: both
uuid: uuid
skin: Skin
skin_name: string
old_skin_name: string
is_verified: bool
packet_sub_client_login:
!id: 0x5e
!bound: client
packet_initiate_web_socket_connection:
!id: 0x5f
!bound: client
server: string
packet_set_last_hurt_by:
!id: 0x60
!bound: client
unknown: varint
packet_book_edit:
!id: 0x61
!bound: client
type: u8 =>
0: replace_page
1: add_page
2: delete_page
3: swap_pages
4: sign
slot: u8
_: type?
if replace_page or add_page:
page_number: u8
text: string
photo_name: string
if delete_page:
page_number: u8
if swap_pages:
page1: u8
page2: u8
if sign:
title: string
author: string
xuid: string
packet_npc_request:
!id: 0x62
!bound: both
runtime_entity_id: varint64
unknown0: u8
unknown1: string
unknown2: u8
packet_photo_transfer:
!id: 0x63
!bound: server
file_name: string
image_data: string
unknown2: string
packet_modal_form_request:
!id: 0x64
!bound: client
form_id: varint
data: string
packet_modal_form_response:
!id: 0x65
!bound: server
form_id: varint
data: string
packet_server_settings_request:
!id: 0x66
!bound: server
packet_server_settings_response:
!id: 0x67
!bound: client
form_id: varint
data: string
packet_show_profile:
!id: 0x68
!bound: client
xuid: string
# SetDefaultGameType is sent by the client when it toggles the default game type in the settings UI, and is
# sent by the server when it actually changes the default game type, resulting in the toggle being changed
# in the settings UI.
packet_set_default_game_type:
!id: 0x69
!bound: client
# GameType is the new game type that is set. When sent by the client, this is the requested new default
# game type.
gamemode: GameMode
packet_remove_objective:
!id: 0x6a
!bound: client
objective_name: string
packet_set_display_objective:
!id: 0x6b
!bound: client
display_slot: string
objective_name: string
display_name: string
criteria_name: string
sort_order: zigzag32
packet_set_score:
!id: 0x6c
!bound: client
entries: ScoreEntries
packet_lab_table:
!id: 0x6d
!bound: both
useless_byte: u8
lab_table_x: varint
lab_table_y: varint
lab_table_z: varint
reaction_type: u8
# UpdateBlockSynced is sent by the server to synchronise the falling of a falling block entity with the
# transitioning back and forth from and to a solid block. It is used to prevent the entity from flickering,
# and is used in places such as the pushing of blocks with pistons.
packet_update_block_synced:
!id: 0x6e
!bound: client
# Position is the block position at which a block is updated.
position: BlockCoordinates
# NewBlockRuntimeID is the runtime ID of the block that is placed at Position after sending the packet
# to the client.
block_runtime_id: varint
# Flags is a combination of flags that specify the way the block is updated client-side. It is a
# combination of the flags above, but typically sending only the BlockUpdateNetwork flag is sufficient.
flags: UpdateBlockFlags
# Layer is the world layer on which the block is updated. For most blocks, this is the first layer, as
# that layer is the default layer to place blocks on, but for blocks inside of each other, this differs.
layer: varint
# EntityUniqueID is the unique ID of the falling block entity that the block transitions to or that the
# entity transitions from.
# Note that for both possible values for TransitionType, the EntityUniqueID should point to the falling
# block entity involved.
entity_unique_id: zigzag64
# TransitionType is the type of the transition that happened. It is either BlockToEntityTransition, when
# a block placed becomes a falling entity, or EntityToBlockTransition, when a falling entity hits the
# ground and becomes a solid block again.
transition_type: varint64 =>
# For falling sand, when a sand turns to an entity
0: entity
# When sand turns back to a new block
1: create
2: destroy
# MoveActorDelta is sent by the server to move an entity. The packet is specifically optimised to save as
# much space as possible, by only writing non-zero fields.
# As of 1.16.100, this packet no longer actually contains any deltas.
packet_move_entity_delta:
!id: 0x6f
!bound: client
# EntityRuntimeID is the runtime ID of the entity that is being moved. The packet works provided a
# non-player entity with this runtime ID is present.
runtime_entity_id: varint64
# Flags is a list of flags that specify what data is in the packet.
flags: DeltaMoveFlags
x: flags.has_x?
if true: lf32
y: flags.has_y?
if true: lf32
z: flags.has_z?
if true: lf32
rot_x: flags.has_rot_x?
if true: u8 # TODO: * implement ByteFloat
rot_y: flags.has_rot_y?
if true: u8
rot_z: flags.has_rot_z?
if true: u8
DeltaMoveFlags: [ "bitflags",
{
"type": "lu16",
"flags": {
"has_x": 0x01,
"has_y": 0x02,
"has_z": 0x04,
"has_rot_x": 0x08,
"has_rot_y": 0x10,
"has_rot_z": 0x20,
"on_ground": 0x40,
"teleport": 0x80,
"force_move": 0x100
}
}
]
packet_set_scoreboard_identity:
!id: 0x70
!bound: client
entries: ScoreboardIdentityEntries
# SetLocalPlayerAsInitialised is sent by the client in response to a PlayStatus packet with the status set
# to spawn. The packet marks the moment at which the client is fully initialised and can receive any packet
# without discarding it.
packet_set_local_player_as_initialized:
!id: 0x71
!bound: server
# EntityRuntimeID is the entity runtime ID the player was assigned earlier in the login sequence in the
# StartGame packet.
runtime_entity_id: varint64
packet_update_soft_enum:
!id: 0x72
!bound: client
packet_network_stack_latency:
!id: 0x73
!bound: both
timestamp: lu64
unknown_flag: u8
packet_script_custom_event:
!id: 0x75
!bound: both
event_name: string
event_data: string
packet_spawn_particle_effect:
!id: 0x76
!bound: client
dimension_id: u8
entity_id: zigzag64
position: vec3f
particle_name: string
packet_available_entity_identifiers:
!id: 0x77
!bound: client
nbt: nbt
packet_level_sound_event_v2:
!id: 0x78
!bound: both
sound_id: u8
position: vec3f
block_id: zigzag32
entity_type: string
is_baby_mob: bool
is_global: bool
packet_network_chunk_publisher_update:
!id: 0x79
!bound: client
coordinates: BlockCoordinates
radius: varint
packet_biome_definition_list:
!id: 0x7a
!bound: client
nbt: nbt
# LevelSoundEvent is sent by the server to make any kind of built-in sound heard to a player. It is sent to,
# for example, play a stepping sound or a shear sound. The packet is also sent by the client, in which case
# it could be forwarded by the server to the other players online. If possible, the packets from the client
# should be ignored however, and the server should play them on its own accord.
packet_level_sound_event:
!id: 0x7b
!bound: both
sound_id: SoundType
position: vec3f
block_id: zigzag32
entity_type: string
is_baby_mob: bool
is_global: bool
# LevelEventGeneric is sent by the server to send a 'generic' level event to the client. This packet sends an
# NBT serialised object and may for that reason be used for any event holding additional data.
packet_level_event_generic:
!id: 0x7c
!bound: client
# EventID is a unique identifier that identifies the event called. The data that follows has fields in
# the NBT depending on what event it is.
event_id: varint
# SerialisedEventData is a network little endian serialised object of event data, with fields that vary
# depending on EventID.
# Unlike many other NBT structures, this data is not actually in a compound but just loosely floating
# NBT tags. To decode using the nbt package, you would need to append 0x0a00 at the start (compound id
# and name length) and add 0x00 at the end, to manually wrap it in a compound. Likewise, you would have
# to remove these bytes when encoding.
nbt: nbtLoop
# LecternUpdate is sent by the client to update the server on which page was opened in a book on a lectern,
# or if the book should be removed from it.
packet_lectern_update:
!id: 0x7d
!bound: client
# Page is the page number in the book that was opened by the player on the lectern.
page: u8
# PageCount is the number of pages that the book opened in the lectern has.
page_count: u8
# Position is the position of the lectern that was updated. If no lectern is at the block position,
# the packet should be ignored.
position: vec3i
# DropBook specifies if the book currently set on display in the lectern should be dropped server-side.
drop_book: bool
packet_video_stream_connect:
!id: 0x7e
!bound: client
server_uri: string
frame_send_frequency: lf32
action: u8
resolution_x: li32
resolution_y: li32
# This is NOT a Minecraft entity, but an entity in the Entity Component System (ECS)
# for the game engine Minecrat Bedrock uses. Internally, all 'Minecraft entities' are
# known as Actors including in packet names and fields. However, these are irrelevant
# internal details so we don't do the renames in these protocol definitions, for simplicity we just use Entity.
#
# AddEntity is sent by the server to the client. Its function is not entirely clear: It does not add an
# entity in the sense of an in-game entity, but has to do with the ECS that Minecraft uses.
packet_add_ecs_entity:
!id: 0x7f
!bound: client
# EntityNetworkID is the network ID of the entity that should be added.
network_id: varint64
# RemoveEntity is sent by the server to the client. Its function is not entirely clear: It does not remove an
# entity in the sense of an in-game entity, but has to do with the ECS that Minecraft uses
packet_remove_ecs_entity:
!id: 0x80
!bound: client
# EntityNetworkID is the network ID of the entity that should be removed.
network_id: varint64
packet_client_cache_status:
!id: 0x81
!bound: both
enabled: bool
packet_on_screen_texture_animation:
!id: 0x82
!bound: client
packet_map_create_locked_copy:
!id: 0x83
!bound: client
packet_structure_template_data_export_request:
!id: 0x84
!bound: client
packet_structure_template_data_export_response:
!id: 0x85
!bound: client
packet_update_block_properties:
!id: 0x86
!bound: client
nbt: nbt
# ClientCacheBlobStatus is part of the blob cache protocol. It is sent by the client to let the server know
# what blobs it needs and which blobs it already has, in an ACK type system.
packet_client_cache_blob_status:
!id: 0x87
!bound: client
# The number of MISSes in this packet
misses: varint
# The number of HITs in this packet
haves: varint
# A list of blob hashes that the client does not have a blob available for. The server
# should send the blobs matching these hashes as soon as possible.
missing: lu64[]$misses
# A list of hashes that the client does have a cached blob for. Server doesn't need to send.
have: lu64[]$haves
# ClientCacheMissResponse is part of the blob cache protocol. It is sent by the server in response to a
# ClientCacheBlobStatus packet and contains the blob data of all blobs that the client acknowledged not to
# have yet.
packet_client_cache_miss_response:
!id: 0x88
!bound: client
blobs: Blob[]varint
# EducationSettings is a packet sent by the server to update Minecraft: Education Edition related settings.
# It is unused by the normal base game.
packet_education_settings:
!id: 0x89
!bound: client
# CodeBuilderDefaultURI is the default URI that the code builder is ran on. Using this, a Code Builder
# program can make code directly affect the server.
CodeBuilderDefaultURI: string
# CodeBuilderTitle is the title of the code builder shown when connected to the CodeBuilderDefaultURI.
CodeBuilderTitle: string
# CanResizeCodeBuilder specifies if clients connected to the world should be able to resize the code
# builder when it is opened.
CanResizeCodeBuilder: bool
HasOverrideURI: bool
OverrideURI: HasOverrideURI?
if true: string
# HasQuiz specifies if the world has a quiz connected to it.
HasQuiz: bool
# MultiPlayerSettings is sent by the client to update multi-player related settings server-side and sent back
# to online players by the server.
# The MultiPlayerSettings packet is a Minecraft: Education Edition packet. It has no functionality for the
# base game.
packet_multiplayer_settings:
!id: 0x8b
!bound: server
# ActionType is the action that should be done when this packet is sent. It is one of the constants that
# may be found above.
action_type: zigzag32 =>
0: enable_multiplayer
1: disable_multiplayer
2: refresh_join_code
# SettingsCommand is sent by the client when it changes a setting in the settings that results in the issuing
# of a command to the server, such as when Show Coordinates is enabled.
packet_settings_command:
!id: 0x8c
!bound: server
# CommandLine is the full command line that was sent to the server as a result of the setting that the
# client changed.
command_line: string
# SuppressOutput specifies if the client requests the suppressing of the output of the command that was
# executed. Generally this is set to true, as the client won't need a message to confirm the output of
# the change.
suppress_output: bool
# AnvilDamage is sent by the client to request the dealing damage to an anvil. This packet is completely
# pointless and the server should never listen to it.
packet_anvil_damage:
!id: 0x8d
!bound: server
# Damage is the damage that the client requests to be dealt to the anvil.
damage: u8
# AnvilPosition is the position in the world that the anvil can be found at.
position: BlockCoordinates
# CompletedUsingItem is sent by the server to tell the client that it should be done using the item it is
# currently using.
packet_completed_using_item:
!id: 0x8e
!bound: client
# UsedItemID is the item ID of the item that the client completed using. This should typically be the
# ID of the item held in the hand.
used_item_id: li16
# UseMethod is the method of the using of the item that was completed. It is one of the constants that
# may be found above.
use_method: li32 =>
0: equip_armor
1: eat
2: attack
3: consume
4: throw
5: shoot
6: place
7: fill_bottle
8: fill_bucket
9: pour_bucket
10: use_tool
11: interact
12: retrieved
13: dyed
14: traded
# NetworkSettings is sent by the server to update a variety of network settings. These settings modify the
# way packets are sent over the network stack.
packet_network_settings:
!id: 0x8f
!bound: both
# CompressionThreshold is the minimum size of a packet that is compressed when sent. If the size of a
# packet is under this value, it is not compressed.
# When set to 0, all packets will be left uncompressed.
compression_threshold: u16
# PlayerAuthInput is sent by the client to allow for server authoritative movement. It is used to synchronise
# the player input with the position server-side.
# The client sends this packet when the ServerAuthoritativeMovementMode field in the StartGame packet is set
# to true, instead of the MovePlayer packet. The client will send this packet once every tick.
packet_player_auth_input:
!id: 0x90
!bound: server
# Pitch that the player reports it has.
pitch: lf32
# Yaw that player reports it has.
yaw: lf32
# Position holds the position that the player reports it has.
position: vec3f
# MoveVector is a Vec2 that specifies the direction in which the player moved, as a combination of X/Z
# values which are created using the WASD/controller stick state.
move_vector: vec2f
# HeadYaw is the horizontal rotation of the head that the player reports it has.
head_yaw: lf32
# InputData is a combination of bit flags that together specify the way the player moved last tick. It
# is a combination of the flags above.
input_data: InputFlag
# InputMode specifies the way that the client inputs data to the screen. It is one of the constants that
# may be found above.
input_mode: varint =>
0: unknown
1: mouse
2: touch
3: game_pad
4: motion_controller
# PlayMode specifies the way that the player is playing. The values it holds, which are rather random,
# may be found above.
play_mode: varint =>
0: normal
1: teaser
2: screen
3: viewer
4: reality
5: placement
6: living_room
7: exit_level
8: exit_level_living_room
9: num_modes
# GazeDirection is the direction in which the player is gazing, when the PlayMode is PlayModeReality: In
# other words, when the player is playing in virtual reality.
gaze_direction: play_mode ?
if reality: vec3f
# Tick is the server tick at which the packet was sent. It is used in relation to
# CorrectPlayerMovePrediction.
tick: varint64
# Delta was the delta between the old and the new position. There isn't any practical use for this field
# as it can be calculated by the server itself.
delta: vec3f
transaction: input_data.item_interact ?
if true:
legacy: TransactionLegacy
actions: TransactionActions
data: TransactionUseItem
item_stack_request: input_data.item_stack_request ?
if true: ItemStackRequest
block_action: input_data.block_action ?
if true: []zigzag32
action: Action
_: action?
if start_break or abort_break or crack_break or predict_break or continue_break:
# BlockPosition is the position of the target block, if the action with the ActionType set concerned a
# block. If that is not the case, the block position will be zero.
position: BlockCoordinates
# BlockFace is the face of the target block that was touched. If the action with the ActionType set
# concerned a block. If not, the face is always 0.
face: zigzag32
#TODO: update to use the new `shift` option in bitflags
InputFlag: [ "bitflags", {
"type": "varint64", "big": true,
"flags": [
"ascend",
"descend",
"north_jump",
"jump_down",
"sprint_down",
"change_height",
"jumping",
"auto_jumping_in_water",
"sneaking",
"sneak_down",
"up",
"down",
"left",
"right",
"up_left",
"up_right",
"want_up",
"want_down",
"want_down_slow",
"want_up_slow",
"sprinting",
"ascend_scaffolding",
"descend_scaffolding",
"sneak_toggle_down",
"persist_sneak",
"start_sprinting",
"stop_sprinting",
"start_sneaking",
"stop_sneaking",
"start_swimming",
"stop_swimming",
"start_jumping",
"start_gliding",
"stop_gliding",
"item_interact",
"block_action",
"item_stack_request"
]
}]
packet_creative_content:
!id: 0x91
!bound: client
items: []varint
entry_id: varint
item: ItemLegacy
packet_player_enchant_options:
!id: 0x92
!bound: client
enchant_options: EnchantOptions
# ItemStackRequest is sent by the client to change item stacks in an inventory. It is essentially a
# replacement of the InventoryTransaction packet added in 1.16 for inventory specific actions, such as moving
# items around or crafting. The InventoryTransaction packet is still used for actions such as placing blocks
# and interacting with entities.
packet_item_stack_request:
!id: 0x93
!bound: server
requests: ItemStackRequest[]varint
packet_item_stack_response:
!id: 0x94
!bound: client
responses: ItemStackResponses
# PlayerArmourDamage is sent by the server to damage the armour of a player. It is a very efficient packet,
# but generally it's much easier to just send a slot update for the damaged armour.
packet_player_armor_damage:
!id: 0x95
!bound: client
# Bitset holds a bitset of 4 bits that indicate which pieces of armour need to have damage dealt to them.
# The first bit, when toggled, is for a helmet, the second for the chestplate, the third for the leggings
# and the fourth for boots.
type: ArmorDamageType
helmet_damage: type.head ?
if true: zigzag32
chestplate_damage: type.chest ?
if true: zigzag32
leggings_damage: type.legs ?
if true: zigzag32
boots_damage: type.feet ?
if true: zigzag32
ArmorDamageType: [ "bitflags",
{
"type": "u8",
"flags": {
"head": 0b1,
"chest": 0b10,
"legs": 0b100,
"feet": 0b1000
}
}
]
# UpdatePlayerGameType is sent by the server to change the game mode of a player. It is functionally
# identical to the SetPlayerGameType packet.
packet_update_player_game_type:
!id: 0x97
!bound: server
# GameType is the new game type of the player. It is one of the constants that can be found in
# set_player_game_type.go. Some of these game types require additional flags to be set in an
# AdventureSettings packet for the game mode to obtain its full functionality.
gamemode: GameMode
# PlayerUniqueID is the entity unique ID of the player that should have its game mode updated. If this
# packet is sent to other clients with the player unique ID of another player, nothing happens.
player_unique_id: zigzag64
# PositionTrackingDBClientRequest is a packet sent by the client to request the position and dimension of a
# 'tracking ID'. These IDs are tracked in a database by the server. In 1.16, this is used for lodestones.
# The client will send this request to find the position a lodestone compass needs to point to. If found, it
# will point to the lodestone. If not, it will start spinning around.
# A PositionTrackingDBServerBroadcast packet should be sent in response to this packet.
packet_position_tracking_db_request:
!id: 0x9a
!bound: server
# RequestAction is the action that should be performed upon the receiving of the packet. It is one of the
# constants found above.
action: u8 =>
0: query
# TrackingID is a unique ID used to identify the request. The server responds with a
# PositionTrackingDBServerBroadcast packet holding the same ID, so that the client can find out what that
# packet was in response to.
tracking_id: zigzag32
# PositionTrackingDBServerBroadcast is sent by the server in response to the
# PositionTrackingDBClientRequest packet. This packet is, as of 1.16, currently only used for lodestones. The
# server maintains a database with tracking IDs and their position and dimension. The client will request
# these tracking IDs, (NBT tag set on the lodestone compass with the tracking ID?) and the server will
# respond with the status of those tracking IDs.
# What is actually done with the data sent depends on what the client chooses to do with it. For the
# lodestone compass, it is used to make the compass point towards lodestones and to make it spin if the
# lodestone at a position is no longer there.
packet_position_tracking_db_broadcast:
!id: 0x99
!bound: client
# BroadcastAction specifies the status of the position tracking DB response. It is one of the constants
# above, specifying the result of the request with the ID below.
# The Update action is sent for setting the position of a lodestone compass, the Destroy and NotFound to
# indicate that there is not (no longer) a lodestone at that position.
broadcast_action: u8 =>
0: update
1: destory
2: not_found
# TrackingID is the ID of the PositionTrackingDBClientRequest packet that this packet was in response to.
# The tracking ID is also present as the 'id' field in the SerialisedData field.
tracking_id: zigzag32
nbt: nbt
# PacketViolationWarning is sent by the client when it receives an invalid packet from the server. It holds
# some information on the error that occurred.
packet_packet_violation_warning:
!id: 0x9c
!bound: server
violation_type: zigzag32 =>
0: malformed
# Severity specifies the severity of the packet violation. The action the client takes after this
# violation depends on the severity sent.
severity: zigzag32 =>
0: warning
1: final_warning
2: terminating
# PacketID is the ID of the invalid packet that was received.
packet_id: zigzag32
# ViolationContext holds a description on the violation of the packet.
reason: string
# MotionPredictionHints is sent by the server to the client. There is a predictive movement component for
# entities. This packet fills the "history" of that component and entity movement is computed based on the
# points. Vanilla sends this packet instead of the SetActorMotion packet when 'spatial optimisations' are
# enabled.
packet_motion_prediction_hints:
!id: 0x9d
!bound: client
# EntityRuntimeID is the runtime ID of the entity whose velocity is sent to the client.
entity_runtime_id: varint64
# Velocity is the server-calculated velocity of the entity at the point of sending the packet.
velocity: vec3f
# OnGround specifies if the server currently thinks the entity is on the ground.
on_ground: bool
# AnimateEntity is sent by the server to animate an entity client-side. It may be used to play a single
# animation, or to activate a controller which can start a sequence of animations based on different
# conditions specified in an animation controller.
# Much of the documentation of this packet can be found at
# https://minecraft.gamepedia.com/Bedrock_Edition_beta_animation_documentation.
packet_animate_entity:
!id: 0x9e
!bound: client
# Animation is the name of a single animation to start playing.
animation: string
# NextState is the first state to start with. These states are declared in animation controllers (which,
# in themselves, are animations too). These states in turn may have animations and transitions to move to
# a next state.
next_state: string
# StopCondition is a MoLang expression that specifies when the animation should be stopped.
stop_condition: string
# Controller is the animation controller that is used to manage animations. These controllers decide when
# to play which animation.
controller: string
# BlendOutTime does not currently seem to be used.
blend_out_time: lf32
# EntityRuntimeIDs is list of runtime IDs of entities that the animation should be applied to.
runtime_entity_ids: varint64[]varint
# CameraShake is sent by the server to make the camera shake client-side. This feature was added for map-
# making partners.
packet_camera_shake:
!id: 0x9f
!bound: client
# Intensity is the intensity of the shaking. The client limits this value to 4, so anything higher may
# not work.
intensity: lf32
# Duration is the number of seconds the camera will shake for.
duration: lf32
# Type is the type of shake, and is one of the constants listed above. The different type affects how
# the shake looks in game.
type: u8
# Action is the action to be performed, and is one of the constants listed above. Currently the
# different actions will either add or stop shaking the client.
action: u8 =>
0: add
1: stop
# PlayerFog is sent by the server to render the different fogs in the Stack. The types of fog are controlled
# by resource packs to change how they are rendered, and the ability to create custom fog.
packet_player_fog:
!id: 0xa0
!bound: client
# Stack is a list of fog identifiers to be sent to the client. Examples of fog identifiers are
# "minecraft:fog_ocean" and "minecraft:fog_hell".
stack: string[]varint
# CorrectPlayerMovePrediction is sent by the server if and only if StartGame.ServerAuthoritativeMovementMode
# is set to AuthoritativeMovementModeServerWithRewind. The packet is used to correct movement at a specific
# point in time.
packet_correct_player_move_prediction:
!id: 0xa1
!bound: client
# Position is the position that the player is supposed to be at at the tick written in the field below.
# The client will change its current position based on movement after that tick starting from the
# Position.
position: vec3f
# Delta is the change in position compared to what the client sent as its position at that specific tick.
delta: vec3f
# OnGround specifies if the player was on the ground at the time of the tick below.
on_ground: bool
# Tick is the tick of the movement which was corrected by this packet.
tick: varint64
# ItemComponent is sent by the server to attach client-side components to a custom item.
packet_item_component:
!id: 0xa2
!bound: client
# `entries` holds a list of all custom items with their respective components set.
entries: ItemComponentList
# FilterText is sent by the both the client and the server. The client sends the packet to the server to
# allow the server to filter the text server-side. The server then responds with the same packet and the
# safer version of the text.
packet_filter_text_packet:
!id: 0xa3
!bound: client
# Text is either the text from the client or the safer version of the text sent by the server.
text: string
# FromServer indicates if the packet was sent by the server or not.
from_server: bool
# ClientBoundDebugRenderer is sent by the server to spawn an outlined cube on client-side.
packet_debug_renderer:
!id: 0xa4
!bound: client
# Type is the type of action. It is one of the constants above.
type: li32 =>
1: clear
2: add_cube
_: type ?
if clear: void
if add_cube:
# Text is the text that is displayed above the debug.
text: string
# Position is the position to spawn the debug on.
position: vec3f
# Red is the red value from the RGBA colour rendered on the debug.
red: lf32
# Green is the green value from the RGBA colour rendered on the debug.
green: lf32
# Blue is the blue value from the RGBA colour rendered on the debug.
blue: lf32
# Alpha is the alpha value from the RGBA colour rendered on the debug.
alpha: lf32
# Duration is how long the debug will last in the world for. It is measured in milliseconds.
duration: li64
Reference in a new issue View git blame Copy permalink