glpg-pygame 1.0.0__tar.gz

glpg_pygame-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 BOU4EYT
+
+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.

glpg_pygame-1.0.0/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: glpg-pygame
+Version: 1.0.0
+Summary: A shorthand wrapper for pygame that makes game development fast and easy
+License: MIT
+Project-URL: Homepage, https://github.com/BOU4EYT/GLPG-GameLib
+Project-URL: Repository, https://github.com/BOU4EYT/GLPG-GameLib
+Keywords: pygame,game,gamedev,wrapper,shorthand
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: pygame
+Requires-Dist: pygame>=2.0.0; extra == "pygame"
+Provides-Extra: pygame-ce
+Requires-Dist: pygame-ce>=2.0.0; extra == "pygame-ce"
+Dynamic: license-file
+
+# GLPG — GameLib for Pygame
+
+A tiny wrapper for pygame that makes game development fast and approachable.
+Write games in a few lines instead of dozens.
+
+```
+pip install glpg
+```
+
+If you need a newer Python version, `pygame-ce` is also supported:
+
+```
+pip install pygame-ce glpg
+```
+
+---
+
+## Quickstart — Managed Loop
+
+```python
+import glpg as gl
+
+gl.window("720p", title="My Game", fps=60, bg_color="#1a1a2e")
+
+@gl.on_update
+def update(dt):
+    if gl.key("escape"):
+        gl.quit()
+
+@gl.on_draw
+def draw():
+    gl.draw.rect(100, 100, 64, 64, "#e63946")
+    gl.draw.circle(400, 300, 40, "cyan")
+    gl.draw.text("Hello GLPG", 20, 20, size=32, color="white")
+
+gl.run()
+```
+
+## Quickstart — Manual Loop
+
+```python
+import glpg as gl
+
+gl.window("720p", title="Manual Loop")
+
+x = 100
+
+while (dt := gl.tick()) is not None:
+    if gl.key("escape"):
+        gl.quit()
+    if gl.key("right"):
+        x += 200 * dt
+
+    gl.draw.rect(x, 300, 48, 48, "white")
+    gl.flip()
+```
+
+---
+
+## API Reference
+
+### Window
+
+| Call | Description |
+|------|-------------|
+| `gl.window(size, title, icon, fps, bg_color)` | Initialise the window. Call once before anything else. |
+| `gl.get_size()` | Returns `(width, height)` |
+| `gl.get_width()` / `gl.get_height()` | Individual dimensions |
+| `gl.set_title(title)` | Change the window title |
+| `gl.set_fps(fps)` | Update the FPS cap at runtime |
+| `gl.set_bg_color(color)` | Update the clear colour |
+| `gl.get_screen()` | Raw `pygame.Surface` for advanced use |
+
+**Size strings:** `"480p"` (854×480) · `"720p"` (1280×720) · `"1080p"` (1920×1080) · `"1440p"` (2560×1440)
+Or pass a custom `(width, height)` tuple.
+
+---
+
+### Managed Loop
+
+| Call | Description |
+|------|-------------|
+| `@gl.on_update` | Decorator that runs each frame and receives `dt` (seconds) |
+| `@gl.on_draw` | Decorator that runs each frame after clearing the screen |
+| `gl.run()` | Start the managed loop and block until the window closes |
+| `gl.quit()` | Signal the loop to stop |
+| `gl.is_running()` | `True` while the loop is active |
+| `gl.get_fps()` | Measured FPS for the current frame |
+
+---
+
+### Manual Loop
+
+| Call | Description |
+|------|-------------|
+| `gl.tick()` | Begin a frame, returns `dt` in seconds or `None` when finished |
+| `gl.flip()` | Present the frame at the end of your loop |
+| `gl.quit()` | Stop the loop on the next tick |
+
+---
+
+### Drawing
+
+All draw calls go through `gl.draw.*`.
+
+| Call | Description |
+|------|-------------|
+| `gl.draw.rect(x, y, w, h, color, border, radius)` | Rectangle. Use `radius` for rounded corners. |
+| `gl.draw.circle(x, y, radius, color, border)` | Circle centred at `(x, y)` |
+| `gl.draw.ellipse(x, y, w, h, color, border)` | Ellipse inside a bounding box |
+| `gl.draw.line(x1, y1, x2, y2, color, width)` | Line between two points |
+| `gl.draw.polygon(points, color, border)` | Polygon from a list of `(x, y)` points |
+| `gl.draw.text(content, x, y, size, color, font, center, antialias)` | Text. `center=True` centres on `(x, y)`. Returns `pygame.Rect` |
+| `gl.draw.image(path, x, y, scale, center, cache)` | Image from file. Returns `pygame.Rect` |
+| `gl.draw.clear(color)` | Clear the screen. Defaults to window `bg_color` |
+| `gl.draw.clear_image_cache()` | Evict cached image surfaces between scenes |
+
+**Colors** accept:
+- Named strings: `"red"`, `"white"`, `"cornflowerblue"`
+- Hex strings: `"#e63946"`, `"#ff0000ff"` (with alpha)
+- RGB tuples: `(255, 99, 71)`, `(255, 99, 71, 128)`
+
+`border=0` means filled. Any positive value draws an outline.
+
+---
+
+### Input — Keyboard
+
+| Call | Description |
+|------|-------------|
+| `gl.key("W")` | `True` while the key is held |
+| `gl.key_pressed("space")` | `True` only on the first frame the key is pressed |
+| `gl.key_released("shift")` | `True` only on the release frame |
+
+**Key names:** letters `a–z`, digits `0–9`, `"space"`, `"enter"`, `"escape"`, `"backspace"`, `"tab"`, `"up"`, `"down"`, `"left"`, `"right"`, `"shift"`, `"ctrl"`, `"alt"` (also `"lshift"`, `"rshift"` etc.), `"f1"–"f12"`, `"delete"`, `"insert"`, `"home"`, `"end"`, `"pageup"`, `"pagedown"`.
+
+---
+
+### Input — Mouse
+
+| Call | Description |
+|------|-------------|
+| `gl.mouse.pos` | `(x, y)` cursor position |
+| `gl.mouse.x` / `gl.mouse.y` | Individual coordinates |
+| `gl.mouse.clicked("left")` | `True` only on the click frame. Buttons: `"left"`, `"right"`, `"middle"` |
+| `gl.mouse.held("right")` | `True` while the button is held |
+
+---
+
+## License
+
+MIT License 2026

