starsec-client 0.910.0__py3-none-any.whl

starsec_client/__init__.py

@@ -0,0 +1,16 @@
+# ruff: noqa: I001  (the vendored-core shim must import before starsec_core)
+"""starsec-client — the standalone STARSEC player app.
+
+Entrypoint is :func:`main` (console script ``starsec-client``). The player
+app shows a main menu, joins a match lobby, and plays: FPS movement plus
+in-world terminal focus. Level authoring lives in starsec-engine, not here.
+"""
+
+# Must be first: registers the vendored starsec_core when it is not installed.
+import starsec_client._bootstrap  # noqa: F401
+
+from starsec_client.client import Client, Mode, main
+from starsec_core.version import CLIENT_VERSION
+
+__version__ = CLIENT_VERSION
+__all__ = ["Client", "Mode", "main"]

starsec_client/_bootstrap.py

@@ -0,0 +1,41 @@
+"""Resolve ``starsec_core`` to the vendored copy when it is not installed.
+
+The client ships a copy of the shared runtime (``_vendor/starsec_core``) so the
+PyPI package never depends on the private core distribution. The copy is loaded
+**under the name** ``starsec_core`` so every absolute import inside it (and in
+the client) resolves unchanged.
+"""
+
+from __future__ import annotations
+
+import importlib
+import importlib.util
+import sys
+from pathlib import Path
+
+
+def install() -> bool:
+    """Make ``starsec_core`` importable. True when the vendored copy is used."""
+    if "starsec_core" in sys.modules:
+        return False
+    try:
+        importlib.import_module("starsec_core")
+        return False
+    except ImportError:
+        pass
+    package_dir = Path(__file__).resolve().parent / "_vendor" / "starsec_core"
+    init = package_dir / "__init__.py"
+    if not init.is_file():
+        raise ImportError("starsec_core is not installed and no vendored copy ships")
+    spec = importlib.util.spec_from_file_location(
+        "starsec_core", init, submodule_search_locations=[str(package_dir)]
+    )
+    if spec is None or spec.loader is None:
+        raise ImportError("vendored starsec_core is malformed")
+    module = importlib.util.module_from_spec(spec)
+    sys.modules["starsec_core"] = module
+    spec.loader.exec_module(module)
+    return True
+
+
+install()

starsec_client/_vendor/starsec_core/__init__.py

@@ -0,0 +1,28 @@
+"""starsec-core — shared STARSEC engine runtime.
+
+Public API re-exports:
+- config, tracing
+- world (World, Team, Platform, Terminal, Spawn, Camera, Model)
+- terminal (Terminal, LocalPtyTransport, LocalDockerTransport)
+- input (PlayerController)
+- render (lighting, color, camera, terminal3d)
+- net (codec, messages, bus)
+- ui (Button, Panel, TextInput, Slider, Checkbox, Modal, modal_confirm)
+"""
+
+from starsec_core.version import CORE_VERSION
+
+from . import config, input, net, render, terminal, tracing, ui, world
+
+__version__ = CORE_VERSION
+
+__all__ = [
+    "config",
+    "input",
+    "net",
+    "render",
+    "terminal",
+    "tracing",
+    "ui",
+    "world",
+]

starsec_client/_vendor/starsec_core/auth.py

