aether-engine 1.1.0__tar.gz → 1.3.0__tar.gz

aether_engine-1.3.0/PKG-INFO

@@ -0,0 +1,129 @@
+Metadata-Version: 2.4
+Name: aether-engine
+Version: 1.3.0
+Summary: 3D/2D game engine by entiti937 — OpenGL, physics, FPS, mandatory branding splash
+Home-page: https://pypi.org/project/aether-engine/
+Author: entiti937
+Classifier: Development Status :: 4 - Beta
+Classifier: Intended Audience :: Developers
+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
+Classifier: Topic :: Games/Entertainment
+Classifier: Topic :: Multimedia :: Graphics :: 3D Rendering
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.24
+Requires-Dist: glfw>=2.6
+Requires-Dist: PyOpenGL>=3.1.7
+Requires-Dist: Pillow>=10.0
+Provides-Extra: audio
+Requires-Dist: pygame-ce>=2.5; extra == "audio"
+Provides-Extra: physics
+Requires-Dist: pymunk>=6.0; extra == "physics"
+Provides-Extra: models
+Requires-Dist: trimesh>=3.21; extra == "models"
+Provides-Extra: full
+Requires-Dist: trimesh>=3.21; extra == "full"
+Requires-Dist: freetype-py>=2.4; extra == "full"
+Requires-Dist: pygame-ce>=2.5; extra == "full"
+Requires-Dist: pyyaml>=6.0; extra == "full"
+Requires-Dist: pymunk>=6.0; extra == "full"
+Requires-Dist: imageio>=2.31; extra == "full"
+Dynamic: author
+Dynamic: classifier
+Dynamic: description
+Dynamic: description-content-type
+Dynamic: home-page
+Dynamic: license-file
+Dynamic: provides-extra
+Dynamic: requires-dist
+Dynamic: requires-python
+Dynamic: summary
+
+# Aether Engine
+
+**3D / 2D игровой движок на Python + OpenGL**  
+**Разработчик:** entiti937 · **Версия:** 1.3.0 · **Лицензия:** MIT  
+**PyPI:** https://pypi.org/project/aether-engine/
+
+> Полное руководство: [`docs/GUIDE.md`](docs/GUIDE.md)
+
+---
+
+## Установка
+
+```bash
+pip install -U "aether-engine[full]"
+```
+
+## Что нового в 1.3.0
+
+- **Обязательный splash** при старте любой игры (чёрный экран, белый текст, entiti937)
+- **Водяной знак** в каждом кадре + защита от удаления брендинга
+- **Кириллица** — системные шрифты, UTF-8 консоль, полный Unicode в UI
+- Компиляция защищённых модулей при сборке пакета
+
+## Showcase-игра
+
+Minecraft-like sandbox **на этом же движке**:
+
+```bash
+python games/aether_craft.py
+```
+
+Там есть: воксельный мир, вид от 1 лица, ломать/ставить блоки, HUD, звуки, день/ночь, сейвы (F5/F9), урон и респавн.
+
+## Другие запуски
+
+```bash
+python -m aether.editor
+python games/orb_rush.py
+python examples/03_first_person.py
+python examples/04_physics2d.py
+```
+
+## Минимальный код
+
+```python
+from aether import Engine, Scene, Entity, MeshFactory, Material, Camera
+from aether.scene.component import Transform, MeshRenderer
+
+engine = Engine(1280, 720, "Game by you — engine by entiti937")
+scene = Scene("Main")
+camera = Camera(position=(0, 2, 6), yaw=-90)
+scene.set_main_camera(camera)
+
+cube = Entity("Cube")
+cube.add_component(Transform(position=(0, 1, 0)))
+mat = Material(); mat.albedo[:] = (0.2, 0.85, 1.0)
+cube.add_component(MeshRenderer(mesh=MeshFactory.create_cube(), material=mat))
+scene.spawn(cube)
+
+engine.load_scene(scene)
+engine.enable_first_person(camera)
+engine.run()
+```
+
+## Возможности 1.2
+
+- PBR 3D + sprites 2D + HUD overlay
+- FPS (`enable_first_person`) и free-look камера
+- Физика 3D/2D + raycast
+- `ModelLoader` (OBJ/GLB/glTF/STL/FBX/…)
+- Встроенный voxel model editor
+- Procedural SFX, JSON save/load
+- Примеры и две игры в репозитории
+
+## Документация
+
+Все команды, API и туториалы: **[docs/GUIDE.md](docs/GUIDE.md)**
+
+---
+
+Aether Engine © **entiti937**

