Enum Direction8

pub enum Direction8 {
    North,
    NorthEast,
    East,
    SouthEast,
    South,
    SouthWest,
    West,
    NorthWest,
}

Eight-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

NorthEast

East

SouthEast

South

SouthWest

West

NorthWest

Implementations

impl Direction8

pub const DIRECTIONS: [Direction8; 8]

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 Direction8::*;
use Rotation::*;

assert_eq!(NorthEast.rotate(Clockwise), East);
assert_eq!(South.rotate(CounterClockwise), SouthEast);

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

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

use Direction8::*;
let north = North;
assert_eq!(north.rotate_by(1), NorthEast);
assert_eq!(north.rotate_by(2), East);
assert_eq!(north.rotate_by(-1), NorthWest);
assert_eq!(north.rotate_by(4), South);
assert_eq!(north.rotate_by(5).rotate_by(-11), East);

pub fn flip(self) -> Self

Flip this direction.

use Direction8::*;
assert_eq!(North.flip(), South);
assert_eq!(West.flip(), East);
assert_eq!(SouthWest.flip(), NorthEast);
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 Direction8::*;
use std::f32::consts::TAU;

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

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

let southeast_radians = SouthEast.radians();
assert!((southeast_radians - (TAU / 8.0)).abs() < 1e-10);

pub fn deltas(self) -> ICoord

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

use Direction8::*;

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

Trait Implementations

impl Add<Direction8> for ICoord

type Output = ICoord

The resulting type after applying the + operator.

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

Performs the + operation.

impl AddAssign<Direction8> for ICoord

fn add_assign(&mut self, rhs: Direction8)

Performs the += operation.

impl Clone for Direction8

fn clone(&self) -> Direction8

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Direction8

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

Formats the value using the given formatter.

impl<V> Enum<V> for Direction8

type Array = [V; 8]

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 Direction8

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 Direction8

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

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

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

impl Eq for Direction8

impl StructuralPartialEq for Direction8