pygkit 1.0.1__py3-none-any.whl

pygkit/transitions/wipes.py

@@ -0,0 +1,185 @@
+import math
+from typing import Callable
+
+from pygame import SRCALPHA, Surface, draw
+
+from ..utils.interpolation import ease_in_out
+
+
+class _WipeBase:
+    __slots__ = ("_easing", "_elapsed", "_duration", "_done", "_mask")
+
+    def __init__(self, easing: Callable[[float], float] = ease_in_out) -> None:
+        self._easing = easing
+        self._elapsed = 0.0
+        self._duration = 0.0
+        self._done = False
+        self._mask: Surface | None = None
+
+    def start(self, duration: float) -> None:
+        self._elapsed = 0.0
+        self._duration = duration
+        self._done = False
+
+    @property
+    def done(self) -> bool:
+        return self._done
+
+    def reset(self) -> None:
+        self._elapsed = 0.0
+        self._duration = 0.0
+        self._done = False
+        self._mask = None
+
+
+class IrisIn(_WipeBase):
+    """
+    Circle closes in from the edges to the center, revealing black (or a color).
+    """
+
+    def __init__(
+        self,
+        color: tuple[int, int, int] = (0, 0, 0),
+        easing: Callable[[float], float] = ease_in_out,
+    ) -> None:
+        super().__init__(easing)
+        self._color = color
+
+    def update(self, dt: float) -> None:
+        if self._done:
+            return
+        self._elapsed += dt
+        if self._elapsed >= self._duration:
+            self._elapsed = self._duration
+            self._done = True
+
+    def render(
+        self,
+        screen: Surface,
+        source: Surface | None = None,
+        target: Surface | None = None,
+    ) -> None:
+        if source is not None:
+            screen.blit(source, (0, 0))
+
+        w, h = screen.get_size()
+        max_radius = int(math.ceil(math.sqrt(w * w + h * h) / 2))
+
+        t = self._easing(self._elapsed / self._duration) if self._duration > 0 else 1.0
+        radius = int(max_radius * (1.0 - t))
+
+        if radius <= 0:
+            screen.fill(self._color)
+            return
+
+        cx, cy = w // 2, h // 2
+
+        if self._mask is None or self._mask.get_size() != (w, h):
+            self._mask = Surface((w, h), SRCALPHA)
+
+        self._mask.fill(self._color)
+        draw.circle(self._mask, (0, 0, 0, 0), (cx, cy), radius)
+        screen.blit(self._mask, (0, 0))
+
+
+class IrisOut(_WipeBase):
+    """
+    Circle expands from the center outward, revealing the target.
+    """
+
+    def __init__(
+        self,
+        easing: Callable[[float], float] = ease_in_out,
+    ) -> None:
+        super().__init__(easing)
+
+    def update(self, dt: float) -> None:
+        if self._done:
+            return
+        self._elapsed += dt
+        if self._elapsed >= self._duration:
+            self._elapsed = self._duration
+            self._done = True
+
+    def render(
+        self,
+        screen: Surface,
+        source: Surface | None = None,
+        target: Surface | None = None,
+    ) -> None:
+        w, h = screen.get_size()
+        max_radius = int(math.ceil(math.sqrt(w * w + h * h) / 2))
+
+        t = self._easing(self._elapsed / self._duration) if self._duration > 0 else 1.0
+        radius = int(max_radius * t)
+        cx, cy = w // 2, h // 2
+
+        if target is not None:
+            screen.blit(target, (0, 0))
+
+        if radius < max_radius:
+            if self._mask is None or self._mask.get_size() != (w, h):
+                self._mask = Surface((w, h), SRCALPHA)
+
+            self._mask.fill((0, 0, 0, 255))
+            draw.circle(self._mask, (0, 0, 0, 0), (cx, cy), radius)
+            screen.blit(self._mask, (0, 0))
+
+
+class Slide(_WipeBase):
+    """
+    Source slides offscreen while target slides in from the opposite side.
+    """
+
+    def __init__(
+        self,
+        direction: str = "left",
+    ) -> None:
+        super().__init__()
+        if direction not in ("left", "right", "up", "down"):
+            raise ValueError(
+                f"Invalid direction '{direction}'. Must be left, right, up, or down."
+            )
+        self._direction = direction
+        self._buffer: Surface | None = None
+
+    def update(self, dt: float) -> None:
+        if self._done:
+            return
+        self._elapsed += dt
+        if self._elapsed >= self._duration:
+            self._elapsed = self._duration
+            self._done = True
+
+    def render(
+        self,
+        screen: Surface,
+        source: Surface | None = None,
+        target: Surface | None = None,
+    ) -> None:
+        w, h = screen.get_size()
+        t = self._elapsed / self._duration if self._duration > 0 else 1.0
+
+        if self._direction == "left":
+            out_offset = (-w * t, 0)
+            in_offset = (w * (1.0 - t), 0)
+        elif self._direction == "right":
+            out_offset = (w * t, 0)
+            in_offset = (-w * (1.0 - t), 0)
+        elif self._direction == "up":
+            out_offset = (0, -h * t)
+            in_offset = (0, h * (1.0 - t))
+        else:
+            out_offset = (0, h * t)
+            in_offset = (0, -h * (1.0 - t))
+
+        if self._buffer is None or self._buffer.get_size() != (w, h):
+            self._buffer = Surface((w, h))
+
+        self._buffer.fill((0, 0, 0))
+        if target is not None:
+            self._buffer.blit(target, in_offset)
+        if source is not None:
+            self._buffer.blit(source, out_offset)
+
+        screen.blit(self._buffer, (0, 0))

