Struct chickenwire::coordinate::double::Double

pub struct Double { /* fields omitted */ }

Double coordinates are similar to offset coordinates. However, instead of alternating rows and columns, the horizontal or vertical step size of the adjacent hexes are doubled. This is useful for a variety of operations.

For a Sharp grid, the column value increases by a factor of two with each column. For a Flat grid, the row value increases by a factor of two with each row. In both cases, the sum of a valid coordinate's row and column values must be even, i.e. for interlaced coordinate (col, row), (col + row) % 2 == 0.

Doubles are opaque, to enforce constraints.

Methods

impl Double

pub const ORIGIN: Double

Double coordinate origin of (0, 0).

pub fn from_coords(col: i32, row: i32) -> CoordResult<Double>

Attempts to create a Double from two i32 values. If these values obey the Double constraint, (row + col) % 2 == 0, then returns that Double in an Ok. Otherwise, returns an Err.

Examples

use chickenwire::coordinate::double::Double;

let double_1 = Double::from_coords(1, 3);
let double_2 = Double::from_coords(0, 1);

assert!(double_1.is_ok());

assert_eq!(double_1.unwrap().col(), 1);
assert_eq!(double_1.unwrap().row(), 3);

assert!(double_2.is_err());

pub fn force_from_coords(col: i32, row: i32) -> Double

Creates a Double from two i32 values.

Panics

Panics if the given i32 values fail to obey the constraint (row + col) % 2 == 0.

Examples

use chickenwire::coordinate::double::Double;

let double_1 = Double::force_from_coords(1, 3);

assert_eq!(double_1.col(), 1);
assert_eq!(double_1.row(), 3);

pub fn from_tuple((col, row): (i32, i32)) -> CoordResult<Double>

Attempts to create a Double from a tuple of two i32 values. If these values obey the Double constraint, (row + col) % 2 == 0, then returns that Double in an Ok. Otherwise, returns an Err.

Examples

use chickenwire::coordinate::double::Double;

let double_1 = Double::from_tuple((1, 3));
let double_2 = Double::from_tuple((0, 1));

assert!(double_1.is_ok());

assert_eq!(double_1.unwrap().col(), 1);
assert_eq!(double_1.unwrap().row(), 3);

assert!(double_2.is_err());

pub fn col(&self) -> i32

Return the column value of a Double.

pub fn row(&self) -> i32

Return the row value of a Double.

pub fn flat_to_cube(self) -> Cube

Convert a Double to a Cube, assuming the grid has a Tilt::Flat.

pub fn sharp_to_cube(self) -> Cube

Convert a Double to a Cube, assuming the grid has a Tilt::Sharp.

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

Calculates the Double coordinates of the hexes surrounding the calling instance, in the context of a HexGrid whose hexes have the Tilt::Flat orientation.

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

Calculates the Double coordinates of the hexes surrounding the calling instance, in the context of a HexGrid whose hexes have the Tilt::Sharp orientation.

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

Calculates the distance between two Double coordinates in the context of a HexGrid whose hexes have the Tilt::Flat orientation.

Examples

use chickenwire::coordinate::Double;

let coord_1 = Double::force_from_coords(1, 1);
let coord_2 = Double::force_from_coords(2, 2);
let coord_3 = Double::force_from_coords(4, 2);

// Determines the distance between any two hexes
assert_eq!(Double::ORIGIN.flat_dist(coord_1), 1);
assert_eq!(coord_1.flat_dist(coord_2), 1);
assert_eq!(coord_1.flat_dist(coord_3), 3);

// The distance between two identical coordinates is always zero
assert_eq!(coord_1.flat_dist(coord_1), 0);
assert_eq!(coord_1.sharp_dist(coord_1), 0);

// Ordering doesn't matter
assert_eq!(
    coord_1.flat_dist(coord_2),
    coord_2.flat_dist(coord_1)
);

// Distance may or may not depend upon hex orientation
assert_eq!(
    coord_1.flat_dist(coord_2),
    coord_1.sharp_dist(coord_2)
);
assert_ne!(
    coord_1.flat_dist(coord_3),
    coord_1.sharp_dist(coord_3)
);

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

Calculates the distance between two Double coordinates in the context of a HexGrid whose hexes have the Tilt::Sharp orientation.

Examples

use chickenwire::coordinate::double::Double;