glpg_pygame-1.0.0/README.md

@@ -0,0 +1,152 @@
+# GLPG — GameLib for Pygame
+
+A tiny wrapper for pygame that makes game development fast and approachable.
+Write games in a few lines instead of dozens.
+
+```
+pip install glpg
+```
+
+If you need a newer Python version, `pygame-ce` is also supported:
+
+```
+pip install pygame-ce glpg
+```
+
+---
+
+## Quickstart — Managed Loop
+
+```python
+import glpg as gl
+
+gl.window("720p", title="My Game", fps=60, bg_color="#1a1a2e")
+
+@gl.on_update
+def update(dt):
+    if gl.key("escape"):
+        gl.quit()
+
+@gl.on_draw
+def draw():
+    gl.draw.rect(100, 100, 64, 64, "#e63946")
+    gl.draw.circle(400, 300, 40, "cyan")
+    gl.draw.text("Hello GLPG", 20, 20, size=32, color="white")
+
+gl.run()
+```
+
+## Quickstart — Manual Loop
+
+```python
+import glpg as gl
+
+gl.window("720p", title="Manual Loop")
+
+x = 100
+
+while (dt := gl.tick()) is not None:
+    if gl.key("escape"):
+        gl.quit()
+    if gl.key("right"):
+        x += 200 * dt
+
+    gl.draw.rect(x, 300, 48, 48, "white")
+    gl.flip()
+```
+
+---
+
+## API Reference
+
+### Window
+
+| Call | Description |
+|------|-------------|
+| `gl.window(size, title, icon, fps, bg_color)` | Initialise the window. Call once before anything else. |
+| `gl.get_size()` | Returns `(width, height)` |
+| `gl.get_width()` / `gl.get_height()` | Individual dimensions |
+| `gl.set_title(title)` | Change the window title |
+| `gl.set_fps(fps)` | Update the FPS cap at runtime |
+| `gl.set_bg_color(color)` | Update the clear colour |
+| `gl.get_screen()` | Raw `pygame.Surface` for advanced use |
+
+**Size strings:** `"480p"` (854×480) · `"720p"` (1280×720) · `"1080p"` (1920×1080) · `"1440p"` (2560×1440)
+Or pass a custom `(width, height)` tuple.
+
+---
+
+### Managed Loop
+
+| Call | Description |
+|------|-------------|
+| `@gl.on_update` | Decorator that runs each frame and receives `dt` (seconds) |
+| `@gl.on_draw` | Decorator that runs each frame after clearing the screen |
+| `gl.run()` | Start the managed loop and block until the window closes |
+| `gl.quit()` | Signal the loop to stop |
+| `gl.is_running()` | `True` while the loop is active |
+| `gl.get_fps()` | Measured FPS for the current frame |
+
+---
+
+### Manual Loop
+
+| Call | Description |
+|------|-------------|
+| `gl.tick()` | Begin a frame, returns `dt` in seconds or `None` when finished |
+| `gl.flip()` | Present the frame at the end of your loop |
+| `gl.quit()` | Stop the loop on the next tick |
+
+---
+
+### Drawing
+
+All draw calls go through `gl.draw.*`.
+
+| Call | Description |
+|------|-------------|
+| `gl.draw.rect(x, y, w, h, color, border, radius)` | Rectangle. Use `radius` for rounded corners. |
+| `gl.draw.circle(x, y, radius, color, border)` | Circle centred at `(x, y)` |
+| `gl.draw.ellipse(x, y, w, h, color, border)` | Ellipse inside a bounding box |
+| `gl.draw.line(x1, y1, x2, y2, color, width)` | Line between two points |
+| `gl.draw.polygon(points, color, border)` | Polygon from a list of `(x, y)` points |
+| `gl.draw.text(content, x, y, size, color, font, center, antialias)` | Text. `center=True` centres on `(x, y)`. Returns `pygame.Rect` |
+| `gl.draw.image(path, x, y, scale, center, cache)` | Image from file. Returns `pygame.Rect` |
+| `gl.draw.clear(color)` | Clear the screen. Defaults to window `bg_color` |
+| `gl.draw.clear_image_cache()` | Evict cached image surfaces between scenes |
+
+**Colors** accept:
+- Named strings: `"red"`, `"white"`, `"cornflowerblue"`
+- Hex strings: `"#e63946"`, `"#ff0000ff"` (with alpha)
+- RGB tuples: `(255, 99, 71)`, `(255, 99, 71, 128)`
+
+`border=0` means filled. Any positive value draws an outline.
+
+---
+
+### Input — Keyboard
+
+| Call | Description |
+|------|-------------|
+| `gl.key("W")` | `True` while the key is held |
+| `gl.key_pressed("space")` | `True` only on the first frame the key is pressed |
+| `gl.key_released("shift")` | `True` only on the release frame |
+
+**Key names:** letters `a–z`, digits `0–9`, `"space"`, `"enter"`, `"escape"`, `"backspace"`, `"tab"`, `"up"`, `"down"`, `"left"`, `"right"`, `"shift"`, `"ctrl"`, `"alt"` (also `"lshift"`, `"rshift"` etc.), `"f1"–"f12"`, `"delete"`, `"insert"`, `"home"`, `"end"`, `"pageup"`, `"pagedown"`.
+
+---
+
+### Input — Mouse
+
+| Call | Description |
+|------|-------------|
+| `gl.mouse.pos` | `(x, y)` cursor position |
+| `gl.mouse.x` / `gl.mouse.y` | Individual coordinates |
+| `gl.mouse.clicked("left")` | `True` only on the click frame. Buttons: `"left"`, `"right"`, `"middle"` |
+| `gl.mouse.held("right")` | `True` while the button is held |
+
+---
+
+## License
+
+MIT License 2026

