Struct Hex 

pub struct Hex {
    pub x: i32,
    pub y: i32,
}

Hexagonal axial coordinates

Why Axial ?

Axial coordinates allow to compute and use cubic coordinates with less storage, and allow:

• Vector operations
• Rotations
• Symmetry
• Simple algorithms

when offset and doubled coordinates don’t. Furthermore, it makes the Hex behave like classic 2D coordinates (IVec2) and therefore more user friendly.

Check out this comparison article for more information.

Conversions

• Cubic: use Self::z to compute the third axis
• Offset: use Self::from_offset_coordinates and Self::to_offset_coordinates
• Doubled: use Self::from_doubled_coordinates and Self::to_doubled_coordinates

Fields

x: i32

x axial coordinate (sometimes called q or i)

y: i32

y axial coordinate (sometimes called r or j)

Implementations

impl Hex

pub const fn to_doubled_coordinates(self, mode: DoubledHexMode) -> [i32; 2]

Converts self to doubled coordinates according to the given mode.

The coordinates are returned as [COLUMN, ROW]

pub const fn to_offset_coordinates(self, mode: OffsetHexMode) -> [i32; 2]

Converts self to offset coordinates according to the given mode.

The coordinates are returned as [COLUMN, ROW]

pub const fn to_hexmod_coordinates(self, range: u32) -> u32

Converts self to hexmod coordinates according to the given range

pub const fn from_hexmod_coordinates(coord: u32, range: u32) -> Hex

Converts hexmod to axial coordinates according to the given range

Note

The resulting coordinate will be wrong if coord is not a valid hexmod value in the given range. coord should be lesser or equal to 3 * range * (range + 1) + 1

pub const fn from_doubled_coordinates(_: [i32; 2], mode: DoubledHexMode) -> Hex

Converts doubled to axial coordinates according to the given mode.

pub const fn from_offset_coordinates(_: [i32; 2], mode: OffsetHexMode) -> Hex

Converts offset to axial coordinates according to the given mode.

impl Hex

pub const fn from_u64(value: u64) -> Hex

Unpack from a u64. x is read from the most signifigant 32 bits; y is read from the least signifigant 32 bits. Intended to be used with Hex::as_u64.

Example

let x: u64 = 0x000000AA_FFFFFF45;
assert_eq!(Hex::from_u64(x), Hex::new(0xAA, -0xBB));

pub const fn as_u64(self) -> u64

Pack into a u64. x is placed in the most signifigant 32 bits; y is placed in the least signifigant 32 bits. Can be used as a sort key, or for saving in a binary format. Intended to be used with Hex::from_u64.

Example

let x = Hex::new(0xAA, -0xBB).as_u64();
assert_eq!(x, 0x000000AA_FFFFFF45u64);

impl Hex

pub fn all_edges(self) -> [GridEdge; 6]

Return all 6 edges of the coordinate

impl Hex

pub fn all_vertices(self) -> [GridVertex; 6]

Returns all vertices of the given coordinate

impl Hex

pub fn custom_ring( self, range: u32, start_dir: EdgeDirection, clockwise: bool, ) -> impl ExactSizeIterator

Retrieves one Hex ring around self in a given range. The returned coordinates start from start_dir and loop counter clockwise around self unless clockwise is set to true.

If you only need the coordinates see Self::ring

Note

The returned iterator will have 6 * range (Self::ring_count) items, unless range is 0 which will return self

pub fn ring(self, range: u32) -> impl ExactSizeIterator

Retrieves one Hex ring around self in a given range. The returned coordinates start from EdgeDirection::default and loop around self counter clockwise.

See Self::custom_ring for more options.

Note

The returned iterator will have 6 * range (Self::ring_count) items, unless range is 0 which will return self

pub fn rings( self, range: impl Iterator<Item = u32>, ) -> impl Iterator<Item = Vec<Hex>>

Retrieves range Hex rings around self in a given range. The returned coordinates start from EdgeDirection::default and loop around self counter clockwise.

See Self::custom_rings for more options. If you only need the coordinates see Self::spiral_range.

Example

let rings: Vec<Vec<Hex>> = Hex::ZERO.rings(3..10).collect();
assert_eq!(rings.len(), 7);

pub fn custom_rings( self, range: impl Iterator<Item = u32>, start_dir: EdgeDirection, clockwise: bool, ) -> impl Iterator<Item = Vec<Hex>>

Retrieves range Hex rings around self in a given range. The returned coordinates start from start_dir and loop around self counter clockwise unless clockwise is set to true.

If you only need the coordinates see Self::spiral_range or Self::rings.

Example

let rings: Vec<Vec<Hex>> = Hex::ZERO
    .custom_rings(3..10, EdgeDirection::FLAT_TOP, true)
    .collect();
assert_eq!(rings.len(), 7);

pub fn custom_ring_edge( self, radius: u32, direction: VertexDirection, clockwise: bool, ) -> impl ExactSizeIterator

Retrieves one Hex ring edge around self in a given radius and direction. The returned coordinates are sorted counter clockwise unless clockwise is set to true.

If you only need the coordinates see Self::ring_edge.

Note

The returned vector will be of radius + 1 length

pub fn ring_edge( self, radius: u32, direction: VertexDirection, ) -> impl ExactSizeIterator

Retrieves one Hex ring edge around self in a given radius and direction. The returned coordinates are sorted counter clockwise around self.

See Self::custom_ring_edge for more options.

Note

The returned vector will be of radius + 1 length

pub fn ring_edges( self, ranges: impl Iterator<Item = u32>, direction: VertexDirection, ) -> impl Iterator<Item = impl ExactSizeIterator>

Retrieves all successive Hex ring edges around self in given ranges and direction. The returned edges coordinates are sorted counter clockwise around self.

Example

let edges: Vec<_> = Hex::ZERO
    .ring_edges(3..10, VertexDirection::FLAT_RIGHT)
    .collect();
assert_eq!(edges.len(), 7);

See also Self::custom_ring_edges If you only need the coordinates see Self::custom_wedge