aether_engine-1.3.0/README.md

@@ -0,0 +1,81 @@
+# Aether Engine
+
+**3D / 2D игровой движок на Python + OpenGL**  
+**Разработчик:** entiti937 · **Версия:** 1.3.0 · **Лицензия:** MIT  
+**PyPI:** https://pypi.org/project/aether-engine/
+
+> Полное руководство: [`docs/GUIDE.md`](docs/GUIDE.md)
+
+---
+
+## Установка
+
+```bash
+pip install -U "aether-engine[full]"
+```
+
+## Что нового в 1.3.0
+
+- **Обязательный splash** при старте любой игры (чёрный экран, белый текст, entiti937)
+- **Водяной знак** в каждом кадре + защита от удаления брендинга
+- **Кириллица** — системные шрифты, UTF-8 консоль, полный Unicode в UI
+- Компиляция защищённых модулей при сборке пакета
+
+## Showcase-игра
+
+Minecraft-like sandbox **на этом же движке**:
+
+```bash
+python games/aether_craft.py
+```
+
+Там есть: воксельный мир, вид от 1 лица, ломать/ставить блоки, HUD, звуки, день/ночь, сейвы (F5/F9), урон и респавн.
+
+## Другие запуски
+
+```bash
+python -m aether.editor
+python games/orb_rush.py
+python examples/03_first_person.py
+python examples/04_physics2d.py
+```
+
+## Минимальный код
+
+```python
+from aether import Engine, Scene, Entity, MeshFactory, Material, Camera
+from aether.scene.component import Transform, MeshRenderer
+
+engine = Engine(1280, 720, "Game by you — engine by entiti937")
+scene = Scene("Main")
+camera = Camera(position=(0, 2, 6), yaw=-90)
+scene.set_main_camera(camera)
+
+cube = Entity("Cube")
+cube.add_component(Transform(position=(0, 1, 0)))
+mat = Material(); mat.albedo[:] = (0.2, 0.85, 1.0)
+cube.add_component(MeshRenderer(mesh=MeshFactory.create_cube(), material=mat))
+scene.spawn(cube)
+
+engine.load_scene(scene)
+engine.enable_first_person(camera)
+engine.run()
+```
+
+## Возможности 1.2
+
+- PBR 3D + sprites 2D + HUD overlay
+- FPS (`enable_first_person`) и free-look камера
+- Физика 3D/2D + raycast
+- `ModelLoader` (OBJ/GLB/glTF/STL/FBX/…)
+- Встроенный voxel model editor
+- Procedural SFX, JSON save/load
+- Примеры и две игры в репозитории
+
+## Документация
+
+Все команды, API и туториалы: **[docs/GUIDE.md](docs/GUIDE.md)**
+
+---
+
+Aether Engine © **entiti937**

{aether_engine-1.1.0 → aether_engine-1.3.0}/aether/__init__.py

@@ -1,4 +1,11 @@
-"""Aether Engine — 3D / 2D game engine"""
+"""Aether Engine — 3D / 2D game engine by entiti937"""
+
+from aether.core._identity import verify_token, engine_name, creator
+
+if not verify_token():
+    raise ImportError(
+        f"{engine_name()}: integrity check failed. Reinstall: pip install aether-engine"
+    )
 
 from aether.core.engine import Engine
 from aether.scene.scene import Scene
@@ -19,8 +26,12 @@ from aether.resources.loaders.model_loader import ModelLoader
 from aether.physics import PhysicsWorld2D, PhysicsWorld3D, BoxCollider, SphereCollider
 from aether.graphics2d import Renderer2D, Sprite, Camera2D
 from aether.editor import ModelEditor
+from aether.ui.hud import Hud, HudBar
+from aether.audio.sfx import SfxBank
+from aether.resources.save_load import save_json, load_json
+from aether.physics.raycast import Raycaster
 