glpg_pygame-1.0.0/glpg/__init__.py

@@ -0,0 +1,72 @@
+# glpg/__init__.py — public API
+"""
+GLPG — GameLib for Pygame
+A shorthand wrapper that makes pygame fast and approachable.
+
+MIT License 2026
+
+Quickstart (managed loop):
+    import glpg as gl
+
+    gl.window("720p", title="My Game")
+
+    @gl.on_update
+    def update(dt):
+        if gl.key("escape"):
+            gl.quit()
+
+    @gl.on_draw
+    def draw():
+        gl.draw.rect(100, 100, 64, 64, "#e63946")
+        gl.draw.text("Hello GLPG", 20, 20, size=32, color="white")
+
+    gl.run()
+
+Quickstart (manual loop):
+    import glpg as gl
+
+    gl.window("720p", title="My Game")
+
+    while (dt := gl.tick()) is not None:
+        if gl.key("escape"):
+            gl.quit()
+        gl.draw.rect(100, 100, 64, 64, "red")
+        gl.flip()
+"""
+
+import pygame as _pg
+
+# ── window ────────────────────────────────────────────────────────────────
+from .window import (
+    window,
+    get_screen,
+    get_size,
+    get_width,
+    get_height,
+    set_title,
+    set_fps,
+    set_bg_color,
+)
+
+# ── loop ──────────────────────────────────────────────────────────────────
+from .loop import (
+    on_update,
+    on_draw,
+    run,
+    tick,
+    flip,
+    quit,
+    is_running,
+    get_fps,
+)
+
+# ── input ─────────────────────────────────────────────────────────────────
+from .input import key, key_pressed, key_released, mouse
+
+# ── draw (namespace) ──────────────────────────────────────────────────────
+from . import draw
+
+# ── meta ──────────────────────────────────────────────────────────────────
+__version__ = "1.0.0"
+__author__  = "GLPG"
+__license__ = "MIT"

glpg_pygame-1.0.0/glpg/_color.py

@@ -0,0 +1,40 @@
+# glpg/_color.py — universal color parser
+
+import pygame as pg
+
+
+def parse(color):
+    """
+    Accept any of:
+      - RGB / RGBA tuple  → (255, 0, 0) | (255, 0, 0, 128)
+      - Hex string        → "#ff0000"   | "#ff0000ff"
+      - Named string      → "red"  "white"  "cornflowerblue"  etc.
+    Returns an (R, G, B) or (R, G, B, A) tuple.
+    """
+    if isinstance(color, (tuple, list)):
+        if len(color) in (3, 4):
+            return tuple(int(c) for c in color)
+        raise ValueError(f"Color tuple must have 3 or 4 values, got {len(color)}: {color}")
+
+    if isinstance(color, str):
+        stripped = color.strip()
+
+        if stripped.startswith("#"):
+            h = stripped.lstrip("#")
+            if len(h) == 6:
+                return (int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16))
+            if len(h) == 8:
+                return (int(h[0:2], 16), int(h[2:4], 16), int(h[4:6], 16), int(h[6:8], 16))
+            raise ValueError(f"Invalid hex color: '{color}' — expected #RRGGBB or #RRGGBBAA")
+
+        # Named color — let pygame validate it
+        try:
+            c = pg.Color(stripped)
+            return (c.r, c.g, c.b) if c.a == 255 else (c.r, c.g, c.b, c.a)
+        except ValueError:
+            raise ValueError(
+                f"Unknown color name: '{color}'. "
+                "Use a pygame color name, hex string, or RGB tuple."
+            )
+
+    raise TypeError(f"Unsupported color type: {type(color).__name__} — value: {color!r}")

glpg_pygame-1.0.0/glpg/_state.py

@@ -0,0 +1,21 @@
+# glpg/_state.py — internal shared state across all modules
+
+import pygame as pg
+
+# Display
+screen = None
+clock  = None
+fps    = 60
+bg_color = (0, 0, 0)
+
+# Loop
+running = False
+
+# Input — reset/updated every frame by input._process_events()
+_events         = []
+_keys_pressed   = set()   # fired only on first-frame press
+_keys_released  = set()   # fired only on release frame
+_keys_held      = set()   # true for every frame the key is down
+_mouse_clicked  = set()   # fired only on click frame
+_mouse_held     = set()   # true for every frame button is down
+_mouse_pos      = (0, 0)

glpg_pygame-1.0.0/glpg/draw.py