pub fn custom_ring_edges( self, ranges: impl Iterator<Item = u32>, direction: VertexDirection, clockwise: bool, ) -> impl Iterator<Item = impl ExactSizeIterator>

Retrieves all successive Hex ring edges around self in given ranges and direction. The returned edges coordinates are sorted counter clockwise around self unless clockwise is set to true.

Example

let edges: Vec<_> = Hex::ZERO
    .custom_ring_edges(3..10, VertexDirection::FLAT_RIGHT, true)
    .collect();
assert_eq!(edges.len(), 7);

See also Self::ring_edges If you only need the coordinates see Self::wedge

pub fn custom_wedge( self, ranges: impl Iterator<Item = u32>, direction: VertexDirection, clockwise: bool, ) -> impl Iterator<Item = Hex>

Retrieves all successive Hex ring edges around self in given ranges and direction. The returned edges coordinates are sorted counter clockwise around self unless clockwise is set to true.

See also Self::custom_ring_edges If you only need the coordinates see Self::wedge If you want a full wedge see Self::custom_full_wedge

pub fn custom_wedge_to( self, rhs: Hex, clockwise: bool, ) -> impl ExactSizeIterator

Retrieves all successive Hex ring edges from self to rhs The returned edges coordinates are sorted counter clockwise around self unless clockwise is set to true.

See also Self::custom_ring_edges and Self::wedge_to

pub fn custom_full_wedge( self, range: u32, direction: VertexDirection, clockwise: bool, ) -> impl ExactSizeIterator

Retrieves all successive Hex ring edges around self in a given range and direction The returned edges coordinates are sorted counter clockwise around self unless clockwise is set to true.

See also Self::custom_wedge and Self::full_wedge

pub const fn wedge_count(range: u32) -> u32

Counts how many coordinates there are in a wedge of given range

Example

let point = Hex::new(3, -6);
let wedge: Vec<Hex> = point.wedge(0..=13, VertexDirection::FLAT_RIGHT).collect();
assert_eq!(wedge.len(), Hex::wedge_count(13) as usize);

pub fn wedge( self, range: impl Iterator<Item = u32>, direction: VertexDirection, ) -> impl Iterator<Item = Hex>

Retrieves all successive Hex ring edges around self in a given range and direction. The returned edges coordinates are sorted counter clockwise around self.

See also Self::custom_ring_edges and Self::custom_wedge

pub fn wedge_to(self, rhs: Hex) -> impl ExactSizeIterator

Retrieves all successive Hex ring edges from self to rhs The returned edges coordinates are sorted counter clockwise.

See also Self::custom_ring_edges and Self::custom_wedge_to

pub fn full_wedge( self, range: u32, direction: VertexDirection, ) -> impl ExactSizeIterator

Retrieves all successive Hex ring edges around self in a given range and direction The returned edges coordinates are sorted counter clockwise around self.

See also Self::custom_full_wedge and Self::wedge

pub fn corner_wedge( self, range: impl Iterator<Item = u32>, direction: EdgeDirection, ) -> impl Iterator<Item = Hex>

Retrieves all successive Hex half ring edges around self in a given range and direction.

See also Self::corner_wedge_to and Self::wedge

pub fn corner_wedge_to(self, rhs: Hex) -> impl Iterator<Item = Hex>

Retrieves all successive Hex half ring edges from self to rhs

See also Self::corner_wedge_to and Self::wedge_to

pub fn cached_custom_ring_edges<const RANGE: usize>( self, direction: VertexDirection, clockwise: bool, ) -> [Vec<Hex>; RANGE]

Retrieves all successive Hex ring edges around self in a given RANGE and direction as an array of edges. The returned edges coordinates are sorted counter clockwise around self unless clockwise is set to true.

See also Self::cached_ring_edges If you only need the coordinates see Self::ring_edges or Self::wedge.

Usage

This function’s objective is to pre-compute edges around a coordinate, the returned array can be used as a cache to avoid extra computation.

Example

// We cache 10 rings around the origin
let cache = Hex::ORIGIN.cached_custom_ring_edges::<10>(VertexDirection::FLAT_RIGHT, true);
// We have our target center
let target = Hex::new(11, 24);
// We retrieve the ring of range 5 and offset it to match the target
let five_ring = cache[5].iter().map(|h| *h + target);

See this article for more information

pub fn cached_ring_edges<const RANGE: usize>( self, direction: VertexDirection, ) -> [Vec<Hex>; RANGE]

Retrieves all successive Hex ring edges around self in a given RANGE and direction as an array of edges. The returned edges coordinates are sorted counter clockwise around self.

See also Self::cached_custom_ring_edges If you only need the coordinates see Self::ring_edges or Self::wedge.

Usage

This function’s objective is to pre-compute edges around a coordinate, the returned array can be used as a cache to avoid extra computation.

Example

// We cache 10 rings around the origin
let cache = Hex::ORIGIN.cached_ring_edges::<10>(VertexDirection::FLAT_RIGHT);
// We have our target center
let target = Hex::new(11, 24);
// We retrieve the ring of range 5 and offset it to match the target
let five_ring = cache[5].iter().map(|h| *h + target);

See this article for more information

pub fn cached_rings<const RANGE: usize>(self) -> [Vec<Hex>; RANGE]

Retrieves all successive Hex rings around self in a given RANGE as an array of rings. The returned rings start from EdgeDirection::default and loop around self counter clockwise.

See also Self::cached_custom_rings If you only need the coordinates see Self::range or Self::spiral_range.

Usage

This function’s objective is to pre-compute rings around a coordinate, the returned array can be used as a cache to avoid extra computation.

Example

// We cache 10 rings around the origin
let cache = Hex::ORIGIN.cached_rings::<10>();
// We have our target center
let target = Hex::new(11, 24);
// We retrieve the ring of range 5 and offset it to match the target
let five_ring = cache[5].iter().map(|h| *h + target);

See this article for more information

pub fn cached_custom_rings<const RANGE: usize>( self, start_dir: EdgeDirection, clockwise: bool, ) -> [Vec<Hex>; RANGE]