pygkit/ui/__init__.py

@@ -0,0 +1,15 @@
+from .base import UIBase, UIOptions, BoxModel, BoxModelResult, generate_box_model
+from .container import Container
+from .cooldown import CooldownOverlay
+from .progressbar import ProgressBarUI
+
+__all__ = [
+    "UIBase",
+    "UIOptions",
+    "BoxModel",
+    "BoxModelResult",
+    "generate_box_model",
+    "ProgressBarUI",
+    "CooldownOverlay",
+    "Container",
+]

pygkit/ui/base.py

@@ -0,0 +1,125 @@
+from typing import Any, Callable, List, TypedDict
+
+import pygame
+from pygame import SRCALPHA, Surface
+from pygame.typing import ColorLike
+
+
+class BoxModel(TypedDict, total=False):
+    margin_x: int
+    margin_y: int
+    padding_x: int
+    padding_y: int
+    width: int
+    height: int
+
+
+class BoxModelResult(TypedDict, total=True):
+    left: int
+    top: int
+    offset_x: int
+    offset_y: int
+    full_width: int
+    full_height: int
+    content_width: int
+    content_height: int
+
+
+class UIOptions(BoxModel, total=False):
+    border_radius: int
+    border_color: ColorLike
+    background: ColorLike
+    fill_color: ColorLike
+
+
+def generate_box_model(model: BoxModel) -> BoxModelResult:
+    width = model.get("width", 0)
+    height = model.get("height", 0)
+    padding_x = model.get("padding_x", 0)
+    padding_y = model.get("padding_y", 0)
+    margin_x = model.get("margin_x", 0)
+    margin_y = model.get("margin_y", 0)
+    border_width = model.get("border_width", 0)
+
+    inner_x = 2 * (padding_x + border_width)
+    inner_y = 2 * (padding_y + border_width)
+
+    return {
+        "left": padding_x + border_width,
+        "top": padding_y + border_width,
+        "offset_x": margin_x,
+        "offset_y": margin_y,
+        "full_width": width,
+        "full_height": height,
+        "content_width": width - inner_x,
+        "content_height": height - inner_y,
+    }
+
+
+class UIBase:
+    def __init__(self, options: UIOptions) -> None:
+        self.colors: dict[str, ColorLike] = {
+            "bg": options.get("background", (0, 0, 0, 0))
+        }
+
+        self.box_model = generate_box_model(options)
+
+        self.border: dict[str, Any] = {
+            "radius": options.get("border_radius", 0),
+            "width": options.get("border_width", 0),
+            "color": options.get("border_color", (0, 0, 0, 0)),
+        }
+
+        local_size = self.box_model["full_width"], self.box_model["full_height"]
+        self.local_surface = Surface(local_size, SRCALPHA)
+
+        self.renderable_plugins: List[Callable[[Surface], Any]] = []
+
+    def add_plugin(self, cb: Callable[[Surface], Any]) -> None:
+        self.renderable_plugins.append(cb)
+
+    def draw_base(self) -> None:
+        local_surf = self.local_surface
+        local_surf.fill((0, 0, 0, 0))
+
+        bg_color = self.colors["bg"]
+        border_width = self.border["width"]
+        border_radius = self.border["radius"]
+        border_color = self.border["color"]
+
+        content_pos = self.box_model["left"], self.box_model["top"]
+        content_size = self.box_model["content_width"], self.box_model["content_height"]
+        surface_size = local_surf.get_size()
+
+        if border_width > 0:
+            pygame.draw.rect(
+                local_surf,
+                border_color,
+                (0, 0, *surface_size),
+                width=border_width,
+                border_radius=border_radius,
+            )
+
+        pygame.draw.rect(
+            local_surf,
+            bg_color,
+            (*content_pos, *content_size),
+            border_radius=max(0, border_radius - border_width),
+        )
+
+    @property
+    def size(self) -> tuple[int, int]:
+        return (self.box_model["full_width"], self.box_model["full_height"])
+
+    def render(self, screen: Surface, pos_offset: tuple[int, int] = (0, 0)) -> None:
+        self.draw_base()
+        for plugin in self.renderable_plugins:
+            plugin(self.local_surface)
+        pos = (
+            self.box_model["offset_x"] + pos_offset[0],
+            self.box_model["offset_y"] + pos_offset[1],
+        )
+        screen.blit(self.local_surface, pos)
+
+    def update(self) -> None:
+        pass