@@ -0,0 +1,204 @@
+# glpg/draw.py — drawing helpers
+
+import pygame as pg
+from . import _state
+from . import _color as _c
+
+
+# ── font cache ───────────────────────────────────────────────────────────────
+
+_font_cache: dict[tuple, pg.font.Font] = {}
+_image_cache: dict[str, pg.Surface]    = {}
+
+
+def _font(name: str | None, size: int) -> pg.font.Font:
+    key = (name, size)
+    if key not in _font_cache:
+        if name is None:
+            _font_cache[key] = pg.font.SysFont(None, size)
+        else:
+            try:
+                _font_cache[key] = pg.font.SysFont(name, size)
+            except Exception:
+                _font_cache[key] = pg.font.SysFont(None, size)
+    return _font_cache[key]
+
+
+def _surf() -> pg.Surface:
+    if _state.screen is None:
+        raise RuntimeError("Call gl.window() before drawing.")
+    return _state.screen
+
+
+# ── shapes ───────────────────────────────────────────────────────────────────
+
+def rect(x, y, w, h, color="white", border: int = 0, radius: int = 0):
+    """
+    Draw a rectangle.
+
+    Args:
+        x, y          : Top-left position.
+        w, h          : Width and height.
+        color         : Fill colour (name / hex / RGB tuple).
+        border        : Line width in pixels; 0 = filled.
+        radius        : Corner radius for rounded rectangles.
+
+    Example:
+        gl.draw.rect(100, 100, 64, 64, "#e63946")
+        gl.draw.rect(100, 100, 64, 64, "white", border=2, radius=8)
+    """
+    pg.draw.rect(_surf(), _c.parse(color), (x, y, w, h), border, border_radius=radius)
+
+
+def circle(x, y, radius, color="white", border: int = 0):
+    """
+    Draw a circle.
+
+    Args:
+        x, y    : Centre position.
+        radius  : Radius in pixels.
+        color   : Colour (name / hex / RGB tuple).
+        border  : Line width; 0 = filled.
+
+    Example:
+        gl.draw.circle(200, 200, 40, "cyan")
+    """
+    pg.draw.circle(_surf(), _c.parse(color), (int(x), int(y)), int(radius), border)
+
+
+def ellipse(x, y, w, h, color="white", border: int = 0):
+    """
+    Draw an ellipse inside the bounding box (x, y, w, h).
+
+    Example:
+        gl.draw.ellipse(100, 100, 200, 80, "yellow")
+    """
+    pg.draw.ellipse(_surf(), _c.parse(color), (int(x), int(y), int(w), int(h)), border)
+
+
+def line(x1, y1, x2, y2, color="white", width: int = 1):
+    """
+    Draw a line from (x1, y1) to (x2, y2).
+
+    Example:
+        gl.draw.line(0, 0, 400, 300, "#ff0000", width=3)
+    """
+    pg.draw.line(_surf(), _c.parse(color), (x1, y1), (x2, y2), max(1, width))
+
+
+def polygon(points: list[tuple], color="white", border: int = 0):
+    """
+    Draw a polygon from a list of (x, y) points.
+
+    Example:
+        gl.draw.polygon([(100,50), (150,150), (50,150)], "green")
+    """
+    pg.draw.polygon(_surf(), _c.parse(color), points, border)
+
+
+# ── text ─────────────────────────────────────────────────────────────────────
+
+def text(
+    content,
+    x, y,
+    size: int = 24,
+    color="white",
+    font: str | None = None,
+    center: bool = False,
+    antialias: bool = True,
+) -> pg.Rect:
+    """
+    Draw text at (x, y).
+
+    Args:
+        content   : String (or anything str()-able) to render.
+        x, y      : Position (top-left unless center=True).
+        size      : Font size in points.
+        color     : Text colour.
+        font      : System font name, or None for the default font.
+        center    : If True, the text is centred on (x, y).
+        antialias : Smooth edges (default True).
+
+    Returns:
+        pygame.Rect of the rendered text.
+
+    Example:
+        gl.draw.text("Score: 0", 20, 20, size=32, color="gold")
+        gl.draw.text("PAUSED", cx, cy, size=64, color="white", center=True)
+    """
+    f    = _font(font, size)
+    surf = f.render(str(content), antialias, _c.parse(color))
+    if center:
+        r = surf.get_rect(center=(int(x), int(y)))
+    else:
+        r = surf.get_rect(topleft=(int(x), int(y)))
+    _surf().blit(surf, r)
+    return r
+
+
+# ── image ────────────────────────────────────────────────────────────────────
+
+def image(
+    path: str,
+    x, y,
+    scale: float = 1.0,
+    center: bool = False,
+    cache: bool = True,
+) -> pg.Rect:
+    """
+    Draw an image from a file path.
+
+    Args:
+        path    : Relative or absolute path to the image file.
+        x, y    : Position (top-left unless center=True).
+        scale   : Scale multiplier (1.0 = original size).
+        center  : If True, the image is centred on (x, y).
+        cache   : Cache the loaded surface (default True).
+
+    Returns:
+        pygame.Rect of the drawn image.
+
+    Example:
+        gl.draw.image("assets/player.png", player.x, player.y)
+        gl.draw.image("assets/logo.png", cx, cy, scale=0.5, center=True)
+    """
+    if cache and path in _image_cache:
+        surf = _image_cache[path]
+    else:
+        try:
+            surf = pg.image.load(path).convert_alpha()
+        except pg.error as e:
+            raise FileNotFoundError(f"Could not load image '{path}': {e}")
+        if cache:
+            _image_cache[path] = surf
+
+    if scale != 1.0:
+        w = max(1, int(surf.get_width()  * scale))
+        h = max(1, int(surf.get_height() * scale))
+        surf = pg.transform.scale(surf, (w, h))
+
+    if center:
+        r = surf.get_rect(center=(int(x), int(y)))
+    else:
+        r = surf.get_rect(topleft=(int(x), int(y)))
+
+    _surf().blit(surf, r)
+    return r
+
+
+def clear_image_cache():
+    """Evict all cached image surfaces (useful between scenes)."""
+    _image_cache.clear()
+
+
+# ── surface ──────────────────────────────────────────────────────────────────
+
+def clear(color=None):
+    """
+    Fill the screen with a solid colour.
+    Defaults to the bg_color set in gl.window() if no colour is given.
+
+    Example:
+        gl.draw.clear("#0d0d0d")
+    """
+    _surf().fill(_c.parse(color) if color is not None else _state.bg_color)

