Struct beehive::Vector

#[repr(C)]pub struct Vector<T> { /* fields omitted */ }

Cube hex coordinates representing vectors. Only valid points on the plane can be normally created.

T should generally be a signed integer type. Floating point numbers have precision problems that may lead to invalid coordinates after operations.

Methods

impl<T> Vector<T>

pub fn x(&self) -> &T

pub fn y(&self) -> &T

pub fn z(&self) -> &T

pub fn w(&self) -> &T

pub fn into_axial(self) -> VectorAxial<T>

impl<T: Copy + Add + Zero> Vector<T>

pub fn try_from_coords(x: T, y: T, z: T, w: T) -> Option<Self>

Create from coordinates. Returns None if invalid.

pub fn new(x: T, y: T, z: T, w: T) -> Self

Create from coordinates. Will panic if invalid.

Panics

The function panics when called with coordinates that don't satisfy the hex plane invariant.

impl<T: Zero> Vector<T>

pub fn zero() -> Self

Return a vector where all components are zero.

impl<T: Real> Vector<T>

pub fn round(self) -> Self

Round in hex space, upholding plane invariant.

pub fn cast_round<N>(self) -> Vector<N> where
    N: 'static + Copy,
    T: AsPrimitive<N>, 

Round in hex space and cast to a primitive type.

N must be a primitive numeric type.

impl<T> Vector<T>

pub fn cast_fix<N>(self) -> Vector<N> where
    N: 'static + Copy + Add + Zero + Sub<Output = N>,
    T: AsPrimitive<N>, 

Cast to a primitive type and fix the coordinate if necessary, by discarding the Z-axis. This is preferable for integral Ts.

N must be a primitive numeric type.

impl<T> Vector<T>

pub fn into_point(self) -> Point<T>

Convert this vector to a point with the same component values.

impl<T: Zero + One + Neg<Output = T>> Vector<T>

Direction vectors.

Flat:

       yz +Y
       __
   yx /  \ xz +X
-X zx \__/ xy
    -Y zy

Pointy:

    yx  /\  yz  +Y
-X  zx |  | xz  +X
-Y  zy  \/  xy

pub fn yz() -> Vector<T>

+Y -Z direction vector.

pub fn xz() -> Vector<T>

+X -Z direction vector.

pub fn xy() -> Vector<T>

+X -Y direction vector.

pub fn zy() -> Vector<T>

+Z -Y direction vector.

pub fn zx() -> Vector<T>

+Z -X direction vector.

pub fn yx() -> Vector<T>

+Y -X direction vector.

pub fn up() -> Vector<T>

+W direction vector.

pub fn down() -> Vector<T>

-W direction vector.

pub fn directions() -> [Vector<T>; 8]

All direction vectors in sequential order.

pub fn in_direction(d: Direction) -> Vector<T>

Get directional vector from a Direction value.

impl<T: Zero + One + Neg<Output = T> + Eq> Vector<T>

pub fn try_into_direction(self) -> Option<Direction>

Return the Direction that represents self, if self is a vector of length 1. Returns None otherwise.

impl<T: Copy + Signed + One + Add + Div> Vector<T>

pub fn length(&self) -> T

Returns the manhattan length in hex space.

Trait Implementations

impl<T> Add<Direction> for Vector<T> where
    T: Zero + One + Add + Neg<Output = T>, 

type Output = Vector<T>

The resulting type after applying the + operator.

fn add(self, rhs: Direction) -> Self::Output

Performs the + operation.

impl<T, O> Add<Vector<T>> for Point<T> where
    T: Add<Output = O>, 

type Output = Point<O>

The resulting type after applying the + operator.

fn add(self, rhs: Vector<T>) -> Self::Output

Performs the + operation.

impl<T, O> Add<Vector<T>> for Vector<T> where
    T: Add<Output = O>, 

type Output = Vector<O>

The resulting type after applying the + operator.

fn add(self, rhs: Vector<T>) -> Self::Output

Performs the + operation.

impl<T> AddAssign<Direction> for Vector<T> where
    T: Zero + One + AddAssign<T> + Neg<Output = T>, 

fn add_assign(&mut self, rhs: Direction)

Performs the += operation.

impl<T> AddAssign<Vector<T>> for Point<T> where
    T: AddAssign, 

fn add_assign(&mut self, rhs: Vector<T>)

Performs the += operation.

impl<T> AddAssign<Vector<T>> for Vector<T> where
    T: AddAssign, 

fn add_assign(&mut self, rhs: Vector<T>)

Performs the += operation.

impl<T: Clone> Clone for Vector<T>

fn clone(&self) -> Vector<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Copy> Copy for Vector<T>

impl<T: Debug> Debug for Vector<T>

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

Formats the value using the given formatter.

impl<T: Default> Default for Vector<T>

fn default() -> Vector<T>

Returns the "default value" for a type.

impl<T: Display> Display for Vector<T>

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

Formats the value using the given formatter.

impl<T: Eq> Eq for Vector<T>

impl<T> From<Vector<T>> for VectorAxial<T>

fn from(c: Vector<T>) -> Self

Performs the conversion.

impl<T: Copy + Zero + Sub<Output = T>> From<VectorAxial<T>> for Vector<T>

fn from(c: VectorAxial<T>) -> Vector<T>

Performs the conversion.

impl<T: Hash> Hash for Vector<T>

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].

impl<T, O> Mul<T> for Vector<T> where
    T: Copy + Mul<Output = O>, 

type Output = Vector<O>

The resulting type after applying the * operator.

fn mul(self, rhs: T) -> Self::Output

Performs the * operation.

impl<T> MulAssign<T> for Vector<T> where
    T: Copy + MulAssign, 

fn mul_assign(&mut self, rhs: T)

Performs the *= operation.

impl<T: PartialEq> PartialEq<Vector<T>> for Vector<T>

fn eq(&self, other: &Vector<T>) -> bool

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

fn ne(&self, other: &Vector<T>) -> bool

This method tests for !=.

impl<T> StructuralEq for Vector<T>

impl<T> StructuralPartialEq for Vector<T>

impl<T> Sub<Direction> for Vector<T> where
    T: Zero + One + Sub<Output = T> + Neg<Output = T>, 

type Output = Vector<T>

The resulting type after applying the - operator.

fn sub(self, rhs: Direction) -> Self::Output

Performs the - operation.

impl<T, O> Sub<Vector<T>> for Point<T> where
    T: Sub<Output = O>, 

type Output = Point<O>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector<T>) -> Self::Output

Performs the - operation.

impl<T, O> Sub<Vector<T>> for Vector<T> where
    T: Sub<Output = O>, 

type Output = Vector<O>

The resulting type after applying the - operator.

fn sub(self, rhs: Vector<T>) -> Self::Output

Performs the - operation.

impl<T> SubAssign<Direction> for Vector<T> where
    T: Zero + One + SubAssign<T> + Neg<Output = T>, 

fn sub_assign(&mut self, rhs: Direction)

Performs the -= operation.

impl<T> SubAssign<Vector<T>> for Point<T> where
    T: SubAssign, 

fn sub_assign(&mut self, rhs: Vector<T>)

Performs the -= operation.

impl<T> SubAssign<Vector<T>> for Vector<T> where
    T: SubAssign, 

fn sub_assign(&mut self, rhs: Vector<T>)

Performs the -= operation.