Struct Coordinates

pub struct Coordinates {
    pub x: u32,
    pub y: u32,
}

Coordinates

A Coordinates represents a 2D grid position with unsigned x and y values. It is the primary spatial unit used throughout the RPGX engine for addressing tiles, shapes, and spatial operations.

Coordinates support basic arithmetic, delta-based translation, and bounding logic.

---

Example

use rpgx::prelude::*;

let a = Coordinates::new(2, 3);
let b = Coordinates::new(1, 1);
let delta = Delta::new(-1, 2);

assert_eq!(a + b, Coordinates::new(3, 4));
assert_eq!(a.offseted(delta), Coordinates::new(1, 5));

---

Fields

x: u32

The horizontal position on the grid (0-indexed).

y: u32

The vertical position on the grid (0-indexed).

---

Constructors

Coordinates::new(x: u32, y: u32) -> Self

Creates a new Coordinates instance at the specified x, y position.

use rpgx::prelude::*;

let coord = Coordinates::new(2, 3);

---

Coordinates::bounding_box(coords: &[Coordinates]) -> Option<(Coordinates, Coordinates)>

Computes the smallest exclusive bounding box that contains all the given coordinates.

use rpgx::prelude::*;

let points = vec![
    Coordinates::new(1, 2),
    Coordinates::new(3, 4),
    Coordinates::new(2, 1),
];
let (min, max) = Coordinates::bounding_box(&points).unwrap();
assert_eq!(min, Coordinates::new(1, 1));
assert_eq!(max, Coordinates::new(4, 5)); // Exclusive

Returns None if the input is empty.

---

Methods

fn is_origin(&self) -> bool

Returns true if the coordinate is at the origin (0, 0).

---

fn is_aligned_with(self, other: Self) -> bool

Returns true if self shares either the same x or y value with other.

---

fn is_within(&self, origin: Coordinates, shape: Shape) -> bool

Checks if the coordinate lies inside the rectangle defined by origin and shape. The bounds are exclusive: [origin, origin + shape).

use rpgx::prelude::*;

let inside = Coordinates::new(3, 4).is_within(Coordinates::new(2, 2), Shape::new(3, 3));

---

fn offseted(self, delta: Delta) -> Self

Applies a Delta to this coordinate, using saturating arithmetic to prevent underflow.

---

fn try_offseted(self, delta: Delta) -> Option<Coordinates>

Applies a delta, returning None if it would result in negative coordinates.

---

fn to_delta(self) -> Delta

Converts the coordinate into a delta with dx = x and dy = y.

---

Design Notes

• Coordinates are unsigned and saturate on subtraction. Use try_offseted when negative shifts should be validated.
• Supports composable arithmetic with Shape, Delta, and other Coordinates.
• Designed for grid-based logic in pathfinding, masking, and tile manipulation.

---

See Also

• Delta: Describes relative movement across coordinates.
• Shape: Describes dimensions for regions starting at a coordinate.
• Rect: Represents rectangular areas of the grid.
• Mask, Layer, Map Represents a 2D grid coordinate with x and y components.

Fields

x: u32

y: u32

Implementations

impl Coordinates

Constructors

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

pub fn bounding_box(coords: &[Self]) -> Option<(Self, Self)>

Computes the exclusive bounding box that contains all the given coordinates.

Returns None if the input slice is empty.

impl Coordinates

Coordinates utils

pub fn is_origin(&self) -> bool

Returns true if the coordinate is at the origin (0, 0).

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

Returns true if the two coordinates share either x or y axis.

impl Coordinates

Shape integration

pub fn is_within(&self, origin: Coordinates, shape: Shape) -> bool

Checks whether this coordinate lies within the rectangular area defined by an origin and a Shape (width × height).

The bounds are half-open: [origin, origin + shape).

impl Coordinates

Delta integration

pub fn offseted(self, delta: Delta) -> Self

Returns a new coordinate by applying the given Delta. Will saturate at u32::MIN or u32::MAX when under-/overflowing.

pub fn try_offseted(self, delta: Delta) -> Option<Self>

Returns a new coordinate by applying the given Delta, or None if it would result in a negative coordinate (invalid in unsigned space).

pub fn to_delta(self) -> Delta

Converts this coordinate into a Delta where dx = x and dy = y.

Trait Implementations

impl Add<Coordinates> for Shape

Arithmetic with coordinates

type Output = Shape

The resulting type after applying the + operator.

fn add(self, coordinates: Coordinates) -> Shape

Performs the + operation.

impl Add<Delta> for Coordinates

fn add(self, delta: Delta) -> Self::Output

Adds a Delta, returning None if the result is negative.

type Output = Option<Coordinates>

The resulting type after applying the + operator.

impl Add<Shape> for Coordinates

fn add(self, shape: Shape) -> Coordinates

Adds a Shape (width, height) to the coordinate.

type Output = Coordinates

The resulting type after applying the + operator.

impl Add for Coordinates

fn add(self, rhs: Coordinates) -> Coordinates

Adds another coordinate component-wise.

type Output = Coordinates

The resulting type after applying the + operator.

impl AddAssign for Coordinates

fn add_assign(&mut self, rhs: Coordinates)

Adds another coordinate in-place component-wise.

impl Clone for Coordinates

fn clone(&self) -> Coordinates

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Coordinates

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

Formats the value using the given formatter.

impl Default for Coordinates

fn default() -> Coordinates

Returns the “default value” for a type.

impl Hash for Coordinates

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 PartialEq for Coordinates

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

Tests for self and other values to be equal, and is used by ==.

const 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 Sub<Coordinates> for Shape

type Output = Shape

The resulting type after applying the - operator.

fn sub(self, coordinates: Coordinates) -> Shape

Performs the - operation.

impl Sub<Delta> for Coordinates

fn sub(self, delta: Delta) -> Self::Output

Subtracts a Delta, returning None if the result is negative.

type Output = Option<Coordinates>

The resulting type after applying the - operator.

impl Sub<Shape> for Coordinates

fn sub(self, shape: Shape) -> Coordinates

Subtracts a Shape (width, height) from the coordinate using saturating subtraction.

type Output = Coordinates

The resulting type after applying the - operator.

impl Sub for Coordinates

fn sub(self, rhs: Coordinates) -> Coordinates

Subtracts another coordinate component-wise using saturating subtraction.

type Output = Coordinates

The resulting type after applying the - operator.

impl Copy for Coordinates

impl Eq for Coordinates

impl StructuralPartialEq for Coordinates