glpg_pygame-1.0.0/glpg/input.py

@@ -0,0 +1,168 @@
+# glpg/input.py — keyboard and mouse input
+
+import pygame as pg
+from . import _state
+
+
+# ── key name → pygame constant map ──────────────────────────────────────────
+
+_KEY_MAP: dict[str, int] = {
+    # Letters
+    **{k: getattr(pg, f"K_{k}") for k in "abcdefghijklmnopqrstuvwxyz"},
+    # Digits
+    **{str(n): getattr(pg, f"K_{n}") for n in range(10)},
+    # Special keys
+    "space":     pg.K_SPACE,
+    "enter":     pg.K_RETURN,
+    "return":    pg.K_RETURN,
+    "escape":    pg.K_ESCAPE,
+    "esc":       pg.K_ESCAPE,
+    "backspace": pg.K_BACKSPACE,
+    "tab":       pg.K_TAB,
+    "delete":    pg.K_DELETE,
+    "insert":    pg.K_INSERT,
+    "home":      pg.K_HOME,
+    "end":       pg.K_END,
+    "pageup":    pg.K_PAGEUP,
+    "pagedown":  pg.K_PAGEDOWN,
+    # Arrows
+    "up":    pg.K_UP,
+    "down":  pg.K_DOWN,
+    "left":  pg.K_LEFT,
+    "right": pg.K_RIGHT,
+    # Modifiers (both sides)
+    "shift":  pg.K_LSHIFT,
+    "lshift": pg.K_LSHIFT,
+    "rshift": pg.K_RSHIFT,
+    "ctrl":   pg.K_LCTRL,
+    "lctrl":  pg.K_LCTRL,
+    "rctrl":  pg.K_RCTRL,
+    "alt":    pg.K_LALT,
+    "lalt":   pg.K_LALT,
+    "ralt":   pg.K_RALT,
+    # Function keys
+    **{f"f{n}": getattr(pg, f"K_F{n}") for n in range(1, 13)},
+}
+
+_MOUSE_MAP: dict[str, int] = {
+    "left":   1,
+    "middle": 2,
+    "right":  3,
+}
+
+
+# ── internal event processor (called by loop each frame) ────────────────────
+
+def _process_events():
+    """Read all queued pygame events and update _state input sets."""
+    _state._keys_pressed  = set()
+    _state._keys_released = set()
+    _state._mouse_clicked = set()
+    _state._mouse_pos     = pg.mouse.get_pos()
+
+    pressed_buttons = pg.mouse.get_pressed(num_buttons=3)
+    _state._mouse_held = {
+        btn for btn, held in zip([1, 2, 3], pressed_buttons) if held
+    }
+
+    for event in pg.event.get():
+        if event.type == pg.QUIT:
+            _state.running = False
+
+        elif event.type == pg.KEYDOWN:
+            _state._keys_pressed.add(event.key)
+            _state._keys_held.add(event.key)
+
+        elif event.type == pg.KEYUP:
+            _state._keys_released.add(event.key)
+            _state._keys_held.discard(event.key)
+
+        elif event.type == pg.MOUSEBUTTONDOWN:
+            _state._mouse_clicked.add(event.button)
+
+
+# ── key helpers ──────────────────────────────────────────────────────────────
+
+def _resolve_key(k) -> int:
+    if isinstance(k, int):
+        return k
+    k_low = k.lower()
+    if k_low in _KEY_MAP:
+        return _KEY_MAP[k_low]
+    attr = f"K_{k_low}"
+    if hasattr(pg, attr):
+        return getattr(pg, attr)
+    raise ValueError(
+        f"Unknown key: '{k}'. Use a letter, digit, or a name like "
+        "'space', 'enter', 'up', 'shift', 'f1', etc."
+    )
+
+
+def key(k) -> bool:
+    """True every frame the key is held down.
+
+    Example:
+        if gl.key("W"): player.move_up()
+    """
+    return _resolve_key(k) in _state._keys_held
+
+
+def key_pressed(k) -> bool:
+    """True only on the first frame the key is pressed (not held).
+
+    Example:
+        if gl.key_pressed("space"): player.jump()
+    """
+    return _resolve_key(k) in _state._keys_pressed
+
+
+def key_released(k) -> bool:
+    """True only on the frame the key is released.
+
+    Example:
+        if gl.key_released("shift"): player.stop_sprint()
+    """
+    return _resolve_key(k) in _state._keys_released
+
+
+# ── mouse ────────────────────────────────────────────────────────────────────
+
+class _Mouse:
+    """Mouse position and button state.
+
+    Example:
+        gl.mouse.pos          # (x, y)
+        gl.mouse.x            # x only
+        gl.mouse.clicked()    # left click this frame
+        gl.mouse.held("right")
+    """
+
+    @property
+    def pos(self) -> tuple[int, int]:
+        """Current (x, y) cursor position."""
+        return _state._mouse_pos
+
+    @property
+    def x(self) -> int:
+        return _state._mouse_pos[0]
+
+    @property
+    def y(self) -> int:
+        return _state._mouse_pos[1]
+
+    def clicked(self, button: str = "left") -> bool:
+        """True only on the frame the button is clicked."""
+        btn = _MOUSE_MAP.get(button.lower())
+        if btn is None:
+            raise ValueError(f"Unknown mouse button: '{button}'. Use 'left', 'right', or 'middle'.")
+        return btn in _state._mouse_clicked
+
+    def held(self, button: str = "left") -> bool:
+        """True every frame the button is held down."""
+        btn = _MOUSE_MAP.get(button.lower())
+        if btn is None:
+            raise ValueError(f"Unknown mouse button: '{button}'. Use 'left', 'right', or 'middle'.")
+        return btn in _state._mouse_held
+
+
+mouse = _Mouse()