Retrieves all successive Hex rings around self in a given RANGE as an array of rings. The returned rings start from start_dir] and loop around self counter clockwise unless clockwise is set to true.

See also Self::cached_rings If you only need the coordinates see Self::range or Self::custom_spiral_range.

Usage

This function’s objective is to pre-compute rings around a coordinate, the returned array can be used as a cache to avoid extra computation.

Example

// We cache 10 rings around the origin
let cache = Hex::ORIGIN.cached_custom_rings::<10>(EdgeDirection::FLAT_TOP, true);
// We have our target center
let target = Hex::new(11, 24);
// We retrieve the ring of range 5 and offset it to match the target
let five_ring = cache[5].iter().map(|h| *h + target);

See this article for more information

pub fn custom_spiral_range( self, range: impl Iterator<Item = u32>, start_dir: EdgeDirection, clockwise: bool, ) -> impl Iterator<Item = Hex>

Retrieves all Hex around self in a given range but ordered as successive rings, starting from start_dir and looping counter clockwise unless clockwise is set to true, forming a spiral

If you only need the coordinates see Self::spiral_range.

See this article for more information

pub fn spiral_range( self, range: impl Iterator<Item = u32>, ) -> impl Iterator<Item = Hex>

Retrieves all Hex around self in a given range but ordered as successive rings, starting from EdgeDirection::FLAT_TOP_RIGHT and looping counter clockwise, forming a spiral.

See Self::custom_spiral_range for more options

See this article for more information

pub const fn ring_count(range: u32) -> usize

Counts how many coordinates there are in a ring at the given range

impl Hex

pub const fn xx(self) -> Hex

Returns a new Hex with both x and y set to the current x value

Example

let point = Hex::new(1, 2);
assert_eq!(point.xx(), Hex::new(1, 1));

pub const fn yy(self) -> Hex

Returns a new Hex with both x and y set to the current y value

Example

let point = Hex::new(1, 2);
assert_eq!(point.yy(), Hex::new(2, 2));

pub const fn zz(self) -> Hex

Returns a new Hex with both x and y set to the current z value

Example

let point = Hex::new(1, 2);
assert_eq!(point.zz(), Hex::new(-3, -3));

pub const fn yx(self) -> Hex

Returns a new Hex with invertex x and y values

Example

let point = Hex::new(1, 2);
assert_eq!(point.yx(), Hex::new(2, 1));

pub const fn yz(self) -> Hex

Returns a new Hex with its y valye as x and its z value as y

Example

let point = Hex::new(1, 2);
assert_eq!(point.yz(), Hex::new(2, -3));

pub const fn xz(self) -> Hex

Returns a new Hex with its z value as y

Example

let point = Hex::new(1, 2);
assert_eq!(point.xz(), Hex::new(1, -3));

pub const fn zx(self) -> Hex

Returns a new Hex with its z value as x and its x value as y

Example

let point = Hex::new(1, 2);
assert_eq!(point.zx(), Hex::new(-3, 1));

pub const fn zy(self) -> Hex

Returns a new Hex with its z value as x

Example

let point = Hex::new(1, 2);
assert_eq!(point.zy(), Hex::new(-3, 2));

impl Hex

pub const ORIGIN: Hex = Self::ZERO

(0, 0)

pub const ZERO: Hex

(0, 0)

pub const ONE: Hex

(1, 1)

pub const NEG_ONE: Hex

(-1, -1)

pub const X: Hex

+X (Q) (1, 0)

pub const NEG_X: Hex

-X (-Q) (-1, 0)

pub const Y: Hex

+Y (R) (0, 1)

pub const NEG_Y: Hex

-Y (-R) (0, -1)

pub const INCR_X: [Hex; 2]

Unit vectors that increase the X axis in clockwise order

pub const INCR_Y: [Hex; 2]

Unit vectors that increase the Y axis in clockwise order

pub const INCR_Z: [Hex; 2]

Unit vectors that increase the Z axis in clockwise order

pub const DECR_X: [Hex; 2]

Unit vectors that decrease the X axis in clockwise order

pub const DECR_Y: [Hex; 2]

Unit vectors that decrease the Y axis in clockwise order

pub const DECR_Z: [Hex; 2]

Unit vectors that decrease the Z axis in clockwise order

pub const NEIGHBORS_COORDS: [Hex; 6]

Hexagon edge neighbor coordinates array, following EdgeDirection order

      Z    ___   -Y
          /   \
      +--+  4  +--+
     / 3  \___/  5 \
     \    /   \    /
 -X   +--+     +--+    X
     /    \___/    \
     \ 2  /   \  0 /
      +--+  1  +--+
          \___/
      Y           -Z

Cubic coordinates:

             (0, -1, 1)
                 ___
                /   \
 (-1, 0, 1) +--+  4  +--+ (1, -1, 0)
           / 3  \___/  5 \
           \    /   \    /
            +--+     +--+
           /    \___/    \
(-1, 1, 0) \ 2  /   \  0 / (1, 0, -1)
            +--+  1  +--+
                \___/
              (0, 1, -1)

pub const DIAGONAL_COORDS: [Hex; 6]

Hexagon diagonal neighbor coordinates array, following VertexDirection order

      Z           -Y
          \___/
     \ 4  /   \ 5  /
      +--+     +--+
   __/    \___/    \__
     \    /   \    /
-X 3  +--+     +--+  0   X
   __/    \___/    \__
     \    /   \    /
      +--+     +--+
     / 2  \___/  1 \

      Y           -Z

pub const fn new(x: i32, y: i32) -> Hex

Instantiates a new hexagon from axial coordinates

Example

let coord = Hex::new(3, 5);
assert_eq!(coord.x, 3);
assert_eq!(coord.y, 5);
assert_eq!(coord.z(), -3 - 5);

pub const fn splat(v: i32) -> Hex

Instantiates a new hexagon with all coordinates set to v

Example

let coord = Hex::splat(3);
assert_eq!(coord.x, 3);
assert_eq!(coord.y, 3);
assert_eq!(coord.z(), -3 - 3);

pub const fn new_cubic(x: i32, y: i32, z: i32) -> Hex

