Struct Coordinate 

pub struct Coordinate<I: Integer = i32> {
    pub x: I,
    pub y: I,
}

Coordinate on 2d hexagonal grid

Fields

x: I

x coordinate

y: I

y coordinate

Implementations

impl<I: Integer> Coordinate<I>

pub fn new(x: I, y: I) -> Coordinate<I>

Create new Coord from x and y

pub fn nearest<F: Float>(x: F, y: F) -> Coordinate<I>

Round x, y float to nearest hex coordinates

pub fn nearest_lossy<F: Float>(x: F, y: F) -> Option<Coordinate<I>>

Round x, y float to nearest hex coordinates

Return None, if exactly on the border of two hex coordinates

pub fn from_pixel<F: Float>(x: F, y: F, spacing: Spacing<F>) -> Coordinate<I>

Find the hex containing a pixel. The origin of the pixel coordinates is the center of the hex at (0,0) in hex coordinates.

pub fn nearest_with_offset( spacing: IntegerSpacing<I>, v: (I, I), ) -> (Coordinate<I>, (I, I))

Convert integer pixel coordinates v using spacing to nearest coordinate that has both integer pixel coordinates lower or equal to v. Also return offset (in integer pixels) from that coordinate.

Useful for ASCII visualization.

pub fn to_pixel<F: Float>(&self, spacing: Spacing<F>) -> (F, F)

Convert to pixel coordinates using spacing, where the parameter means the edge length of a hexagon.

This function is meant for graphical user interfaces where resolution is big enough that floating point calculation make sense.

pub fn to_pixel_integer(&self, spacing: IntegerSpacing<I>) -> (I, I)

Convert to integer pixel coordinates using spacing, where the parameters mean the width and height multiplications

pub fn scale(&self, s: I) -> Coordinate<I>

Scale coordinate by a factor s

pub fn neighbors(&self) -> [Coordinate<I>; 6]

Array with all the neighbors of a coordinate

pub fn rotate_around_zero(&self, a: Angle) -> Coordinate<I>

Rotate self around a point (0, 0, 0) using angle of rotation a

pub fn rotate_around(&self, center: Coordinate<I>, a: Angle) -> Coordinate<I>

Rotate self around a center using angle of rotation a

pub fn line_to_iter(&self, dest: Coordinate<I>) -> LineTo<I>

Iterator over each coordinate in straight line from self to dest

pub fn line_to_lossy_iter(&self, dest: Coordinate<I>) -> LineToLossy<I>

Iterator over each coordinate in straight line from self to dest

Skip points on the border of two tiles

pub fn line_to_with_edge_detection_iter( &self, dest: Coordinate<I>, ) -> LineToWithEdgeDetection<I>

Iterator over each coordinate in straight line from self to dest

On edge condition the pair contains different members, otherwise it’s the same.

pub fn z(&self) -> I

Z coordinate

pub fn direction_from_center_cw(&self) -> Option<Direction>

Direction from center (0, 0) to coordinate

In case of diagonals (edge of two major directions), prefers direction that is clockwise from the diagonal

Returns: None if is center

use hex2d::{Direction, Coordinate};
use hex2d::{Left, Right};

let center = Coordinate::new(0, 0);

assert_eq!(center.direction_from_center_cw(), None);

for &d in Direction::all() {
    assert_eq!((center + d).direction_from_center_cw(), Some(d));
    assert_eq!((center + d + (d + Left)).direction_from_center_cw(), Some(d));
    assert_eq!((center + d + (d + Right)).direction_from_center_cw(), Some(d + Right));
}

pub fn directions_from_center(&self) -> Vec<Direction>

Directions that lead from center to a given point.

Returns an array of one or two directions.

pub fn direction_from_center_ccw(&self) -> Option<Direction>

Direction from center (0, 0) to coordinate

In case of diagonals (edge of two major directions), prefers direction that is counter-clockwise from the diagonal.

Returns: None if is center

use hex2d::{Direction, Coordinate};
use hex2d::{Left, Right};

let center = Coordinate::new(0, 0);

assert_eq!(center.direction_from_center_ccw(), None);