pygkit/ui/container.py

@@ -0,0 +1,21 @@
+from typing import List, Tuple
+
+from pygame import Surface
+
+from .base import UIBase
+
+
+class Container:
+    def __init__(self) -> None:
+        self.children: List[Tuple[UIBase, Tuple[int, int]]] = []
+
+    def add(self, child: UIBase, pos: Tuple[int, int] = (0, 0)) -> None:
+        self.children.append((child, pos))
+
+    def update(self) -> None:
+        for child, _ in self.children:
+            child.update()
+
+    def render(self, screen: Surface) -> None:
+        for child, offset in self.children:
+            child.render(screen, offset)

pygkit/ui/cooldown.py

@@ -0,0 +1,107 @@
+import math
+from typing import List, Optional, Tuple, Unpack
+
+import pygame
+from pygame import SRCALPHA, Surface, draw, transform
+
+from ..utils.timer import Timer
+from .base import UIBase, UIOptions
+
+
+class CooldownOverlay(UIBase):
+    def __init__(
+        self,
+        timer: Timer,
+        size: int | float,
+        icon: Optional[Surface] = None,
+        overlay_color: tuple[int, int, int, int] = (0, 0, 0, 255),
+        disabled_color: tuple[int, int, int, int] = (50, 50, 55, 200),
+        **overrides: Unpack[UIOptions],
+    ) -> None:
+        super().__init__({"width": int(size), "height": int(size), **overrides})
+
+        self.timer = timer
+        self.overlay_color = overlay_color
+        self.disabled_color = disabled_color
+        self.disabled = False
+
+        content_w = self.box_model["content_width"]
+        content_h = self.box_model["content_height"]
+
+        r = min(content_w, content_h) / 2
+        self.radius = r
+        self.scalar: float = 1.0
+        b = overrides.get("border_radius", 0)
+        if b < r:
+            self.scalar = (math.sqrt(2 * (r - b) ** 2) + b) / r
+
+        self.overlay_parent = Surface((content_w, content_h), SRCALPHA)
+        self._disabled_surf: Optional[Surface] = None
+        self.add_plugin(self._draw_overlay)
+        self.add_plugin(self._draw_disabled_overlay)
+        if icon is not None:
+            scale = content_w / icon.width, content_h / icon.height
+            self.icon = transform.scale_by(icon, scale)
+            self.add_plugin(self._draw_icon)
+
+    def _draw_icon(self, surface: Surface) -> None:
+        icon: Optional[Surface] = getattr(self, "icon", None)
+        if icon is None:
+            return
+
+        center_x = self.box_model["content_width"] // 2
+        center_y = self.box_model["content_height"] // 2
+
+        rect = icon.get_rect(
+            center=(
+                self.box_model["left"] + center_x,
+                self.box_model["top"] + center_y,
+            )
+        )
+
+        if self.disabled:
+            icon.set_alpha(80)
+        elif not self.timer.reached():
+            icon.set_alpha(150)
+        elif icon.get_alpha() != 255:
+            icon.set_alpha(255)
+        surface.blit(icon, rect.topleft)
+
+    def _draw_overlay(self, surface: Surface) -> None:
+        if self.disabled or self.timer.reached():
+            return
+
+        progress = 1.0 - self.timer.ratio()
+
+        center = (self.radius, self.radius)
+        points: List[Tuple[float, float]] = [center]
+
+        end_degrees = int(progress * 360)
+
+        for degree in range(-90, end_degrees - 90):
+            angle = math.radians(degree)
+            x = self.radius + self.radius * math.cos(angle) * self.scalar
+            y = self.radius + self.radius * math.sin(angle) * self.scalar
+            points.append((x, y))
+
+        op = self.overlay_parent
+        op.fill((0, 0, 0, 0))
+
+        if len(points) > 2:
+            draw.polygon(op, self.overlay_color, points)
+
+        pos = self.box_model["left"], self.box_model["top"]
+        surface.blit(op, pos)
+
+    def _draw_disabled_overlay(self, surface: Surface) -> None:
+        if not self.disabled:
+            return
+
+        w = self.box_model["content_width"]
+        h = self.box_model["content_height"]
+        if self._disabled_surf is None or self._disabled_surf.get_size() != (w, h):
+            self._disabled_surf = Surface((w, h), SRCALPHA)
+
+        self._disabled_surf.fill(self.disabled_color)
+        pos = self.box_model["left"], self.box_model["top"]
+        surface.blit(self._disabled_surf, pos)