glpg_pygame-1.0.0/glpg/loop.py

@@ -0,0 +1,148 @@
+# glpg/loop.py — managed and manual game loop
+
+import pygame as pg
+from . import _state
+from . import input as _input
+
+
+# ── registered hooks (managed loop) ─────────────────────────────────────────
+
+_update_fn = None
+_draw_fn   = None
+
+
+def on_update(fn):
+    """
+    Decorator — register a function to run every frame.
+    Receives `dt` (delta-time in seconds since last frame).
+
+    Example:
+        @gl.on_update
+        def update(dt):
+            player.x += speed * dt
+    """
+    global _update_fn
+    _update_fn = fn
+    return fn
+
+
+def on_draw(fn):
+    """
+    Decorator — register a function to run every frame for rendering.
+    Called after the screen is cleared.
+
+    Example:
+        @gl.on_draw
+        def draw():
+            gl.draw.rect(player.x, player.y, 32, 32, "red")
+    """
+    global _draw_fn
+    _draw_fn = fn
+    return fn
+
+
+# ── managed loop ─────────────────────────────────────────────────────────────
+
+def run():
+    """
+    Start the managed game loop.  Blocks until the window is closed.
+    Requires gl.window() to have been called first.
+    Register logic with @gl.on_update and rendering with @gl.on_draw.
+
+    Example:
+        gl.window("720p", title="My Game")
+
+        @gl.on_update
+        def update(dt): ...
+
+        @gl.on_draw
+        def draw(): ...
+
+        gl.run()
+    """
+    _require_window("gl.run()")
+    _state.running = True
+
+    while _state.running:
+        dt = _state.clock.tick(_state.fps) / 1000.0
+        _input._process_events()
+
+        if not _state.running:
+            break
+
+        _state.screen.fill(_state.bg_color)
+
+        if _update_fn:
+            _update_fn(dt)
+        if _draw_fn:
+            _draw_fn()
+
+        pg.display.flip()
+
+    pg.quit()
+
+
+# ── manual loop ──────────────────────────────────────────────────────────────
+
+def tick() -> float | None:
+    """
+    Manual loop mode — call once at the top of your own while loop.
+    Handles events, clears the screen, and returns dt in seconds.
+    Returns None (and calls pg.quit) when the window should close.
+
+    Example:
+        gl.window("720p")
+        while (dt := gl.tick()) is not None:
+            if gl.key("escape"):
+                gl.quit()
+            gl.draw.rect(x, y, 32, 32, "white")
+            gl.flip()
+    """
+    _require_window("gl.tick()")
+
+    if not _state.running:
+        _state.running = True
+
+    dt = _state.clock.tick(_state.fps) / 1000.0
+    _input._process_events()
+
+    if not _state.running:
+        pg.quit()
+        return None
+
+    _state.screen.fill(_state.bg_color)
+    return dt
+
+
+def flip():
+    """
+    Manual loop mode — push the current frame to the display.
+    Call once at the end of your loop body.
+    """
+    pg.display.flip()
+
+
+# ── shared utilities ─────────────────────────────────────────────────────────
+
+def quit():
+    """Signal the loop to stop at the end of the current frame."""
+    _state.running = False
+
+
+def is_running() -> bool:
+    """True while the game loop is active."""
+    return _state.running
+
+
+def get_fps() -> float:
+    """Return the actual measured FPS this frame."""
+    if _state.clock:
+        return _state.clock.get_fps()
+    return 0.0
+
+
+# ── internal ─────────────────────────────────────────────────────────────────
+
+def _require_window(caller: str):
+    if _state.screen is None:
+        raise RuntimeError(f"Call gl.window() before {caller}.")

glpg_pygame-1.0.0/glpg/window.py