@@ -0,0 +1,130 @@
+"""D5i account auth — GitHub device flow + credentials store (Phase 11).
+
+D5-Interactive accounts ride GitHub: client-side device-flow OAuth (stdlib
+``urllib``; ``http`` injectable for tests), token + login stored in the
+home's ``credentials.json`` (chmod 600; Windows: best-effort ACL later).
+The updater (``net.updates``) reads the token for the private engine
+channel; nothing else consumes credentials yet.
+"""
+
+from __future__ import annotations
+
+import json
+import os
+import stat
+import time
+import urllib.parse
+import urllib.request
+from collections.abc import Callable
+from pathlib import Path
+
+DEVICE_URL = "https://github.com/login/device/code"
+TOKEN_URL = "https://github.com/login/oauth/access_token"
+
+#: Set when the D5i OAuth app is registered; empty = the flow refuses so
+#: callers fail loudly instead of hitting an unconfigured app entry.
+CLIENT_ID = ""
+
+CREDENTIALS_FALLBACK = "~/.starsec_credentials.json"
+
+Http = Callable[[str, str, dict, dict], "tuple[int, bytes]"]
+
+
+def _http_default(method: str, url: str, headers: dict, data: dict):
+    body = urllib.parse.urlencode(data).encode()
+    request = urllib.request.Request(url, data=body, headers=headers, method=method)
+    try:
+        with urllib.request.urlopen(request, timeout=30) as resp:
+            return resp.status, resp.read()
+    except urllib.error.HTTPError as exc:  # GitHub answers errors in-band
+        return exc.code, exc.read()
+
+
+def request_device_code(client_id: str, *, http: Http | None = None) -> dict:
+    """Start the device flow; returns the device-code payload from GitHub."""
+    if not client_id:
+        raise ValueError("client_id not configured")
+    transport = http or _http_default
+    status, body = transport(
+        "POST", DEVICE_URL, {"Accept": "application/json"}, {"client_id": client_id}
+    )
+    if status != 200:
+        raise RuntimeError(f"device-code request failed: HTTP {status}")
+    return json.loads(body)
+
+
+def poll_token(
+    device_code: dict,
+    client_id: str,
+    *,
+    http: Http | None = None,
+    tries: int = 8,
+    sleep: Callable[[float], None] = time.sleep,
+) -> dict:
+    """Poll for the access token; ``None``-free contract: raise on timeout.
+
+    Bounded on purpose (Review Focus 3): ``tries`` rounds at the device
+    code's ``interval``; ``slow_down`` adds the 5-second penalty and keeps
+    polling. Exhaustion raises ``TimeoutError``.
+    """
+    if not client_id:
+        raise ValueError("client_id not configured")
+    transport = http or _http_default
+    interval = float(device_code.get("interval", 5))
+    data = {
+        "client_id": client_id,
+        "device_code": device_code.get("device_code", ""),
+        "grant_type": "urn:ietf:params:oauth:grant-type:device_code",
+    }
+    for _attempt in range(tries):
+        status, body = transport("POST", TOKEN_URL, {"Accept": "application/json"}, dict(data))
+        payload = json.loads(body)
+        error = payload.get("error")
+        if status == 200 and payload.get("access_token"):
+            return payload
+        if error == "slow_down":
+            interval += 5.0
+        elif error not in (None, "authorization_pending"):
+            raise RuntimeError(f"device flow error: {error}")
+        sleep(interval)
+    raise TimeoutError(f"device flow timed out after {tries} rounds")
+
+
+# --------------------------------------------------------------------------- #
+# Credentials store
+# --------------------------------------------------------------------------- #
+def credentials_path(env: dict[str, str] | None = None) -> Path:
+    """``<home>/credentials.json`` when home is active, else the user file."""
+    from starsec_core.home import home_root
+
+    home = home_root(env=env)
+    if home is not None:
+        return home / "credentials.json"
+    return Path(CREDENTIALS_FALLBACK).expanduser()
+
+
+def save_credentials(path: Path, creds: dict) -> None:
+    """Write atomically-ish with owner-only permissions."""
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(creds, indent=2))
+    try:
+        os.chmod(path, stat.S_IRUSR | stat.S_IWUSR)
+    except OSError:  # Windows: no chmod; ACL pass later
+        pass
+
+
+def load_credentials(path: Path) -> dict:
+    return json.loads(Path(path).read_text())
+
+
+def _self_check() -> None:
+    assert (
+        credentials_path(env={"STARSEC_HOME_MARKER": "/nonexistent"}).name
+        == ".starsec_credentials.json"
+    )
+    assert CLIENT_ID == ""  # flow refuses until the OAuth app is registered
+    print("auth self-check ok")
+
+
+if __name__ == "__main__":
+    _self_check()

starsec_client/_vendor/starsec_core/combat_hitbox.py

