Struct PositionGrid 

pub struct PositionGrid(/* private fields */);

A grid-aligned position used for chunk look-ups.

A PositionGrid stores the coordinates of a chunk in the world grid. Each component is the index of the chunk in the X and Y direction.

Implementations

impl PositionGrid

pub fn distance(&self, other: &PositionGrid) -> isize

Calculates the Euclidean distance between two grid positions.

The distance is computed by converting both grid positions to world coordinates and then using Position::distance.

pub fn to_position(&self) -> Position

Converts the grid coordinates to world coordinates.

Each component is multiplied by CHUNK_SIZE to obtain the corresponding world position.

Trait Implementations

impl Add for PositionGrid

type Output = PositionGrid

The resulting type after applying the + operator.

fn add(self, __rhs: Self) -> Self::Output

Performs the + operation.

impl Clone for PositionGrid

fn clone(&self) -> PositionGrid

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for PositionGrid

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

Formats the value using the given formatter.

impl Default for PositionGrid

fn default() -> PositionGrid

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for PositionGrid

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl From<(isize, isize)> for PositionGrid

Convert a tuple of two signed integers into a PositionGrid.

This implementation simply wraps the (isize, isize) tuple into a Position struct. It is equivalent to Position(x, y) where x is the first element and y is the second.

fn from(value: (isize, isize)) -> Self

Converts to this type from the input type.

impl FromStr for PositionGrid

Parse a string into a PositionGrid.

The string is expected to contain two signed integers separated by a comma, optionally surrounded by whitespace. Each component is trimmed before parsing, so leading and trailing whitespace is ignored.

The parsing logic is the same as for Position:

• Split on the comma; there must be exactly one comma.
• Trim each component and parse it as an isize.
• Convert the resulting Position to a grid distance with Position::to_grid_distance.

Errors

• EpochError::InvalidPositionFormat - the string does not contain exactly one comma or there are not exactly two components.
• EpochError::ParsePositionError - one of the components cannot be parsed as an isize. (These errors come from the underlying Position implementation.)

type Err = EpochError

The associated error which can be returned from parsing.

fn from_str(s: &str) -> Result<Self, Self::Err>

Parses a string s to return a value of this type.

impl<__derive_more_Rhs> Mul<__derive_more_Rhs> for PositionGrid

where isize: Mul<__derive_more_Rhs, Output = isize>, __derive_more_Rhs: Copy,

type Output = PositionGrid

The resulting type after applying the * operator.

fn mul(self, __rhs: __derive_more_Rhs) -> Self::Output

Performs the * operation.

impl Serialize for PositionGrid

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Sub for PositionGrid

type Output = PositionGrid

The resulting type after applying the - operator.

fn sub(self, __rhs: Self) -> Self::Output

Performs the - operation.