@@ -0,0 +1,97 @@
+# glpg/window.py — display initialisation
+
+import pygame as pg
+from . import _state
+from . import _color as _c
+
+
+SIZES = {
+    "480p":  (854,  480),
+    "720p":  (1280, 720),
+    "1080p": (1920, 1080),
+    "1440p": (2560, 1440),
+}
+
+
+def window(size="720p", title="GLPG", icon=None, fps=60, bg_color=(0, 0, 0)):
+    """
+    Initialise the game window.  Call this once before anything else.
+
+    Args:
+        size      : Resolution string "480p" | "720p" | "1080p" | "1440p"
+                    or a custom (width, height) tuple.
+        title     : Window title bar string.
+        icon      : Path to an image file to use as the window icon (optional).
+        fps       : Target frames per second (default 60).
+        bg_color  : Background clear colour — name, hex, or RGB tuple.
+
+    Example:
+        gl.window("1080p", title="My Game", fps=144, bg_color="#1a1a2e")
+    """
+    if not pg.get_init():
+        pg.init()
+
+    # ── resolve resolution ──────────────────────────────────────────────────
+    if isinstance(size, str):
+        resolution = SIZES.get(size.lower())
+        if resolution is None:
+            raise ValueError(
+                f"Unknown size string '{size}'. "
+                f"Choose from {list(SIZES.keys())} or pass a (w, h) tuple."
+            )
+    elif isinstance(size, (tuple, list)) and len(size) == 2:
+        resolution = (int(size[0]), int(size[1]))
+    else:
+        raise TypeError(f"size must be a resolution string or (w, h) tuple, got: {size!r}")
+
+    # ── create display ──────────────────────────────────────────────────────
+    _state.screen   = pg.display.set_mode(resolution)
+    _state.clock    = pg.time.Clock()
+    _state.fps      = fps
+    _state.bg_color = _c.parse(bg_color)
+
+    pg.display.set_caption(title)
+
+    if icon:
+        try:
+            icon_surf = pg.image.load(icon).convert_alpha()
+            pg.display.set_icon(icon_surf)
+        except pg.error as e:
+            raise FileNotFoundError(f"Could not load icon '{icon}': {e}")
+
+
+# ── helpers ─────────────────────────────────────────────────────────────────
+
+def get_screen():
+    """Return the raw pygame Surface."""
+    return _state.screen
+
+
+def get_size():
+    """Return (width, height) of the current window."""
+    if _state.screen:
+        return _state.screen.get_size()
+    raise RuntimeError("Window not initialised — call gl.window() first.")
+
+
+def get_width():
+    return get_size()[0]
+
+
+def get_height():
+    return get_size()[1]
+
+
+def set_title(title: str):
+    """Update the window title bar text."""
+    pg.display.set_caption(title)
+
+
+def set_fps(fps: int):
+    """Change the target FPS cap."""
+    _state.fps = fps
+
+
+def set_bg_color(color):
+    """Change the background clear colour."""
+    _state.bg_color = _c.parse(color)

glpg_pygame-1.0.0/glpg_pygame.egg-info/PKG-INFO