Instantiates new hexagonal coordinates in cubic space

Panics

Will panic if the coordinates are invalid, meaning that the sum of coordinates is not equal to zero

Example

let coord = Hex::new_cubic(3, 5, -8);
assert_eq!(coord.x, 3);
assert_eq!(coord.y, 5);
assert_eq!(coord.z(), -8);

pub const fn x(self) -> i32

x coordinate (sometimes called q or i)

pub const fn y(self) -> i32

y coordinate (sometimes called r or j)

pub const fn z(self) -> i32

z coordinate (sometimes called s or k).

This cubic space coordinate is computed as -x - y

pub const fn from_array(_: [i32; 2]) -> Hex

Creates a Hex from an array

Example

let p = Hex::from_array([3, 5]);
assert_eq!(p.x, 3);
assert_eq!(p.y, 5);

pub const fn to_array(self) -> [i32; 2]

Converts self to an array as [x, y]

Example

let coord = Hex::new(3, 5);
let [x, y] = coord.to_array();
assert_eq!(x, 3);
assert_eq!(y, 5);

pub const fn to_array_f32(self) -> [f32; 2]

Converts self to an f32 array as [x, y]

pub const fn to_cubic_array(self) -> [i32; 3]

Converts self to cubic coordinates array as [x, y, z]

Example

let coord = Hex::new(3, 5);
let [x, y, z] = coord.to_cubic_array();
assert_eq!(x, 3);
assert_eq!(y, 5);
assert_eq!(z, -3 - 5);

pub const fn to_cubic_array_f32(self) -> [f32; 3]

Converts self to cubic f32 coordinates array as [x, y, z]

pub const fn from_slice(slice: &[i32]) -> Hex

Creates a Hex from the first 2 values in slice.

Panics

Panics if slice is less than 2 elements long.

pub fn write_to_slice(self, slice: &mut [i32])

Writes the elements of self to the first 2 elements in slice.

Panics

Panics if slice is less than 2 elements long.

pub const fn as_ivec2(self) -> IVec2

Converts self to an IVec2. This operation is a direct mapping of coordinates, no hex to square coordinates are performed. To convert hex coordinates to world space use HexLayout

pub const fn as_ivec3(self) -> IVec3

Converts self to an IVec3 using cubic coordinates. This operation is a direct mapping of coordinates. To convert hex coordinates to world space use HexLayout

pub const fn as_vec2(self) -> Vec2

Converts self to a Vec2. This operation is a direct mapping of coordinates. To convert hex coordinates to world space use HexLayout

pub const fn const_neg(self) -> Hex

Negates the coordinate, giving its reflection (symmetry) around the origin.

Hex implements Neg (- operator) but this method is const.

pub const fn const_add(self, other: Hex) -> Hex

adds self and other.

Hex implements Add (+ operator) but this method is const.

pub const fn const_sub(self, rhs: Hex) -> Hex

substracts self and rhs.

Hex implements Sub (- operator) but this method is const.

pub fn round(_: [f32; 2]) -> Hex

Rounds floating point coordinates to Hex. This method is used for operations like multiplications and divisions with floating point numbers. See the original author Jacob Rus’s article for more details

Example

let point = [0.6, 10.2];
let coord = Hex::round(point);
assert_eq!(coord.x, 1);
assert_eq!(coord.y, 10);

pub const fn abs(self) -> Hex

Computes the absolute value of self

Example

let coord = Hex::new(-1, -32).abs();
assert_eq!(coord.x, 1);
assert_eq!(coord.y, 32);

pub fn min(self, rhs: Hex) -> Hex

Returns a vector containing the minimum values for each element of self and rhs.

In other words this computes [self.x.min(rhs.x), self.y.min(rhs.y), ..].

pub fn max(self, rhs: Hex) -> Hex

Returns a vector containing the maximum values for each element of self and rhs.

In other words this computes [self.x.max(rhs.x), self.y.max(rhs.y), ..].

pub const fn dot(self, rhs: Hex) -> i32

Computes the dot product of self and rhs.

pub const fn signum(self) -> Hex

Returns a Hex with elements representing the sign of self.

• 0 if the number is zero
• 1 if the number is positive
• -1 if the number is negative

pub const fn length(self) -> i32

Computes coordinates length as a signed integer. The length of a Hex coordinate is equal to its distance from the origin.

See Self::ulength for the unsigned version

Example

let coord = Hex::new(10, 0);
assert_eq!(coord.length(), 10);

pub const fn ulength(self) -> u32

Computes coordinates length as an unsigned integer The length of a Hex coordinate is equal to its distance from the origin.

See Self::length for the signed version

Example

let coord = Hex::new(10, 0);
assert_eq!(coord.ulength(), 10);

pub const fn distance_to(self, rhs: Hex) -> i32

Computes the distance from self to rhs in hexagonal space as a signed integer

See Self::unsigned_distance_to for the unsigned version

pub const fn unsigned_distance_to(self, rhs: Hex) -> u32

Computes the distance from self to rhs in hexagonal space as an unsigned integer

See Self::distance_to for the signed version

pub const fn neighbor_coord(direction: EdgeDirection) -> Hex

Retrieves the hexagonal neighbor coordinates matching the given direction

pub const fn diagonal_neighbor_coord(direction: VertexDirection) -> Hex

Retrieves the diagonal neighbor coordinates matching the given direction

pub const fn neighbor(self, direction: EdgeDirection) -> Hex

Retrieves the neighbor coordinates matching the given direction

Example

let coord = Hex::new(10, 5);
let bottom = coord.neighbor(EdgeDirection::FLAT_BOTTOM);
assert_eq!(bottom, Hex::new(10, 6));

pub const fn diagonal_neighbor(self, direction: VertexDirection) -> Hex

Retrieves the diagonal neighbor coordinates matching the given direction

Example

let coord = Hex::new(10, 5);
let bottom = coord.diagonal_neighbor(VertexDirection::FLAT_RIGHT);
assert_eq!(bottom, Hex::new(12, 4));

pub fn neighbor_direction(self, other: Hex) -> Option<EdgeDirection>