@@ -0,0 +1,102 @@
+"""Rectangular OBB hitboxes (Phase 23C): same test for combat and editor.
+
+Euler degrees use the same world convention as ``world.euler``: rotate around
+X, then Y, then Z. Segment tests operate in box-local space via inverse
+rotation, so a rotated fighter's hitbox matches its rendered box.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+from starsec_core.world import Vec3, v3_add, v3_dot, v3_rotate_axis, v3_sub
+
+
+@dataclass(frozen=True)
+class Hitbox:
+    half_extents: Vec3 = (1.0, 0.5, 1.0)
+    offset: Vec3 = (0.0, 0.0, 0.0)
+    rotation: Vec3 = (0.0, 0.0, 0.0)
+
+    def valid(self) -> bool:
+        return all(value > 0.0 for value in self.half_extents)
+
+
+def _to_local(point: Vec3, center: Vec3, rotation: Vec3) -> Vec3:
+    relative = v3_sub(point, center)
+    # inverse Euler order: undo Z, then Y, then X
+    out = v3_rotate_axis(relative, (0.0, 0.0, 1.0), -math.radians(rotation[2]))
+    out = v3_rotate_axis(out, (0.0, 1.0, 0.0), -math.radians(rotation[1]))
+    return v3_rotate_axis(out, (1.0, 0.0, 0.0), -math.radians(rotation[0]))
+
+
+def hitbox_center(hitbox: Hitbox, position: Vec3, rotation: Vec3) -> Vec3:
+    # offset rotates with the fighter; reuse forward rotation via positive axes
+    return v3_add(position, _rotate_forward(hitbox.offset, rotation))
+
+
+def _rotate_forward(vector: Vec3, rotation: Vec3) -> Vec3:
+    out = v3_rotate_axis(vector, (1.0, 0.0, 0.0), math.radians(rotation[0]))
+    out = v3_rotate_axis(out, (0.0, 1.0, 0.0), math.radians(rotation[1]))
+    return v3_rotate_axis(out, (0.0, 0.0, 1.0), math.radians(rotation[2]))
+
+
+def point_in_hitbox(point: Vec3, hitbox: Hitbox, position: Vec3, rotation: Vec3) -> bool:
+    center = hitbox_center(hitbox, position, rotation)
+    local = _to_local(point, center, rotation)
+    return all(abs(local[i]) <= hitbox.half_extents[i] for i in range(3))
+
+
+def segment_hitbox(
+    start: Vec3,
+    end: Vec3,
+    hitbox: Hitbox,
+    position: Vec3,
+    rotation: Vec3,
+) -> float | None:
+    """Ray/segment vs OBB; returns the entry fraction 0..1 or None."""
+    if not hitbox.valid():
+        return None
+    center = hitbox_center(hitbox, position, rotation)
+    local_start = _to_local(start, center, rotation)
+    local_end = _to_local(end, center, rotation)
+    direction = v3_sub(local_end, local_start)
+    t_min, t_max = 0.0, 1.0
+    for axis in range(3):
+        if abs(direction[axis]) < 1e-9:
+            if abs(local_start[axis]) > hitbox.half_extents[axis]:
+                return None
+            continue
+        first = (-hitbox.half_extents[axis] - local_start[axis]) / direction[axis]
+        second = (hitbox.half_extents[axis] - local_start[axis]) / direction[axis]
+        low, high = sorted((first, second))
+        t_min = max(t_min, low)
+        t_max = min(t_max, high)
+        if t_min > t_max:
+            return None
+    return t_min if t_max >= 0.0 else None
+
+
+def sphere_hitbox(
+    center: Vec3, radius: float, hitbox: Hitbox, position: Vec3, rotation: Vec3
+) -> bool:
+    """Sphere vs OBB via the closest local point."""
+    box_center = hitbox_center(hitbox, position, rotation)
+    local = _to_local(center, box_center, rotation)
+    closest = tuple(
+        max(-hitbox.half_extents[i], min(hitbox.half_extents[i], local[i])) for i in range(3)
+    )
+    delta = v3_sub(local, closest)
+    return v3_dot(delta, delta) <= radius * radius
+
+
+def _self_check() -> None:
+    box = Hitbox((1.0, 1.0, 1.0))
+    assert point_in_hitbox((0.0, 0.0, 0.0), box, (0.0, 0.0, 0.0), (0, 0, 0))
+    assert segment_hitbox((-5, 0, 0), (5, 0, 0), box, (0, 0, 0), (0, 0, 0)) is not None
+    print("hitbox self-check ok")
+
+
+if __name__ == "__main__":
+    _self_check()