@@ -0,0 +1,180 @@
+Metadata-Version: 2.4
+Name: glpg-pygame
+Version: 1.0.0
+Summary: A shorthand wrapper for pygame that makes game development fast and easy
+License: MIT
+Project-URL: Homepage, https://github.com/BOU4EYT/GLPG-GameLib
+Project-URL: Repository, https://github.com/BOU4EYT/GLPG-GameLib
+Keywords: pygame,game,gamedev,wrapper,shorthand
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Intended Audience :: Developers
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Software Development :: Libraries
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Provides-Extra: pygame
+Requires-Dist: pygame>=2.0.0; extra == "pygame"
+Provides-Extra: pygame-ce
+Requires-Dist: pygame-ce>=2.0.0; extra == "pygame-ce"
+Dynamic: license-file
+
+# GLPG — GameLib for Pygame
+
+A tiny wrapper for pygame that makes game development fast and approachable.
+Write games in a few lines instead of dozens.
+
+```
+pip install glpg
+```
+
+If you need a newer Python version, `pygame-ce` is also supported:
+
+```
+pip install pygame-ce glpg
+```
+
+---
+
+## Quickstart — Managed Loop
+
+```python
+import glpg as gl
+
+gl.window("720p", title="My Game", fps=60, bg_color="#1a1a2e")
+
+@gl.on_update
+def update(dt):
+    if gl.key("escape"):
+        gl.quit()
+
+@gl.on_draw
+def draw():
+    gl.draw.rect(100, 100, 64, 64, "#e63946")
+    gl.draw.circle(400, 300, 40, "cyan")
+    gl.draw.text("Hello GLPG", 20, 20, size=32, color="white")
+
+gl.run()
+```
+
+## Quickstart — Manual Loop
+
+```python
+import glpg as gl
+
+gl.window("720p", title="Manual Loop")
+
+x = 100
+
+while (dt := gl.tick()) is not None:
+    if gl.key("escape"):
+        gl.quit()
+    if gl.key("right"):
+        x += 200 * dt
+
+    gl.draw.rect(x, 300, 48, 48, "white")
+    gl.flip()
+```
+
+---
+
+## API Reference
+
+### Window
+
+| Call | Description |
+|------|-------------|
+| `gl.window(size, title, icon, fps, bg_color)` | Initialise the window. Call once before anything else. |
+| `gl.get_size()` | Returns `(width, height)` |
+| `gl.get_width()` / `gl.get_height()` | Individual dimensions |
+| `gl.set_title(title)` | Change the window title |
+| `gl.set_fps(fps)` | Update the FPS cap at runtime |
+| `gl.set_bg_color(color)` | Update the clear colour |
+| `gl.get_screen()` | Raw `pygame.Surface` for advanced use |
+
+**Size strings:** `"480p"` (854×480) · `"720p"` (1280×720) · `"1080p"` (1920×1080) · `"1440p"` (2560×1440)
+Or pass a custom `(width, height)` tuple.
+
+---
+
+### Managed Loop
+
+| Call | Description |
+|------|-------------|
+| `@gl.on_update` | Decorator that runs each frame and receives `dt` (seconds) |
+| `@gl.on_draw` | Decorator that runs each frame after clearing the screen |
+| `gl.run()` | Start the managed loop and block until the window closes |
+| `gl.quit()` | Signal the loop to stop |
+| `gl.is_running()` | `True` while the loop is active |
+| `gl.get_fps()` | Measured FPS for the current frame |
+
+---
+
+### Manual Loop
+
+| Call | Description |
+|------|-------------|
+| `gl.tick()` | Begin a frame, returns `dt` in seconds or `None` when finished |
+| `gl.flip()` | Present the frame at the end of your loop |
+| `gl.quit()` | Stop the loop on the next tick |
+
+---
+
+### Drawing
+
+All draw calls go through `gl.draw.*`.
+
+| Call | Description |
+|------|-------------|
+| `gl.draw.rect(x, y, w, h, color, border, radius)` | Rectangle. Use `radius` for rounded corners. |
+| `gl.draw.circle(x, y, radius, color, border)` | Circle centred at `(x, y)` |
+| `gl.draw.ellipse(x, y, w, h, color, border)` | Ellipse inside a bounding box |
+| `gl.draw.line(x1, y1, x2, y2, color, width)` | Line between two points |
+| `gl.draw.polygon(points, color, border)` | Polygon from a list of `(x, y)` points |
+| `gl.draw.text(content, x, y, size, color, font, center, antialias)` | Text. `center=True` centres on `(x, y)`. Returns `pygame.Rect` |
+| `gl.draw.image(path, x, y, scale, center, cache)` | Image from file. Returns `pygame.Rect` |
+| `gl.draw.clear(color)` | Clear the screen. Defaults to window `bg_color` |
+| `gl.draw.clear_image_cache()` | Evict cached image surfaces between scenes |
+
+**Colors** accept:
+- Named strings: `"red"`, `"white"`, `"cornflowerblue"`
+- Hex strings: `"#e63946"`, `"#ff0000ff"` (with alpha)
+- RGB tuples: `(255, 99, 71)`, `(255, 99, 71, 128)`
+
+`border=0` means filled. Any positive value draws an outline.
+
+---
+
+### Input — Keyboard
+
+| Call | Description |
+|------|-------------|
+| `gl.key("W")` | `True` while the key is held |
+| `gl.key_pressed("space")` | `True` only on the first frame the key is pressed |
+| `gl.key_released("shift")` | `True` only on the release frame |
+
+**Key names:** letters `a–z`, digits `0–9`, `"space"`, `"enter"`, `"escape"`, `"backspace"`, `"tab"`, `"up"`, `"down"`, `"left"`, `"right"`, `"shift"`, `"ctrl"`, `"alt"` (also `"lshift"`, `"rshift"` etc.), `"f1"–"f12"`, `"delete"`, `"insert"`, `"home"`, `"end"`, `"pageup"`, `"pagedown"`.
+
+---
+
+### Input — Mouse
+
+| Call | Description |
+|------|-------------|
+| `gl.mouse.pos` | `(x, y)` cursor position |
+| `gl.mouse.x` / `gl.mouse.y` | Individual coordinates |
+| `gl.mouse.clicked("left")` | `True` only on the click frame. Buttons: `"left"`, `"right"`, `"middle"` |
+| `gl.mouse.held("right")` | `True` while the button is held |
+
+---
+
+## License
+
+MIT License 2026

glpg_pygame-1.0.0/glpg_pygame.egg-info/SOURCES.txt

@@ -0,0 +1,15 @@
+LICENSE
+README.md
+pyproject.toml
+glpg/__init__.py
+glpg/_color.py
+glpg/_state.py
+glpg/draw.py
+glpg/input.py
+glpg/loop.py
+glpg/window.py
+glpg_pygame.egg-info/PKG-INFO
+glpg_pygame.egg-info/SOURCES.txt
+glpg_pygame.egg-info/dependency_links.txt
+glpg_pygame.egg-info/requires.txt
+glpg_pygame.egg-info/top_level.txt

glpg_pygame-1.0.0/glpg_pygame.egg-info/dependency_links.txt

@@ -0,0 +1 @@
+

glpg_pygame-1.0.0/glpg_pygame.egg-info/requires.txt

@@ -0,0 +1,6 @@
+
+[pygame]
+pygame>=2.0.0
+
+[pygame-ce]
+pygame-ce>=2.0.0

glpg_pygame-1.0.0/glpg_pygame.egg-info/top_level.txt

@@ -0,0 +1 @@
+glpg

glpg_pygame-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires      = ["setuptools>=61.0"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name            = "glpg-pygame"
+version         = "1.0.0"
+description     = "A shorthand wrapper for pygame that makes game development fast and easy"
+readme          = "README.md"
+license         = { text = "MIT" }
+requires-python = ">=3.10"
+dependencies    = []
+keywords        = ["pygame", "game", "gamedev", "wrapper", "shorthand"]
+classifiers     = [
+    "Development Status :: 5 - Production/Stable",
+    "Intended Audience :: Developers",
+    "Topic :: Games/Entertainment",
+    "Topic :: Software Development :: Libraries",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: 3.14",
+]
+
+[project.optional-dependencies]
+pygame    = ["pygame>=2.0.0"]
+pygame-ce = ["pygame-ce>=2.0.0"]
+
+[project.urls]
+Homepage   = "https://github.com/BOU4EYT/GLPG-GameLib"
+Repository = "https://github.com/BOU4EYT/GLPG-GameLib"

glpg_pygame-1.0.0/setup.cfg

@@ -0,0 +1,4 @@
+[egg_info]
+tag_build = 
+tag_date = 0
+