Retrieves the direction of the given neighbor. Will return None if other is not a neighbor of self

Example

let coord = Hex::new(10, 5);
let bottom = coord.neighbor(EdgeDirection::FLAT_BOTTOM);
let dir = coord.neighbor_direction(bottom).unwrap();
assert_eq!(dir, EdgeDirection::FLAT_BOTTOM);

pub fn main_diagonal_to(self, rhs: Hex) -> VertexDirection

Find in which VertexDirection wedge rhs is relative to self.

This method can be innaccurate in case of a tie between directions, prefer using Self::diagonal_way_to instead

pub fn diagonal_way_to(self, rhs: Hex) -> DirectionWay<VertexDirection>

Find in which VertexDirection wedge rhs is relative to self

pub fn main_direction_to(self, rhs: Hex) -> EdgeDirection

Find in which EdgeDirection wedge rhs is relative to self

This method can be innaccurate in case of a tie between directions, prefer using Self::way_to for accuracy

pub fn way_to(self, rhs: Hex) -> DirectionWay<EdgeDirection>

Find in which EdgeDirection wedge rhs is relative to self

pub fn all_neighbors(self) -> [Hex; 6]

Retrieves all 6 neighbor coordinates around self

pub fn all_diagonals(self) -> [Hex; 6]

Retrieves all 6 neighbor diagonal coordinates around self

pub const fn counter_clockwise(self) -> Hex

Rotates self around Hex::ZERO counter clockwise (by -60 degrees)

Example

let p = Hex::new(1, 2);
assert_eq!(p.counter_clockwise(), Hex::new(3, -1));

pub const fn ccw_around(self, center: Hex) -> Hex

Rotates self around center counter clockwise (by -60 degrees)

pub const fn rotate_ccw(self, m: u32) -> Hex

Rotates self around Hex::ZERO counter clockwise by m (by -60 * m degrees)

pub const fn rotate_ccw_around(self, center: Hex, m: u32) -> Hex

Rotates self around center counter clockwise by m (by -60 * m degrees)

pub const fn clockwise(self) -> Hex

Rotates self around Hex::ZERO clockwise (by 60 degrees)

Example

let p = Hex::new(1, 2);
assert_eq!(p.clockwise(), Hex::new(-2, 3));

pub const fn cw_around(self, center: Hex) -> Hex

Rotates self around center clockwise (by 60 degrees)

pub const fn rotate_cw(self, m: u32) -> Hex

Rotates self around Hex::ZERO clockwise by m (by 60 * m degrees)

pub const fn rotate_cw_around(self, center: Hex, m: u32) -> Hex

Rotates self around center clockwise by m (by 60 * m degrees)

pub const fn reflect_x(self) -> Hex

Computes the reflection of self accross the x axis

pub const fn reflect_y(self) -> Hex

Computes the reflection of self accross the y axis

pub const fn reflect_z(self) -> Hex

Computes the reflection of self accross the z axis

pub fn line_to(self, other: Hex) -> impl ExactSizeIterator

Computes all coordinates in a line from self to other.

Example

let start = Hex::ZERO;
let end = Hex::new(5, 0);

let line = start.line_to(end);
assert_eq!(line.len(), 6);
let line: Vec<Hex> = line.collect();
assert_eq!(line.len(), 6);

pub fn rectiline_to(self, other: Hex, clockwise: bool) -> impl ExactSizeIterator

Computes all coordinate in a two segment rectiline path from self to other

Arguments

• other - The destination coordinate
• clockwise - If set to true the line paths will be clockwise

Example

let start = Hex::ZERO;
let end = Hex::new(5, 0);

let line = start.rectiline_to(end, true);
assert_eq!(line.len(), 6);
let line: Vec<Hex> = line.collect();
assert_eq!(line.len(), 6);
assert_eq!(line[0], start);
assert_eq!(line[5], end);

pub fn lerp(self, rhs: Hex, s: f32) -> Hex

Performs a linear interpolation between self and rhs based on the value s.

When s is 0.0, the result will be equal to self. When s is 1.0, the result will be equal to rhs. When s is outside of range [0, 1], the result is linearly extrapolated.

pub fn range(self, range: u32) -> impl ExactSizeIterator

Retrieves all Hex around self in a given range. The number of returned coordinates is equal to Hex::range_count(range)

See also Hex::xrange to retrieve all coordinates excluding self

Example

let coord = hex(12, 34);
assert_eq!(coord.range(0).len(), 1);
assert_eq!(coord.range(1).len(), 7);

pub fn xrange(self, range: u32) -> impl ExactSizeIterator

Retrieves all Hex around self in a given range except self. The number of returned coordinates is equal to Hex::range_count(range) - 1

See also Hex::range to retrieve all coordinates including self

Example

let coord = hex(12, 34);
assert_eq!(coord.xrange(0).len(), 0);
assert_eq!(coord.xrange(1).len(), 6);

pub fn to_lower_res(self, radius: u32) -> Hex

Computes the coordinate of a lower resolution hexagon containing self of a given radius. The lower resolution coordinate can be considered parent of the contained higher resolution coordinates. The radius can be thought of as a chunk size, as if the grid was split in hexagonal chunks of that radius. The returned value are the coordinates of that chunk, in its own coordinates system.

See the source documentation for more information

See also Self::to_higher_res and Self::to_local

Example

// We define a coordinate
let coord = hex(23, 45);
// We take its *parent* in a coordinate system of size 5
let parent = coord.to_lower_res(5);
// We can then retrieve the center of that parent in the same system as `coord`
let center = parent.to_higher_res(5);
// Therefore the distance between the parent center and `coord` should be lower than 5
assert!(coord.distance_to(center) <= 5);

pub const fn to_higher_res(self, radius: u32) -> Hex

Computes the center coordinates of self in a higher resolution system of a given radius. The higher resolution coordinate can be considered as a child of self as it is contained by it in a lower resolution coordinates system. The radius can be thought of as a chunk size, as if the grid was split in hexagonal chunks of that radius. The returned value are the coordinates of the center that chunk, in a higher resolution coordinates system.

See the source documentation for more information

