Move the roguebasin package to erynrl

erynrl/geometry.py

@@ -0,0 +1,183 @@
+# Eryn Wells <eryn@erynwells.me>
+
+'''A bunch of geometric primitives'''
+
+import math
+from dataclasses import dataclass
+from typing import Any, Iterator, Optional, overload
+
+@dataclass(frozen=True)
+class Point:
+    '''A two-dimensional point, with coordinates in X and Y axes'''
+
+    x: int = 0
+    y: int = 0
+
+    def is_adjacent_to(self, other: 'Point') -> bool:
+        '''Check if this point is adjacent to, but not overlapping the given point
+
+        Parameters
+        ----------
+        other : Point
+            The point to check
+
+        Returns
+        -------
+        bool
+            True if this point is adjacent to the other point
+        '''
+        return (self.x in (other.x - 1, other.x + 1)) and (self.y in (other.y -1, other.y + 1))
+
+    def direction_to_adjacent_point(self, other: 'Point') -> Optional['Direction']:
+        for direction in Direction.all():
+            if (self + direction) != other:
+                continue
+            return direction
+
+        return None
+
+    def euclidean_distance_to(self, other: 'Point') -> float:
+        '''Compute the Euclidean distance to another Point'''
+        return math.sqrt((self.x - other.x) ** 2 + (self.y - other.y) ** 2)
+
+    @overload
+    def __add__(self, other: 'Vector') -> 'Point':
+        ...
+
+    def __add__(self, other: Any) -> 'Point':
+        if not isinstance(other, Vector):
+            raise TypeError('Only Vector can be added to a Point')
+        return Point(self.x + other.dx, self.y + other.dy)
+
+    def __iter__(self):
+        yield self.x
+        yield self.y
+
+    def __str__(self):
+        return f'(x:{self.x}, y:{self.y})'
+
+@dataclass(frozen=True)
+class Vector:
+    '''A two-dimensional vector, representing change in position in X and Y axes'''
+
+    dx: int = 0
+    dy: int = 0
+
+    def __iter__(self):
+        yield self.dx
+        yield self.dy
+
+    def __str__(self):
+        return f'(δx:{self.dx}, δy:{self.dy})'
+
+class Direction:
+    '''A collection of simple uint vectors in each of the eight major compass directions. This is a namespace, not a class.'''
+
+    North = Vector(0, -1)
+    NorthEast = Vector(1, -1)
+    East = Vector(1, 0)
+    SouthEast = Vector(1, 1)
+    South = Vector(0, 1)
+    SouthWest = Vector(-1, 1)
+    West = Vector(-1, 0)
+    NorthWest = Vector(-1, -1)
+
+    @classmethod
+    def all(cls) -> Iterator['Direction']:
+        '''Iterate through all directions, starting with North and proceeding clockwise'''
+        yield Direction.North
+        yield Direction.NorthEast
+        yield Direction.East
+        yield Direction.SouthEast
+        yield Direction.South
+        yield Direction.SouthWest
+        yield Direction.West
+        yield Direction.NorthWest
+
+@dataclass(frozen=True)
+class Size:
+    '''A two-dimensional size, representing size in X (width) and Y (height) axes'''
+
+    width: int = 0
+    height: int = 0
+
+    def __iter__(self):
+        yield self.width
+        yield self.height
+
+    def __str__(self):
+        return f'(w:{self.width}, h:{self.height})'
+
+@dataclass(frozen=True)
+class Rect:
+    '''A two-dimensional rectangle, defined by an origin point and size'''
+
+    origin: Point
+    size: Size
+
+    @property
+    def min_x(self) -> int:
+        '''Minimum x-value that is still within the bounds of this rectangle. This is the origin's x-value.'''
+        return self.origin.x
+
+    @property
+    def min_y(self) -> int:
+        '''Minimum y-value that is still within the bounds of this rectangle. This is the origin's y-value.'''
+        return self.origin.y
+
+    @property
+    def mid_x(self) -> int:
+        '''The x-value of the center point of this rectangle.'''
+        return int(self.origin.x + self.size.width / 2)
+
+    @property
+    def mid_y(self) -> int:
+        '''The y-value of the center point of this rectangle.'''
+        return int(self.origin.y + self.size.height / 2)
+
+    @property
+    def max_x(self) -> int:
+        '''Maximum x-value that is still within the bounds of this rectangle.'''
+        return self.origin.x + self.size.width - 1
+
+    @property
+    def max_y(self) -> int:
+        '''Maximum y-value that is still within the bounds of this rectangle.'''
+        return self.origin.y + self.size.height - 1
+
+    @property
+    def midpoint(self) -> Point:
+        '''A Point in the middle of the Rect'''
+        return Point(self.mid_x, self.mid_y)
+
+    def inset_rect(self, top: int = 0, right: int = 0, bottom: int = 0, left: int = 0) -> 'Rect':
+        '''
+        Return a new Rect inset from this rect by the specified values. Arguments are listed in clockwise order around
+        the permeter. This method doesn't validate the returned Rect, or transform it to a canonical representation with
+        the origin at the top-left.
+
+        Parameters
+        ----------
+        top : int
+            Amount to inset from the top
+        right : int
+            Amount to inset from the right
+        bottom : int
+            Amount to inset from the bottom
+        left : int
+            Amount to inset from the left
+
+        Returns
+        -------
+        Rect
+            A new Rect, inset from `self` by the given amount on each side
+        '''
+        return Rect(Point(self.origin.x + left, self.origin.y + top),
+                    Size(self.size.width - right - left, self.size.height - top - bottom))
+
+    def __iter__(self):
+        yield tuple(self.origin)
+        yield tuple(self.size)
+
+    def __str__(self):
+        return f'[{self.origin}, {self.size}]'