Struct Vec2D

pub struct Vec2D<T> {
    x: T,
    y: T,
}

A 2D vector generic over any numeric type.

This struct represents a 2D point or vector in space and provides common mathematical operations such as addition, normalization, rotation, and distance calculations.

Type Parameters

• T - The functionality for the vector depends on traits implemented by T.

Fields

x: T

The x-component of the vector.

y: T

The y-component of the vector.

Implementations

impl<T> Vec2D<T>

where T: FixedSigned + NumAssignOps,

pub fn abs(&self) -> T

Computes the magnitude (absolute value) of the vector.

Returns

The magnitude of the vector as a scalar of type T.

pub fn abs_sq(&self) -> T

pub fn round(&self) -> Self

pub fn round_to_2(&self) -> Self

pub fn floor(&self) -> Self

pub fn from_real<R>(other: &Vec2D<R>) -> Self

where R: Copy + ToFixed,

pub fn to(&self, other: &Self) -> Self

Creates a vector pointing from the current vector (self) to another vector (other).

Arguments

• other - The target vector.

Returns

A new vector representing the direction from self to other.

pub fn to_num<R: FromFixed + Copy>(self) -> Vec2D<R>

pub fn project_overboundary_fw(&self, dir: &Self) -> Self

pub fn project_overboundary_bw(&self, dir: &Self) -> Self

pub fn unwrapped_to(&self, other: &Self) -> Self

Computes an “unwrapped” vector pointing from the current vector (self) to another vector (other).

This method considers potential wrapping around a 2D map (based on the map size) and calculates the smallest vector that connects self to other. The wrapping allows for efficient navigation across boundaries.

Arguments

• other - The target vector to which the direction is computed.

Returns

A Vec2D representing the shortest unwrapped direction from self to other.

pub fn unwrap_all(&self) -> [Self; 9]

pub fn unwrapped_to_top_right(&self, other: &Self) -> Self

pub fn unwrapped_to_bottom_right(&self, other: &Self) -> Self

fn get_projected_in_range( &self, to: &Self, range: (&[i8], &[i8]), ) -> Vec<(Self, I64F64)>

pub fn perp_unit_to(&self, other: &Self) -> Self

Computes a perpendicular unit vector pointing to another vector (other).

The direction of the perpendicular vector depends on whether self is clockwise or counterclockwise to other.

Arguments

• other - The target vector to compare directions with.

Returns

A unit Vec2D perpendicular to self pointing towards other. Returns a zero vector if self and other are collinear.

pub fn perp_unit(&self, clockwise: bool) -> Self

Computes a perpendicular unit vector to the current vector.

The direction of the perpendicular vector depends on the clockwise parameter.

Arguments

• clockwise - A boolean indicating the direction. true for clockwise, false for counterclockwise.

Returns

A normalized perpendicular Vec2D.

pub fn flip_unit(&self) -> Self

Computes a flipped collinear unit vector to the current vector.

This is equivalent to rotating the vector 180 degrees.

Returns

A normalized flipped collinear Vec2D.

pub fn is_clockwise_to(&self, other: &Self) -> Option<bool>

Determines whether the current vector is clockwise relative to another vector (other).

This is determined using the cross product:

• Some(true) if self is clockwise to other.
• Some(false) if self is counterclockwise to other.
• None if self and other are collinear.

Arguments

• other - The vector to compare relative direction with.

Returns

An Option<bool> indicating the relative direction.

pub fn angle_to(&self, other: &Self) -> T

Computes the angle (in degrees) between the current vector and another vector (other).

The method calculates the cosine of the angle using the dot product, clamps it to the valid range of [-1, 1], and then computes the angle in degrees.

Arguments

• other - The target vector to compute the angle to.

Returns

The angle in degrees as a scalar of type T.

pub fn normalize(self) -> Self

Normalizes the vector to have a magnitude of 1. If the magnitude is zero, the original vector is returned unmodified.

Returns

A normalized vector.

pub fn rotate_by(&mut self, angle_degrees: T)

Rotates the vector by a given angle in degrees.

Arguments

• angle_degrees - The angle to rotate by, in degrees.

pub fn is_eq_signum(&self, other: &Self) -> bool

pub fn euclid_distance(&self, other: &Self) -> T

Computes the Euclidean distance between the current vector and another vector.

Arguments

• other - The other vector to compute the distance to.

Returns

The Euclidean distance as a scalar of type T.

pub fn euclid_distance_sq(&self, other: &Self) -> T

Computes the Euclidean distance squared.

Arguments

• other - The other vector to compute the distance to.

Returns

The Euclidean distance squared as a scalar of type T.

pub fn from_axis_and_val(axis: VecAxis, val: T) -> Self

impl<T: Copy> Vec2D<T>

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

Creates a new vector with the given x and y components.

Arguments

• x - The x-component of the vector.
• y - The y-component of the vector.

Returns

A new Vec2D object.

pub const fn x(&self) -> T

Returns the x-component of the vector.

Returns

The x value of type T.

pub const fn y(&self) -> T

Returns the y-component of the vector.

Returns

The y value of type T.

pub const fn get(&self, axis: VecAxis) -> T

impl<T: Fixed + Copy> Vec2D<T>

pub fn dot(self, other: &Self) -> T

Computes the dot product of the current vector with another vector. The dot product is defined as:

dot_product = (x1 * x2) + (y1 * y2)

Arguments

• other - Another Vec2D vector to compute the dot product with.

Returns

A scalar value of type T that represents the dot product of the two vectors.