See also Self::to_lower_res and Self::to_local

Example

// We define a coordinate
let coord = hex(23, 45);
// We take its *parent* in a coordinate system of size 5
let parent = coord.to_lower_res(5);
// We can then retrieve the center of that parent in the same system as `coord`
let center = parent.to_higher_res(5);
// Therefore the distance between the parent center and `coord` should be lower than 5
assert!(coord.distance_to(center) <= 5);

pub fn to_local(self, radius: u32) -> Hex

Computes the local coordinates of self in a lower resolution coordinates system relative to its containing parent hexagon

See the source documentation for more information

See also Self::to_lower_res and Self::to_local

Example

// We define a coordinate
let coord = hex(23, 45);
// We can then retrieve the center of that hexagon in a higher res of size 5
let center = coord.to_higher_res(5);
// Therefore, the local coordinates of `center` relative to `coord` should be zero
assert_eq!(center.to_local(5), Hex::ZERO);

pub const fn range_count(range: u32) -> u32

Counts how many coordinates there are in the given range

Example

assert_eq!(Hex::range_count(15), 721);
assert_eq!(Hex::range_count(0), 1);

pub fn wrap_in_range(self, range: u32) -> Hex

Wraps self in an hex range around the origin (Hex::ZERO). this allows for seamless wraparound hexagonal maps. See this article for more information.

Use HexBounds for custom wrapping

Trait Implementations

impl Add<EdgeDirection> for Hex

type Output = Hex

The resulting type after applying the + operator.

fn add(self, rhs: EdgeDirection) -> <Hex as Add<EdgeDirection>>::Output

Performs the + operation.

impl Add<VertexDirection> for Hex

type Output = Hex

The resulting type after applying the + operator.

fn add(self, rhs: VertexDirection) -> <Hex as Add<VertexDirection>>::Output

Performs the + operation.

impl Add<i32> for Hex

type Output = Hex

The resulting type after applying the + operator.

fn add(self, rhs: i32) -> <Hex as Add<i32>>::Output

Performs the + operation.

impl Add for Hex

type Output = Hex

The resulting type after applying the + operator.

fn add(self, rhs: Hex) -> <Hex as Add>::Output

Performs the + operation.

impl AddAssign<EdgeDirection> for Hex

fn add_assign(&mut self, rhs: EdgeDirection)

Performs the += operation.

impl AddAssign<VertexDirection> for Hex

fn add_assign(&mut self, rhs: VertexDirection)

Performs the += operation.

impl AddAssign<i32> for Hex

fn add_assign(&mut self, rhs: i32)

Performs the += operation.

impl AddAssign for Hex

fn add_assign(&mut self, rhs: Hex)

Performs the += operation.

impl BitAnd<i32> for Hex

type Output = Hex

The resulting type after applying the & operator.

fn bitand(self, rhs: i32) -> <Hex as BitAnd<i32>>::Output

Performs the & operation.

impl BitAnd for Hex

type Output = Hex

The resulting type after applying the & operator.

fn bitand(self, rhs: Hex) -> <Hex as BitAnd>::Output

Performs the & operation.

impl BitOr<i32> for Hex

type Output = Hex

The resulting type after applying the | operator.

fn bitor(self, rhs: i32) -> <Hex as BitOr<i32>>::Output

Performs the | operation.

impl BitOr for Hex

type Output = Hex

The resulting type after applying the | operator.

fn bitor(self, rhs: Hex) -> <Hex as BitOr>::Output

Performs the | operation.

impl BitXor<i32> for Hex

type Output = Hex

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: i32) -> <Hex as BitXor<i32>>::Output

Performs the ^ operation.

impl BitXor for Hex

type Output = Hex

The resulting type after applying the ^ operator.

fn bitxor(self, rhs: Hex) -> <Hex as BitXor>::Output

Performs the ^ operation.

impl Clone for Hex

fn clone(&self) -> Hex

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Hex

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

Formats the value using the given formatter.

impl Default for Hex

fn default() -> Hex

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Hex

fn deserialize<__D>( __deserializer: __D, ) -> Result<Hex, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Div<f32> for Hex

type Output = Hex

The resulting type after applying the / operator.

fn div(self, rhs: f32) -> <Hex as Div<f32>>::Output

Performs the / operation.

impl Div<i32> for Hex

type Output = Hex

The resulting type after applying the / operator.

fn div(self, rhs: i32) -> <Hex as Div<i32>>::Output

Performs the / operation.

impl Div for Hex

type Output = Hex

The resulting type after applying the / operator.

fn div(self, rhs: Hex) -> <Hex as Div>::Output

Performs the / operation.

impl DivAssign<f32> for Hex

fn div_assign(&mut self, rhs: f32)

Performs the /= operation.

impl DivAssign<i32> for Hex

fn div_assign(&mut self, rhs: i32)

Performs the /= operation.

impl DivAssign for Hex

fn div_assign(&mut self, rhs: Hex)

Performs the /= operation.

impl From<[f32; 2]> for Hex

fn from(v: [f32; 2]) -> Hex

Converts to this type from the input type.

impl From<[i32; 2]> for Hex

fn from(a: [i32; 2]) -> Hex

Converts to this type from the input type.

impl From<(f32, f32)> for Hex

fn from(v: (f32, f32)) -> Hex

Converts to this type from the input type.

impl From<(i32, i32)> for Hex

fn from(_: (i32, i32)) -> Hex

Converts to this type from the input type.

impl From<EdgeDirection> for Hex

fn from(value: EdgeDirection) -> Hex

Converts to this type from the input type.

impl From<Hex> for Tile

fn from(value: Hex) -> Self

Converts to this type from the input type.

impl From<IVec2> for Hex

fn from(v: IVec2) -> Hex

Converts to this type from the input type.

impl From<Vec2> for Hex

fn from(value: Vec2) -> Hex

Converts to this type from the input type.

impl From<VertexDirection> for Hex

fn from(value: VertexDirection) -> Hex

Converts to this type from the input type.

impl FromIterator<Hex> for Maze

fn from_iter<T: IntoIterator<Item = Hex>>(iter: T) -> Self

