Struct Axial 

pub struct Axial {
    pub q: i32,
    pub r: i32,
}

Axial coordinates use the same system as cube coordinates, but only store two of the coordinate values. This is possible since, for cube coordinate (x, y, z), the third value can always be calculated when the other two are known due to the constraint x + y + z == 0.

Fields

q: i32

r: i32

Implementations

impl Axial

pub const ORIGIN: Axial

Axial coordinate origin of (0, 0).

pub fn from_coords(q: i32, r: i32) -> Self

For two unsigned 32-bit integers x and y, the corresponding axial coordinate is (x, y).

Examples

use chickenwire::coordinate::axial::Axial;

assert_eq!(Axial::from((1, 2)), Axial::from_coords(1, 2));

pub fn neighbors(self) -> Vec<Self>

[ docs missing ]

pub fn diagonals(self) -> Vec<Self>

[ docs missing ]

pub fn dist(self, other: Self) -> i32

Determines the distance between two axial coordinates.

Examples

use chickenwire::coordinate::axial::Axial;

let origin = Axial::ORIGIN;
let coord_1 = Axial { q: 1, r: -3 };
let coord_2 = Axial { q: -8, r: 2 };

assert_eq!(origin.dist(coord_1), 3);
assert_eq!(coord_1.dist(origin), 3);
assert_eq!(coord_1.dist(coord_1), 0);
assert_eq!(coord_2.dist(coord_1), 9);

Trait Implementations

impl Add for Axial

Adds two Axial coordinates in the same manner as vectors.

Examples

use chickenwire::coordinate::axial::Axial;

let coord_1 = Axial::from_coords(1, -3);
let coord_2 = Axial::from_coords(-5, 12);

assert_eq!(coord_1 + coord_2, Axial::from_coords(-4, 9));
assert_eq!(coord_2 + coord_1, Axial::from_coords(-4, 9));

type Output = Axial

The resulting type after applying the + operator.

fn add(self, other: Self) -> Self

Performs the + operation.

impl Clone for Axial

fn clone(&self) -> Axial

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Axial

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

Formats the value using the given formatter.

impl Default for Axial

fn default() -> Axial

Returns the “default value” for a type.

impl Div<i32> for Axial

Divides an Axial coordinate by an i32 scalar, like a vector. Values are truncated (i.e. rounded toward zero).

Panics

Panics when trying to divide by zero.

Examples

use chickenwire::coordinate::axial::Axial;

let coord = Axial::from_coords(12, -36);

assert_eq!(coord / -1, Axial::from_coords(-12, 36));
assert_eq!(coord / 2, Axial::from_coords(6, -18));
assert_eq!(coord / 3, Axial::from_coords(4, -12));

type Output = Axial

The resulting type after applying the / operator.

fn div(self, n: i32) -> Self

Performs the / operation.

impl From<(i32, i32)> for Axial

Creates an Axial from an (i32, i32).

Examples

use chickenwire::coordinate::axial::Axial;

assert_eq!(
    Axial::from((1, 2)),
    Axial { q: 1, r: 2 }
);

fn from((q, r): (i32, i32)) -> Self

Converts to this type from the input type.

impl From<Axial> for CoordSys

Creates a CoordSys::Axial from an Axial.

fn from(_: Axial) -> Self

Converts to this type from the input type.

impl From<Axial> for Cube

For axial coordinate (q, r), cube coordinate (x, y, z) is calculated by solving for y based upon the constraint x + y + z == 0, where x == q and z == r.

Examples

use chickenwire::coordinate::axial::Axial;
use chickenwire::coordinate::cube::Cube;

let axial = Axial::from_coords(1, 2);

assert_eq!(Cube::from(Axial::ORIGIN), Cube::ORIGIN);
assert_eq!(Cube::from(axial), Cube::force_from_coords(1, -3, 2));

fn from(coord: Axial) -> Self

Converts to this type from the input type.

impl From<Axial> for MultiCoord

Creates a MultiCoord from an Axial.

fn from(coord: Axial) -> Self

Converts to this type from the input type.

impl From<Cube> for Axial

Creates an Axial from a Cube.

Examples

use chickenwire::coordinate::axial::Axial;
use chickenwire::coordinate::cube::Cube;

let cube = Cube::force_from_coords(1, 2, -3);

assert_eq!(
    Axial::from(cube),
    Axial { q: 1, r: -3 }
);
assert_eq!(
    Axial::from(Cube::ORIGIN),
    Axial::ORIGIN
);

fn from(coord: Cube) -> Self

Converts to this type from the input type.

impl From<MultiCoord> for Axial

Creates an Axial from a MultiCoord.

Conversion from both axial and cube MultiCoords is supported.

Panics

Panics when parsing a double or offset MultiCoord.

fn from(coord: MultiCoord) -> Self

Converts to this type from the input type.

impl Hash for Axial

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 Mul<Axial> for i32

type Output = Axial

The resulting type after applying the * operator.

fn mul(self, coord: Axial) -> Axial

Performs the * operation.

impl Mul<i32> for Axial

Multiplies an Axial coordinate by an i32 scalar, like a vector.

Examples

use chickenwire::coordinate::axial::Axial;

let coord = Axial::from_coords(1, -3);

assert_eq!(-1 * coord, Axial::from_coords(-1, 3));
assert_eq!(0 * coord, Axial::ORIGIN);
assert_eq!(coord * 2, Axial::from_coords(2, -6));

type Output = Axial

The resulting type after applying the * operator.

fn mul(self, n: i32) -> Self

Performs the * operation.

impl Ord for Axial

fn cmp(&self, other: &Axial) -> Ordering

This method returns an Ordering between self and other.

fn max(self, other: Self) -> Self

where Self: Sized,

Compares and returns the maximum of two values.

fn min(self, other: Self) -> Self

where Self: Sized,

Compares and returns the minimum of two values.

fn clamp(self, min: Self, max: Self) -> Self

where Self: Sized,

Restrict a value to a certain interval.

impl PartialEq for Axial

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

fn partial_cmp(&self, other: &Axial) -> Option<Ordering>

This method returns an ordering between self and other values if one exists.

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

Tests less than (for self and other) and is used by the < operator.

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

Tests less than or equal to (for self and other) and is used by the <= operator.

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

Tests greater than (for self and other) and is used by the > operator.

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

Tests greater than or equal to (for self and other) and is used by the >= operator.

impl Sub for Axial

Subtracts two Axial coordinates in the same manner as vectors.

Examples

use chickenwire::coordinate::axial::Axial;

let coord_1 = Axial::from_coords(1, -3);
let coord_2 = Axial::from_coords(5, -12);

assert_eq!(coord_1 - coord_2, Axial::from_coords(-4, 9));
assert_eq!(coord_2 - coord_1, Axial::from_coords(4, -9));

type Output = Axial

The resulting type after applying the - operator.

fn sub(self, other: Self) -> Self

Performs the - operation.

impl Copy for Axial

impl Eq for Axial

impl StructuralPartialEq for Axial