pyverse2d 0.4.2__tar.gz

pyverse2d-0.4.2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 WhiteWolf45380
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

pyverse2d-0.4.2/PKG-INFO

@@ -0,0 +1,16 @@
+Metadata-Version: 2.4
+Name: pyverse2d
+Version: 0.4.2
+Summary: 2D Game Engine using pyglet (OpenGL) for rendering
+Author: WhiteWolf45380
+License: MIT
+Project-URL: Homepage, https://github.com/WhiteWolf45380/pyverse2d
+Keywords: game,engine,2d,pyglet,opengl
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: pyglet>=2.0
+Dynamic: license-file
+
+pip install https://github.com/WhiteWolf45380/PyVerse2D/archive/refs/heads/main.zip
+

pyverse2d-0.4.2/README.md

@@ -0,0 +1,2 @@
+pip install https://github.com/WhiteWolf45380/PyVerse2D/archive/refs/heads/main.zip
+

pyverse2d-0.4.2/pyproject.toml

@@ -0,0 +1,23 @@
+[build-system]
+requires = ["setuptools>=65.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "pyverse2d"
+version = "0.4.2"
+description = "2D Game Engine using pyglet (OpenGL) for rendering"
+authors = [{ name = "WhiteWolf45380" }]
+readme = "README.md"
+license = { text = "MIT" }
+requires-python = ">=3.10"
+keywords = ["game", "engine", "2d", "pyglet", "opengl"]
+dependencies = [
+    "pyglet>=2.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/WhiteWolf45380/pyverse2d"
+
+[tool.setuptools.packages.find]
+where = ["."]
+include = ["pyverse2d*"]

pyverse2d-0.4.2/pyverse2d/__init__.py

@@ -0,0 +1,72 @@
+# ======================================== IMPORTS ========================================
+from __future__ import annotations
+
+from . import abc, math, shape, asset, world, map, ui, scene
+
+from ._rendering import Camera, Viewport, Screen, Window
+
+import pyglet
+
+# ======================================== STATE ========================================
+_window: Window | None = None
+_fps: int = 60
+
+# ======================================== SETTERS ========================================
+def set_window(window: Window):
+    """
+    Définit la fenêtre du moteur
+
+    Args:
+        window (Window): fenêtre à utiliser
+    """
+    global _window
+    if not isinstance(window, Window):
+        raise TypeError("Expected a Window instance")
+    _window = window
+
+    @_window.native.event
+    def on_draw():
+        _window.clear()
+        scene.draw()
+
+def set_fps(fps: int):
+    """
+    Définit le nombre de mises à jour par seconde
+
+    Args:
+        fps (int): fps cible
+    """
+    global _fps
+    _fps = int(fps)
+
+# ======================================== LOOP ========================================
+def run():
+    """Démarre la boucle de mise à jour"""
+    if _window is None:
+        raise RuntimeError("No window set — call engine.set_window() before engine.run()")
+    pyglet.clock.schedule_interval(_update, 1 / _fps)
+    pyglet.app.run()
+
+def _update(dt: float):
+    scene.update(dt)
+
+# ======================================== EXPORTS ========================================
+__all__ = [
+    "Camera",
+    "Viewport",
+    "Screen",
+    "Window",
+
+    "abc",
+    "math",
+    "shape",
+    "asset",
+    "world",
+    "map",
+    "ui",
+    "scene",
+
+    "set_window",
+    "set_fps",
+    "run",
+]

pyverse2d-0.4.2/pyverse2d/_flag/__init__.py

@@ -0,0 +1,9 @@
+# ======================================== IMPORTS ========================================
+from ._stack_mode import StackMode
+from ._update_phase import UpdatePhase
+
+# ======================================== EXPORTS ========================================
+__all__ = [
+    "StackMode",
+    "UpdatePhase",
+]

pyverse2d-0.4.2/pyverse2d/_flag/_stack_mode.py

@@ -0,0 +1,8 @@
+# ======================================== IMPORTS ========================================
+from enum import Enum
+
+# ======================================== FLAG ========================================
+class StackMode(Enum):
+    PAUSE = "pause"    # scene du dessous stop tout
+    SUSPEND = "suspend"  # scene du dessous stop update mais continue draw
+    OVERLAY = "overlay"  # scene du dessous continue tout

pyverse2d-0.4.2/pyverse2d/_flag/_update_phase.py

@@ -0,0 +1,8 @@
+# ======================================== IMPORTS ========================================
+from enum import Enum
+
+# ======================================== FLAG ========================================
+class UpdatePhase(Enum):
+    EARLY = 0   # Pré-actualisation
+    UPDATE = 1  # Actualisation
+    LATE = 2    # Post-actualisation

pyverse2d-0.4.2/pyverse2d/_internal/__init__.py

@@ -0,0 +1,19 @@
+# ======================================== IMPORTS ========================================
+from .validators import (
+    typename,
+    expect,
+    not_null,
+    positive,
+    clamped,
+    rgba
+)
+
+# ======================================== EXPORTS ========================================
+__all__ = [
+    "typename",
+    "expect",
+    "not_null",
+    "positive",
+    "clamped",
+    "rgba",
+]

pyverse2d-0.4.2/pyverse2d/_internal/validators.py

@@ -0,0 +1,247 @@
+# ======================================== IMPORTS ========================================
+from types import UnionType
+from typing import Tuple, get_args, get_origin, Union
+from numbers import Real
+
+# ======================================== TYPE CHECK ========================================
+def typename(t: type):
+    """
+    Renvoie le str du type
+
+    Args:
+        t(type): type à vérifier
+    """
+    return getattr(t, "__name__", str(t))
+
+
+def expect(value: object, types: type | Tuple[type, ...]):
+    """
+    Vérifie la valeur contre un type supporté :
+        T                   type simple
+        (T1, T2, T3)        multi-types
+        T1 | T2             union
+        list[T]             liste typée
+        set[T]              set typé
+        tuple[T]            tuple broadcast
+        tuple[T1, T2, T3]   tuple positionnel
+        dict[K, V]          dictionnaire typé
+
+    Args:
+        value(object): valeur à vérifier
+        types(type|Tuple[type, ...]): types à vérifier
+
+    Returns:
+        value(object): si valide
+    
+    Raises:
+        TypeError: si la valeur n'est pas conforme
+    """
+    # (T1, T2, T3)
+    if isinstance(types, tuple):
+        types = tuple(type(None) if t is None else t for t in types)
+        if not isinstance(value, types):
+            readable = " | ".join(typename(t) for t in types)
+            raise TypeError(f"expected ({readable}), got ({typename(value)})")
+        return value
+
+    # T
+    origin = get_origin(types)
+    if origin is None:
+        types = type(None) if types is None else types
+        if not isinstance(value, types):
+            raise TypeError(f"expected ({typename(types)}), got ({typename(value)})")
+        return value
+    
+    # T1 |T2
+    args = get_args(types)
+    if origin in (UnionType, Union):
+        for t in args:
+            try:
+                return expect(value, t)
+            except TypeError:
+                continue
+        readable = " | ".join(typename(t) for t in args)
+        raise TypeError(f"expected ({readable}), got ({typename(value)})")
+
+    # list[T] / set[T] / frozenset[T]
+    if origin in (list, set, frozenset):
+        if not isinstance(value, origin):
+            raise TypeError(f"expected ({typename(origin)}), got ({typename(value)})")
+        inner = args[0]
+        if get_origin(inner) is None:
+            for i, v in enumerate(value):
+                if not isinstance(v, inner):
+                    raise TypeError(f"at index {i}: expected ({typename(inner)}), got ({typename(v)})")
+        else:
+            for i, v in enumerate(value):
+                try:
+                    expect(v, inner)
+                except TypeError as e:
+                    raise TypeError(f"at index {i}: {e}") from e
+        return value
+
+    # tuple[T] / tuple[T1, T2, T3]
+    if origin is tuple:
+        if not isinstance(value, tuple):
+            raise TypeError(f"expected (tuple), got ({typename(value)})")
+        if len(args) == 1 or len(args) == 2 and args[1] is Ellipsis:
+            inner = args[0]
+            if get_origin(inner) is None:
+                for i, v in enumerate(value):
+                    if not isinstance(v, inner):
+                        raise TypeError(f"at index {i}: expected ({typename(inner)}), got ({typename(v)})")
+            else:
+                for i, v in enumerate(value):
+                    try:
+                        expect(v, inner)
+                    except TypeError as e:
+                        raise TypeError(f"at index {i}: {e}") from e
+        else:
+            if len(value) != len(args):
+                raise TypeError(f"expected (tuple) of len {len(args)}, got {len(value)}")
+            for i, (v, t) in enumerate(zip(value, args)):
+                if get_origin(t) is None:
+                    if not isinstance(v, t):
+                        raise TypeError(f"at index {i}: expected ({typename(t)}), got ({typename(v)})")
+                else:
+                    try:
+                        expect(v, t)
+                    except TypeError as e:
+                        raise TypeError(f"at index {i}: {e}") from e
+        return value
+
+    # dict[K, V]
+    if origin is dict:
+        if not isinstance(value, dict):
+            raise TypeError(f"expected (dict), got ({typename(value)})")
+        kt, vt = args
+        kt_simple = get_origin(kt) is None
+        vt_simple = get_origin(vt) is None
+        for k, v in value.items():
+            if kt_simple:
+                if not isinstance(k, kt):
+                    raise TypeError(f"at key {k!r}: invalid key: expected ({typename(kt)}), got ({typename(k)})")
+            else:
+                try:
+                    expect(k, kt)
+                except TypeError as e:
+                    raise TypeError(f"at key {k!r}: invalid key: {e}") from e
+            if vt_simple:
+                if not isinstance(v, vt):
+                    raise TypeError(f"at key {k!r}: expected ({typename(vt)}), got ({typename(v)})")
+            else:
+                try:
+                    expect(v, vt)
+                except TypeError as e:
+                    raise TypeError(f"at key {k!r}: {e}") from e
+        return value
+
+    raise TypeError(f"unsupported type annotation: {types!r}")
+
+# ======================================== VALUE CHECK ========================================
+def not_null(value: object, arg: str = "Argument"):
+    """
+    Vérifie que la valeur ne soit pas nulle
+
+    Args:
+        value(object): valeur à vérifier
+        arg(str): nom de l'argument à vérifier
+    """
+    # None
+    if value is None:
+        raise ValueError(f"{arg} cannot be None")
+
+    # Nombre
+    if isinstance(value, (int, float, complex)):
+        if value == 0:
+            raise ValueError(f"{arg} cannot be None")
+        return value
+    
+    # Types composés
+    if isinstance(value, (str, list, tuple, set, dict, frozenset)):
+        if len(value) == 0:
+            raise ValueError(f"{arg} cannot be empty")
+        return value
+        
+    # Objet possédant une méthode __len__
+    if hasattr(value, "__len__"):
+        if len(value) == 0:
+            raise ValueError(f"{arg} cannot be empty")
+        return value
+    
+    # Objet custom
+    return value
+
+def positive(value: object, arg: str = "Argument"):
+    """
+    Vérifie que la valeur soit positive
+
+    Args:
+        value(object): valeur à vérifier
+        arg(str): nom de l'argument à vérifier
+    """
+    # Nombres
+    if isinstance(value, Real):
+        if float(value) < 0:
+            raise ValueError(f"{arg} cannot be negative")
+        return value
+    
+    # Par défaut
+    return  value
+
+def clamped(value: object, min: float = 0.0, max: float = 1.0, arg: str ="Argument"):
+    """
+    Vérifie que la valeur soit comprise entre min et max
+
+    Args:
+        value(object): valeur à vérifier
+        min(float, optional): valeur minimale autorisée
+        max(float, optional): valeur maximale autorisée
+        arg(str, optional): nom de l'argument à vérifier
+    """
+    # Nombres
+    if isinstance(value, Real):
+        if float(value) < min or float(value) > max:
+            raise ValueError(f"{arg} must be between {min} and {max}")
+        return value
+    
+    # Par défaut
+    return value
+
+# ======================================== CONVERSIONS ========================================
+def rgba(value: object, argument: str = "Argument") -> tuple[int, int, int, float]:
+    """
+    Renvoie, si cela est possible, la valeur en couleur rgba (255, 255, 255, 1.0)
+
+    Args:
+        value(object): valeur à convertir
+    """
+    # Type
+    if type(value) is not tuple:
+        raise TypeError(f"{argument} doit être un tuple")
+
+    # Taille
+    n = len(value)
+    if n == 3:
+        r, g, b = value
+        a = 1.0
+    elif n == 4:
+        r, g, b, a = value
+    elif n < 3:
+        v = value + (0, 0, 0, 1.0)
+        r, g, b, a = v[0], v[1], v[2], v[3]
+    else:
+        raise ValueError(f"{argument} doit être un tuple de longueur <= 4")
+
+    # RGB
+    if type(r) is float: r = int(r * 255 + 0.5)
+    if type(g) is float: g = int(g * 255 + 0.5)
+    if type(b) is float: b = int(b * 255 + 0.5)
+
+    # Alpha
+    if type(a) is int:
+        a = a / 255
+    else:
+        a = float(a)
+
+    return r, g, b, a

pyverse2d-0.4.2/pyverse2d/_rendering/__init__.py

@@ -0,0 +1,13 @@
+# ======================================== IMPORTS ========================================
+from ._camera import Camera
+from ._viewport import Viewport
+from ._screen import Screen
+from ._window import Window
+
+# ======================================== EXPORTS ========================================
+__all__ = [
+    "Camera",
+    "Viewport",
+    "Screen",
+    "Window",
+]

pyverse2d-0.4.2/pyverse2d/_rendering/_camera.py

@@ -0,0 +1,138 @@
+# ======================================== IMPORTS ========================================
+from __future__ import annotations
+
+from .._internal import expect, not_null, positive
+from ..math import Point, Vector
+from ..world import Entity, Transform
+
+from pyglet.math import Mat4, Vec3
+from numbers import Real
+
+# ======================================== CAMERA ========================================
+class Camera:
+    """
+    Définit le point de vue dans le monde
+
+    Args:
+        pos(Point): position de la caméra
+        zoom (Real): facteur de zoom
+    """
+    __slots__ = ("_pos", "_following", "_offset", "_zoom")
+
+    def __init__(self, pos: Point = (0.0, 0.0), zoom: Real = 1.0):
+        self._pos: Point = Point(pos)
+        self._following: Entity | None = None
+        self._offset: Vector = Vector(0.0, 0.0)
+        self._zoom: float = float(positive(not_null(expect(zoom, Real))))
+
+    # ======================================== GETTERS ========================================
+    @property
+    def x(self) -> float:
+        """Renvoie la position horizontale"""
+        return self._pos.x
+
+    @property
+    def y(self) -> float:
+        """Renvoie la position verticale"""
+        return self._pos.y
+
+    @property
+    def pos(self) -> Point:
+        """Renvoie la position"""
+        return self._pos
+
+    @property
+    def offset(self) -> Vector:
+        """Renvoie le vecteur de décalage à la position"""
+        return self._offset
+    
+    @property
+    def final_x(self) -> float:
+        """Position horizontale finale"""
+        self._check_follow()
+        base = self._following.get(Transform).x if self._following else self._pos.x
+        return base + self._offset.x
+    
+    @property
+    def final_y(self) -> float:
+        """Position verticale finale"""
+        self._check_follow()
+        base = self._following.get(Transform).y if self._following else self._pos.y
+        return base + self._offset.y
+
+    @property
+    def final_pos(self) -> Point:
+        """Renvoie la position finale"""
+        self._check_follow()
+        base = self._following.get(Transform).pos if self._following else self._pos
+        return base + self._offset
+
+    @property
+    def zoom(self) -> float:
+        return self._zoom
+
+    # ======================================== SETTERS ========================================
+    @x.setter
+    def x(self, value: Real):
+        self._pos.x = float(expect(value, Real))
+
+    @y.setter
+    def y(self, value: Real):
+        self._pos.y = float(expect(value, Real))
+
+    @pos.setter
+    def pos(self, value: Point):
+        self._pos = Point(value)
+
+    @zoom.setter
+    def zoom(self, value: Real):
+        if float(value) <= 0:
+            raise ValueError("Zoom must be greater than 0")
+        self._zoom = float(value)
+
+    # ======================================== FOLLOW ========================================
+    def follow(self, entity: Entity):
+        """
+        Suit le Transform d'une entité
+
+        Args:
+            entity (Entity): entité à suivre
+        """
+        if not entity.has(Transform):
+            raise ValueError(f"Entity {entity.id[:8]}... has no Transform component")
+        self._following = entity
+
+    def unfollow(self):
+        """Détache la camera de l'entité suivie"""
+        self._following = None
+
+    def _check_follow(self):
+        """Unfollow automatique si l'entité est inactive"""
+        if self._following is not None and not self._following.is_active():
+            self._following = None
+
+    # ======================================== DÉPLACEMENT ========================================
+    def move(self, vector: Vector):
+        """
+        Déplace la position manuelle de la camera
+
+        Args:
+            vectorr(Vector): vecteur de translation
+        """
+        self._pos += Vector(vector)
+
+    # ======================================== RENDU ========================================
+    def view_matrix(self, virtual_width: int, virtual_height: int) -> Mat4:
+        """
+        Produit la matrice de vue à appliquer à la fenêtre
+
+        Args:
+            virtual_width (int): largeur de l'espace virtuel
+            virtual_height (int): hauteur de l'espace virtuel
+        """
+        cx = virtual_width  / 2
+        cy = virtual_height / 2
+        fx, fy = self.final_pos
+        translate = Mat4.from_translation(Vec3(cx - fx, cy - fy, 0))
+        scale = Mat4.from_scale(Vec3(self._zoom, self._zoom, 1))
+        return translate @ scale

pyverse2d-0.4.2/pyverse2d/_rendering/_pipeline.py

@@ -0,0 +1,61 @@
+# ======================================== IMPORTS ========================================
+from __future__ import annotations
+
+import pyglet
+import pyglet.gl as gl
+from pyglet.graphics import Batch, Group
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from ..scene import Scene
+
+# ======================================== RENDERER ========================================
+class Pipeline:
+    """
+    Pipeline de rendu exploitant OpenGL
+
+    Args:
+        virtual_width (int): largeur de l'espace virtuel
+        virtual_height (int): hauteur de l'espace virtuel
+    """
+
+    def __init__(self, virtual_width: int, virtual_height: int):
+        self._virtual_width: int = int(virtual_width)
+        self._virtual_height: int = int(virtual_height)
+        self._batch: Batch = Batch()
+        self._groups: dict[int, Group] = {}
+
+    # ======================================== GETTERS ========================================
+    @property
+    def batch(self) -> Batch:
+        """Renvoie le batch global"""
+        return self._batch
+    
+    def get_group(self, z: int = 0) -> Group:
+        """
+        Renvoie le Group associé au z_order, le crée si inexistant
+
+        Args:
+            z (int): z_order du group
+        """
+        if z not in self._groups:
+            self._groups[z] = Group(order=z)
+        return self._groups[z]
+
+    # ======================================== PIPELINE ========================================
+    def begin(self, scene: Scene):
+        """
+        Configure le contexte de rendu depuis la scene active.
+        Applique la caméra et le viewport.
+
+        Args:
+            scene (Scene): scene à rendre
+        """
+        x, y, w, h = scene.viewport.resolve(self._virtual_width, self._virtual_height)
+        gl.glViewport(int(x), int(y), int(w), int(h))
+        pyglet.get_default_window().view = scene.camera.view_matrix(self._virtual_width, self._virtual_height)
+
+    def flush(self):
+        """Envoie tout le batch au GPU"""
+        self._batch.draw()