Creates a value from an iterator.

impl FromReflect for Hex

where Hex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn from_reflect(reflect: &(dyn PartialReflect + 'static)) -> Option<Hex>

Constructs a concrete instance of Self from a reflected value.

fn take_from_reflect( reflect: Box<dyn PartialReflect>, ) -> Result<Self, Box<dyn PartialReflect>>

Attempts to downcast the given value to Self using, constructing the value using from_reflect if that fails.

impl GetTypeRegistration for Hex

where Hex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_type_registration() -> TypeRegistration

Returns the default TypeRegistration for this type.

fn register_type_dependencies(registry: &mut TypeRegistry)

Registers other types needed by this type.

impl Hash for Hex

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

where __H: Hasher,

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<f32> for Hex

type Output = Hex

The resulting type after applying the * operator.

fn mul(self, rhs: f32) -> <Hex as Mul<f32>>::Output

Performs the * operation.

impl Mul<i32> for Hex

type Output = Hex

The resulting type after applying the * operator.

fn mul(self, rhs: i32) -> <Hex as Mul<i32>>::Output

Performs the * operation.

impl Mul for Hex

type Output = Hex

The resulting type after applying the * operator.

fn mul(self, rhs: Hex) -> <Hex as Mul>::Output

Performs the * operation.

impl MulAssign<f32> for Hex

fn mul_assign(&mut self, rhs: f32)

Performs the *= operation.

impl MulAssign<i32> for Hex

fn mul_assign(&mut self, rhs: i32)

Performs the *= operation.

impl MulAssign for Hex

fn mul_assign(&mut self, rhs: Hex)

Performs the *= operation.

impl Neg for Hex

type Output = Hex

The resulting type after applying the - operator.

fn neg(self) -> <Hex as Neg>::Output

Performs the unary - operation.

impl PartialEq<Hex> for &Hex

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

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

where Hex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn get_represented_type_info(&self) -> Option<&'static TypeInfo>

Returns the TypeInfo of the type represented by this value.

fn clone_value(&self) -> Box<dyn PartialReflect>

Clones the value as a Reflect trait object.

fn try_apply( &mut self, value: &(dyn PartialReflect + 'static), ) -> Result<(), ApplyError>

Tries to apply a reflected value to this value.

fn reflect_kind(&self) -> ReflectKind

Returns a zero-sized enumeration of “kinds” of type.

fn reflect_ref(&self) -> ReflectRef<'_>

Returns an immutable enumeration of “kinds” of type.

fn reflect_mut(&mut self) -> ReflectMut<'_>

Returns a mutable enumeration of “kinds” of type.

fn reflect_owned(self: Box<Hex>) -> ReflectOwned

Returns an owned enumeration of “kinds” of type.

fn try_into_reflect( self: Box<Hex>, ) -> Result<Box<dyn Reflect>, Box<dyn PartialReflect>>

Attempts to cast this type to a boxed, fully-reflected value.

fn try_as_reflect(&self) -> Option<&(dyn Reflect + 'static)>

Attempts to cast this type to a fully-reflected value.

fn try_as_reflect_mut(&mut self) -> Option<&mut (dyn Reflect + 'static)>

Attempts to cast this type to a mutable, fully-reflected value.

fn into_partial_reflect(self: Box<Hex>) -> Box<dyn PartialReflect>

Casts this type to a boxed, reflected value.

fn as_partial_reflect(&self) -> &(dyn PartialReflect + 'static)

Casts this type to a reflected value.

fn as_partial_reflect_mut(&mut self) -> &mut (dyn PartialReflect + 'static)

Casts this type to a mutable, reflected value.

fn reflect_partial_eq( &self, value: &(dyn PartialReflect + 'static), ) -> Option<bool>

Returns a “partial equality” comparison result.

fn apply(&mut self, value: &(dyn PartialReflect + 'static))

Applies a reflected value to this value.

fn reflect_hash(&self) -> Option<u64>

Returns a hash of the value (which includes the type).

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

Debug formatter for the value.

fn serializable(&self) -> Option<Serializable<'_>>

Returns a serializable version of the value.

fn is_dynamic(&self) -> bool

Indicates whether or not this type is a dynamic type.

impl<'a> Product<&'a Hex> for Hex

fn product<I>(iter: I) -> Hex

where I: Iterator<Item = &'a Hex>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl Product for Hex

fn product<I>(iter: I) -> Hex

where I: Iterator<Item = Hex>,

Takes an iterator and generates Self from the elements by multiplying the items.

impl Reflect for Hex

where Hex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn into_any(self: Box<Hex>) -> Box<dyn Any>

Returns the value as a Box<dyn Any>.

fn as_any(&self) -> &(dyn Any + 'static)

Returns the value as a &dyn Any.

fn as_any_mut(&mut self) -> &mut (dyn Any + 'static)

Returns the value as a &mut dyn Any.

fn into_reflect(self: Box<Hex>) -> Box<dyn Reflect>

Casts this type to a boxed, fully-reflected value.

fn as_reflect(&self) -> &(dyn Reflect + 'static)

Casts this type to a fully-reflected value.

fn as_reflect_mut(&mut self) -> &mut (dyn Reflect + 'static)

Casts this type to a mutable, fully-reflected value.

fn set(&mut self, value: Box<dyn Reflect>) -> Result<(), Box<dyn Reflect>>

Performs a type-checked assignment of a reflected value to this value.

impl Rem<i32> for Hex

type Output = Hex

The resulting type after applying the % operator.

fn rem(self, rhs: i32) -> <Hex as Rem<i32>>::Output

Performs the % operation.

impl Rem for Hex

type Output = Hex

The resulting type after applying the % operator.

fn rem(self, rhs: Hex) -> <Hex as Rem>::Output

Performs the % operation.

impl RemAssign<i32> for Hex

fn rem_assign(&mut self, rhs: i32)

Performs the %= operation.

impl RemAssign for Hex

fn rem_assign(&mut self, rhs: Hex)

Performs the %= operation.

impl Serialize for Hex

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl Shl<i16> for Hex

type Output = Hex

The resulting type after applying the << operator.

fn shl(self, rhs: i16) -> <Hex as Shl<i16>>::Output

Performs the << operation.

impl Shl<i32> for Hex

type Output = Hex

The resulting type after applying the << operator.

fn shl(self, rhs: i32) -> <Hex as Shl<i32>>::Output

Performs the << operation.

impl Shl<i8> for Hex

type Output = Hex

The resulting type after applying the << operator.

fn shl(self, rhs: i8) -> <Hex as Shl<i8>>::Output

Performs the << operation.

impl Shl<u16> for Hex

type Output = Hex

The resulting type after applying the << operator.

fn shl(self, rhs: u16) -> <Hex as Shl<u16>>::Output

Performs the << operation.

impl Shl<u32> for Hex

type Output = Hex

The resulting type after applying the << operator.

fn shl(self, rhs: u32) -> <Hex as Shl<u32>>::Output

Performs the << operation.

impl Shl<u8> for Hex

type Output = Hex

The resulting type after applying the << operator.

fn shl(self, rhs: u8) -> <Hex as Shl<u8>>::Output

Performs the << operation.

impl Shl for Hex

type Output = Hex

The resulting type after applying the << operator.

fn shl(self, rhs: Hex) -> <Hex as Shl>::Output

Performs the << operation.

impl Shr<i16> for Hex

type Output = Hex

The resulting type after applying the >> operator.

fn shr(self, rhs: i16) -> <Hex as Shr<i16>>::Output

Performs the >> operation.

impl Shr<i32> for Hex

type Output = Hex

The resulting type after applying the >> operator.

fn shr(self, rhs: i32) -> <Hex as Shr<i32>>::Output

Performs the >> operation.

impl Shr<i8> for Hex

type Output = Hex

The resulting type after applying the >> operator.

fn shr(self, rhs: i8) -> <Hex as Shr<i8>>::Output

Performs the >> operation.

impl Shr<u16> for Hex

type Output = Hex

The resulting type after applying the >> operator.

fn shr(self, rhs: u16) -> <Hex as Shr<u16>>::Output

Performs the >> operation.

impl Shr<u32> for Hex

type Output = Hex

The resulting type after applying the >> operator.

fn shr(self, rhs: u32) -> <Hex as Shr<u32>>::Output

Performs the >> operation.

impl Shr<u8> for Hex

type Output = Hex

The resulting type after applying the >> operator.

fn shr(self, rhs: u8) -> <Hex as Shr<u8>>::Output

Performs the >> operation.

impl Struct for Hex

where Hex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn field(&self, name: &str) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field named name as a &dyn PartialReflect.

fn field_mut( &mut self, name: &str, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field named name as a &mut dyn PartialReflect.

fn field_at(&self, index: usize) -> Option<&(dyn PartialReflect + 'static)>

Returns a reference to the value of the field with index index as a &dyn PartialReflect.

fn field_at_mut( &mut self, index: usize, ) -> Option<&mut (dyn PartialReflect + 'static)>

Returns a mutable reference to the value of the field with index index as a &mut dyn PartialReflect.

fn name_at(&self, index: usize) -> Option<&str>

Returns the name of the field with index index.

fn field_len(&self) -> usize

Returns the number of fields in the struct.

fn iter_fields(&self) -> FieldIter<'_>

Returns an iterator over the values of the reflectable fields for this struct.

fn clone_dynamic(&self) -> DynamicStruct

Clones the struct into a DynamicStruct.

fn get_represented_struct_info(&self) -> Option<&'static StructInfo>

Will return None if TypeInfo is not available.

impl Sub<EdgeDirection> for Hex

type Output = Hex

The resulting type after applying the - operator.

fn sub(self, rhs: EdgeDirection) -> <Hex as Sub<EdgeDirection>>::Output

Performs the - operation.

impl Sub<VertexDirection> for Hex

type Output = Hex

The resulting type after applying the - operator.

fn sub(self, rhs: VertexDirection) -> <Hex as Sub<VertexDirection>>::Output

Performs the - operation.

impl Sub<i32> for Hex

type Output = Hex

The resulting type after applying the - operator.

fn sub(self, rhs: i32) -> <Hex as Sub<i32>>::Output

Performs the - operation.

impl Sub for Hex

type Output = Hex

The resulting type after applying the - operator.

fn sub(self, rhs: Hex) -> <Hex as Sub>::Output

Performs the - operation.

impl SubAssign<EdgeDirection> for Hex

fn sub_assign(&mut self, rhs: EdgeDirection)

Performs the -= operation.

impl SubAssign<VertexDirection> for Hex

fn sub_assign(&mut self, rhs: VertexDirection)

Performs the -= operation.

impl SubAssign<i32> for Hex

fn sub_assign(&mut self, rhs: i32)

Performs the -= operation.

impl SubAssign for Hex

fn sub_assign(&mut self, rhs: Hex)

Performs the -= operation.

impl<'a> Sum<&'a Hex> for Hex

fn sum<I>(iter: I) -> Hex

where I: Iterator<Item = &'a Hex>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl Sum for Hex

fn sum<I>(iter: I) -> Hex

where I: Iterator<Item = Hex>,

Takes an iterator and generates Self from the elements by “summing up” the items.

impl TypePath for Hex

where Hex: Any + Send + Sync,

fn type_path() -> &'static str

Returns the fully qualified path of the underlying type.

fn short_type_path() -> &'static str

Returns a short, pretty-print enabled path to the type.

fn type_ident() -> Option<&'static str>

Returns the name of the type, or None if it is anonymous.

fn crate_name() -> Option<&'static str>

Returns the name of the crate the type is in, or None if it is anonymous.

fn module_path() -> Option<&'static str>

Returns the path to the module the type is in, or None if it is anonymous.

impl Typed for Hex

where Hex: Any + Send + Sync, i32: FromReflect + TypePath + MaybeTyped + RegisterForReflection,

fn type_info() -> &'static TypeInfo

Returns the compile-time info for the underlying type.

impl Copy for Hex

impl Eq for Hex

impl StructuralPartialEq for Hex