002f14ce53
Locator bar for vanilla clients on Horizon servers (waypoint packets as vanilla sends them)
2100 lines
74 KiB
Rust
2100 lines
74 KiB
Rust
//! Play state packets: world, entities, player state, inventory and chat.
|
|
use crate::{
|
|
Error, Result,
|
|
buf::{
|
|
Bool, Byte, ChunkPos, Codec, Double, Float, Ident, Int, List, Long, LpVec3, Nbt, Opt,
|
|
OptVarInt, Pos, Reader, SectionPos, Short, Str, StrN, UByte, Uuid, VarInt, VarLong, Vec3d,
|
|
Writer,
|
|
},
|
|
chunk::{ChunkData, LightData},
|
|
entity_data::{EntityData, Value},
|
|
item::{Hashed, HashedSlot, Slot, Stack},
|
|
packet, packet_enum,
|
|
packets::{
|
|
Empty,
|
|
configuration::{
|
|
ClientInformation, CustomPayload, Disconnect, KeepAlive, Ping, ResourcePackPush,
|
|
ResourcePackResponse, UpdateTags,
|
|
},
|
|
login::Property,
|
|
},
|
|
};
|
|
use horizon_world::nbt::Tag;
|
|
|
|
// ---- shared structures -------------------------------------------------
|
|
|
|
packet!(
|
|
/// GlobalPos: a dimension and a block position.
|
|
GlobalPos { dimension: String => Ident, pos: [i32; 3] => Pos }
|
|
);
|
|
packet!(
|
|
/// CommonPlayerSpawnInfo.
|
|
SpawnInfo {
|
|
dimension_type: i32 => VarInt,
|
|
dimension: String => Ident,
|
|
seed: i64 => Long,
|
|
game_type: i32 => VarInt,
|
|
previous_game_type: Option<i32> => OptVarInt,
|
|
debug: bool => Bool,
|
|
flat: bool => Bool,
|
|
last_death: Option<GlobalPos> => Opt<GlobalPos>,
|
|
portal_cooldown: i32 => VarInt,
|
|
sea_level: i32 => VarInt,
|
|
}
|
|
);
|
|
|
|
/// Relative flags (Relative.pack): X, Y, Z, Y_ROT, X_ROT, DELTA_X/Y/Z, ROTATE_DELTA.
|
|
pub mod relative {
|
|
pub const X: i32 = 1;
|
|
pub const Y: i32 = 2;
|
|
pub const Z: i32 = 4;
|
|
pub const Y_ROT: i32 = 8;
|
|
pub const X_ROT: i32 = 16;
|
|
pub const DELTA_X: i32 = 32;
|
|
pub const DELTA_Y: i32 = 64;
|
|
pub const DELTA_Z: i32 = 128;
|
|
pub const ROTATE_DELTA: i32 = 256;
|
|
}
|
|
|
|
// ---- clientbound -------------------------------------------------------
|
|
|
|
packet!(AddEntity {
|
|
id: i32 => VarInt,
|
|
uuid: u128 => Uuid,
|
|
kind: i32 => VarInt,
|
|
position: [f64; 3] => Vec3d,
|
|
velocity: [f64; 3] => LpVec3,
|
|
pitch: i8 => Byte,
|
|
yaw: i8 => Byte,
|
|
head_yaw: i8 => Byte,
|
|
data: i32 => VarInt,
|
|
});
|
|
packet!(Animate { id: i32 => VarInt, action: u8 => UByte });
|
|
packet!(BlockChangedAck { sequence: i32 => VarInt });
|
|
packet!(BlockDestruction { id: i32 => VarInt, pos: [i32; 3] => Pos, progress: u8 => UByte });
|
|
packet!(BlockEntityData { pos: [i32; 3] => Pos, kind: i32 => VarInt, tag: Tag => Nbt });
|
|
packet!(BlockUpdate { pos: [i32; 3] => Pos, state: i32 => VarInt });
|
|
packet!(ChangeDifficulty { difficulty: i32 => VarInt, locked: bool => Bool });
|
|
// ResourceKey<GameRule<?>> is an identifier, followed by its string value.
|
|
packet!(GameRuleEntry { name: String => Ident, value: String => Str });
|
|
packet!(GameRuleValues { entries: Vec<GameRuleEntry> => List<GameRuleEntry> });
|
|
packet!(ChunkBatchFinished { size: i32 => VarInt });
|
|
packet!(ContainerClose { container: i32 => VarInt });
|
|
packet!(ContainerSetContent {
|
|
container: i32 => VarInt,
|
|
state: i32 => VarInt,
|
|
items: Vec<Option<Stack>> => List<Slot>,
|
|
carried: Option<Stack> => Slot,
|
|
});
|
|
/// ItemCost.STREAM_CODEC: item, count, then the exact component predicate
|
|
/// (Horizon sends and reads it as a component patch without removals).
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct NetCost {
|
|
pub item: i32,
|
|
pub count: i32,
|
|
}
|
|
/// MerchantOffer.STREAM_CODEC.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct NetOffer {
|
|
pub cost_a: NetCost,
|
|
pub result: Stack,
|
|
pub cost_b: Option<NetCost>,
|
|
pub out_of_stock: bool,
|
|
pub uses: i32,
|
|
pub max_uses: i32,
|
|
pub xp: i32,
|
|
pub special_price: i32,
|
|
pub price_multiplier: f32,
|
|
pub demand: i32,
|
|
}
|
|
pub struct Offers;
|
|
impl Codec<Vec<NetOffer>> for Offers {
|
|
fn read(r: &mut Reader) -> Result<Vec<NetOffer>> {
|
|
fn cost(r: &mut Reader) -> Result<NetCost> {
|
|
let item = r.varint()?;
|
|
let count = r.varint()?;
|
|
if r.varint()? != 0 {
|
|
return Err(Error::new("item cost components are not supported"));
|
|
}
|
|
Ok(NetCost { item, count })
|
|
}
|
|
let n = r.count(r.remaining())?;
|
|
let mut out = Vec::with_capacity(n.min(64));
|
|
for _ in 0..n {
|
|
let cost_a = cost(r)?;
|
|
let result = Slot::read(r)?.ok_or_else(|| Error::new("empty merchant result"))?;
|
|
let cost_b = if r.bool()? { Some(cost(r)?) } else { None };
|
|
out.push(NetOffer {
|
|
cost_a,
|
|
result,
|
|
cost_b,
|
|
out_of_stock: r.bool()?,
|
|
uses: r.i32()?,
|
|
max_uses: r.i32()?,
|
|
xp: r.i32()?,
|
|
special_price: r.i32()?,
|
|
price_multiplier: r.f32()?,
|
|
demand: r.i32()?,
|
|
});
|
|
}
|
|
Ok(out)
|
|
}
|
|
fn write(v: &Vec<NetOffer>, w: &mut Writer) {
|
|
fn cost(c: &NetCost, w: &mut Writer) {
|
|
w.varint(c.item);
|
|
w.varint(c.count);
|
|
w.varint(0);
|
|
}
|
|
w.varint(v.len() as i32);
|
|
for o in v {
|
|
cost(&o.cost_a, w);
|
|
Slot::write(&Some(o.result.clone()), w);
|
|
w.bool(o.cost_b.is_some());
|
|
if let Some(b) = &o.cost_b {
|
|
cost(b, w);
|
|
}
|
|
w.bool(o.out_of_stock);
|
|
w.i32(o.uses);
|
|
w.i32(o.max_uses);
|
|
w.i32(o.xp);
|
|
w.i32(o.special_price);
|
|
w.f32(o.price_multiplier);
|
|
w.i32(o.demand);
|
|
}
|
|
}
|
|
}
|
|
packet!(
|
|
/// ClientboundMerchantOffersPacket.
|
|
MerchantOffers {
|
|
container: i32 => VarInt,
|
|
offers: Vec<NetOffer> => Offers,
|
|
level: i32 => VarInt,
|
|
xp: i32 => VarInt,
|
|
show_progress: bool => Bool,
|
|
can_restock: bool => Bool,
|
|
}
|
|
);
|
|
packet!(ContainerSetData { container: i32 => VarInt, id: i16 => Short, value: i16 => Short });
|
|
packet!(ContainerSetSlot { container: i32 => VarInt, state: i32 => VarInt, slot: i16 => Short, item: Option<Stack> => Slot });
|
|
/// A holder reference: registry id + 1, or 0 for an inline value (unsupported).
|
|
pub struct HolderId;
|
|
impl Codec<i32> for HolderId {
|
|
fn read(r: &mut Reader) -> Result<i32> {
|
|
match r.varint()? {
|
|
0 => Err(Error::new("inline registry values are not supported")),
|
|
id => Ok(id - 1),
|
|
}
|
|
}
|
|
fn write(v: &i32, w: &mut Writer) {
|
|
w.varint(v + 1)
|
|
}
|
|
}
|
|
packet!(
|
|
/// ChatType.Bound.
|
|
ChatTypeBound { chat_type: i32 => HolderId, name: Tag => Nbt, target: Option<Tag> => Opt<Nbt> }
|
|
);
|
|
packet!(DisguisedChat { message: Tag => Nbt, chat_type: ChatTypeBound => ChatTypeBound });
|
|
packet!(EntityEvent { id: i32 => Int, event: i8 => Byte });
|
|
/// PositionPath: Linear(end position) or Stepped(list of (position, tick offset)).
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum PositionPath {
|
|
Linear([f64; 3]),
|
|
Stepped(Vec<([f64; 3], i32)>),
|
|
}
|
|
impl PositionPath {
|
|
pub fn end(&self) -> [f64; 3] {
|
|
match self {
|
|
Self::Linear(p) => *p,
|
|
Self::Stepped(steps) => steps.last().map_or([0.0; 3], |s| s.0),
|
|
}
|
|
}
|
|
}
|
|
impl Codec<PositionPath> for PositionPath {
|
|
fn read(r: &mut Reader) -> Result<Self> {
|
|
Ok(match r.varint()? {
|
|
1 => {
|
|
let n = r.count(r.remaining() / 25)?;
|
|
Self::Stepped(
|
|
(0..n)
|
|
.map(|_| Ok((Vec3d::read(r)?, r.varint()?)))
|
|
.collect::<Result<_>>()?,
|
|
)
|
|
}
|
|
_ => Self::Linear(Vec3d::read(r)?),
|
|
})
|
|
}
|
|
fn write(v: &Self, w: &mut Writer) {
|
|
match v {
|
|
Self::Linear(p) => {
|
|
w.varint(0);
|
|
Vec3d::write(p, w);
|
|
}
|
|
Self::Stepped(steps) => {
|
|
w.varint(1);
|
|
w.varint(steps.len() as i32);
|
|
for (p, t) in steps {
|
|
Vec3d::write(p, w);
|
|
w.varint(*t);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
packet!(EntityPositionSync { id: i32 => VarInt, path: PositionPath => PositionPath, yaw: f32 => Float, pitch: f32 => Float, on_ground: bool => Bool });
|
|
packet!(ForgetLevelChunk { pos: [i32; 2] => ChunkPos });
|
|
packet!(GameEvent { event: u8 => UByte, param: f32 => Float });
|
|
packet!(HurtAnimation { id: i32 => VarInt, yaw: f32 => Float });
|
|
packet!(LevelChunkWithLight { x: i32 => Int, z: i32 => Int, chunk: ChunkData => ChunkData, light: LightData => LightData });
|
|
packet!(LevelEvent { kind: i32 => Int, pos: [i32; 3] => Pos, data: i32 => Int, global: bool => Bool });
|
|
packet!(LightUpdate { x: i32 => VarInt, z: i32 => VarInt, light: LightData => LightData });
|
|
packet!(Login {
|
|
player_id: i32 => Int,
|
|
hardcore: bool => Bool,
|
|
levels: Vec<String> => List<Ident>,
|
|
max_players: i32 => VarInt,
|
|
chunk_radius: i32 => VarInt,
|
|
simulation_distance: i32 => VarInt,
|
|
reduced_debug_info: bool => Bool,
|
|
show_death_screen: bool => Bool,
|
|
limited_crafting: bool => Bool,
|
|
spawn: SpawnInfo => SpawnInfo,
|
|
online_mode: bool => Bool,
|
|
enforces_secure_chat: bool => Bool,
|
|
});
|
|
/// VecDelta: per-axis deltas in 1/4096 blocks, linear or in timed steps.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum VecDelta {
|
|
Linear([i16; 3]),
|
|
Stepped(Vec<([i16; 3], i32)>),
|
|
}
|
|
impl VecDelta {
|
|
/// VecDeltaCodec.decode against a base position: zero deltas keep the
|
|
/// base coordinate exactly, others add to its 1/4096 quantization.
|
|
pub fn apply(base: [f64; 3], delta: [i16; 3]) -> [f64; 3] {
|
|
let mut out = base;
|
|
for i in 0..3 {
|
|
if delta[i] != 0 {
|
|
out[i] = ((base[i] * 4096.0).round() as i64 + i64::from(delta[i])) as f64 / 4096.0;
|
|
}
|
|
}
|
|
out
|
|
}
|
|
/// The final position after all steps.
|
|
pub fn end(&self, base: [f64; 3]) -> [f64; 3] {
|
|
match self {
|
|
Self::Linear(d) => Self::apply(base, *d),
|
|
Self::Stepped(steps) => steps.iter().fold(base, |p, (d, _)| Self::apply(p, *d)),
|
|
}
|
|
}
|
|
fn read(r: &mut Reader, steps: usize) -> Result<Self> {
|
|
if steps == 0 {
|
|
return Ok(Self::Linear([r.i16()?, r.i16()?, r.i16()?]));
|
|
}
|
|
if steps > r.remaining() / 7 {
|
|
return Err(Error::new("VecDelta with too many steps"));
|
|
}
|
|
Ok(Self::Stepped(
|
|
(0..steps)
|
|
.map(|_| {
|
|
let ticks = r.varint()?;
|
|
Ok(([r.i16()?, r.i16()?, r.i16()?], ticks))
|
|
})
|
|
.collect::<Result<_>>()?,
|
|
))
|
|
}
|
|
fn steps(&self) -> usize {
|
|
match self {
|
|
Self::Linear(_) => 0,
|
|
Self::Stepped(s) => s.len(),
|
|
}
|
|
}
|
|
fn write(&self, w: &mut Writer) {
|
|
match self {
|
|
Self::Linear(d) => d.iter().for_each(|v| w.i16(*v)),
|
|
Self::Stepped(steps) => {
|
|
for (d, ticks) in steps {
|
|
w.varint(*ticks);
|
|
d.iter().for_each(|v| w.i16(*v));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|
|
/// ClientboundMoveEntityPacket.Pos / PosRot / Rot.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct MoveEntity {
|
|
pub id: i32,
|
|
pub delta: Option<VecDelta>,
|
|
pub rotation: Option<(i8, i8)>,
|
|
pub on_ground: bool,
|
|
}
|
|
macro_rules! move_entity {
|
|
($name:ident, pos: $pos:expr, rot: $rot:expr) => {
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct $name(pub MoveEntity);
|
|
impl Codec<$name> for $name {
|
|
fn read(r: &mut Reader) -> Result<$name> {
|
|
Self::read_inner(r).map($name)
|
|
}
|
|
fn write(v: &$name, w: &mut Writer) {
|
|
Self::write_inner(&v.0, w)
|
|
}
|
|
}
|
|
impl $name {
|
|
fn read_inner(r: &mut Reader) -> Result<MoveEntity> {
|
|
let id = r.varint()?;
|
|
if !$pos {
|
|
let on_ground = r.bool()?;
|
|
let rotation = Some((r.i8()?, r.i8()?));
|
|
return Ok(MoveEntity {
|
|
id,
|
|
delta: None,
|
|
rotation,
|
|
on_ground,
|
|
});
|
|
}
|
|
let properties = r.varint()?;
|
|
let delta = Some(VecDelta::read(r, (properties as u32 >> 1) as usize)?);
|
|
let rotation = if $rot { Some((r.i8()?, r.i8()?)) } else { None };
|
|
Ok(MoveEntity {
|
|
id,
|
|
delta,
|
|
rotation,
|
|
on_ground: properties & 1 != 0,
|
|
})
|
|
}
|
|
fn write_inner(v: &MoveEntity, w: &mut Writer) {
|
|
w.varint(v.id);
|
|
if !$pos {
|
|
w.bool(v.on_ground);
|
|
} else {
|
|
let delta = v.delta.clone().unwrap_or(VecDelta::Linear([0; 3]));
|
|
w.varint(i32::from(v.on_ground) | (delta.steps() as i32) << 1);
|
|
delta.write(w);
|
|
}
|
|
if let Some((y, x)) = v.rotation.filter(|_| $rot) {
|
|
w.i8(y);
|
|
w.i8(x);
|
|
}
|
|
}
|
|
}
|
|
};
|
|
}
|
|
move_entity!(MoveEntityPos, pos: true, rot: false);
|
|
move_entity!(MoveEntityPosRot, pos: true, rot: true);
|
|
move_entity!(MoveEntityRot, pos: false, rot: true);
|
|
packet!(OpenScreen { container: i32 => VarInt, menu: i32 => VarInt, title: Tag => Nbt });
|
|
packet!(PlayerAbilities { flags: i8 => Byte, flying_speed: f32 => Float, walking_speed: f32 => Float });
|
|
/// MessageSignature.Packed: an index into the last-seen cache or a full signature.
|
|
pub struct PackedSignature;
|
|
impl Codec<(i32, Option<Vec<u8>>)> for PackedSignature {
|
|
fn read(r: &mut Reader) -> Result<(i32, Option<Vec<u8>>)> {
|
|
let id = r.varint()? - 1;
|
|
Ok(if id == -1 {
|
|
(-1, Some(r.bytes(256)?.to_vec()))
|
|
} else {
|
|
(id, None)
|
|
})
|
|
}
|
|
fn write(v: &(i32, Option<Vec<u8>>), w: &mut Writer) {
|
|
w.varint(v.0 + 1);
|
|
if let Some(sig) = &v.1 {
|
|
w.bytes(sig);
|
|
}
|
|
}
|
|
}
|
|
/// MessageSignature: 256 raw bytes.
|
|
pub struct Signature;
|
|
impl Codec<Vec<u8>> for Signature {
|
|
fn read(r: &mut Reader) -> Result<Vec<u8>> {
|
|
Ok(r.bytes(256)?.to_vec())
|
|
}
|
|
fn write(v: &Vec<u8>, w: &mut Writer) {
|
|
w.bytes(v)
|
|
}
|
|
}
|
|
/// FilterMask: 0 pass-through, 1 fully filtered, 2 partially (with a BitSet).
|
|
pub struct FilterMask;
|
|
impl Codec<(i32, Vec<i64>)> for FilterMask {
|
|
fn read(r: &mut Reader) -> Result<(i32, Vec<i64>)> {
|
|
let kind = r.varint()?;
|
|
Ok((
|
|
kind,
|
|
if kind == 2 {
|
|
r.long_array()?
|
|
} else {
|
|
Vec::new()
|
|
},
|
|
))
|
|
}
|
|
fn write(v: &(i32, Vec<i64>), w: &mut Writer) {
|
|
w.varint(v.0);
|
|
if v.0 == 2 {
|
|
w.long_array(&v.1);
|
|
}
|
|
}
|
|
}
|
|
packet!(PlayerChat {
|
|
global_index: i32 => VarInt,
|
|
sender: u128 => Uuid,
|
|
index: i32 => VarInt,
|
|
signature: Option<Vec<u8>> => Opt<Signature>,
|
|
content: String => StrN<256>,
|
|
timestamp: i64 => Long,
|
|
salt: i64 => Long,
|
|
last_seen: Vec<(i32, Option<Vec<u8>>)> => List<PackedSignature>,
|
|
unsigned_content: Option<Tag> => Opt<Nbt>,
|
|
filter: (i32, Vec<i64>) => FilterMask,
|
|
chat_type: ChatTypeBound => ChatTypeBound,
|
|
});
|
|
packet!(PlayerCombatKill { id: i32 => VarInt, message: Tag => Nbt });
|
|
packet!(PlayerInfoRemove { uuids: Vec<u128> => List<Uuid> });
|
|
/// One ClientboundPlayerInfoUpdatePacket entry; fields are set for the
|
|
/// actions in the packet.
|
|
#[derive(Clone, Debug, Default, PartialEq)]
|
|
pub struct PlayerInfo {
|
|
pub uuid: u128,
|
|
pub name: Option<String>,
|
|
pub properties: Vec<Property>,
|
|
/// RemoteChatSession.Data: session id, key expiry, key, key signature.
|
|
pub chat_session: Option<(u128, i64, Vec<u8>, Vec<u8>)>,
|
|
pub game_mode: Option<i32>,
|
|
pub listed: Option<bool>,
|
|
pub latency: Option<i32>,
|
|
pub display_name: Option<Option<Tag>>,
|
|
pub list_order: Option<i32>,
|
|
pub show_hat: Option<bool>,
|
|
}
|
|
/// Actions bits: ADD_PLAYER, INITIALIZE_CHAT, UPDATE_GAME_MODE, UPDATE_LISTED,
|
|
/// UPDATE_LATENCY, UPDATE_DISPLAY_NAME, UPDATE_LIST_ORDER, UPDATE_HAT.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct PlayerInfoUpdate {
|
|
pub actions: u8,
|
|
pub entries: Vec<PlayerInfo>,
|
|
}
|
|
impl Codec<PlayerInfoUpdate> for PlayerInfoUpdate {
|
|
fn read(r: &mut Reader) -> Result<Self> {
|
|
let actions = r.u8()?;
|
|
let n = r.count(r.remaining())?;
|
|
let mut entries = Vec::with_capacity(n.min(256));
|
|
for _ in 0..n {
|
|
let mut e = PlayerInfo {
|
|
uuid: r.uuid()?,
|
|
..PlayerInfo::default()
|
|
};
|
|
if actions & 1 != 0 {
|
|
e.name = Some(r.string(16)?);
|
|
let count = r.count(16)?;
|
|
e.properties = (0..count)
|
|
.map(|_| Property::read(r))
|
|
.collect::<Result<_>>()?;
|
|
}
|
|
if actions & 2 != 0 && r.bool()? {
|
|
e.chat_session =
|
|
Some((r.uuid()?, r.i64()?, r.byte_array(512)?, r.byte_array(4096)?));
|
|
}
|
|
if actions & 4 != 0 {
|
|
e.game_mode = Some(r.varint()?);
|
|
}
|
|
if actions & 8 != 0 {
|
|
e.listed = Some(r.bool()?);
|
|
}
|
|
if actions & 16 != 0 {
|
|
e.latency = Some(r.varint()?);
|
|
}
|
|
if actions & 32 != 0 {
|
|
e.display_name = Some(if r.bool()? { Some(r.nbt()?) } else { None });
|
|
}
|
|
if actions & 64 != 0 {
|
|
e.list_order = Some(r.varint()?);
|
|
}
|
|
if actions & 128 != 0 {
|
|
e.show_hat = Some(r.bool()?);
|
|
}
|
|
entries.push(e);
|
|
}
|
|
Ok(Self { actions, entries })
|
|
}
|
|
fn write(v: &Self, w: &mut Writer) {
|
|
w.u8(v.actions);
|
|
w.varint(v.entries.len() as i32);
|
|
for e in &v.entries {
|
|
w.uuid(e.uuid);
|
|
if v.actions & 1 != 0 {
|
|
w.string(e.name.as_deref().unwrap_or(""));
|
|
w.varint(e.properties.len() as i32);
|
|
e.properties.iter().for_each(|p| Property::write(p, w));
|
|
}
|
|
if v.actions & 2 != 0 {
|
|
w.bool(e.chat_session.is_some());
|
|
if let Some((id, expires, key, sig)) = &e.chat_session {
|
|
w.uuid(*id);
|
|
w.i64(*expires);
|
|
w.byte_array(key);
|
|
w.byte_array(sig);
|
|
}
|
|
}
|
|
if v.actions & 4 != 0 {
|
|
w.varint(e.game_mode.unwrap_or(0));
|
|
}
|
|
if v.actions & 8 != 0 {
|
|
w.bool(e.listed.unwrap_or(false));
|
|
}
|
|
if v.actions & 16 != 0 {
|
|
w.varint(e.latency.unwrap_or(0));
|
|
}
|
|
if v.actions & 32 != 0 {
|
|
let name = e.display_name.clone().flatten();
|
|
w.bool(name.is_some());
|
|
if let Some(t) = &name {
|
|
w.nbt(t);
|
|
}
|
|
}
|
|
if v.actions & 64 != 0 {
|
|
w.varint(e.list_order.unwrap_or(0));
|
|
}
|
|
if v.actions & 128 != 0 {
|
|
w.bool(e.show_hat.unwrap_or(false));
|
|
}
|
|
}
|
|
}
|
|
}
|
|
packet!(PlayerPosition {
|
|
teleport: i32 => VarInt,
|
|
position: [f64; 3] => Vec3d,
|
|
delta: [f64; 3] => Vec3d,
|
|
yaw: f32 => Float,
|
|
pitch: f32 => Float,
|
|
relatives: i32 => Int,
|
|
});
|
|
packet!(PlayerRotation { yaw: f32 => Float, relative_yaw: bool => Bool, pitch: f32 => Float, relative_pitch: bool => Bool });
|
|
packet!(RemoveEntities { ids: Vec<i32> => List<VarInt> });
|
|
packet!(Respawn { spawn: SpawnInfo => SpawnInfo, keep: i8 => Byte });
|
|
packet!(RotateHead { id: i32 => VarInt, head_yaw: i8 => Byte });
|
|
packet!(
|
|
/// Each change is `state << 12 | x << 8 | z << 4 | y` within the section.
|
|
SectionBlocksUpdate { section: [i32; 3] => SectionPos, changes: Vec<i64> => List<VarLong> }
|
|
);
|
|
packet!(Text { text: Tag => Nbt });
|
|
packet!(SetChunkCacheCenter { x: i32 => VarInt, z: i32 => VarInt });
|
|
packet!(
|
|
/// ClientboundTickingStatePacket: the tick rate and whether the level is frozen.
|
|
TickingState { rate: f32 => Float, frozen: bool => Bool }
|
|
);
|
|
packet!(
|
|
/// ClientboundTickingStepPacket: the ticks a frozen level runs (`/tick step`).
|
|
TickingStep { steps: i32 => VarInt }
|
|
);
|
|
packet!(Distance { distance: i32 => VarInt });
|
|
packet!(SetCursorItem { item: Option<Stack> => Slot });
|
|
packet!(SetDefaultSpawnPosition { pos: GlobalPos => GlobalPos, yaw: f32 => Float, pitch: f32 => Float });
|
|
packet!(SetEntityData { id: i32 => VarInt, values: Vec<(u8, i32, Value)> => EntityData });
|
|
packet!(SetEntityMotion { id: i32 => VarInt, velocity: [f64; 3] => LpVec3 });
|
|
/// ClientboundSetEquipmentPacket: (EquipmentSlot ordinal, stack) pairs.
|
|
pub struct Equipment;
|
|
impl Codec<Vec<(u8, Option<Stack>)>> for Equipment {
|
|
fn read(r: &mut Reader) -> Result<Vec<(u8, Option<Stack>)>> {
|
|
let mut out = Vec::new();
|
|
loop {
|
|
let slot = r.u8()?;
|
|
out.push((slot & 127, Slot::read(r)?));
|
|
if slot & 128 == 0 {
|
|
return Ok(out);
|
|
}
|
|
}
|
|
}
|
|
fn write(v: &Vec<(u8, Option<Stack>)>, w: &mut Writer) {
|
|
for (i, (slot, stack)) in v.iter().enumerate() {
|
|
w.u8(if i + 1 < v.len() { slot | 128 } else { *slot });
|
|
Slot::write(stack, w);
|
|
}
|
|
}
|
|
}
|
|
packet!(SetEquipment { id: i32 => VarInt, slots: Vec<(u8, Option<Stack>)> => Equipment });
|
|
packet!(SetExperience { progress: f32 => Float, level: i32 => VarInt, total: i32 => VarInt });
|
|
packet!(SetHealth { health: f32 => Float, food: i32 => VarInt, saturation: f32 => Float });
|
|
packet!(SetHeldSlot { slot: i32 => VarInt });
|
|
packet!(SetPlayerInventory { slot: i32 => VarInt, item: Option<Stack> => Slot });
|
|
packet!(
|
|
/// ClockNetworkState for one world clock (registry id).
|
|
ClockState { clock: i32 => VarInt, total_ticks: i64 => VarLong, partial_tick: f32 => Float, rate: f32 => Float }
|
|
);
|
|
packet!(SetTime { game_time: i64 => Long, clocks: Vec<ClockState> => List<ClockState> });
|
|
packet!(TitlesAnimation { fade_in: i32 => Int, stay: i32 => Int, fade_out: i32 => Int });
|
|
/// SoundEvent holder: a registry id, or an inline location with optional range.
|
|
pub struct SoundHolder;
|
|
impl Codec<(i32, Option<(String, Option<f32>)>)> for SoundHolder {
|
|
fn read(r: &mut Reader) -> Result<(i32, Option<(String, Option<f32>)>)> {
|
|
let id = r.varint()?;
|
|
if id != 0 {
|
|
return Ok((id - 1, None));
|
|
}
|
|
let location = r.string(32767)?;
|
|
let range = if r.bool()? { Some(r.f32()?) } else { None };
|
|
Ok((-1, Some((location, range))))
|
|
}
|
|
fn write(v: &(i32, Option<(String, Option<f32>)>), w: &mut Writer) {
|
|
match &v.1 {
|
|
None => w.varint(v.0 + 1),
|
|
Some((location, range)) => {
|
|
w.varint(0);
|
|
w.string(location);
|
|
<Opt<Float> as Codec<Option<f32>>>::write(range, w);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
packet!(Sound {
|
|
sound: (i32, Option<(String, Option<f32>)>) => SoundHolder,
|
|
source: i32 => VarInt,
|
|
x: i32 => Int,
|
|
y: i32 => Int,
|
|
z: i32 => Int,
|
|
volume: f32 => Float,
|
|
pitch: f32 => Float,
|
|
seed: i64 => Long,
|
|
});
|
|
packet!(SystemChat { content: Tag => Nbt, overlay: bool => Bool });
|
|
packet!(TakeItemEntity { item: i32 => VarInt, player: i32 => VarInt, amount: i32 => VarInt });
|
|
packet!(TeleportEntity {
|
|
id: i32 => VarInt,
|
|
position: [f64; 3] => Vec3d,
|
|
delta: [f64; 3] => Vec3d,
|
|
yaw: f32 => Float,
|
|
pitch: f32 => Float,
|
|
relatives: i32 => Int,
|
|
on_ground: bool => Bool,
|
|
});
|
|
|
|
packet!(BlockEvent { pos: [i32; 3] => Pos, b0: u8 => UByte, b1: u8 => UByte, block: i32 => VarInt });
|
|
packet!(
|
|
/// ClientboundInitializeBorderPacket.
|
|
InitializeBorder {
|
|
center_x: f64 => Double,
|
|
center_z: f64 => Double,
|
|
old_size: f64 => Double,
|
|
new_size: f64 => Double,
|
|
lerp_time: i64 => VarLong,
|
|
absolute_max_size: i32 => VarInt,
|
|
warning_blocks: i32 => VarInt,
|
|
warning_time: i32 => VarInt,
|
|
}
|
|
);
|
|
packet!(TabList { header: Tag => Nbt, footer: Tag => Nbt });
|
|
packet!(
|
|
/// ClientboundSetBorderCenterPacket.
|
|
SetBorderCenter { x: f64 => Double, z: f64 => Double }
|
|
);
|
|
packet!(
|
|
/// ClientboundSetBorderLerpSizePacket.
|
|
SetBorderLerpSize { old_size: f64 => Double, new_size: f64 => Double, lerp_time: i64 => VarLong }
|
|
);
|
|
packet!(
|
|
/// ClientboundSetBorderSizePacket.
|
|
SetBorderSize { size: f64 => Double }
|
|
);
|
|
packet!(
|
|
/// ClientboundSetBorderWarningDelayPacket (ticks).
|
|
SetBorderWarningDelay { delay: i32 => VarInt }
|
|
);
|
|
packet!(
|
|
/// ClientboundSetBorderWarningDistancePacket.
|
|
SetBorderWarningDistance { blocks: i32 => VarInt }
|
|
);
|
|
packet!(
|
|
/// ClientboundSetDisplayObjectivePacket: `DisplaySlot` id (0 list,
|
|
/// 1 sidebar, 2 below name, 3.. team sidebars) and the objective ("" clears).
|
|
SetDisplayObjective { slot: i32 => VarInt, objective: String => Str }
|
|
);
|
|
packet!(
|
|
/// ClientboundResetScorePacket: one objective, or all of them when absent.
|
|
ResetScore { owner: String => Str, objective: Option<String> => Opt<Str> }
|
|
);
|
|
/// `NumberFormatTypes.STREAM_CODEC`, by `number_format_type` registry id.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum NumberFormat {
|
|
/// 0: `minecraft:blank`.
|
|
Blank,
|
|
/// 1: `minecraft:styled`, a style compound.
|
|
Styled(Tag),
|
|
/// 2: `minecraft:fixed`, a component.
|
|
Fixed(Tag),
|
|
}
|
|
impl Codec<NumberFormat> for NumberFormat {
|
|
fn read(r: &mut Reader) -> Result<Self> {
|
|
Ok(match r.varint()? {
|
|
0 => NumberFormat::Blank,
|
|
1 => NumberFormat::Styled(r.nbt()?),
|
|
2 => NumberFormat::Fixed(r.nbt()?),
|
|
other => return Err(crate::Error::new(format!("unknown number format {other}"))),
|
|
})
|
|
}
|
|
fn write(v: &Self, w: &mut Writer) {
|
|
match v {
|
|
NumberFormat::Blank => w.varint(0),
|
|
NumberFormat::Styled(t) => {
|
|
w.varint(1);
|
|
w.nbt(t);
|
|
}
|
|
NumberFormat::Fixed(t) => {
|
|
w.varint(2);
|
|
w.nbt(t);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
packet!(
|
|
/// ClientboundSetScorePacket.
|
|
SetScore {
|
|
owner: String => Str,
|
|
objective: String => Str,
|
|
score: i32 => VarInt,
|
|
display: Option<Tag> => Opt<Nbt>,
|
|
number_format: Option<NumberFormat> => Opt<NumberFormat>,
|
|
}
|
|
);
|
|
/// ClientboundSetObjectivePacket: method 0 adds, 1 removes, 2 changes;
|
|
/// adds and changes carry the display name, render type (0 integer,
|
|
/// 1 hearts) and number format.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct SetObjective {
|
|
pub name: String,
|
|
pub method: i8,
|
|
pub display: Option<(Tag, i32, Option<NumberFormat>)>,
|
|
}
|
|
impl Codec<SetObjective> for SetObjective {
|
|
fn read(r: &mut Reader) -> Result<Self> {
|
|
let name = r.string(32767)?;
|
|
let method = r.i8()?;
|
|
let display = if method == 0 || method == 2 {
|
|
Some((r.nbt()?, r.varint()?, <Opt<NumberFormat>>::read(r)?))
|
|
} else {
|
|
None
|
|
};
|
|
Ok(Self {
|
|
name,
|
|
method,
|
|
display,
|
|
})
|
|
}
|
|
fn write(v: &Self, w: &mut Writer) {
|
|
w.string(&v.name);
|
|
w.i8(v.method);
|
|
if v.method == 0 || v.method == 2 {
|
|
let (name, render, format) = v.display.clone().unwrap_or((Tag::End, 0, None));
|
|
w.nbt(&name);
|
|
w.varint(render);
|
|
<Opt<NumberFormat>>::write(&format, w);
|
|
}
|
|
}
|
|
}
|
|
/// `ClientboundSetPlayerTeamPacket.Parameters`.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct TeamParameters {
|
|
pub display_name: Tag,
|
|
pub prefix: Tag,
|
|
pub suffix: Tag,
|
|
/// `Team.Visibility` id.
|
|
pub name_tag_visibility: i32,
|
|
/// `Team.CollisionRule` id.
|
|
pub collision_rule: i32,
|
|
/// `TeamColor` id (0 black .. 15 white), absent for no colour.
|
|
pub color: Option<i32>,
|
|
/// 1: friendly fire, 2: see friendly invisibles.
|
|
pub options: i8,
|
|
}
|
|
/// ClientboundSetPlayerTeamPacket: method 0 adds (parameters and players),
|
|
/// 1 removes, 2 changes (parameters), 3 joins and 4 leaves (players).
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct SetPlayerTeam {
|
|
pub name: String,
|
|
pub method: i8,
|
|
pub parameters: Option<TeamParameters>,
|
|
pub players: Vec<String>,
|
|
}
|
|
impl Codec<SetPlayerTeam> for SetPlayerTeam {
|
|
fn read(r: &mut Reader) -> Result<Self> {
|
|
let name = r.string(32767)?;
|
|
let method = r.i8()?;
|
|
let parameters = if method == 0 || method == 2 {
|
|
Some(TeamParameters {
|
|
display_name: r.nbt()?,
|
|
prefix: r.nbt()?,
|
|
suffix: r.nbt()?,
|
|
name_tag_visibility: r.varint()?,
|
|
collision_rule: r.varint()?,
|
|
color: <Opt<VarInt>>::read(r)?,
|
|
options: r.i8()?,
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
let players = if matches!(method, 0 | 3 | 4) {
|
|
<List<Str>>::read(r)?
|
|
} else {
|
|
Vec::new()
|
|
};
|
|
Ok(Self {
|
|
name,
|
|
method,
|
|
parameters,
|
|
players,
|
|
})
|
|
}
|
|
fn write(v: &Self, w: &mut Writer) {
|
|
w.string(&v.name);
|
|
w.i8(v.method);
|
|
if v.method == 0 || v.method == 2 {
|
|
let p = v.parameters.clone().unwrap_or(TeamParameters {
|
|
display_name: Tag::End,
|
|
prefix: Tag::End,
|
|
suffix: Tag::End,
|
|
name_tag_visibility: 0,
|
|
collision_rule: 0,
|
|
color: None,
|
|
options: 0,
|
|
});
|
|
w.nbt(&p.display_name);
|
|
w.nbt(&p.prefix);
|
|
w.nbt(&p.suffix);
|
|
w.varint(p.name_tag_visibility);
|
|
w.varint(p.collision_rule);
|
|
<Opt<VarInt>>::write(&p.color, w);
|
|
w.i8(p.options);
|
|
}
|
|
if matches!(v.method, 0 | 3 | 4) {
|
|
<List<Str>>::write(&v.players, w);
|
|
}
|
|
}
|
|
}
|
|
packet!(ServerData { motd: Tag => Nbt, icon: Option<Vec<u8>> => Opt<crate::buf::Bytes> });
|
|
packet!(
|
|
/// ClientboundUpdateMobEffectPacket; flags: 1 ambient, 2 visible, 4 icon, 8 blend.
|
|
UpdateMobEffect { id: i32 => VarInt, effect: i32 => VarInt, amplifier: i32 => VarInt, duration: i32 => VarInt, flags: i8 => Byte }
|
|
);
|
|
packet!(RemoveMobEffect { id: i32 => VarInt, effect: i32 => VarInt });
|
|
packet!(
|
|
/// ClientboundSwingAnimationPacket: hand (0 main, 1 off) and the swing
|
|
/// type (0 none, 1 whack, 2 stab) with its duration in ticks.
|
|
SwingAnimation { id: i32 => VarInt, hand: i32 => VarInt, kind: i32 => VarInt, duration: i32 => VarInt }
|
|
);
|
|
packet!(SoundEntity {
|
|
sound: (i32, Option<(String, Option<f32>)>) => SoundHolder,
|
|
source: i32 => VarInt,
|
|
id: i32 => VarInt,
|
|
volume: f32 => Float,
|
|
pitch: f32 => Float,
|
|
seed: i64 => Long,
|
|
});
|
|
/// One entry of ClientboundCommandsPacket: a literal or an argument node.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct CommandNode {
|
|
/// 0 root, 1 literal, 2 argument.
|
|
pub kind: u8,
|
|
pub executable: bool,
|
|
pub restricted: bool,
|
|
pub children: Vec<i32>,
|
|
pub redirect: Option<i32>,
|
|
pub name: String,
|
|
/// Argument parser registry id and its raw property bytes.
|
|
pub parser: Option<(i32, Vec<u8>)>,
|
|
/// Custom suggestion provider (`minecraft:ask_server`).
|
|
pub suggestions: Option<String>,
|
|
}
|
|
/// The command tree: nodes and the index of the root.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct Commands {
|
|
pub nodes: Vec<CommandNode>,
|
|
pub root: i32,
|
|
}
|
|
impl Codec<Commands> for Commands {
|
|
fn read(r: &mut Reader) -> Result<Self> {
|
|
let n = r.count(r.remaining())?;
|
|
let mut nodes = Vec::with_capacity(n.min(4096));
|
|
for _ in 0..n {
|
|
let flags = r.u8()?;
|
|
let count = r.count(r.remaining())?;
|
|
let children = (0..count).map(|_| r.varint()).collect::<Result<_>>()?;
|
|
let redirect = if flags & 8 != 0 {
|
|
Some(r.varint()?)
|
|
} else {
|
|
None
|
|
};
|
|
let kind = flags & 3;
|
|
let (mut name, mut parser, mut suggestions) = (String::new(), None, None);
|
|
if kind >= 1 {
|
|
name = r.string(32767)?;
|
|
}
|
|
if kind == 2 {
|
|
// Properties are parser specific; only the property-less parsers
|
|
// can be skipped without a table, so keep the rest of the packet.
|
|
return Err(crate::Error::new("argument nodes are not decoded"));
|
|
}
|
|
let _ = (&mut parser, &mut suggestions);
|
|
nodes.push(CommandNode {
|
|
kind,
|
|
executable: flags & 4 != 0,
|
|
restricted: flags & 32 != 0,
|
|
children,
|
|
redirect,
|
|
name,
|
|
parser,
|
|
suggestions,
|
|
});
|
|
}
|
|
Ok(Self {
|
|
nodes,
|
|
root: r.varint()?,
|
|
})
|
|
}
|
|
fn write(v: &Self, w: &mut Writer) {
|
|
w.varint(v.nodes.len() as i32);
|
|
for n in &v.nodes {
|
|
let mut flags = n.kind & 3;
|
|
if n.executable {
|
|
flags |= 4;
|
|
}
|
|
if n.redirect.is_some() {
|
|
flags |= 8;
|
|
}
|
|
if n.suggestions.is_some() {
|
|
flags |= 16;
|
|
}
|
|
if n.restricted {
|
|
flags |= 32;
|
|
}
|
|
w.u8(flags);
|
|
w.varint(n.children.len() as i32);
|
|
n.children.iter().for_each(|c| w.varint(*c));
|
|
if let Some(r) = n.redirect {
|
|
w.varint(r);
|
|
}
|
|
if n.kind >= 1 {
|
|
w.string(&n.name);
|
|
}
|
|
if n.kind == 2 {
|
|
let (id, props) = n.parser.clone().unwrap_or((5, Vec::new()));
|
|
w.varint(id);
|
|
w.bytes(&props);
|
|
if let Some(s) = &n.suggestions {
|
|
w.string(s);
|
|
}
|
|
}
|
|
}
|
|
w.varint(v.root);
|
|
}
|
|
}
|
|
|
|
/// `DisplayInfo` of an advancement as sent.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct AdvancementDisplay {
|
|
pub title: Tag,
|
|
pub description: Tag,
|
|
pub icon: crate::item::Stack,
|
|
/// `AdvancementType` ordinal: task, challenge, goal.
|
|
pub frame: i32,
|
|
pub show_toast: bool,
|
|
pub hidden: bool,
|
|
pub background: Option<String>,
|
|
}
|
|
/// `ClientboundUpdateAdvancementsPacket.PositionedAdvancement`.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct Advancement {
|
|
pub id: String,
|
|
pub parent: Option<String>,
|
|
pub display: Option<AdvancementDisplay>,
|
|
pub requirements: Vec<Vec<String>>,
|
|
pub telemetry: bool,
|
|
pub x: f32,
|
|
pub y: f32,
|
|
}
|
|
/// `ClientboundUpdateAdvancementsPacket`: whether it replaces what the
|
|
/// client has, the advancements added and removed, the progress of each
|
|
/// changed one (criterion, when obtained in epoch milliseconds), and whether
|
|
/// to show toasts.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct UpdateAdvancements {
|
|
pub reset: bool,
|
|
pub added: Vec<Advancement>,
|
|
pub removed: Vec<String>,
|
|
pub progress: Vec<(String, Vec<(String, Option<i64>)>)>,
|
|
pub show: bool,
|
|
}
|
|
impl Codec<UpdateAdvancements> for UpdateAdvancements {
|
|
fn read(r: &mut Reader) -> Result<Self> {
|
|
let reset = r.bool()?;
|
|
let n = r.count(r.remaining())?;
|
|
let mut added = Vec::with_capacity(n.min(1024));
|
|
for _ in 0..n {
|
|
let id = r.string(32767)?;
|
|
let parent = if r.bool()? {
|
|
Some(r.string(32767)?)
|
|
} else {
|
|
None
|
|
};
|
|
let display = if r.bool()? {
|
|
let title = r.nbt()?;
|
|
let description = r.nbt()?;
|
|
let icon = crate::item::Template::read(r)?;
|
|
let frame = r.varint()?;
|
|
let flags = r.i32()?;
|
|
let background = if flags & 1 != 0 {
|
|
Some(r.string(32767)?)
|
|
} else {
|
|
None
|
|
};
|
|
Some(AdvancementDisplay {
|
|
title,
|
|
description,
|
|
icon,
|
|
frame,
|
|
show_toast: flags & 2 != 0,
|
|
hidden: flags & 4 != 0,
|
|
background,
|
|
})
|
|
} else {
|
|
None
|
|
};
|
|
let groups = r.count(r.remaining())?;
|
|
let mut requirements = Vec::with_capacity(groups.min(256));
|
|
for _ in 0..groups {
|
|
let k = r.count(r.remaining())?;
|
|
requirements.push((0..k).map(|_| r.string(32767)).collect::<Result<_>>()?);
|
|
}
|
|
let telemetry = r.bool()?;
|
|
let (x, y) = (r.f32()?, r.f32()?);
|
|
added.push(Advancement {
|
|
id,
|
|
parent,
|
|
display,
|
|
requirements,
|
|
telemetry,
|
|
x,
|
|
y,
|
|
});
|
|
}
|
|
let n = r.count(r.remaining())?;
|
|
let removed = (0..n).map(|_| r.string(32767)).collect::<Result<_>>()?;
|
|
let n = r.count(r.remaining())?;
|
|
let mut progress = Vec::with_capacity(n.min(1024));
|
|
for _ in 0..n {
|
|
let id = r.string(32767)?;
|
|
let k = r.count(r.remaining())?;
|
|
let mut criteria = Vec::with_capacity(k.min(256));
|
|
for _ in 0..k {
|
|
let name = r.string(32767)?;
|
|
let at = if r.bool()? { Some(r.i64()?) } else { None };
|
|
criteria.push((name, at));
|
|
}
|
|
progress.push((id, criteria));
|
|
}
|
|
let show = r.bool()?;
|
|
Ok(Self {
|
|
reset,
|
|
added,
|
|
removed,
|
|
progress,
|
|
show,
|
|
})
|
|
}
|
|
fn write(v: &Self, w: &mut Writer) {
|
|
w.bool(v.reset);
|
|
w.varint(v.added.len() as i32);
|
|
for a in &v.added {
|
|
w.string(&a.id);
|
|
w.bool(a.parent.is_some());
|
|
if let Some(p) = &a.parent {
|
|
w.string(p);
|
|
}
|
|
w.bool(a.display.is_some());
|
|
if let Some(d) = &a.display {
|
|
w.nbt(&d.title);
|
|
w.nbt(&d.description);
|
|
crate::item::Template::write(&d.icon, w);
|
|
w.varint(d.frame);
|
|
w.i32(
|
|
i32::from(d.background.is_some())
|
|
| i32::from(d.show_toast) << 1
|
|
| i32::from(d.hidden) << 2,
|
|
);
|
|
if let Some(b) = &d.background {
|
|
w.string(b);
|
|
}
|
|
}
|
|
w.varint(a.requirements.len() as i32);
|
|
for g in &a.requirements {
|
|
w.varint(g.len() as i32);
|
|
for c in g {
|
|
w.string(c);
|
|
}
|
|
}
|
|
w.bool(a.telemetry);
|
|
w.f32(a.x);
|
|
w.f32(a.y);
|
|
}
|
|
w.varint(v.removed.len() as i32);
|
|
for id in &v.removed {
|
|
w.string(id);
|
|
}
|
|
w.varint(v.progress.len() as i32);
|
|
for (id, criteria) in &v.progress {
|
|
w.string(id);
|
|
w.varint(criteria.len() as i32);
|
|
for (name, at) in criteria {
|
|
w.string(name);
|
|
w.bool(at.is_some());
|
|
if let Some(at) = at {
|
|
w.i64(*at);
|
|
}
|
|
}
|
|
}
|
|
w.bool(v.show);
|
|
}
|
|
}
|
|
packet!(
|
|
/// ClientboundAwardStatsPacket: (stat type, value, count) by network id.
|
|
AwardStats { stats: Vec<(i32, i32, i32)> => StatList }
|
|
);
|
|
/// `Object2IntMap<Stat<?>>`: each stat's type and value ids, then its count.
|
|
pub struct StatList;
|
|
impl Codec<Vec<(i32, i32, i32)>> for StatList {
|
|
fn read(r: &mut Reader) -> Result<Vec<(i32, i32, i32)>> {
|
|
let n = r.count(r.remaining())?;
|
|
(0..n)
|
|
.map(|_| Ok((r.varint()?, r.varint()?, r.varint()?)))
|
|
.collect()
|
|
}
|
|
fn write(v: &Vec<(i32, i32, i32)>, w: &mut Writer) {
|
|
w.varint(v.len() as i32);
|
|
for &(a, b, c) in v {
|
|
w.varint(a);
|
|
w.varint(b);
|
|
w.varint(c);
|
|
}
|
|
}
|
|
}
|
|
|
|
packet_enum!(Clientbound, crate::ids::play::clientbound {
|
|
BundleDelimiter(Empty) = BUNDLE_DELIMITER,
|
|
AddEntity(AddEntity) = ADD_ENTITY,
|
|
Animate(Animate) = ANIMATE,
|
|
AwardStats(AwardStats) = AWARD_STATS,
|
|
BlockChangedAck(BlockChangedAck) = BLOCK_CHANGED_ACK,
|
|
BlockDestruction(BlockDestruction) = BLOCK_DESTRUCTION,
|
|
BlockEntityData(BlockEntityData) = BLOCK_ENTITY_DATA,
|
|
BlockEvent(BlockEvent) = BLOCK_EVENT,
|
|
BlockUpdate(BlockUpdate) = BLOCK_UPDATE,
|
|
ChangeDifficulty(ChangeDifficulty) = CHANGE_DIFFICULTY,
|
|
ChunkBatchFinished(ChunkBatchFinished) = CHUNK_BATCH_FINISHED,
|
|
ChunkBatchStart(Empty) = CHUNK_BATCH_START,
|
|
ClearTitles(Bool1) = CLEAR_TITLES,
|
|
Commands(Commands) = COMMANDS,
|
|
ContainerClose(ContainerClose) = CONTAINER_CLOSE,
|
|
ContainerSetContent(ContainerSetContent) = CONTAINER_SET_CONTENT,
|
|
ContainerSetData(ContainerSetData) = CONTAINER_SET_DATA,
|
|
ContainerSetSlot(ContainerSetSlot) = CONTAINER_SET_SLOT,
|
|
CustomPayload(CustomPayload) = CUSTOM_PAYLOAD,
|
|
Disconnect(Disconnect) = DISCONNECT,
|
|
DisguisedChat(DisguisedChat) = DISGUISED_CHAT,
|
|
EntityEvent(EntityEvent) = ENTITY_EVENT,
|
|
EntityPositionSync(EntityPositionSync) = ENTITY_POSITION_SYNC,
|
|
ForgetLevelChunk(ForgetLevelChunk) = FORGET_LEVEL_CHUNK,
|
|
GameEvent(GameEvent) = GAME_EVENT,
|
|
GameRuleValues(GameRuleValues) = GAME_RULE_VALUES,
|
|
HurtAnimation(HurtAnimation) = HURT_ANIMATION,
|
|
KeepAlive(KeepAlive) = KEEP_ALIVE,
|
|
InitializeBorder(InitializeBorder) = INITIALIZE_BORDER,
|
|
LevelChunkWithLight(LevelChunkWithLight) = LEVEL_CHUNK_WITH_LIGHT,
|
|
LevelEvent(LevelEvent) = LEVEL_EVENT,
|
|
LightUpdate(LightUpdate) = LIGHT_UPDATE,
|
|
Login(Login) = LOGIN,
|
|
MoveEntityPos(MoveEntityPos) = MOVE_ENTITY_POS,
|
|
MoveEntityPosRot(MoveEntityPosRot) = MOVE_ENTITY_POS_ROT,
|
|
MoveEntityRot(MoveEntityRot) = MOVE_ENTITY_ROT,
|
|
MerchantOffers(MerchantOffers) = MERCHANT_OFFERS,
|
|
OpenScreen(OpenScreen) = OPEN_SCREEN,
|
|
Ping(Ping) = PING,
|
|
PongResponse(crate::packets::status::Ping) = PONG_RESPONSE,
|
|
PlayerAbilities(PlayerAbilities) = PLAYER_ABILITIES,
|
|
PlayerChat(PlayerChat) = PLAYER_CHAT,
|
|
PlayerCombatKill(PlayerCombatKill) = PLAYER_COMBAT_KILL,
|
|
PlayerInfoRemove(PlayerInfoRemove) = PLAYER_INFO_REMOVE,
|
|
PlayerInfoUpdate(PlayerInfoUpdate) = PLAYER_INFO_UPDATE,
|
|
PlayerPosition(PlayerPosition) = PLAYER_POSITION,
|
|
PlayerRotation(PlayerRotation) = PLAYER_ROTATION,
|
|
RemoveEntities(RemoveEntities) = REMOVE_ENTITIES,
|
|
RemoveMobEffect(RemoveMobEffect) = REMOVE_MOB_EFFECT,
|
|
ResetScore(ResetScore) = RESET_SCORE,
|
|
ResourcePackPush(ResourcePackPush) = RESOURCE_PACK_PUSH,
|
|
Respawn(Respawn) = RESPAWN,
|
|
RotateHead(RotateHead) = ROTATE_HEAD,
|
|
SectionBlocksUpdate(SectionBlocksUpdate) = SECTION_BLOCKS_UPDATE,
|
|
ServerData(ServerData) = SERVER_DATA,
|
|
SetActionBarText(Text) = SET_ACTION_BAR_TEXT,
|
|
SetBorderCenter(SetBorderCenter) = SET_BORDER_CENTER,
|
|
SetBorderLerpSize(SetBorderLerpSize) = SET_BORDER_LERP_SIZE,
|
|
SetBorderSize(SetBorderSize) = SET_BORDER_SIZE,
|
|
SetBorderWarningDelay(SetBorderWarningDelay) = SET_BORDER_WARNING_DELAY,
|
|
SetBorderWarningDistance(SetBorderWarningDistance) = SET_BORDER_WARNING_DISTANCE,
|
|
SetChunkCacheCenter(SetChunkCacheCenter) = SET_CHUNK_CACHE_CENTER,
|
|
SetChunkCacheRadius(Distance) = SET_CHUNK_CACHE_RADIUS,
|
|
SetCursorItem(SetCursorItem) = SET_CURSOR_ITEM,
|
|
SetDefaultSpawnPosition(SetDefaultSpawnPosition) = SET_DEFAULT_SPAWN_POSITION,
|
|
SetDisplayObjective(SetDisplayObjective) = SET_DISPLAY_OBJECTIVE,
|
|
SetEntityData(SetEntityData) = SET_ENTITY_DATA,
|
|
SetEntityMotion(SetEntityMotion) = SET_ENTITY_MOTION,
|
|
SetEquipment(SetEquipment) = SET_EQUIPMENT,
|
|
SetExperience(SetExperience) = SET_EXPERIENCE,
|
|
SetHealth(SetHealth) = SET_HEALTH,
|
|
SetHeldSlot(SetHeldSlot) = SET_HELD_SLOT,
|
|
SetObjective(SetObjective) = SET_OBJECTIVE,
|
|
SetPlayerInventory(SetPlayerInventory) = SET_PLAYER_INVENTORY,
|
|
SetPlayerTeam(SetPlayerTeam) = SET_PLAYER_TEAM,
|
|
SetScore(SetScore) = SET_SCORE,
|
|
SetSimulationDistance(Distance) = SET_SIMULATION_DISTANCE,
|
|
SetSubtitleText(Text) = SET_SUBTITLE_TEXT,
|
|
SetTime(SetTime) = SET_TIME,
|
|
SetTitleText(Text) = SET_TITLE_TEXT,
|
|
SetTitlesAnimation(TitlesAnimation) = SET_TITLES_ANIMATION,
|
|
Sound(Sound) = SOUND,
|
|
SoundEntity(SoundEntity) = SOUND_ENTITY,
|
|
StartConfiguration(Empty) = START_CONFIGURATION,
|
|
SwingAnimation(SwingAnimation) = SWING_ANIMATION,
|
|
SystemChat(SystemChat) = SYSTEM_CHAT,
|
|
TabList(TabList) = TAB_LIST,
|
|
TakeItemEntity(TakeItemEntity) = TAKE_ITEM_ENTITY,
|
|
TeleportEntity(TeleportEntity) = TELEPORT_ENTITY,
|
|
TickingState(TickingState) = TICKING_STATE,
|
|
TickingStep(TickingStep) = TICKING_STEP,
|
|
UpdateAdvancements(UpdateAdvancements) = UPDATE_ADVANCEMENTS,
|
|
UpdateMobEffect(UpdateMobEffect) = UPDATE_MOB_EFFECT,
|
|
UpdateTags(UpdateTags) = UPDATE_TAGS,
|
|
TrackedWaypoint(TrackedWaypoint) = WAYPOINT,
|
|
});
|
|
packet!(
|
|
/// ClientboundClearTitlesPacket: whether to also reset the timings.
|
|
Bool1 { value: bool => Bool }
|
|
);
|
|
|
|
/// ClientboundTrackedWaypointPacket.Operation, by ordinal.
|
|
pub mod waypoint_operation {
|
|
pub const TRACK: i32 = 0;
|
|
pub const UNTRACK: i32 = 1;
|
|
pub const UPDATE: i32 = 2;
|
|
}
|
|
|
|
/// TrackedWaypoint's identifier: `Either<UUID, String>`.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub enum WaypointId {
|
|
Uuid(u128),
|
|
Name(String),
|
|
}
|
|
|
|
/// What a TrackedWaypoint points at (its `Type` and contents).
|
|
#[derive(Clone, Copy, Debug, PartialEq)]
|
|
pub enum WaypointTarget {
|
|
/// `TrackedWaypoint.empty`: an untracked waypoint.
|
|
Empty,
|
|
/// A block position (`Vec3iWaypoint`).
|
|
Block([i32; 3]),
|
|
/// A chunk (`ChunkWaypoint`).
|
|
Chunk([i32; 2]),
|
|
/// An angle in radians (`AzimuthWaypoint`).
|
|
Azimuth(f32),
|
|
}
|
|
|
|
/// ClientboundTrackedWaypointPacket: the locator bar's waypoints.
|
|
#[derive(Clone, Debug, PartialEq)]
|
|
pub struct TrackedWaypoint {
|
|
/// `waypoint_operation`.
|
|
pub operation: i32,
|
|
pub id: WaypointId,
|
|
/// Waypoint.Icon: the style (a `waypoint_style_asset` key) and an RGB colour.
|
|
pub style: String,
|
|
pub color: Option<i32>,
|
|
pub target: WaypointTarget,
|
|
}
|
|
|
|
impl Codec<TrackedWaypoint> for TrackedWaypoint {
|
|
fn read(r: &mut Reader) -> Result<TrackedWaypoint> {
|
|
let operation = r.varint()?;
|
|
if !(0..=2).contains(&operation) {
|
|
return Err(Error::new(format!("waypoint operation {operation}")));
|
|
}
|
|
let id = if r.bool()? {
|
|
WaypointId::Uuid(r.uuid()?)
|
|
} else {
|
|
WaypointId::Name(r.string(32767)?)
|
|
};
|
|
let style = Ident::read(r)?;
|
|
// ByteBufCodecs.RGB_COLOR: three bytes, read back as an opaque ARGB colour.
|
|
let color = if r.bool()? {
|
|
let [red, green, blue] = [r.u8()?, r.u8()?, r.u8()?].map(i32::from);
|
|
Some(-16_777_216 | red << 16 | green << 8 | blue)
|
|
} else {
|
|
None
|
|
};
|
|
let target = match r.varint()? {
|
|
0 => WaypointTarget::Empty,
|
|
1 => WaypointTarget::Block([r.varint()?, r.varint()?, r.varint()?]),
|
|
2 => WaypointTarget::Chunk([r.varint()?, r.varint()?]),
|
|
3 => WaypointTarget::Azimuth(r.f32()?),
|
|
other => return Err(Error::new(format!("waypoint type {other}"))),
|
|
};
|
|
Ok(TrackedWaypoint {
|
|
operation,
|
|
id,
|
|
style,
|
|
color,
|
|
target,
|
|
})
|
|
}
|
|
fn write(v: &TrackedWaypoint, w: &mut Writer) {
|
|
w.varint(v.operation);
|
|
match &v.id {
|
|
WaypointId::Uuid(uuid) => {
|
|
w.bool(true);
|
|
w.uuid(*uuid);
|
|
}
|
|
WaypointId::Name(name) => {
|
|
w.bool(false);
|
|
w.string(name);
|
|
}
|
|
}
|
|
w.string(&v.style);
|
|
w.bool(v.color.is_some());
|
|
if let Some(color) = v.color {
|
|
for shift in [16, 8, 0] {
|
|
w.u8((color >> shift) as u8);
|
|
}
|
|
}
|
|
match v.target {
|
|
WaypointTarget::Empty => w.varint(0),
|
|
WaypointTarget::Block([x, y, z]) => {
|
|
w.varint(1);
|
|
w.varint(x);
|
|
w.varint(y);
|
|
w.varint(z);
|
|
}
|
|
WaypointTarget::Chunk([x, z]) => {
|
|
w.varint(2);
|
|
w.varint(x);
|
|
w.varint(z);
|
|
}
|
|
WaypointTarget::Azimuth(angle) => {
|
|
w.varint(3);
|
|
w.f32(angle);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
// ---- serverbound -------------------------------------------------------
|
|
|
|
packet!(AcceptTeleportation { id: i32 => VarInt, x: f64 => Double, y: f64 => Double, z: f64 => Double, yaw: f32 => Float, pitch: f32 => Float });
|
|
packet!(Attack { id: i32 => VarInt });
|
|
packet!(
|
|
/// GameType ids: 0 survival, 1 creative, 2 adventure, 3 spectator.
|
|
ChangeGameMode { mode: i32 => VarInt }
|
|
);
|
|
packet!(LastSeenUpdate { offset: i32 => VarInt, acknowledged: [u8; 3] => Fixed3, checksum: i8 => Byte });
|
|
/// LastSeenMessages.Update's fixed 20-bit BitSet (3 bytes).
|
|
pub struct Fixed3;
|
|
impl Codec<[u8; 3]> for Fixed3 {
|
|
fn read(r: &mut Reader) -> Result<[u8; 3]> {
|
|
Ok(r.bytes(3)?.try_into().expect("3 bytes"))
|
|
}
|
|
fn write(v: &[u8; 3], w: &mut Writer) {
|
|
w.bytes(v)
|
|
}
|
|
}
|
|
packet!(Chat {
|
|
message: String => StrN<256>,
|
|
timestamp: i64 => Long,
|
|
salt: i64 => Long,
|
|
signature: Option<Vec<u8>> => Opt<Signature>,
|
|
last_seen: LastSeenUpdate => LastSeenUpdate,
|
|
});
|
|
packet!(ChatCommand { command: String => Str });
|
|
packet!(ChangeDifficultyRequest { difficulty: i32 => VarInt });
|
|
packet!(LockDifficulty { locked: bool => Bool });
|
|
packet!(SetGameRule { entries: Vec<GameRuleEntry> => List<GameRuleEntry> });
|
|
packet!(ChunkBatchReceived { chunks_per_tick: f32 => Float });
|
|
packet!(
|
|
/// ServerboundClientCommandPacket.Action: 0 respawn, 1 request stats, 2 request game rules.
|
|
ClientCommand { action: i32 => VarInt }
|
|
);
|
|
/// Changed slots: (slot, hashed stack) pairs.
|
|
pub struct ChangedSlots;
|
|
impl Codec<Vec<(i16, Option<Hashed>)>> for ChangedSlots {
|
|
fn read(r: &mut Reader) -> Result<Vec<(i16, Option<Hashed>)>> {
|
|
let n = r.count(128)?;
|
|
(0..n)
|
|
.map(|_| Ok((r.i16()?, HashedSlot::read(r)?)))
|
|
.collect()
|
|
}
|
|
fn write(v: &Vec<(i16, Option<Hashed>)>, w: &mut Writer) {
|
|
w.varint(v.len() as i32);
|
|
for (slot, h) in v {
|
|
w.i16(*slot);
|
|
HashedSlot::write(h, w);
|
|
}
|
|
}
|
|
}
|
|
packet!(
|
|
/// ContainerInput: 0 pickup, 1 quick move, 2 swap, 3 clone, 4 throw, 5 quick craft, 6 pickup all.
|
|
ContainerClick {
|
|
container: i32 => VarInt,
|
|
state: i32 => VarInt,
|
|
slot: i16 => Short,
|
|
button: i8 => Byte,
|
|
input: i32 => VarInt,
|
|
changed: Vec<(i16, Option<Hashed>)> => ChangedSlots,
|
|
carried: Option<Hashed> => HashedSlot,
|
|
}
|
|
);
|
|
packet!(SelectTrade { item: i32 => VarInt });
|
|
packet!(Interact { id: i32 => VarInt, hand: i32 => VarInt, location: [f64; 3] => LpVec3, secondary: bool => Bool });
|
|
packet!(
|
|
/// ServerboundMovePlayerPacket flags: 1 on ground, 2 horizontal collision.
|
|
MovePlayerPos { x: f64 => Double, y: f64 => Double, z: f64 => Double, flags: u8 => UByte }
|
|
);
|
|
packet!(MovePlayerPosRot { x: f64 => Double, y: f64 => Double, z: f64 => Double, yaw: f32 => Float, pitch: f32 => Float, flags: u8 => UByte });
|
|
packet!(MovePlayerRot { yaw: f32 => Float, pitch: f32 => Float, flags: u8 => UByte });
|
|
packet!(MovePlayerStatus { flags: u8 => UByte });
|
|
packet!(PickItemFromBlock { pos: [i32; 3] => Pos, include_data: bool => Bool });
|
|
packet!(
|
|
/// ServerboundPlayerActionPacket.Action: 0 start destroy, 1 change destroy
|
|
/// direction, 2 abort, 3 stop destroy, 4 drop all, 5 drop item, 6 release
|
|
/// use item, 7 swap offhand, 8 stab. Direction is the 3D data value.
|
|
PlayerAction { action: i32 => VarInt, pos: [i32; 3] => Pos, direction: u8 => UByte, sequence: i32 => VarInt }
|
|
);
|
|
packet!(
|
|
/// ServerboundPlayerCommandPacket.Action: 0 stop sleeping, 1 start sprinting,
|
|
/// 2 stop sprinting, 3/4 riding jump, 5 open inventory, 6 start fall flying.
|
|
PlayerCommand { id: i32 => VarInt, action: i32 => VarInt, data: i32 => VarInt }
|
|
);
|
|
packet!(
|
|
/// Input flags: forward 1, backward 2, left 4, right 8, jump 16, shift 32, sprint 64.
|
|
PlayerInput { flags: u8 => UByte }
|
|
);
|
|
packet!(SetCarriedItem { slot: i16 => Short });
|
|
packet!(SetCreativeModeSlot { slot: i16 => Short, item: Option<Stack> => Slot });
|
|
packet!(UseItem { hand: i32 => VarInt, sequence: i32 => VarInt, yaw: f32 => Float, pitch: f32 => Float });
|
|
packet!(UseItemOn {
|
|
hand: i32 => VarInt,
|
|
pos: [i32; 3] => Pos,
|
|
face: i32 => VarInt,
|
|
cursor: [f32; 3] => Cursor,
|
|
inside: bool => Bool,
|
|
world_border: bool => Bool,
|
|
sequence: i32 => VarInt,
|
|
});
|
|
/// The click location relative to the block (three floats).
|
|
pub struct Cursor;
|
|
impl Codec<[f32; 3]> for Cursor {
|
|
fn read(r: &mut Reader) -> Result<[f32; 3]> {
|
|
Ok([r.f32()?, r.f32()?, r.f32()?])
|
|
}
|
|
fn write(v: &[f32; 3], w: &mut Writer) {
|
|
v.iter().for_each(|f| w.f32(*f));
|
|
}
|
|
}
|
|
|
|
packet_enum!(Serverbound, crate::ids::play::serverbound {
|
|
ChangeDifficulty(ChangeDifficultyRequest) = CHANGE_DIFFICULTY,
|
|
LockDifficulty(LockDifficulty) = LOCK_DIFFICULTY,
|
|
SetGameRule(SetGameRule) = SET_GAME_RULE,
|
|
AcceptTeleportation(AcceptTeleportation) = ACCEPT_TELEPORTATION,
|
|
Attack(Attack) = ATTACK,
|
|
ChangeGameMode(ChangeGameMode) = CHANGE_GAME_MODE,
|
|
Chat(Chat) = CHAT,
|
|
ChatCommand(ChatCommand) = CHAT_COMMAND,
|
|
ChunkBatchReceived(ChunkBatchReceived) = CHUNK_BATCH_RECEIVED,
|
|
ClientCommand(ClientCommand) = CLIENT_COMMAND,
|
|
ClientInformation(ClientInformation) = CLIENT_INFORMATION,
|
|
ClientTickEnd(Empty) = CLIENT_TICK_END,
|
|
ConfigurationAcknowledged(Empty) = CONFIGURATION_ACKNOWLEDGED,
|
|
ContainerClick(ContainerClick) = CONTAINER_CLICK,
|
|
ContainerClose(ContainerClose) = CONTAINER_CLOSE,
|
|
CustomPayload(CustomPayload) = CUSTOM_PAYLOAD,
|
|
Interact(Interact) = INTERACT,
|
|
KeepAlive(KeepAlive) = KEEP_ALIVE,
|
|
MovePlayerPos(MovePlayerPos) = MOVE_PLAYER_POS,
|
|
MovePlayerPosRot(MovePlayerPosRot) = MOVE_PLAYER_POS_ROT,
|
|
MovePlayerRot(MovePlayerRot) = MOVE_PLAYER_ROT,
|
|
MovePlayerStatus(MovePlayerStatus) = MOVE_PLAYER_STATUS_ONLY,
|
|
PickItemFromBlock(PickItemFromBlock) = PICK_ITEM_FROM_BLOCK,
|
|
PingRequest(crate::packets::status::Ping) = PING_REQUEST,
|
|
PlayerAction(PlayerAction) = PLAYER_ACTION,
|
|
PlayerCommand(PlayerCommand) = PLAYER_COMMAND,
|
|
PlayerInput(PlayerInput) = PLAYER_INPUT,
|
|
PlayerLoaded(Empty) = PLAYER_LOADED,
|
|
Pong(Ping) = PONG,
|
|
Punch(Empty) = PUNCH,
|
|
ResourcePack(ResourcePackResponse) = RESOURCE_PACK,
|
|
SelectTrade(SelectTrade) = SELECT_TRADE,
|
|
SetCarriedItem(SetCarriedItem) = SET_CARRIED_ITEM,
|
|
SetCreativeModeSlot(SetCreativeModeSlot) = SET_CREATIVE_MODE_SLOT,
|
|
UseItem(UseItem) = USE_ITEM,
|
|
UseItemOn(UseItemOn) = USE_ITEM_ON,
|
|
});
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::{chunk::BlockEntityInfo, packets::round_trip, text::literal};
|
|
|
|
#[test]
|
|
fn world_options_packets_match_vanilla_stream_codecs() {
|
|
// mcsrc.dev 26.3: difficulty is a VarInt, locking is a Boolean,
|
|
// rule entries are ResourceKey identifiers followed by UTF-8 values.
|
|
let difficulty = Serverbound::ChangeDifficulty(ChangeDifficultyRequest { difficulty: 3 });
|
|
assert_eq!(&difficulty.encode()[1..], &[3]);
|
|
round_trip(difficulty, Serverbound::encode, Serverbound::decode);
|
|
let lock = Serverbound::LockDifficulty(LockDifficulty { locked: true });
|
|
assert_eq!(&lock.encode()[1..], &[1]);
|
|
round_trip(lock, Serverbound::encode, Serverbound::decode);
|
|
let payload = b"\x01\x18minecraft:keep_inventory\x04true";
|
|
let entry = GameRuleEntry {
|
|
name: "minecraft:keep_inventory".into(),
|
|
value: "true".into(),
|
|
};
|
|
let set = Serverbound::SetGameRule(SetGameRule {
|
|
entries: vec![entry.clone()],
|
|
});
|
|
assert_eq!(&set.encode()[1..], payload);
|
|
assert_eq!(
|
|
Serverbound::decode(crate::ids::play::serverbound::SET_GAME_RULE, payload).unwrap(),
|
|
set
|
|
);
|
|
let values = Clientbound::GameRuleValues(GameRuleValues {
|
|
entries: vec![entry],
|
|
});
|
|
assert_eq!(&values.encode()[1..], payload);
|
|
assert_eq!(
|
|
Clientbound::decode(crate::ids::play::clientbound::GAME_RULE_VALUES, payload).unwrap(),
|
|
values
|
|
);
|
|
assert!(
|
|
Serverbound::decode(
|
|
crate::ids::play::serverbound::SET_GAME_RULE,
|
|
&payload[..payload.len() - 1]
|
|
)
|
|
.is_err()
|
|
);
|
|
}
|
|
|
|
fn spawn() -> SpawnInfo {
|
|
SpawnInfo {
|
|
dimension_type: 0,
|
|
dimension: "minecraft:overworld".into(),
|
|
seed: -123,
|
|
game_type: 0,
|
|
previous_game_type: None,
|
|
debug: false,
|
|
flat: false,
|
|
last_death: Some(GlobalPos {
|
|
dimension: "minecraft:the_nether".into(),
|
|
pos: [1, 2, 3],
|
|
}),
|
|
portal_cooldown: 0,
|
|
sea_level: 63,
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn tracked_waypoint_bytes() {
|
|
// TRACK, a UUID, the default style, red (#FF5555), a block position.
|
|
let track = Clientbound::TrackedWaypoint(TrackedWaypoint {
|
|
operation: waypoint_operation::TRACK,
|
|
id: WaypointId::Uuid(0x0102_0304_0506_0708_090a_0b0c_0d0e_0f10),
|
|
style: "minecraft:default".into(),
|
|
color: Some(0xFFFF_5555_u32 as i32),
|
|
target: WaypointTarget::Block([1, -2, 300]),
|
|
});
|
|
let mut expected = vec![141, 1, 0, 1];
|
|
expected.extend(1..=16u8);
|
|
expected.push(17);
|
|
expected.extend(b"minecraft:default");
|
|
expected.extend([
|
|
1, 0xFF, 0x55, 0x55, 1, 1, 0xFE, 0xFF, 0xFF, 0xFF, 0x0F, 0xAC, 0x02,
|
|
]);
|
|
assert_eq!(track.encode(), expected);
|
|
assert_eq!(Clientbound::decode(141, &expected[2..]).unwrap(), track);
|
|
for target in [
|
|
WaypointTarget::Empty,
|
|
WaypointTarget::Chunk([-3, 4]),
|
|
WaypointTarget::Azimuth(-1.25),
|
|
] {
|
|
let packet = Clientbound::TrackedWaypoint(TrackedWaypoint {
|
|
operation: waypoint_operation::UPDATE,
|
|
id: WaypointId::Name("spawn".into()),
|
|
style: "minecraft:bowtie".into(),
|
|
color: None,
|
|
target,
|
|
});
|
|
let bytes = packet.encode();
|
|
assert_eq!(Clientbound::decode(141, &bytes[2..]).unwrap(), packet);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn clientbound_round_trips() {
|
|
let packets = vec![
|
|
Clientbound::BundleDelimiter(Empty),
|
|
Clientbound::PongResponse(crate::packets::status::Ping { time: 1_234_567 }),
|
|
Clientbound::SetBorderCenter(SetBorderCenter { x: 1.5, z: -2.0 }),
|
|
Clientbound::SetBorderLerpSize(SetBorderLerpSize {
|
|
old_size: 10.0,
|
|
new_size: 200.0,
|
|
lerp_time: 1200,
|
|
}),
|
|
Clientbound::SetBorderSize(SetBorderSize { size: 30.0 }),
|
|
Clientbound::SetBorderWarningDelay(SetBorderWarningDelay { delay: 300 }),
|
|
Clientbound::SetBorderWarningDistance(SetBorderWarningDistance { blocks: 5 }),
|
|
Clientbound::SetDisplayObjective(SetDisplayObjective {
|
|
slot: 0,
|
|
objective: "kills".into(),
|
|
}),
|
|
Clientbound::ResetScore(ResetScore {
|
|
owner: "Steve".into(),
|
|
objective: Some("kills".into()),
|
|
}),
|
|
Clientbound::SetScore(SetScore {
|
|
owner: "Steve".into(),
|
|
objective: "kills".into(),
|
|
score: -3,
|
|
display: Some(Tag::String("S".into())),
|
|
number_format: Some(NumberFormat::Styled(Tag::compound([(
|
|
"color",
|
|
Tag::String("red".into()),
|
|
)]))),
|
|
}),
|
|
Clientbound::SetObjective(SetObjective {
|
|
name: "kills".into(),
|
|
method: 0,
|
|
display: Some((Tag::String("Kills".into()), 1, Some(NumberFormat::Blank))),
|
|
}),
|
|
Clientbound::SetObjective(SetObjective {
|
|
name: "kills".into(),
|
|
method: 1,
|
|
display: None,
|
|
}),
|
|
Clientbound::SetPlayerTeam(SetPlayerTeam {
|
|
name: "red".into(),
|
|
method: 0,
|
|
parameters: Some(TeamParameters {
|
|
display_name: Tag::String("Red".into()),
|
|
prefix: Tag::String("[R] ".into()),
|
|
suffix: Tag::String("".into()),
|
|
name_tag_visibility: 0,
|
|
collision_rule: 0,
|
|
color: Some(12),
|
|
options: 3,
|
|
}),
|
|
players: vec!["Steve".into(), "Alex".into()],
|
|
}),
|
|
Clientbound::SetPlayerTeam(SetPlayerTeam {
|
|
name: "red".into(),
|
|
method: 4,
|
|
parameters: None,
|
|
players: vec!["Alex".into()],
|
|
}),
|
|
Clientbound::AddEntity(AddEntity {
|
|
id: 5,
|
|
uuid: 9,
|
|
kind: 100,
|
|
position: [1.5, 64.0, -3.25],
|
|
velocity: [0.0; 3],
|
|
pitch: 0,
|
|
yaw: 64,
|
|
head_yaw: 64,
|
|
data: 0,
|
|
}),
|
|
Clientbound::BlockUpdate(BlockUpdate {
|
|
pos: [-5, -60, 7],
|
|
state: 1,
|
|
}),
|
|
Clientbound::ContainerSetContent(ContainerSetContent {
|
|
container: 0,
|
|
state: 3,
|
|
items: vec![None, Some(Stack::new(1, 64))],
|
|
carried: None,
|
|
}),
|
|
Clientbound::ContainerSetSlot(ContainerSetSlot {
|
|
container: 0,
|
|
state: 4,
|
|
slot: 36,
|
|
item: Some(Stack::new(2, 1)),
|
|
}),
|
|
Clientbound::Disconnect(Disconnect {
|
|
reason: literal("kicked"),
|
|
}),
|
|
Clientbound::EntityPositionSync(EntityPositionSync {
|
|
id: 1,
|
|
path: PositionPath::Stepped(vec![([1.0, 2.0, 3.0], 0), ([1.5, 2.0, 3.0], 2)]),
|
|
yaw: 1.0,
|
|
pitch: 2.0,
|
|
on_ground: true,
|
|
}),
|
|
Clientbound::ForgetLevelChunk(ForgetLevelChunk { pos: [-1, 2] }),
|
|
Clientbound::GameEvent(GameEvent {
|
|
event: 13,
|
|
param: 0.0,
|
|
}),
|
|
Clientbound::LevelChunkWithLight(LevelChunkWithLight {
|
|
x: 3,
|
|
z: -4,
|
|
chunk: ChunkData {
|
|
heightmaps: vec![(4, vec![0; 37])],
|
|
buffer: vec![0, 0, 0, 0, 0, 0, 0, 0],
|
|
block_entities: vec![BlockEntityInfo {
|
|
packed_xz: 1,
|
|
y: 70,
|
|
kind: 3,
|
|
tag: Tag::End,
|
|
}],
|
|
},
|
|
light: LightData {
|
|
sky_mask: vec![1],
|
|
block_mask: vec![],
|
|
empty_sky_mask: vec![],
|
|
empty_block_mask: vec![2],
|
|
sky: vec![vec![0xFF; 2048]],
|
|
block: vec![],
|
|
},
|
|
}),
|
|
Clientbound::Login(Login {
|
|
player_id: 42,
|
|
hardcore: false,
|
|
levels: vec!["minecraft:overworld".into(), "minecraft:the_nether".into()],
|
|
max_players: 20,
|
|
chunk_radius: 10,
|
|
simulation_distance: 10,
|
|
reduced_debug_info: false,
|
|
show_death_screen: true,
|
|
limited_crafting: false,
|
|
spawn: spawn(),
|
|
online_mode: false,
|
|
enforces_secure_chat: false,
|
|
}),
|
|
Clientbound::MoveEntityPos(MoveEntityPos(MoveEntity {
|
|
id: 3,
|
|
delta: Some(VecDelta::Linear([4096, 0, -4096])),
|
|
rotation: None,
|
|
on_ground: true,
|
|
})),
|
|
Clientbound::MoveEntityPosRot(MoveEntityPosRot(MoveEntity {
|
|
id: 3,
|
|
delta: Some(VecDelta::Stepped(vec![([1, 2, 3], 1), ([0, 0, 1], 2)])),
|
|
rotation: Some((10, -10)),
|
|
on_ground: false,
|
|
})),
|
|
Clientbound::MoveEntityRot(MoveEntityRot(MoveEntity {
|
|
id: 3,
|
|
delta: None,
|
|
rotation: Some((1, 2)),
|
|
on_ground: true,
|
|
})),
|
|
Clientbound::OpenScreen(OpenScreen {
|
|
container: 1,
|
|
menu: 2,
|
|
title: literal("Chest"),
|
|
}),
|
|
Clientbound::MerchantOffers(MerchantOffers {
|
|
container: 3,
|
|
offers: vec![NetOffer {
|
|
cost_a: NetCost { item: 5, count: 24 },
|
|
result: Stack::new(7, 1),
|
|
cost_b: Some(NetCost { item: 9, count: 1 }),
|
|
out_of_stock: false,
|
|
uses: 2,
|
|
max_uses: 16,
|
|
xp: 2,
|
|
special_price: -3,
|
|
price_multiplier: 0.05,
|
|
demand: 4,
|
|
}],
|
|
level: 2,
|
|
xp: 12,
|
|
show_progress: true,
|
|
can_restock: true,
|
|
}),
|
|
Clientbound::PlayerChat(PlayerChat {
|
|
global_index: 0,
|
|
sender: 5,
|
|
index: 0,
|
|
signature: None,
|
|
content: "hello".into(),
|
|
timestamp: 1,
|
|
salt: 2,
|
|
last_seen: vec![(3, None), (-1, Some(vec![7; 256]))],
|
|
unsigned_content: None,
|
|
filter: (0, vec![]),
|
|
chat_type: ChatTypeBound {
|
|
chat_type: 0,
|
|
name: literal("Steve"),
|
|
target: None,
|
|
},
|
|
}),
|
|
Clientbound::PlayerInfoUpdate(PlayerInfoUpdate {
|
|
actions: 0b0001_1101,
|
|
entries: vec![PlayerInfo {
|
|
uuid: 1,
|
|
name: Some("Steve".into()),
|
|
game_mode: Some(1),
|
|
listed: Some(true),
|
|
latency: Some(12),
|
|
..PlayerInfo::default()
|
|
}],
|
|
}),
|
|
Clientbound::PlayerPosition(PlayerPosition {
|
|
teleport: 1,
|
|
position: [0.5, 70.0, 0.5],
|
|
delta: [0.0; 3],
|
|
yaw: 90.0,
|
|
pitch: 0.0,
|
|
relatives: relative::DELTA_X,
|
|
}),
|
|
Clientbound::Respawn(Respawn {
|
|
spawn: spawn(),
|
|
keep: 3,
|
|
}),
|
|
Clientbound::SectionBlocksUpdate(SectionBlocksUpdate {
|
|
section: [1, -4, 2],
|
|
changes: vec![(9 << 12) | 0x123],
|
|
}),
|
|
Clientbound::SetEntityData(SetEntityData {
|
|
id: 2,
|
|
values: vec![(8, 7, Value::Item(Some(Stack::new(5, 3))))],
|
|
}),
|
|
Clientbound::SetEntityMotion(SetEntityMotion {
|
|
id: 2,
|
|
velocity: [0.0; 3],
|
|
}),
|
|
Clientbound::SetEquipment(SetEquipment {
|
|
id: 2,
|
|
slots: vec![(0, None), (5, Some(Stack::new(1, 1)))],
|
|
}),
|
|
Clientbound::SetHealth(SetHealth {
|
|
health: 17.5,
|
|
food: 18,
|
|
saturation: 3.0,
|
|
}),
|
|
Clientbound::SetTime(SetTime {
|
|
game_time: 100,
|
|
clocks: vec![ClockState {
|
|
clock: 0,
|
|
total_ticks: 6000,
|
|
partial_tick: 0.0,
|
|
rate: 1.0,
|
|
}],
|
|
}),
|
|
Clientbound::Sound(Sound {
|
|
sound: (12, None),
|
|
source: 4,
|
|
x: 8,
|
|
y: 9,
|
|
z: 10,
|
|
volume: 1.0,
|
|
pitch: 1.0,
|
|
seed: 3,
|
|
}),
|
|
Clientbound::Sound(Sound {
|
|
sound: (-1, Some(("minecraft:x".into(), Some(16.0)))),
|
|
source: 0,
|
|
x: 0,
|
|
y: 0,
|
|
z: 0,
|
|
volume: 1.0,
|
|
pitch: 1.0,
|
|
seed: 0,
|
|
}),
|
|
Clientbound::SystemChat(SystemChat {
|
|
content: literal("hi"),
|
|
overlay: false,
|
|
}),
|
|
Clientbound::TeleportEntity(TeleportEntity {
|
|
id: 1,
|
|
position: [1.0; 3],
|
|
delta: [0.0; 3],
|
|
yaw: 0.0,
|
|
pitch: 0.0,
|
|
relatives: 0,
|
|
on_ground: true,
|
|
}),
|
|
Clientbound::TickingState(TickingState {
|
|
rate: 40.0,
|
|
frozen: true,
|
|
}),
|
|
Clientbound::TickingStep(TickingStep { steps: 7 }),
|
|
Clientbound::AwardStats(AwardStats {
|
|
stats: vec![(8, 3, 120), (0, 1, 2)],
|
|
}),
|
|
Clientbound::UpdateAdvancements(UpdateAdvancements {
|
|
reset: true,
|
|
added: vec![Advancement {
|
|
id: "minecraft:story/root".into(),
|
|
parent: None,
|
|
display: Some(AdvancementDisplay {
|
|
title: literal("Minecraft"),
|
|
description: literal("The heart and story of the game"),
|
|
icon: crate::item::Stack::new(42, 1),
|
|
frame: 0,
|
|
show_toast: false,
|
|
hidden: false,
|
|
background: Some("minecraft:block/stone".into()),
|
|
}),
|
|
requirements: vec![vec!["crafting_table".into()]],
|
|
telemetry: false,
|
|
x: 0.0,
|
|
y: 1.5,
|
|
}],
|
|
removed: vec!["minecraft:story/gone".into()],
|
|
progress: vec![(
|
|
"minecraft:story/root".into(),
|
|
vec![("crafting_table".into(), Some(1_792_216_800_000))],
|
|
)],
|
|
show: true,
|
|
}),
|
|
];
|
|
for p in packets {
|
|
round_trip(p, Clientbound::encode, Clientbound::decode);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn serverbound_round_trips() {
|
|
let packets = vec![
|
|
Serverbound::PingRequest(crate::packets::status::Ping { time: -7 }),
|
|
Serverbound::AcceptTeleportation(AcceptTeleportation {
|
|
id: 1,
|
|
x: 0.5,
|
|
y: 64.0,
|
|
z: 0.5,
|
|
yaw: 0.0,
|
|
pitch: 0.0,
|
|
}),
|
|
Serverbound::Chat(Chat {
|
|
message: "hello".into(),
|
|
timestamp: 1,
|
|
salt: 0,
|
|
signature: None,
|
|
last_seen: LastSeenUpdate {
|
|
offset: 0,
|
|
acknowledged: [0; 3],
|
|
checksum: 0,
|
|
},
|
|
}),
|
|
Serverbound::ChatCommand(ChatCommand {
|
|
command: "time set day".into(),
|
|
}),
|
|
Serverbound::ChunkBatchReceived(ChunkBatchReceived {
|
|
chunks_per_tick: 9.5,
|
|
}),
|
|
Serverbound::ClientCommand(ClientCommand { action: 0 }),
|
|
Serverbound::ClientTickEnd(Empty),
|
|
Serverbound::ContainerClick(ContainerClick {
|
|
container: 0,
|
|
state: 5,
|
|
slot: 36,
|
|
button: 0,
|
|
input: 0,
|
|
changed: vec![(36, None)],
|
|
carried: Some(Hashed::of(&Stack::new(1, 64))),
|
|
}),
|
|
Serverbound::MovePlayerPosRot(MovePlayerPosRot {
|
|
x: 1.0,
|
|
y: 2.0,
|
|
z: 3.0,
|
|
yaw: 4.0,
|
|
pitch: 5.0,
|
|
flags: 1,
|
|
}),
|
|
Serverbound::MovePlayerStatus(MovePlayerStatus { flags: 3 }),
|
|
Serverbound::PlayerAction(PlayerAction {
|
|
action: 0,
|
|
pos: [1, 2, 3],
|
|
direction: 1,
|
|
sequence: 7,
|
|
}),
|
|
Serverbound::PlayerInput(PlayerInput { flags: 0b0101_0001 }),
|
|
Serverbound::PlayerLoaded(Empty),
|
|
Serverbound::Punch(Empty),
|
|
Serverbound::SetCarriedItem(SetCarriedItem { slot: 4 }),
|
|
Serverbound::UseItemOn(UseItemOn {
|
|
hand: 0,
|
|
pos: [1, 64, 1],
|
|
face: 1,
|
|
cursor: [0.5, 1.0, 0.5],
|
|
inside: false,
|
|
world_border: false,
|
|
sequence: 8,
|
|
}),
|
|
Serverbound::Interact(Interact {
|
|
id: 9,
|
|
hand: 0,
|
|
location: [0.25, 1.0, 0.0],
|
|
secondary: false,
|
|
}),
|
|
];
|
|
for p in packets {
|
|
if let Serverbound::Interact(_) = &p {
|
|
// LpVec3 is lossy; check bytes instead.
|
|
let body = p.encode();
|
|
let mut r = Reader::new(&body);
|
|
let id = r.varint().unwrap();
|
|
assert!(matches!(
|
|
Serverbound::decode(id, r.rest()).unwrap(),
|
|
Serverbound::Interact(Interact { id: 9, .. })
|
|
));
|
|
continue;
|
|
}
|
|
round_trip(p, Serverbound::encode, Serverbound::decode);
|
|
}
|
|
round_trip(
|
|
Serverbound::SelectTrade(SelectTrade { item: 3 }),
|
|
Serverbound::encode,
|
|
Serverbound::decode,
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn change_game_mode_uses_the_game_type_varint() {
|
|
for mode in 0..=3 {
|
|
let packet = Serverbound::ChangeGameMode(ChangeGameMode { mode });
|
|
assert_eq!(packet.encode(), vec![5, mode as u8]);
|
|
round_trip(packet, Serverbound::encode, Serverbound::decode);
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn move_entity_deltas_decode_like_vec_delta_codec() {
|
|
let base = [10.0, 64.0, -3.5];
|
|
assert_eq!(
|
|
VecDelta::Linear([4096, 0, -2048]).end(base),
|
|
[11.0, 64.0, -4.0]
|
|
);
|
|
// Zero deltas keep unquantized base coordinates exactly.
|
|
assert_eq!(
|
|
VecDelta::Linear([0, 0, 0]).end([0.123_456_789, 1.0, 2.0]),
|
|
[0.123_456_789, 1.0, 2.0]
|
|
);
|
|
assert_eq!(
|
|
VecDelta::Stepped(vec![([4096, 0, 0], 1), ([4096, 0, 0], 2)]).end(base),
|
|
[12.0, 64.0, -3.5]
|
|
);
|
|
}
|
|
|
|
#[test]
|
|
fn unknown_packets_keep_their_payload() {
|
|
let p = Clientbound::decode(crate::ids::play::clientbound::BOSS_EVENT, &[1, 2, 3]).unwrap();
|
|
assert_eq!(
|
|
p,
|
|
Clientbound::Unknown(crate::ids::play::clientbound::BOSS_EVENT, vec![1, 2, 3])
|
|
);
|
|
assert_eq!(p.encode()[1..], [1, 2, 3]);
|
|
}
|
|
}
|