Struct Position 

pub struct Position {
    pub x: i32,
    pub y: i32,
    pub z: i32,
}

A packed block position encoded as a single 64-bit integer.

The Minecraft protocol packs three spatial coordinates into one i64 to minimize bandwidth for the most common spatial reference in the game. Used in packets like block changes, player digging, block placement, sign updates, and many more.

Bit layout (MSB to LSB):

• x: 26 bits (signed, range -33554432 to 33554431)
• z: 26 bits (signed, range -33554432 to 33554431)
• y: 12 bits (signed, range -2048 to 2047)

Encoding: (x & 0x3FFFFFF) << 38 | (z & 0x3FFFFFF) << 12 | (y & 0xFFF)

Fields

x: i32

y: i32

z: i32

Implementations

impl Position

pub fn new(x: i32, y: i32, z: i32) -> Self

Creates a new position from block coordinates.

Trait Implementations

impl Clone for Position

fn clone(&self) -> Position

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Position

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Decode for Position

Decodes a Position from a packed 64-bit big-endian integer.

Reads 8 bytes as a big-endian i64, then unpacks x (26 bits), z (26 bits), and y (12 bits) with proper sign extension for negative coordinates.

fn decode(buf: &mut &[u8]) -> Result<Self>

Reads 8 big-endian bytes, unpacks into x, y, z with sign extension.

Fails with Error::BufferUnderflow if fewer than 8 bytes remain.

impl Default for Position

fn default() -> Position

Returns the “default value” for a type.

impl Encode for Position

Encodes a Position as a packed 64-bit big-endian integer.

The three coordinates are packed into a single i64 using the bit layout described on the type. The packed value is then written as 8 big-endian bytes, matching the Minecraft protocol wire format.

fn encode(&self, buf: &mut Vec<u8>) -> Result<()>

Packs x, y, z into a 64-bit integer and writes it as 8 big-endian bytes.

impl EncodedSize for Position

A Position always occupies exactly 8 bytes on the wire (one packed i64).

fn encoded_size(&self) -> usize

impl From<BlockPosition> for Position

Converts a BlockPosition into a Position for wire serialization.

Coordinates outside the Position range (x/z: 26-bit signed, y: 12-bit signed) will be silently truncated during packing.

fn from(pos: BlockPosition) -> Self

Converts to this type from the input type.

impl From<Position> for BlockPosition

Converts a Position (packed wire format) into a BlockPosition (full i32 coordinates).

fn from(pos: Position) -> Self

Converts to this type from the input type.

impl Hash for Position

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for Position

fn eq(&self, other: &Position) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Copy for Position

impl Eq for Position

impl StructuralPartialEq for Position