PlayPy 0.2.1__py3-none-any.whl

playpy/state.py

@@ -0,0 +1,565 @@
+from __future__ import annotations
+
+from enum import IntEnum
+from typing import Self, overload, Union
+from . import resources
+
+import pygame as pg
+
+ColorValue = tuple[int, int, int] | tuple[int, int, int, int]
+
+RectValue = Union[tuple[int, int, int, int], tuple[tuple[int, int], tuple[int, int]], pg.Rect, "Rect"]
+FRectValue = Union[tuple[float, float, float, float], tuple[tuple[float, float], tuple[float, float]], "FRect"]
+CoordinateValue = tuple[int, int]
+FCoordinateValue = tuple[float, float]
+
+def arg_to_rect(arg: RectValue) -> tuple[int, int, int, int]:
+    if isinstance(arg, pg.Rect):
+        return (arg.x, arg.y, arg.w, arg.h)
+    elif isinstance(arg, Rect):
+        return (arg.x, arg.y, arg.w, arg.h)
+    elif len(arg) == 2 and isinstance(arg[0], tuple):
+        topleft, size = arg
+        return (topleft[0], topleft[1], size[0], size[1])
+    else:
+        return arg # type: ignore
+
+def arg_to_frect(arg: FRectValue) -> tuple[float, float, float, float]:
+    if isinstance(arg, FRect):
+        return (arg.x, arg.y, arg.w, arg.h)
+    elif len(arg) == 2 and isinstance(arg[0], tuple):
+        topleft, size = arg
+        return (topleft[0], topleft[1], size[0], size[1])
+    else:
+        return arg # type: ignore
+
+
+class _KeyBase(IntEnum):
+    def __str__(self) -> str:
+        return f"{type(self).__name__}.{self.name}"
+
+    @classmethod
+    def from_pygame(cls, value: int | Self) -> Self | int:
+        if isinstance(value, cls):
+            return value
+        try:
+            return cls(value)
+        except ValueError:
+            return value
+
+
+class Key(_KeyBase):
+    # These values are defined explicitly so PlayPy's key API stays stable
+    # and easy to inspect without depending on runtime enum generation.
+    DIGIT_0 = pg.K_0
+    DIGIT_1 = pg.K_1
+    DIGIT_2 = pg.K_2
+    DIGIT_3 = pg.K_3
+    DIGIT_4 = pg.K_4
+    DIGIT_5 = pg.K_5
+    DIGIT_6 = pg.K_6
+    DIGIT_7 = pg.K_7
+    DIGIT_8 = pg.K_8
+    DIGIT_9 = pg.K_9
+    AC_BACK = pg.K_AC_BACK
+    AMPERSAND = pg.K_AMPERSAND
+    ASTERISK = pg.K_ASTERISK
+    AT = pg.K_AT
+    BACKQUOTE = pg.K_BACKQUOTE
+    BACKSLASH = pg.K_BACKSLASH
+    BACKSPACE = pg.K_BACKSPACE
+    BREAK = pg.K_BREAK
+    CAPSLOCK = pg.K_CAPSLOCK
+    CARET = pg.K_CARET
+    CLEAR = pg.K_CLEAR
+    COLON = pg.K_COLON
+    COMMA = pg.K_COMMA
+    CURRENCYSUBUNIT = pg.K_CURRENCYSUBUNIT
+    CURRENCYUNIT = pg.K_CURRENCYUNIT
+    DELETE = pg.K_DELETE
+    DOLLAR = pg.K_DOLLAR
+    DOWN = pg.K_DOWN
+    END = pg.K_END
+    EQUALS = pg.K_EQUALS
+    ESCAPE = pg.K_ESCAPE
+    EURO = pg.K_EURO
+    EXCLAIM = pg.K_EXCLAIM
+    F1 = pg.K_F1
+    F10 = pg.K_F10
+    F11 = pg.K_F11
+    F12 = pg.K_F12
+    F13 = pg.K_F13
+    F14 = pg.K_F14
+    F15 = pg.K_F15
+    F2 = pg.K_F2
+    F3 = pg.K_F3
+    F4 = pg.K_F4
+    F5 = pg.K_F5
+    F6 = pg.K_F6
+    F7 = pg.K_F7
+    F8 = pg.K_F8
+    F9 = pg.K_F9
+    GREATER = pg.K_GREATER
+    HASH = pg.K_HASH
+    HELP = pg.K_HELP
+    HOME = pg.K_HOME
+    INSERT = pg.K_INSERT
+    KP_0 = pg.K_KP0
+    KP_1 = pg.K_KP1
+    KP_2 = pg.K_KP2
+    KP_3 = pg.K_KP3
+    KP_4 = pg.K_KP4
+    KP_5 = pg.K_KP5
+    KP_6 = pg.K_KP6
+    KP_7 = pg.K_KP7
+    KP_8 = pg.K_KP8
+    KP_9 = pg.K_KP9
+    KP_DIVIDE = pg.K_KP_DIVIDE
+    KP_ENTER = pg.K_KP_ENTER
+    KP_EQUALS = pg.K_KP_EQUALS
+    KP_MINUS = pg.K_KP_MINUS
+    KP_MULTIPLY = pg.K_KP_MULTIPLY
+    KP_PERIOD = pg.K_KP_PERIOD
+    KP_PLUS = pg.K_KP_PLUS
+    LALT = pg.K_LALT
+    LCTRL = pg.K_LCTRL
+    LEFT = pg.K_LEFT
+    LEFTBRACKET = pg.K_LEFTBRACKET
+    LEFTPAREN = pg.K_LEFTPAREN
+    LESS = pg.K_LESS
+    LGUI = pg.K_LGUI
+    LMETA = pg.K_LMETA
+    LSHIFT = pg.K_LSHIFT
+    LSUPER = pg.K_LSUPER
+    MENU = pg.K_MENU
+    MINUS = pg.K_MINUS
+    MODE = pg.K_MODE
+    NUMLOCK = pg.K_NUMLOCK
+    NUMLOCKCLEAR = pg.K_NUMLOCKCLEAR
+    PAGEDOWN = pg.K_PAGEDOWN
+    PAGEUP = pg.K_PAGEUP
+    PAUSE = pg.K_PAUSE
+    PERCENT = pg.K_PERCENT
+    PERIOD = pg.K_PERIOD
+    PLUS = pg.K_PLUS
+    POWER = pg.K_POWER
+    PRINT = pg.K_PRINT
+    PRINTSCREEN = pg.K_PRINTSCREEN
+    QUESTION = pg.K_QUESTION
+    QUOTE = pg.K_QUOTE
+    QUOTEDBL = pg.K_QUOTEDBL
+    RALT = pg.K_RALT
+    RCTRL = pg.K_RCTRL
+    RETURN = pg.K_RETURN
+    RGUI = pg.K_RGUI
+    RIGHT = pg.K_RIGHT
+    RIGHTBRACKET = pg.K_RIGHTBRACKET
+    RIGHTPAREN = pg.K_RIGHTPAREN
+    RMETA = pg.K_RMETA
+    RSHIFT = pg.K_RSHIFT
+    RSUPER = pg.K_RSUPER
+    SCROLLLOCK = pg.K_SCROLLLOCK
+    SEMICOLON = pg.K_SEMICOLON
+    SLASH = pg.K_SLASH
+    SPACE = pg.K_SPACE
+    SYSREQ = pg.K_SYSREQ
+    TAB = pg.K_TAB
+    UNDERSCORE = pg.K_UNDERSCORE
+    UNKNOWN = pg.K_UNKNOWN
+    UP = pg.K_UP
+    A = pg.K_a
+    B = pg.K_b
+    C = pg.K_c
+    D = pg.K_d
+    E = pg.K_e
+    F = pg.K_f
+    G = pg.K_g
+    H = pg.K_h
+    I = pg.K_i
+    J = pg.K_j
+    K = pg.K_k
+    L = pg.K_l
+    M = pg.K_m
+    N = pg.K_n
+    O = pg.K_o
+    P = pg.K_p
+    Q = pg.K_q
+    R = pg.K_r
+    S = pg.K_s
+    T = pg.K_t
+    U = pg.K_u
+    V = pg.K_v
+    W = pg.K_w
+    X = pg.K_x
+    Y = pg.K_y
+    Z = pg.K_z
+
+
+class MouseButton(_KeyBase):
+    LEFT = pg.BUTTON_LEFT
+    MIDDLE = pg.BUTTON_MIDDLE
+    RIGHT = pg.BUTTON_RIGHT
+    WHEELUP = pg.BUTTON_WHEELUP
+    WHEELDOWN = pg.BUTTON_WHEELDOWN
+    X1 = pg.BUTTON_X1
+    X2 = pg.BUTTON_X2
+
+
+KeyValue = Key | int
+MouseButtonValue = MouseButton | int
+
+
+class InputState:
+    def __init__(self):
+        self.keys_pressed: set[KeyValue] = set()
+        self.keys_pressed_last_frame: set[KeyValue] = set()
+        self.mouse_buttons_pressed: set[MouseButtonValue] = set()
+        self.mouse_buttons_pressed_last_frame: set[MouseButtonValue] = set()
+        self.mouse_pos: tuple[int, int] = (0, 0)
+        self.mouse_pos_last_frame: tuple[int, int] = (0, 0)
+        self.text_input: list[str] = []
+        self.mouse_wheel: int = 0
+        self.runtime: float = 0.0
+        self.dt: float = 0.0
+        self.quit = False
+
+    def next_frame(self, dt: float):
+        self.keys_pressed_last_frame = self.keys_pressed.copy()
+        self.mouse_buttons_pressed_last_frame = self.mouse_buttons_pressed.copy()
+        self.mouse_pos_last_frame = self.mouse_pos
+        self.dt = dt
+        self.runtime += dt
+
+    @property
+    def key_downs(self) -> set[KeyValue]:
+        return self.keys_pressed - self.keys_pressed_last_frame
+
+    @property
+    def key_ups(self) -> set[KeyValue]:
+        return self.keys_pressed_last_frame - self.keys_pressed
+
+    @property
+    def mouse_downs(self) -> set[int]:
+        return self.mouse_buttons_pressed - self.mouse_buttons_pressed_last_frame
+
+    @property
+    def mouse_ups(self) -> set[int]:
+        return self.mouse_buttons_pressed_last_frame - self.mouse_buttons_pressed
+
+    @property
+    def mouse_delta(self) -> tuple[int, int]:
+        return (self.mouse_pos[0] - self.mouse_pos_last_frame[0], self.mouse_pos[1] - self.mouse_pos_last_frame[1])
+
+    def key_held(self, key: KeyValue) -> bool: return key in self.keys_pressed
+    def key_up(self, key: KeyValue) -> bool: return key in self.key_ups
+    def key_down(self, key: KeyValue) -> bool: return key in self.key_downs
+
+    def mousebutton_held(self, mousebutton: MouseButtonValue) -> bool: return mousebutton in self.mouse_buttons_pressed
+    def mousebutton_up(self, mousebutton: MouseButtonValue) -> bool: return mousebutton in self.mouse_ups
+    def mousebutton_down(self, mousebutton: MouseButtonValue) -> bool: return mousebutton in self.mouse_downs
+
+class FRect:
+    @overload
+    def __init__(self, x: float, y: float, w: float, h: float, /) -> None: ...
+
+    @overload
+    def __init__(self, topleft: FCoordinateValue, size: FCoordinateValue, /) -> None: ...
+
+    @overload
+    def __init__(self, rect: FRectValue, /) -> None: ...
+
+    def __init__(self, *args):
+        if not (1 <= len(args) <= 4):
+            resources.log(resources.Severity.ERROR, resources.InvalidValue, "FRect constructor takes 1 to 4 arguments")
+        arg1 = args[0]
+        arg2 = args[1] if len(args) > 1 else None
+        arg3 = args[2] if len(args) > 2 else None
+        arg4 = args[3] if len(args) > 3 else None
+        if isinstance(arg1, (int, float)) and isinstance(arg2, (int, float)) and isinstance(arg3, (int, float)) and isinstance(arg4, (int, float)):
+            x, y, w, h = float(arg1), float(arg2), float(arg3), float(arg4)
+        elif isinstance(arg1, tuple) and len(arg1) == 2:
+            val1, val2 = arg1
+            if isinstance(val1, (int, float)) and isinstance(val2, (int, float)) and isinstance(arg2, tuple):
+                x, y = float(val1), float(val2)
+                w, h = float(arg2[0]), float(arg2[1])
+            elif isinstance(val1, tuple) and isinstance(val2, tuple) and len(val1) == 2 and len(val2) == 2 and arg2 is None:
+                topleft, size = val1, val2
+                x, y = float(topleft[0]), float(topleft[1])
+                w, h = float(size[0]), float(size[1])
+            else:
+                resources.log(resources.Severity.ERROR, resources.InvalidValue, "Invalid arguments for FRect constructor")
+        elif isinstance(arg1, pg.Rect) and arg2 is None and arg3 is None and arg4 is None:
+            x, y, w, h = float(arg1.x), float(arg1.y), float(arg1.w), float(arg1.h)
+        else:
+            resources.log(resources.Severity.ERROR, resources.InvalidValue, "Invalid arguments for FRect constructor")
+        self._x = x
+        self._y = y
+        self._w = w
+        self._h = h
+
+    def tuple(self) -> tuple[float, float, float, float]:
+        return (self._x, self._y, self._w, self._h)
+
+    @property
+    def x(self):
+        return self._x
+
+    @x.setter
+    def x(self, new: float):
+        self._x = new
+
+    @property
+    def y(self):
+        return self._y
+
+    @y.setter
+    def y(self, new: float):
+        self._y = new
+
+    @property
+    def w(self):
+        return self._w
+
+    @w.setter
+    def w(self, new: float):
+        self._w = new
+
+    @property
+    def h(self):
+        return self._h
+
+    @h.setter
+    def h(self, new: float):
+        self._h = new
+
+    left = x
+    top = y
+
+    @property
+    def right(self) -> float:
+        return self._x + self._w
+    
+    @right.setter
+    def right(self, new: float):
+        self._x = new - self._w
+
+    @property
+    def bottom(self) -> float:
+        return self._y + self._h
+    
+    @bottom.setter
+    def bottom(self, new: float):
+        self._y = new - self._h
+
+    @property
+    def topleft(self):
+        return (self.x, self.y)
+    
+    @topleft.setter
+    def topleft(self, new: tuple[float, float]):
+        self.x, self.y = new
+
+    @property
+    def bottomleft(self):
+        return (self.x, self.bottom)
+
+    @bottomleft.setter
+    def bottomleft(self, new: tuple[float, float]):
+        self.x, self.bottom = new
+
+    @property
+    def topright(self):
+        return (self.right, self.y)
+    
+    @topright.setter
+    def topright(self, new: tuple[float, float]):
+        self.right, self.y = new
+
+    @property
+    def bottomright(self):
+        return (self.right, self.bottom)
+    
+    @bottomright.setter
+    def bottomright(self, new: tuple[float, float]):
+        self.right, self.bottom = new
+
+    @property
+    def center(self):
+        return (self.x + self.w / 2, self.y + self.h / 2)
+    
+    @center.setter
+    def center(self, new: tuple[float, float]):
+        cx, cy = new
+        self.x = cx - self.w / 2
+        self.y = cy - self.h / 2
+
+    def copy(self):
+        return FRect(self.x, self.y, self.w, self.h)
+
+
+class Rect:
+    @overload
+    def __init__(self, x: int, y: int, w: int, h: int, /) -> None: ...
+
+    @overload
+    def __init__(self, topleft: CoordinateValue, size: CoordinateValue, /) -> None: ...
+
+    @overload
+    def __init__(self, rect: RectValue, /) -> None: ...
+
+    def __init__(self, *args):
+        if not (1 <= len(args) <= 4):
+            resources.log(resources.Severity.ERROR, resources.InvalidValue, "Rect constructor takes 1 to 4 arguments")
+        arg1 = args[0]
+        arg2 = args[1] if len(args) > 1 else None
+        arg3 = args[2] if len(args) > 2 else None
+        arg4 = args[3] if len(args) > 3 else None
+        if isinstance(arg1, int) and isinstance(arg2, int) and isinstance(arg3, int) and isinstance(arg4, int):
+            x, y, w, h = arg1, arg2, arg3, arg4
+        elif isinstance(arg1, tuple) and len(arg1) == 2:
+            val1, val2 = arg1
+            if isinstance(val1, int) and isinstance(val2, int) and isinstance(arg2, tuple):
+                x, y = val1, val2
+                w, h = arg2
+            elif isinstance(val1, tuple) and isinstance(val2, tuple) and len(val1) == 2 and len(val2) == 2 and arg2 is None:
+                topleft, size = val1, val2
+                x, y = topleft
+                w, h = size
+            else:
+                resources.log(resources.Severity.ERROR, resources.InvalidValue, "Invalid arguments for Rect constructor")
+        elif isinstance(arg1, pg.Rect) and arg2 is None and arg3 is None and arg4 is None:
+            x, y, w, h = arg1.x, arg1.y, arg1.w, arg1.h
+        else:
+            resources.log(resources.Severity.ERROR, resources.InvalidValue, "Invalid arguments for Rect constructor")
+        self._x = x
+        self._y = y
+        self._w = w
+        self._h = h
+        self._rect = pg.Rect(x, y, w, h)
+
+    def tuple(self) -> tuple[int, int, int, int]:
+        return (self._x, self._y, self._w, self._h)
+
+    @property
+    def x(self):
+        return self._x
+
+    @x.setter
+    def x(self, new: int):
+        self._x = new
+        self._rect.x = new
+
+    @property
+    def y(self):
+        return self._y
+
+    @y.setter
+    def y(self, new: int):
+        self._y = new
+        self._rect.y = new
+
+    @property
+    def w(self):
+        return self._w
+
+    @w.setter
+    def w(self, new: int):
+        self._w = new
+        self._rect.w = new
+
+    @property
+    def h(self):
+        return self._h
+
+    @h.setter
+    def h(self, new: int):
+        self._h = new
+        self._rect.h = new
+
+    left = x
+    top = y
+
+    @property
+    def right(self) -> int:
+        return self._x + self._w
+    
+    @right.setter
+    def right(self, new: int):
+        self._x = new - self._w
+        self._rect.right = new
+
+    @property
+    def bottom(self) -> int:
+        return self._y + self._h
+    
+    @bottom.setter
+    def bottom(self, new: int):
+        self._y = new - self._h
+        self._rect.bottom = new
+
+    @property
+    def topleft(self):
+        return (self.x, self.y)
+    
+    @topleft.setter
+    def topleft(self, new: tuple[int, int]):
+        self.x, self.y = new
+
+    @property
+    def bottomleft(self):
+        return (self.x, self.bottom)
+
+    @bottomleft.setter
+    def bottomleft(self, new: tuple[int, int]):
+        self.x, self.bottom = new
+
+    @property
+    def topright(self):
+        return (self.right, self.y)
+    
+    @topright.setter
+    def topright(self, new: tuple[int, int]):
+        self.right, self.y = new
+
+    @property
+    def bottomright(self):
+        return (self.right, self.bottom)
+    
+    @bottomright.setter
+    def bottomright(self, new: tuple[int, int]):
+        self.right, self.bottom = new
+
+    @property
+    def center(self):
+        return (self.x + self.w // 2, self.y + self.h // 2)
+    
+    @center.setter
+    def center(self, new: tuple[int, int]):
+        cx, cy = new
+        self.x = cx - self.w // 2
+        self.y = cy - self.h // 2
+
+    def copy(self):
+        return Rect(self.x, self.y, self.w, self.h)
+
+def empty_rect():
+    return Rect(0, 0, 0, 0)
+
+def empty_frect():
+    return FRect(0, 0, 0, 0)
+
+
+__all__ = [
+    "ColorValue",
+    "RectValue",
+    "FRectValue",
+    "CoordinateValue",
+    "FCoordinateValue",
+    "Key",
+    "MouseButton",
+    "InputState",
+    "FRect",
+    "Rect",
+    "empty_rect",
+    "empty_frect"
+]