pub fn cross(self, other: &Self) -> T

Computes the cross product of the current vector with another vector.

The cross product is defined as:

cross_product = (x1 * y2) - (y1 * x2)

Arguments

• other - Another Vec2D vector to compute the cross product with.

Returns

A scalar value of type T that represents the cross product of the two vectors.

pub fn abs_f64(self) -> f64

Computes the magnitude (absolute value) of the vector as an f64. This enables magnitude calculation for integer types T.

Returns

The magnitude of the vector as an f64.

pub fn zero() -> Self

Creates a zero vector (x = 0, y = 0).

Returns

A zero-initialized Vec2D with member type T.

pub fn is_zero(&self) -> bool

impl Vec2D<i32>

pub fn to_unsigned(self) -> Vec2D<u32>

Converts the vector to an unsigned equivalent.

This method casts both the x and y components of the vector from i32 to u32.

Returns

A Vec2D<u32> with the unsigned components of the original vector.

Note

The conversion may cause loss of sign. Negative values will wrap around.

impl<T> Vec2D<T>

where T: Add<Output = T> + Rem<Output = T> + Copy + MapSize<Output = T> + PartialEq,

pub fn wrap_around_map(&self) -> Self

Wraps the vector around a predefined 2D map.

This method ensures the vector’s coordinates do not exceed the boundaries of the map defined by map_size(). If coordinates go beyond these boundaries, they are wrapped to remain within valid values.

pub fn wraps(&self) -> WrapDirection

pub fn wrap_by(&self, dir: &WrapDirection) -> Self

pub fn wrap_coordinate(value: T, max_value: T) -> T

Wraps a single coordinate around a specific maximum value.

Arguments

• value - The value to wrap.
• max_value - The maximum value to wrap around.

Returns

The wrapped coordinate as type T.

Trait Implementations

impl<T> Add for Vec2D<T>

where T: Add<Output = T>,

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

Implements the + operator for two Vec2D objects.

Arguments

• rhs - The vector to add.

Returns

A new Vec2D representing the sum of the vectors.

type Output = Vec2D<T>

The resulting type after applying the + operator.

impl<T: Clone> Clone for Vec2D<T>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: Debug> Debug for Vec2D<T>

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

Formats the value using the given formatter.

impl<'de, T> Deserialize<'de> for Vec2D<T>

where T: Deserialize<'de>,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<T> Display for Vec2D<T>

where T: Display,

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

Formats the Vec2D as a string in the format [x, y].

Arguments

• f - A mutable reference to the formatter.

Returns

A Result indicating the success of the formatting operation.

impl<T> Div<T> for Vec2D<T>

where T: Div<T, Output = T> + Copy,

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

Implements the / operator for a Vec2D and a scalar.

Arguments

• rhs - The scalar value to divide by.

Returns

A new scaled vector.

type Output = Vec2D<T>

The resulting type after applying the / operator.

impl<T> From<&[T; 2]> for Vec2D<T>

where T: Copy,

fn from(slice: &[T; 2]) -> Self

Creates a Vec2D from a slice of (x, y) values.

Arguments

• slice - A slice representing the x and y values.

Returns

A new Vec2D created from the slice.

impl<T: Num> From<(T, T)> for Vec2D<T>

fn from(tuple: (T, T)) -> Self

Creates a Vec2D from a tuple of (x, y) values.

Arguments

• tuple - A tuple representing the x and y values.

Returns

A new Vec2D created from the tuple.

impl<T> From<Vec2D<T>> for [T; 2]

where T: Copy,

fn from(vec: Vec2D<T>) -> Self

Creates a slice [x, y] from a Vec2D.

Arguments

• vec - A Vec2D representing the x and y values.

Returns

A new slice created from the Vec2D.

impl<T: Num> From<Vec2D<T>> for (T, T)

fn from(value: Vec2D<T>) -> Self

Creates a tuple from a Vec2D of (x, y) values.

Arguments

• tuple - A tuple representing the x and y values.

Returns

A new Vec2D created from the tuple.

impl<T: Hash> Hash for Vec2D<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, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl<T> MapSize for Vec2D<T>

where T: MapSize<Output = T>,

Implementation of the MapSize trait for a Vec2D type with components that also implement the MapSize trait.

fn map_size() -> Vec2D<Self::Output>

Defines the size of the map by delegating to the map_size implementation of T.

Returns

A Vec2D with components of type T representing the map dimensions.

type Output = T

The output type of the map dimensions.

impl<T, TMul> Mul<TMul> for Vec2D<T>

where T: Fixed, TMul: Fixed + Copy,

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

Implements the * operator for a Vec2D and a scalar.

Arguments

• rhs - The scalar value to multiply by.

Returns

A new scaled vector.

type Output = Vec2D<T>

The resulting type after applying the * operator.

impl<T: PartialEq> PartialEq for Vec2D<T>

fn eq(&self, other: &Vec2D<T>) -> 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<T> Serialize for Vec2D<T>

where T: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<T, TSub> Sub<Vec2D<TSub>> for Vec2D<T>

where T: FixedSigned, TSub: Fixed,

fn sub(self, rhs: Vec2D<TSub>) -> Self::Output

Implements the - operator for two Vec2D.

Arguments

• rhs - The Vec2D to subtract.

Returns

A new vector.

type Output = Vec2D<T>

The resulting type after applying the - operator.

impl<T: Copy> Copy for Vec2D<T>

impl<T: Eq> Eq for Vec2D<T>

impl<T> StructuralPartialEq for Vec2D<T>