Enum Direction4

pub enum Direction4 {
    North,
    East,
    South,
    West,
}

Four-way directions.

These start at North and increment counter-clockwise, so you can convert them to integers with as and use them in rotational calculations if you need.

Variants

North

East

South

West

Implementations

impl Direction4

pub const DIRECTIONS: [Direction4; 4]

All the directions in order. This is used internally for rotations and flips. I made it public just in case it’s helpful for you the programmer.

pub fn rotate(self, rot: Rotation) -> Self

Rotate this by the given amount.

use Direction4::*;
use Rotation::*;

assert_eq!(North.rotate(Clockwise), East);
assert_eq!(North.rotate(CounterClockwise), West);

pub fn rotate_by(self, steps_clockwise: isize) -> Self

Get this direction, rotated by this many steps clockwise. Negative numbers go counter-clockwise.

use Direction4::*;
assert_eq!(North.rotate_by(1), East);
assert_eq!(North.rotate_by(2), South);
assert_eq!(North.rotate_by(-1), West);
assert_eq!(North.rotate_by(5).rotate_by(-11), South);

pub fn flip(self) -> Self

Flip this direction.

use Direction4::*;
assert_eq!(North.flip(), South);
assert_eq!(West.flip(), East);
assert_eq!(East.flip().flip(), East);

pub fn radians(self) -> f32

Get this direction in radians.

This uses trigonometric + graphical standard, where:

• 0 radians is to the right
• Positive radians increment clockwise. NOTE: this is opposite from normal trig, but makes sense in computer graphics where +Y is downwards.

If you need it in degrees just call .to_degrees on the result.

use Direction4::*;
use std::f32::consts::TAU;

let north_radians = North.radians();
assert!((north_radians - (TAU / 4.0 * 3.0)).abs() < 1e-10);

let west_radians = West.radians();
assert!((west_radians - (TAU / 4.0 * 2.0)).abs() < 1e-10);

pub fn deltas(self) -> ICoord

Get the deltas a step in this direction would result in, as a ICoord.

use Direction4::*;

assert_eq!(North.deltas(), ICoord {x: 0, y: -1});
assert_eq!(West.deltas(), ICoord {x: -1, y: 0});

pub fn is_horizontal(self) -> bool

See if this direction points horizontally (ie, is East or West).

use Direction4::*;

assert!(East.is_horizontal());
assert!(!South.is_horizontal());

pub fn is_vertical(self) -> bool

See if this direction points vertically (ie, is North or South).

use Direction4::*;

assert!(North.is_vertical());
assert!(!West.is_vertical());

Trait Implementations

impl Add<Direction4> for ICoord

type Output = ICoord

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Direction4> for ICoord

fn add_assign(&mut self, rhs: Direction4)

Performs the += operation.

impl Clone for Direction4

fn clone(&self) -> Direction4

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Direction4

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

Formats the value using the given formatter.

impl<V> Enum<V> for Direction4

type Array = [V; 4]

Representation of an enum map for type V.

fn from_usize(value: usize) -> Self

Takes an usize, and returns an element matching into_usize function.

fn into_usize(self) -> usize

Returns an unique identifier for a value within range of 0..Array::LENGTH.

impl Hash for Direction4

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 Ord for Direction4

fn cmp(&self, other: &Direction4) -> 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 Direction4

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

fn partial_cmp(&self, other: &Direction4) -> 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 Copy for Direction4

impl Eq for Direction4

impl StructuralPartialEq for Direction4