pygkit/ui/progressbar.py

@@ -0,0 +1,64 @@
+from typing import Unpack
+
+import pygame
+from pygame import Surface
+
+from ..utils.interpolation import SimpleInterpolation
+from .base import UIBase, UIOptions
+
+PROGRESSBAR_DEFAULTS: UIOptions = {
+    "width": 250,
+    "height": 24,
+    "border_width": 2,
+    "border_radius": 6,
+    "padding_x": 2,
+    "padding_y": 2,
+    "margin_x": 0,
+    "margin_y": 0,
+    "border_color": (40, 44, 52, 255),
+    "background": (33, 37, 43, 255),
+    "fill_color": (255, 255, 255, 255),
+}
+
+
+class ProgressBarUI(UIBase):
+    def __init__(self, **overrides: Unpack[UIOptions]) -> None:
+        options: UIOptions = {**PROGRESSBAR_DEFAULTS, **overrides}
+        super().__init__(options)
+        self.colors["fill"] = options.get("fill_color", (255, 255, 255, 255))
+        self.interpolation = SimpleInterpolation(speed=0.05)
+
+    def set_progress(self, value: float) -> None:
+        self.interpolation.set(value)
+
+    def get_progress(self) -> float:
+        return self.interpolation.current
+
+    def update(self) -> None:
+        self.interpolation.update()
+
+    def render(self, screen: Surface, pos_offset: tuple[int, int] = (0, 0)) -> None:
+        self.draw_base()
+
+        intrp_current = self.interpolation.current
+        if intrp_current > 0:
+            fill_width = int(self.box_model["content_width"] * intrp_current)
+            inner_radius = max(0, self.border["radius"] - self.border["width"])
+
+            pygame.draw.rect(
+                self.local_surface,
+                self.colors["fill"],
+                (
+                    self.box_model["left"],
+                    self.box_model["top"],
+                    fill_width,
+                    self.box_model["content_height"],
+                ),
+                border_radius=inner_radius,
+            )
+
+        pos = (
+            self.box_model["offset_x"] + pos_offset[0],
+            self.box_model["offset_y"] + pos_offset[1],
+        )
+        screen.blit(self.local_surface, pos)

pygkit/utils/__init__.py

@@ -0,0 +1,19 @@
+from .interpolation import SimpleInterpolation, ease_in, ease_in_out, ease_out, lerp, smoothstep
+from .text import fit, load_font, outline, render_multiline, shadow, wrap
+from .timer import Timer
+
+__all__ = [
+    "Timer",
+    "SimpleInterpolation",
+    "lerp",
+    "smoothstep",
+    "ease_in_out",
+    "ease_out",
+    "ease_in",
+    "load_font",
+    "outline",
+    "shadow",
+    "wrap",
+    "render_multiline",
+    "fit",
+]

pygkit/utils/interpolation.py

@@ -0,0 +1,45 @@
+import math
+
+
+def lerp(a: float, b: float, t: float) -> float:
+    return a + (b - a) * t
+
+
+def smoothstep(t: float) -> float:
+    return t * t * (3 - 2 * t)
+
+
+def ease_in(t: float) -> float:
+    return t * t
+
+
+def ease_out(t: float) -> float:
+    return 1 - (1 - t) ** 2
+
+
+def ease_in_out(t: float) -> float:
+    if t < 0.5:
+        return 2 * t * t
+    return 1 - ((-2 * t + 2) ** 2) / 2
+
+
+class SimpleInterpolation:
+    __slots__ = ("current", "target", "speed")
+
+    def __init__(self, value: float = 1.0, speed: float = 0.1) -> None:
+        self.current = value
+        self.target = value
+        self.speed = speed
+
+    def set(self, target: float) -> None:
+        self.target = max(0, min(target, 1.0))
+
+    def update(self) -> None:
+        diff = self.target - self.current
+        if abs(diff) < 0.001:
+            self.current = self.target
+        else:
+            self.current += diff * self.speed
+
+    def finished(self) -> bool:
+        return abs(self.current - self.target) < 0.001