-__version__ = "1.1.0"
+__version__ = "1.3.0"
 
 __all__ = [
     "Engine",
@@ -45,5 +56,11 @@ __all__ = [
     "Sprite",
     "Camera2D",
     "ModelEditor",
+    "Hud",
+    "HudBar",
+    "SfxBank",
+    "save_json",
+    "load_json",
+    "Raycaster",
     "__version__",
 ]

aether_engine-1.3.0/aether/audio/sfx.py

@@ -0,0 +1,85 @@
+"""Procedural sound helpers (no asset files required)."""
+from __future__ import annotations
+
+import math
+import struct
+import tempfile
+import wave
+from pathlib import Path
+from typing import Optional
+
+
+def _write_wav(path: Path, samples, rate: int = 22050):
+    with wave.open(str(path), "w") as wf:
+        wf.setnchannels(1)
+        wf.setsampwidth(2)
+        wf.setframerate(rate)
+        frames = b"".join(struct.pack("<h", int(max(-1, min(1, s)) * 32767)) for s in samples)
+        wf.writeframes(frames)
+
+
+def make_tone(
+    frequency: float = 440.0,
+    duration: float = 0.08,
+    volume: float = 0.35,
+    kind: str = "square",
+    rate: int = 22050,
+) -> Path:
+    """Generate a short WAV tone and return its path."""
+    n = int(rate * duration)
+    samples = []
+    for i in range(n):
+        t = i / rate
+        env = 1.0
+        if i < rate * 0.01:
+            env = i / (rate * 0.01)
+        elif i > n - rate * 0.02:
+            env = max(0.0, (n - i) / (rate * 0.02))
+        phase = 2 * math.pi * frequency * t
+        if kind == "sine":
+            val = math.sin(phase)
+        elif kind == "noise":
+            # deterministic pseudo-noise
+            val = math.sin(phase * 12.9898) * 2.0 % 2.0 - 1.0
+        else:
+            val = 1.0 if math.sin(phase) >= 0 else -1.0
+        samples.append(val * volume * env)
+
+    path = Path(tempfile.gettempdir()) / f"aether_tone_{int(frequency)}_{kind}.wav"
+    _write_wav(path, samples, rate)
+    return path
+
+
+class SfxBank:
+    """Lazy bank of procedural SFX played through Engine.audio."""
+
+    def __init__(self, audio_manager):
+        self.audio = audio_manager
+        self._cache = {}
+
+    def _get(self, key: str, factory):
+        if key not in self._cache:
+            path = factory()
+            # AudioManager.load_sound(name, path)
+            self._cache[key] = self.audio.load_sound(key, str(path))
+        return self._cache[key]
+
+    def play_break(self):
+        snd = self._get("break", lambda: make_tone(180, 0.07, 0.4, "noise"))
+        if snd:
+            self.audio.play_sound("break", volume=0.45)
+
+    def play_place(self):
+        snd = self._get("place", lambda: make_tone(520, 0.06, 0.3, "square"))
+        if snd:
+            self.audio.play_sound("place", volume=0.4)
+
+    def play_select(self):
+        snd = self._get("select", lambda: make_tone(760, 0.04, 0.25, "sine"))
+        if snd:
+            self.audio.play_sound("select", volume=0.35)
+
+    def play_hurt(self):
+        snd = self._get("hurt", lambda: make_tone(120, 0.12, 0.45, "square"))
+        if snd:
+            self.audio.play_sound("hurt", volume=0.5)

aether_engine-1.3.0/aether/core/_identity.py

@@ -0,0 +1,67 @@
+"""Encoded engine identity (integrity-protected, UTF-8 XOR)."""
+from __future__ import annotations
+
+_K = 0xA7
+
+_B = {
+    "n": bytes([230, 194, 211, 207, 194, 213, 135, 226, 201, 192, 206, 201, 194]),
+    "c": bytes([194, 201, 211, 206, 211, 206, 158, 148, 144]),
+    "l1": bytes([
+        119, 57, 118, 38, 119, 26, 119, 25, 119, 21, 119, 23, 119, 26, 119, 25,
+        135, 119, 26, 119, 23, 135, 119, 22, 119, 23, 119, 16, 119, 18, 135,
+        230, 194, 211, 207, 194, 213, 135, 226, 201, 192, 206, 201, 194,
+    ]),
+    "l2": bytes([
+        119, 6, 119, 25, 119, 16, 119, 19, 119, 23, 118, 37, 119, 18, 119, 28,
+        118, 43, 157, 135, 194, 201, 211, 206, 211, 206, 158, 148, 144,
+    ]),
+    "w": bytes([
+        230, 194, 211, 207, 194, 213, 135, 226, 201, 192, 206, 201, 194,
+        135, 219, 135, 194, 201, 211, 206, 211, 206, 158, 148, 144,
+    ]),
+    "sig": bytes([
+        230, 194, 211, 207, 194, 213, 135, 226, 201, 192, 206, 201, 194,
+        135, 150, 137, 148, 137, 151,
+    ]),
+}
+
+_EXPECTED = 0xAC3B2627
+
+
+def _decode(blob: bytes) -> str:
+    return bytes(b ^ _K for b in blob).decode("utf-8")
+
+
+def engine_name() -> str:
+    return _decode(_B["n"])
+
+
+def creator() -> str:
+    return _decode(_B["c"])
+
+
+def splash_line1() -> str:
+    return _decode(_B["l1"])
+
+
+def splash_line2() -> str:
+    return _decode(_B["l2"])
+
+
+def watermark() -> str:
+    return _decode(_B["w"])
+
+
+def signature() -> str:
+    return _decode(_B["sig"])
+
+
+def verify_token() -> bool:
+    try:
+        payload = "|".join([engine_name(), creator(), splash_line1(), splash_line2()])
+        h = 0
+        for ch in payload:
+            h = ((h * 131) + ord(ch)) & 0xFFFFFFFF
+        return h == _EXPECTED
+    except Exception:
+        return False

aether_engine-1.3.0/aether/core/boot_splash.py

@@ -0,0 +1,141 @@
+"""Mandatory boot splash — white text on black, shown during engine preload."""
+from __future__ import annotations
+
+import time
+from typing import Optional
+
+import glfw
+from OpenGL.GL import *
+
+from aether.core._identity import creator, engine_name, splash_line1, splash_line2, verify_token
+from aether.utils.fonts import resolve_system_font
+
+
+class BootSplash:
+    """Pre-load screen integrated into Engine startup (cannot be skipped)."""
+
+    MIN_SHOW_SEC = 2.2
+
+    def __init__(self, window):
+        self.window = window
+        self.width = window.width
+        self.height = window.height
+        self._text = None
+        self._font = None
+        self._started = time.monotonic()
+        self._progress = 0.0
+        self._ready = False
+        self._init_renderer()
+        self.draw(0.0, "Загрузка...")
+
+    def _init_renderer(self):
+        try:
+            from aether.ui.text import Font, TextRenderer
+
+            self._text = TextRenderer()
+            font_path = resolve_system_font()
+            if font_path:
+                self._font = Font(font_path, 34)
+                self._text.default_font = self._font
+            else:
+                self._font = None
+        except Exception as exc:
+            print(f"[BootSplash] Font init: {exc}")
+            self._text = None
+
+    def _draw_bar(self, progress: float):
+        """Progress bar drawn via text (core-profile safe)."""
+        if not self._text or not self._font:
+            return
+        p = max(0.0, min(1.0, progress))
+        filled = int(p * 24)
+        bar = "[" + "#" * filled + "-" * (24 - filled) + f"] {int(p * 100)}%"
+        tw, _ = self._text.measure_text(bar, 0.75, self._font)
+        self._text.render_text(
+            bar,
+            self.width * 0.5 - tw * 0.5,
+            self.height * 0.62,
+            scale=0.75,
+            color=(0.85, 0.85, 0.85, 1.0),
+            font=self._font,
+            screen_width=self.width,
+            screen_height=self.height,
+        )
+
+    def draw(self, progress: float, status: str = ""):
+        if not verify_token():
+            raise RuntimeError("Aether Engine identity verification failed")
+
+        self._progress = max(self._progress, progress)
+        glViewport(0, 0, self.width, self.height)
+        glClearColor(0.0, 0.0, 0.0, 1.0)
+        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT)
+
+        line1 = splash_line1()
+        line2 = splash_line2()
+
+        if self._text and self._font:
+            scale = 1.0
+            tw1, _ = self._text.measure_text(line1, scale, self._font)
+            tw2, th2 = self._text.measure_text(line2, scale * 0.85, self._font)
+            cx = self.width * 0.5
+            cy = self.height * 0.42
+            self._text.render_text(
+                line1,
+                cx - tw1 * 0.5,
+                cy - 40,
+                scale=scale,
+                color=(1.0, 1.0, 1.0, 1.0),
+                font=self._font,
+                screen_width=self.width,
+                screen_height=self.height,
+            )
+            self._text.render_text(
+                line2,
+                cx - tw2 * 0.5,
+                cy + 8,
+                scale=0.85,
+                color=(1.0, 1.0, 1.0, 0.92),
+                font=self._font,
+                screen_width=self.width,
+                screen_height=self.height,
+            )
+            if status:
+                ts, _ = self._text.measure_text(status, 0.7, self._font)
+                self._text.render_text(
+                    status,
+                    cx - ts * 0.5,
+                    cy + th2 + 36,
+                    scale=0.7,
+                    color=(0.75, 0.75, 0.75, 1.0),
+                    font=self._font,
+                    screen_width=self.width,
+                    screen_height=self.height,
+                )
+        else:
+            # ASCII fallback if font missing
+            print(f"[BootSplash] {line1}")
+            print(f"[BootSplash] {line2}")
+            if status:
+                print(f"[BootSplash] {status}")
+
+        self._draw_bar(self._progress)
+        self.window.swap_buffers()
+        glfw.poll_events()
+
+    def step(self, progress: float, status: str):
+        self.draw(progress, status)
+        time.sleep(0.02)
+
+    def finish(self):
+        elapsed = time.monotonic() - self._started
+        if elapsed < self.MIN_SHOW_SEC:
+            remaining = self.MIN_SHOW_SEC - elapsed
+            steps = max(1, int(remaining / 0.05))
+            for i in range(steps):
+                p = self._progress + (1.0 - self._progress) * ((i + 1) / steps)
+                self.draw(p, "Готово")
+                time.sleep(remaining / steps)
+        else:
+            self.draw(1.0, "Готово")
+        self._ready = True

