pyxora.wrapper.shapes

  1from .functions import vector
  2from abc import ABC, abstractmethod
  3from math import ceil
  4from typing import Tuple
  5import pygame
  6
  7class Shape(ABC):
  8    """Abstract base class for all drawable shapes."""
  9
 10    def __init__(self, pos: Tuple[int | float, int | float] | pygame.math.Vector2 | pygame.math.Vector3, color: str | tuple):
 11        """
 12        Initializes the shape with a position and color.
 13
 14        Args:
 15            pos (pos: Tuple[int | float, int | float] | pygame.math.Vector2 | pygame.math.Vector3): The position of the shape.
 16            color (str | tuple): The color of the shape, either as a string (e.g., "red") or a tuple (R, G, B).
 17        """
 18        self._pos = vector(*pos)
 19        self._color = color
 20
 21    @property
 22    def position(self) -> pygame.math.Vector2 | pygame.math.Vector3:
 23        """property to get a copy of the position of the shape."""
 24        return self._pos.copy()
 25
 26    @property
 27    def color(self) -> str | Tuple[int,int,int]:
 28        """property to get the color of the shape."""
 29        return self._color
 30
 31    @property
 32    @abstractmethod
 33    def rect(self) -> pygame.Rect | pygame.FRect:
 34        """
 35        Returns the bounding rectangle (pygame.Rect or pygame.FRect) based on coordinate types.
 36
 37        Returns:
 38            pygame.Rect | pygame.FRect: The bounding rectangle of the shape.
 39        """
 40        pass
 41
 42    @abstractmethod
 43    def draw(self, surf: pygame.Surface, fill: int, scale: int | float) -> None:
 44        """
 45        Abstract method to draw the shape on a surface with a given fill and scale.
 46
 47        Args:
 48            surf (pygame.Surface): The surface to draw on.
 49            fill (int): The fill value for the shape (positive values for outline else is solid).
 50            scale (int | float): The scale factor for the shape size.
 51        """
 52        pass
 53
 54    def move(self,pos: Tuple[int | float, int | float] | pygame.math.Vector2 | pygame.math.Vector3) -> None:
 55        """
 56        Moves the shape by the given offset.
 57
 58        Args:
 59            pos (Tuple[int | float, int | float] | Vector2 | Vector3):
 60                The amount to move the shape by, relative to its current position.
 61        """
 62        self._pos.x += pos[0]
 63        self._pos.y += pos[1]
 64
 65    def move_at(self,pos: Tuple[int | float, int | float] | pygame.math.Vector2 | pygame.math.Vector3) -> None:
 66        """
 67        Moves the shape to a position.
 68
 69        Args:
 70            pos (Tuple[int | float, int | float] | Vector2 | Vector3):
 71                The new position for the shape.
 72        """
 73        self._pos.x = pos[0]
 74        self._pos.y = pos[1]
 75
 76
 77class Rect(Shape):
 78    """Represents a rectangle shape."""
 79
 80    def __init__(
 81            self,
 82            pos: Tuple[int | float, int | float] | pygame.math.Vector2 | pygame.math.Vector3,
 83            size: Tuple[int | float, int | float] | pygame.math.Vector2 | pygame.math.Vector3,
 84            color: str | tuple
 85    ):
 86        """
 87        Initializes the rectangle with position, size, and color.
 88
 89        Args:
 90            pos (tuple[int | float, int | float] | pygame.math.Vector2 | pygame.math.Vector3): The position of the rectangle.
 91            size (tuple[int | float, int | float] | pygame.math.Vector2 | pygame.math.Vector3): The size of the rectangle (width, height).
 92            color (str | tuple): The color of the rectangle, either as a string (e.g., "red") or a tuple (R, G, B).
 93        """
 94        super().__init__(pos, color)
 95        self._size = tuple(size)
 96
 97    @property
 98    def size(self) -> Tuple[int | float, int | float]:
 99        """ The size of the Rect"""
100        return self._size
101
102    @property
103    def rect(self) -> pygame.Rect | pygame.FRect:
104        """
105        Returns the bounding rectangle (pygame.Rect or pygame.FRect) based on coordinate types.
106
107        Returns:
108            pygame.Rect | pygame.FRect: The bounding rectangle of the shape.
109        """
110        if all(isinstance(i, int) for i in (self._pos[0], self._pos[1], self._size[0], self._size[1])):
111            return pygame.Rect(self._pos, self._size)  # Use pygame.Rect if all values are integers
112        return pygame.FRect(self._pos, self._size)  # Use pygame.FRect otherwise
113
114    def draw(self, surf: pygame.Surface, fill: int, scale: int | float) -> None:
115        """
116        Draws the rectangle on the surface with a given fill and scale.
117
118        Args:
119            surf (pygame.Surface): The surface to draw on.
120            fill (int): The fill value for the shape (positive values for outline else is solid).
121            scale (int | float): The scale factor for the rectangle size.
122        """
123        # Scale the rectangle and fill value
124        rect = self.rect
125        color = self.color
126        fill *= scale
127        rect.width *= scale
128        rect.height *= scale
129        fill = ceil(fill)  # Ensure fill is an integer
130
131        # Draw the rectangle
132        pygame.draw.rect(surf, color, rect, width=fill if fill > 0 else 0)
133
134
135class Circle(Shape):
136    """Represents a circle shape."""
137
138    def __init__(self, pos: Tuple[int | float, int | float] | pygame.math.Vector2 | pygame.math.Vector3, radius: int | float, color: str | tuple):
139        """
140        Initializes the circle with position, radius, and color.
141
142        Args:
143            pos: Tuple[int | float, int | float] | pygame.math.Vector2 | pygame.math.Vector3,
144            radius (int | float): The radius of the circle.
145            color (str | tuple): The color of the circle, either as a string (e.g., "red") or a tuple (R, G, B).
146        """
147        super().__init__(pos, color)
148        self._radius = radius
149
150    @property
151    def radius(self) -> int | float:
152        """ The radius of the Circle"""
153        return self._radius
154
155    @property
156    def rect(self) -> pygame.Rect:
157        """
158        Returns the bounding rectangle for the circle.
159
160        Returns:
161            pygame.Rect: The bounding rectangle that encloses the circle.
162        """
163        pos = (self._pos[0] - self.radius, self._pos[1] - self.radius)  # Top-left corner of the bounding rect
164        size = (self.radius * 2, self.radius * 2)  # Size of the bounding rectangle
165        return pygame.Rect(pos, size)
166
167    def draw(self, surf: pygame.Surface, fill: int, scale: int | float) -> None:
168        """
169        Draws the circle on the surface with a given fill and scale.
170
171        Args:
172            surf (pygame.Surface): The surface to draw on.
173            fill (int): The fill value for the circle outline (negative for outline, positive for solid).
174            scale (int | float): The scale factor for the circle size.
175        """
176        # Scale the circle and fill value
177        pos = self._pos
178        fill *= scale
179        radius = self.radius * scale  # Scale the radius
180        fill = ceil(fill)  # Ensure fill is an integer
181
182        # Draw the circle
183        pygame.draw.circle(surf, self.color, pos, radius, width=fill if fill > 0 else 0)