Struct Angle 

pub struct Angle(pub u8);

A rotation angle encoded as a single unsigned byte.

The Minecraft protocol represents rotations as a single byte where the full 0-255 range maps to 0-360 degrees. This is used for entity head rotation (Entity Head Look packet), entity look direction, and similar rotation fields. The conversion formula is:

• Byte to degrees: value / 256.0 * 360.0
• Degrees to byte: degrees / 360.0 * 256.0

The mapping wraps naturally: 256 steps for a full rotation gives approximately 1.4° precision per step, which is sufficient for visual entity rotation in the game.

Tuple Fields

0: u8

Implementations

impl Angle

pub fn from_degrees(degrees: f32) -> Self

Creates an Angle from a degree value.

The degree value is normalized to the 0-255 byte range. Values outside 0-360 wrap naturally (e.g., 720° wraps to the same byte as 360°, which is 0).

pub fn to_degrees(self) -> f32

Converts the angle to degrees in the range 0.0 to ~359.0.

The result has approximately 1.4° precision due to the single-byte encoding. A byte value of 0 maps to 0°, 64 to 90°, 128 to 180°, and 192 to 270°.

Trait Implementations

impl Clone for Angle

fn clone(&self) -> Angle

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Angle

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

Formats the value using the given formatter.

impl Decode for Angle

Decodes an Angle from a single unsigned byte.

Reads exactly one byte. Any byte value is valid — the full 0-255 range maps to 0-360 degrees.

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

Reads one byte and wraps it as an Angle.

Fails with Error::BufferUnderflow if the buffer is empty.

impl Encode for Angle

Encodes an Angle as a single unsigned byte.

The angle is written directly as one byte with no transformation. This is the simplest encoding in the Minecraft protocol.

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

Writes the angle as a single byte.

impl EncodedSize for Angle

An Angle always occupies exactly 1 byte on the wire.

fn encoded_size(&self) -> usize

impl Hash for Angle

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 Angle

fn eq(&self, other: &Angle) -> 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 Angle

impl Eq for Angle

impl StructuralPartialEq for Angle