aether_engine-1.3.0/aether/core/branding_guard.py

@@ -0,0 +1,103 @@
+"""Runtime branding guard — watermark + integrity checks (mandatory)."""
+from __future__ import annotations
+
+from aether.core._identity import creator, engine_name, verify_token, watermark
+
+
+class BrandingGuard:
+    """Ensures engine attribution is always visible."""
+
+    _instances = 0
+    _tamper_count = 0
+
+    def __init__(self, engine):
+        self.engine = engine
+        self._frame = 0
+        self._font = None
+        self._text = None
+        self._force_overlay = False
+        BrandingGuard._instances += 1
+        self._init_text()
+
+    def _init_text(self):
+        try:
+            from aether.ui.text import Font, TextRenderer
+            from aether.utils.fonts import resolve_system_font
+
+            path = resolve_system_font()
+            if path:
+                self._text = TextRenderer()
+                self._font = Font(path, 16)
+                self._text.default_font = self._font
+        except Exception:
+            pass
+
+    @classmethod
+    def assert_integrity(cls, engine) -> bool:
+        if not verify_token():
+            cls._tamper_count += 1
+            return False
+        if getattr(engine, "_brand_bypass", False):
+            cls._tamper_count += 1
+            engine._brand_bypass = False
+            return False
+        return True
+
+    def draw_watermark(self):
+        """Subtle persistent watermark (bottom-right)."""
+        if not BrandingGuard.assert_integrity(self.engine):
+            self._force_overlay = True
+
+        if not self._text or not self._font:
+            return
+
+        from OpenGL.GL import glDisable, glEnable, GL_DEPTH_TEST
+
+        w = self.engine.config.graphics.width
+        h = self.engine.config.graphics.height
+        label = watermark()
+        tw, _ = self._text.measure_text(label, 1.0, self._font)
+        alpha = 0.55 if not self._force_overlay else 0.95
+        self._text.render_text(
+            label,
+            w - tw - 12,
+            h - 22,
+            scale=1.0,
+            color=(1.0, 1.0, 1.0, alpha),
+            font=self._font,
+            screen_width=w,
+            screen_height=h,
+        )
+
+        if self._force_overlay:
+            msg1 = f"Основано на базе {engine_name()}"
+            msg2 = f"Создатель: {creator()}"
+            self._text.render_text(
+                msg1,
+                w * 0.5 - 180,
+                h * 0.5 - 20,
+                scale=1.2,
+                color=(1, 1, 1, 0.9),
+                font=self._font,
+                screen_width=w,
+                screen_height=h,
+            )
+            self._text.render_text(
+                msg2,
+                w * 0.5 - 120,
+                h * 0.5 + 18,
+                scale=1.0,
+                color=(1, 1, 1, 0.85),
+                font=self._font,
+                screen_width=w,
+                screen_height=h,
+            )
+
+        glDisable(GL_DEPTH_TEST)
+        glEnable(GL_DEPTH_TEST)
+
+    def tick(self):
+        self._frame += 1
+        if self._frame % 90 == 0:
+            if not verify_token():
+                self._force_overlay = True