154 lines
3.9 KiB
Rust
154 lines
3.9 KiB
Rust
use std::fmt::{Debug, Formatter};
|
|
use std::marker::PhantomData;
|
|
use std::ops::{Mul, Sub, Add};
|
|
use num::{One, pow, integer::Roots};
|
|
use std::cmp::{min, max};
|
|
|
|
pub trait CoordinateSpace {}
|
|
|
|
#[derive(PartialEq, Eq, Clone, Copy, PartialOrd, Ord)]
|
|
pub struct Coordinates<T: CoordLimits<Data = T>, S: CoordinateSpace> {
|
|
pub x: T,
|
|
pub y: T,
|
|
space: PhantomData<S>,
|
|
}
|
|
|
|
impl<T: CoordLimits<Data = T> + Debug, S: CoordinateSpace> Debug for Coordinates<T, S> {
|
|
fn fmt(&self, f: &mut Formatter<'_>) -> std::fmt::Result {
|
|
f.debug_tuple("@")
|
|
.field(&self.x)
|
|
.field(&self.y)
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
pub trait CoordLimits: PartialOrd + PartialEq + Sub + Clone + Mul + Copy + One + Add {
|
|
type Data: CoordLimits;
|
|
const MIN: Self::Data;
|
|
const MAX: Self::Data;
|
|
|
|
fn distance(x1: Self, y1: Self, x2: Self, y2: Self) -> Self;
|
|
}
|
|
|
|
impl CoordLimits for u8 {
|
|
type Data = u8;
|
|
const MIN: u8 = 0;
|
|
const MAX: u8 = 255;
|
|
|
|
fn distance(x1: Self, y1: Self, x2: Self, y2: Self) -> Self {
|
|
(max(x2, x1) - min(x2, x1)).saturating_add(max(y2, y1) - min(y2, y1))
|
|
//(pow(x2 as u16 - x1 as u16, 2) + pow(y2 as u16 - y1 as u16, 2)).sqrt() as u8
|
|
}
|
|
}
|
|
|
|
impl CoordLimits for u16 {
|
|
type Data = u16;
|
|
const MIN: u16 = u16::MIN;
|
|
const MAX: u16 = u16::MAX;
|
|
|
|
fn distance(x1: Self, y1: Self, x2: Self, y2: Self) -> Self {
|
|
(pow(x2 - x1, 2) + pow(y2 - y1, 2)).sqrt()
|
|
}
|
|
}
|
|
|
|
impl CoordLimits for usize {
|
|
type Data = usize;
|
|
const MIN: usize = usize::MIN;
|
|
const MAX: usize = usize::MAX;
|
|
|
|
fn distance(x1: Self, y1: Self, x2: Self, y2: Self) -> Self {
|
|
(pow(x2 - x1, 2) + pow(y2 - y1, 2)).sqrt()
|
|
}
|
|
}
|
|
|
|
impl<T: CoordLimits<Data = T>, S: CoordinateSpace> Coordinates<T, S> {
|
|
pub const fn new(x: T, y: T) -> Self {
|
|
Self {
|
|
x,
|
|
y,
|
|
space: PhantomData,
|
|
}
|
|
}
|
|
|
|
fn top_left() -> Self {
|
|
Self::new(T::MIN, T::MIN)
|
|
}
|
|
|
|
fn top_right() -> Self {
|
|
Self::new(T::MAX, T::MIN)
|
|
}
|
|
|
|
fn bottom_left() -> Self {
|
|
Self::new(T::MIN, T::MAX)
|
|
}
|
|
|
|
fn bottom_right() -> Self {
|
|
Self::new(T::MAX, T::MAX)
|
|
}
|
|
|
|
pub fn distance_to(&self, other: &Self) -> T {
|
|
T::distance(self.x, other.x, self.y, other.y)
|
|
}
|
|
}
|
|
|
|
#[derive(PartialEq, Debug, Copy, Clone)]
|
|
pub struct Virtual {}
|
|
impl CoordinateSpace for Virtual {}
|
|
|
|
#[derive(PartialEq, Debug, Copy, Clone)]
|
|
pub struct Coord8<S: CoordinateSpace> {
|
|
x: u8,
|
|
y: u8,
|
|
space: PhantomData<S>
|
|
}
|
|
|
|
pub type VirtualCoordinates = Coordinates<u8, Virtual>;
|
|
|
|
#[derive(PartialEq, Eq, Copy, Clone, Debug, PartialOrd)]
|
|
pub struct Rectangle<CoordData: CoordLimits<Data = CoordData>, Space: CoordinateSpace> {
|
|
pub top_left: Coordinates<CoordData, Space>,
|
|
pub bottom_right: Coordinates<CoordData, Space>
|
|
}
|
|
|
|
impl<CoordData: CoordLimits<Data = CoordData> + Sub<Output=CoordData>, Space: CoordinateSpace> Rectangle<CoordData, Space> {
|
|
pub fn new(top_left: Coordinates<CoordData, Space>, bottom_right: Coordinates<CoordData, Space>) -> Self {
|
|
debug_assert!(top_left.x <= bottom_right.x);
|
|
debug_assert!(top_left.y <= bottom_right.y);
|
|
Self {
|
|
top_left,
|
|
bottom_right
|
|
}
|
|
}
|
|
|
|
pub fn everything() -> Self {
|
|
Self {
|
|
top_left: Coordinates::<CoordData, Space>::top_left(),
|
|
bottom_right: Coordinates::<CoordData, Space>::bottom_right()
|
|
}
|
|
}
|
|
|
|
pub fn width(&self) -> CoordData {
|
|
self.bottom_right.x.clone() - self.top_left.x.clone()
|
|
}
|
|
|
|
pub fn height(&self) -> CoordData {
|
|
self.bottom_right.y.clone() - self.top_left.y.clone()
|
|
}
|
|
|
|
pub const fn left(&self) -> CoordData {
|
|
self.top_left.x
|
|
}
|
|
|
|
pub const fn top(&self) -> CoordData {
|
|
self.top_left.y
|
|
}
|
|
|
|
pub const fn right (&self) -> CoordData {
|
|
self.bottom_right.x
|
|
}
|
|
|
|
pub const fn bottom(&self) -> CoordData {
|
|
self.bottom_right.y
|
|
}
|
|
}
|