for &d in Direction::all() {
    assert_eq!((center + d).direction_from_center_ccw(), Some(d));
    assert_eq!((center + d + (d + Left)).direction_from_center_ccw(), Some(d + Left));
    assert_eq!((center + d + (d + Right)).direction_from_center_ccw(), Some(d));
}

pub fn directions_to(&self, coord: Coordinate<I>) -> Vec<Direction>

Directions from self to coord

pub fn direction_to_cw(&self, coor: Coordinate<I>) -> Option<Direction>

Direction from self to coord

In case of diagonals (edge of two major directions), prefers direction that is clockwise from the diagonal.

Returns: None if is center

pub fn direction_to_ccw(&self, coor: Coordinate<I>) -> Option<Direction>

Direction from self to coor

In case of diagonals (edge of two major directions), prefers direction that is counter-clockwise from the diagonal.

Returns: None if is center

pub fn distance(&self, c: Coordinate<I>) -> I

Distance between two Coordinates

pub fn range_iter(&self, r: I) -> Range<I>

An iterator over all coordinates in radius r

pub fn ring_iter(&self, r: i32, s: Spin) -> Ring<I>

Iterator over each coordinate in a ring

Example: Elements in order for Ring of radius 2, Direction ZX, CCW

             8
           9   7
        10   .   6
           .   .
        11   x   5
           .   .
         0   .   4
           1   3
             2

use hex2d::{Coordinate, Spin, XY};

let center = Coordinate::new(5, -1);

for &c in &center.neighbors() {
    for ring_c in c.ring_iter(5, Spin::CCW(XY)) {
        assert_eq!(c.distance(ring_c), 5);
    }
}

Trait Implementations

impl<I: Integer> Add<Coordinate<I>> for Position<I>

type Output = Position<I>

The resulting type after applying the + operator.

fn add(self, c: Coordinate<I>) -> Position<I>

Performs the + operation.

impl<I: Integer, T: Into<Coordinate<I>>> Add<T> for Coordinate<I>

type Output = Coordinate<I>

The resulting type after applying the + operator.

fn add(self, c: T) -> Coordinate<I>

Performs the + operation.

impl<I: Clone + Integer> Clone for Coordinate<I>

fn clone(&self) -> Coordinate<I>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<I: Debug + Integer> Debug for Coordinate<I>

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

Formats the value using the given formatter.

impl<'de, I> Deserialize<'de> for Coordinate<I>

where I: Deserialize<'de> + Integer,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<I: Integer> From<(I, I)> for Coordinate<I>

fn from(xy: (I, I)) -> Self

Converts to this type from the input type.

impl<I: Integer> From<Direction> for Coordinate<I>

fn from(dir: Direction) -> Self

Converts to this type from the input type.

impl<I: Integer> From<Position<I>> for Coordinate<I>

fn from(pos: Position<I>) -> Self

Converts to this type from the input type.

impl<I: Hash + Integer> Hash for Coordinate<I>

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<I: Integer> Neg for Coordinate<I>

type Output = Coordinate<I>

The resulting type after applying the - operator.

fn neg(self) -> Coordinate<I>

Performs the unary - operation.

impl<I: Ord + Integer> Ord for Coordinate<I>

fn cmp(&self, other: &Coordinate<I>) -> 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<I: PartialEq + Integer> PartialEq for Coordinate<I>

fn eq(&self, other: &Coordinate<I>) -> 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<I: PartialOrd + Integer> PartialOrd for Coordinate<I>

fn partial_cmp(&self, other: &Coordinate<I>) -> 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<I> Serialize for Coordinate<I>

where I: Serialize + Integer,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<I: Integer> Sub<Coordinate<I>> for Position<I>

type Output = Position<I>

The resulting type after applying the - operator.

fn sub(self, c: Coordinate<I>) -> Position<I>

Performs the - operation.

impl<I: Integer, T: Into<Coordinate<I>>> Sub<T> for Coordinate<I>

type Output = Coordinate<I>

The resulting type after applying the - operator.

fn sub(self, c: T) -> Coordinate<I>

Performs the - operation.

impl<I: Copy + Integer> Copy for Coordinate<I>

impl<I: Eq + Integer> Eq for Coordinate<I>

impl<I: Integer> StructuralPartialEq for Coordinate<I>