let coord_1 = Double::force_from_coords(1, 1);
let coord_2 = Double::force_from_coords(2, 2);
let coord_3 = Double::force_from_coords(4, 2);

// Determines the distance between any two hexes
assert_eq!(Double::ORIGIN.sharp_dist(coord_1), 1);
assert_eq!(coord_1.sharp_dist(coord_2), 1);
assert_eq!(coord_1.sharp_dist(coord_3), 2);

// The distance between two identical coordinates is always zero
assert_eq!(coord_1.sharp_dist(coord_1), 0);
assert_eq!(coord_1.flat_dist(coord_1), 0);

// Ordering doesn't matter
assert_eq!(
    coord_1.sharp_dist(coord_2),
    coord_2.sharp_dist(coord_1)
);

// Distance may or may not depend upon hex orientation
assert_eq!(
    coord_1.sharp_dist(coord_2),
    coord_1.flat_dist(coord_2)
);
assert_ne!(
    coord_1.sharp_dist(coord_3),
    coord_1.flat_dist(coord_3)
);

Trait Implementations

impl From<(i32, i32)> for Double

Creates a Double from an (i32, i32).

Panics

Panics when the sum of the tuple elements is odd, since this violates the constraints of the Double coordinate system.

Examples

use chickenwire::coordinate::double::Double;

let double = Double::from((0, 2));

assert_eq!(double.col(), 0);
assert_eq!(double.row(), 2);

fn from((col, row): (i32, i32)) -> Self

Performs the conversion.

impl From<MultiCoord> for Double

Creates a Double from a MultiCoord.

Panics

Panics when the MultiCoord encodes an Axial, Cube, or Offset.

fn from(coord: MultiCoord) -> Self

Performs the conversion.

impl From<Double> for CoordSys

Creates a CoordSys::Double from a Double.

fn from(_: Double) -> Self

Performs the conversion.

impl From<Double> for MultiCoord

Creates a MultiCoord from a Double.

fn from(coord: Double) -> Self

Performs the conversion.

impl Ord for Double

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

This method returns an Ordering between self and other.

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

Compares and returns the maximum of two values.

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

Compares and returns the minimum of two values.

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

🔬 This is a nightly-only experimental API. (clamp)

Restrict a value to a certain interval.

impl PartialOrd<Double> for Double

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

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

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

This method tests less than (for self and other) and is used by the < operator.

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

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

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

This method tests greater than (for self and other) and is used by the > operator.

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

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

impl PartialEq<Double> for Double

fn eq(&self, other: &Double) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Double) -> bool

This method tests for !=.

impl Default for Double

fn default() -> Double

Returns the "default value" for a type.

impl Clone for Double

fn clone(&self) -> Double

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Eq for Double

impl Copy for Double

impl Debug for Double

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

Formats the value using the given formatter.

impl Add<Double> for Double

Adds two Double coordinates in the same manner as vectors.

Examples

use chickenwire::coordinate::double::Double;

assert_eq!(
    Double::force_from_coords(-2, 2) + Double::force_from_coords(3, 5),
    Double::force_from_coords(1, 7)
);

type Output = Self

The resulting type after applying the + operator.

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

Performs the + operation.

impl Sub<Double> for Double

Subtracts two Double coordinates in the same manner as vectors.

Examples

use chickenwire::coordinate::double::Double;

assert_eq!(
    Double::force_from_coords(3, 1) - Double::force_from_coords(6, 2),
    Double::force_from_coords(-3, -1)
);

type Output = Self

The resulting type after applying the - operator.

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

Performs the - operation.

impl Mul<i32> for Double

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

Examples

use chickenwire::coordinate::double::Double;

assert_eq!(
    Double::force_from_coords(1, 3) * 5,
    Double::force_from_coords(5, 15)
);
assert_eq!(
    0 * Double::force_from_coords(100, 2),
    Double::ORIGIN
);
assert_eq!(
    Double::force_from_coords(1, 3) * (-1),
    Double::force_from_coords(-1, -3)
);

type Output = Self

The resulting type after applying the * operator.

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

Performs the * operation.

impl Mul<Double> for i32

type Output = Double

The resulting type after applying the * operator.

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

Performs the * operation.

impl Hash for Double

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, 

Feeds a slice of this type into the given [Hasher].