aether-engine 1.0.0__py3-none-any.whl

aether/core/save_system.py

@@ -0,0 +1,409 @@
+"""Система сохранения и загрузки игрового прогресса"""
+import json
+import os
+import pickle
+import base64
+import zlib
+from datetime import datetime
+from typing import Dict, Any, List, Optional, Callable
+from pathlib import Path
+import threading
+
+
+class SaveData:
+    """Данные сохранения"""
+    
+    def __init__(self, slot_name: str = "auto"):
+        self.slot_name = slot_name
+        self.timestamp = datetime.now().isoformat()
+        self.version = "1.0"
+        self.playtime = 0.0  # Время игры в секундах
+        
+        # Данные сцены
+        self.scene_name = ""
+        self.scene_data = {}
+        
+        # Пользовательские данные
+        self.custom_data: Dict[str, Any] = {}
+        
+        # Метаданные
+        self.metadata = {
+            'save_version': 1,
+            'game_version': '1.0',
+            'checksum': '',
+        }
+    
+    def set_custom(self, key: str, value: Any):
+        """Сохраняет пользовательские данные"""
+        self.custom_data[key] = value
+    
+    def get_custom(self, key: str, default: Any = None) -> Any:
+        """Получает пользовательские данные"""
+        return self.custom_data.get(key, default)
+    
+    def to_dict(self) -> dict:
+        """Сериализует в словарь"""
+        return {
+            'slot_name': self.slot_name,
+            'timestamp': self.timestamp,
+            'version': self.version,
+            'playtime': self.playtime,
+            'scene_name': self.scene_name,
+            'scene_data': self.scene_data,
+            'custom_data': self.custom_data,
+            'metadata': self.metadata,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: dict) -> 'SaveData':
+        """Создаёт из словаря"""
+        save = cls(data.get('slot_name', 'unknown'))
+        save.timestamp = data.get('timestamp', '')
+        save.version = data.get('version', '1.0')
+        save.playtime = data.get('playtime', 0.0)
+        save.scene_name = data.get('scene_name', '')
+        save.scene_data = data.get('scene_data', {})
+        save.custom_data = data.get('custom_data', {})
+        save.metadata = data.get('metadata', {})
+        return save
+
+
+class SaveSlot:
+    """Слот сохранения"""
+    
+    def __init__(self, slot_id: int, name: str = ""):
+        self.id = slot_id
+        self.name = name or f"Save {slot_id + 1}"
+        self.save_data: Optional[SaveData] = None
+        self.empty = True
+        self.screenshot_path = ""
+    
+    def to_dict(self) -> dict:
+        return {
+            'id': self.id,
+            'name': self.name,
+            'empty': self.empty,
+            'screenshot_path': self.screenshot_path,
+            'save_data': self.save_data.to_dict() if self.save_data else None,
+        }
+
+
+class SaveSystem:
+    """Система сохранения и загрузки"""
+    
+    _instance = None
+    
+    def __new__(cls):
+        if cls._instance is None:
+            cls._instance = super().__new__(cls)
+            cls._instance._initialize()
+        return cls._instance
+    
+    def _initialize(self):
+        """Инициализация системы сохранения"""
+        self._save_dir = Path("./saves")
+        self._max_slots = 10
+        self._slots: List[SaveSlot] = []
+        self._auto_save_enabled = True
+        self._auto_save_interval = 300  # 5 минут
+        self._auto_save_timer = 0.0
+        self._compression_enabled = True
+        self._encryption_enabled = False
+        self._encryption_key = b"aether_engine_key_2024"
+        
+        # Коллбэки
+        self.on_save: List[Callable] = []
+        self.on_load: List[Callable] = []
+        self.on_slot_created: List[Callable] = []
+        
+        # Создаём директорию
+        os.makedirs(self._save_dir, exist_ok=True)
+        
+        # Загружаем информацию о слотах
+        self._load_slots_info()
+        
+        print(f"[SaveSystem] Initialized ({self._max_slots} slots)")
+    
+    def _load_slots_info(self):
+        """Загружает информацию о слотах"""
+        slots_file = self._save_dir / "slots_info.json"
+        
+        if slots_file.exists():
+            try:
+                with open(slots_file, 'r') as f:
+                    data = json.load(f)
+                
+                self._slots = []
+                for slot_data in data.get('slots', []):
+                    slot = SaveSlot(slot_data['id'], slot_data['name'])
+                    slot.empty = slot_data.get('empty', True)
+                    slot.screenshot_path = slot_data.get('screenshot_path', '')
+                    self._slots.append(slot)
+            except Exception as e:
+                print(f"[SaveSystem] Failed to load slots info: {e}")
+                self._create_default_slots()
+        else:
+            self._create_default_slots()
+    
+    def _create_default_slots(self):
+        """Создаёт слоты по умолчанию"""
+        self._slots = []
+        for i in range(self._max_slots):
+            self._slots.append(SaveSlot(i))
+        self._save_slots_info()
+    
+    def _save_slots_info(self):
+        """Сохраняет информацию о слотах"""
+        slots_file = self._save_dir / "slots_info.json"
+        
+        try:
+            data = {
+                'slots': [slot.to_dict() for slot in self._slots]
+            }
+            with open(slots_file, 'w') as f:
+                json.dump(data, f, indent=2)
+        except Exception as e:
+            print(f"[SaveSystem] Failed to save slots info: {e}")
+    
+    def save(self, slot_id: int, save_data: SaveData, 
+             screenshot_data: bytes = None) -> bool:
+        """
+        Сохраняет данные в слот.
+        Возвращает True при успехе.
+        """
+        if slot_id < 0 or slot_id >= len(self._slots):
+            print(f"[SaveSystem] Invalid slot ID: {slot_id}")
+            return False
+        
+        try:
+            slot = self._slots[slot_id]
+            
+            # Обновляем временную метку
+            save_data.timestamp = datetime.now().isoformat()
+            
+            # Сериализуем
+            data = save_data.to_dict()
+            
+            # Сжимаем (опционально)
+            if self._compression_enabled:
+                serialized = self._compress(json.dumps(data))
+            else:
+                serialized = json.dumps(data).encode()
+            
+            # Шифруем (опционально)
+            if self._encryption_enabled:
+                serialized = self._encrypt(serialized)
+            
+            # Сохраняем файл
+            save_file = self._save_dir / f"slot_{slot_id}.sav"
+            with open(save_file, 'wb') as f:
+                f.write(serialized)
+            
+            # Сохраняем скриншот
+            if screenshot_data:
+                screenshot_file = self._save_dir / f"slot_{slot_id}.png"
+                with open(screenshot_file, 'wb') as f:
+                    f.write(screenshot_data)
+                slot.screenshot_path = str(screenshot_file)
+            
+            # Обновляем слот
+            slot.save_data = save_data
+            slot.empty = False
+            
+            # Сохраняем метаданные
+            self._save_slots_info()
+            
+            # Вызываем коллбэки
+            for callback in self.on_save:
+                callback(slot_id, save_data)
+            
+            print(f"[SaveSystem] Saved to slot {slot_id}: {slot.name}")
+            return True
+            
+        except Exception as e:
+            print(f"[SaveSystem] Failed to save: {e}")
+            return False
+    
+    def load(self, slot_id: int) -> Optional[SaveData]:
+        """
+        Загружает данные из слота.
+        Возвращает SaveData или None при ошибке.
+        """
+        if slot_id < 0 or slot_id >= len(self._slots):
+            print(f"[SaveSystem] Invalid slot ID: {slot_id}")
+            return None
+        
+        try:
+            save_file = self._save_dir / f"slot_{slot_id}.sav"
+            
+            if not save_file.exists():
+                print(f"[SaveSystem] No save file in slot {slot_id}")
+                return None
+            
+            # Читаем файл
+            with open(save_file, 'rb') as f:
+                serialized = f.read()
+            
+            # Расшифровываем
+            if self._encryption_enabled:
+                serialized = self._decrypt(serialized)
+            
+            # Распаковываем
+            if self._compression_enabled:
+                data_str = self._decompress(serialized)
+            else:
+                data_str = serialized.decode()
+            
+            # Десериализуем
+            data = json.loads(data_str)
+            save_data = SaveData.from_dict(data)
+            
+            # Обновляем слот
+            self._slots[slot_id].save_data = save_data
+            self._slots[slot_id].empty = False
+            
+            # Вызываем коллбэки
+            for callback in self.on_load:
+                callback(slot_id, save_data)
+            
+            print(f"[SaveSystem] Loaded from slot {slot_id}: {self._slots[slot_id].name}")
+            return save_data
+            
+        except Exception as e:
+            print(f"[SaveSystem] Failed to load: {e}")
+            return None
+    
+    def delete_save(self, slot_id: int) -> bool:
+        """Удаляет сохранение из слота"""
+        if slot_id < 0 or slot_id >= len(self._slots):
+            return False
+        
+        try:
+            # Удаляем файлы
+            save_file = self._save_dir / f"slot_{slot_id}.sav"
+            screenshot_file = self._save_dir / f"slot_{slot_id}.png"
+            
+            if save_file.exists():
+                os.remove(save_file)
+            if screenshot_file.exists():
+                os.remove(screenshot_file)
+            
+            # Очищаем слот
+            self._slots[slot_id].save_data = None
+            self._slots[slot_id].empty = True
+            self._slots[slot_id].screenshot_path = ""
+            
+            self._save_slots_info()
+            
+            print(f"[SaveSystem] Deleted save in slot {slot_id}")
+            return True
+            
+        except Exception as e:
+            print(f"[SaveSystem] Failed to delete save: {e}")
+            return False
+    
+    def get_slot_info(self, slot_id: int) -> Optional[SaveSlot]:
+        """Возвращает информацию о слоте"""
+        if slot_id < 0 or slot_id >= len(self._slots):
+            return None
+        return self._slots[slot_id]
+    
+    def get_all_slots(self) -> List[SaveSlot]:
+        """Возвращает все слоты"""
+        return self._slots.copy()
+    
+    def get_all_saves(self) -> List[SaveData]:
+        """Возвращает все сохранения"""
+        saves = []
+        for slot in self._slots:
+            if not slot.empty:
+                # Загружаем, если ещё не загружено
+                if slot.save_data is None:
+                    slot.save_data = self.load(slot.id)
+                if slot.save_data:
+                    saves.append(slot.save_data)
+        return saves
+    
+    def quick_save(self, save_data: SaveData) -> bool:
+        """Быстрое сохранение в первый свободный слот"""
+        for slot in self._slots:
+            if slot.empty:
+                return self.save(slot.id, save_data)
+        
+        # Если нет свободных — перезаписываем последний
+        return self.save(self._max_slots - 1, save_data)
+    
+    def quick_load(self) -> Optional[SaveData]:
+        """Быстрая загрузка последнего сохранения"""
+        for slot in reversed(self._slots):
+            if not slot.empty:
+                return self.load(slot.id)
+        return None
+    
+    def auto_save(self, save_data: SaveData):
+        """Автосохранение"""
+        if not self._auto_save_enabled:
+            return
+        
+        save_data.slot_name = "auto"
+        self.quick_save(save_data)
+    
+    def update(self, dt: float):
+        """Обновление таймера автосохранения"""
+        if self._auto_save_enabled:
+            self._auto_save_timer += dt
+            if self._auto_save_timer >= self._auto_save_interval:
+                self._auto_save_timer = 0.0
+                # Автосохранение будет вызвано извне
+    
+    def export_save(self, slot_id: int, path: str) -> bool:
+        """Экспортирует сохранение в файл"""
+        save_data = self.load(slot_id)
+        if not save_data:
+            return False
+        
+        try:
+            with open(path, 'w') as f:
+                json.dump(save_data.to_dict(), f, indent=2)
+            return True
+        except Exception as e:
+            print(f"[SaveSystem] Failed to export: {e}")
+            return False
+    
+    def import_save(self, path: str) -> Optional[SaveData]:
+        """Импортирует сохранение из файла"""
+        try:
+            with open(path, 'r') as f:
+                data = json.load(f)
+            
+            save_data = SaveData.from_dict(data)
+            return save_data
+        except Exception as e:
+            print(f"[SaveSystem] Failed to import: {e}")
+            return None
+    
+    def _compress(self, data: str) -> bytes:
+        """Сжимает данные"""
+        return zlib.compress(data.encode())
+    
+    def _decompress(self, data: bytes) -> str:
+        """Распаковывает данные"""
+        return zlib.decompress(data).decode()
+    
+    def _encrypt(self, data: bytes) -> bytes:
+        """Шифрует данные (простое XOR)"""
+        key = self._encryption_key
+        return bytes([data[i] ^ key[i % len(key)] for i in range(len(data))])
+    
+    def _decrypt(self, data: bytes) -> bytes:
+        """Расшифровывает данные"""
+        return self._encrypt(data)  # XOR — симметричный
+    
+    def set_encryption_key(self, key: bytes):
+        """Устанавливает ключ шифрования"""
+        self._encryption_key = key
+    
+    def cleanup(self):
+        """Очистка"""
+        self._save_slots_info()
+        print("[SaveSystem] Cleanup complete")

aether/core/time_manager.py

@@ -0,0 +1,25 @@
+"""Управление временем и FPS"""
+import time
+
+
+class Time:
+    def __init__(self):
+        self.delta_time = 0.0
+        self.total_time = 0.0
+        self.fps = 0.0
+        self._last_frame = time.perf_counter()
+        self._frame_count = 0
+        self._fps_timer = 0.0
+    
+    def update(self):
+        current = time.perf_counter()
+        self.delta_time = current - self._last_frame
+        self._last_frame = current
+        self.total_time += self.delta_time
+        
+        self._frame_count += 1
+        self._fps_timer += self.delta_time
+        if self._fps_timer >= 1.0:
+            self.fps = self._frame_count / self._fps_timer
+            self._frame_count = 0
+            self._fps_timer = 0.0

aether/core/window.py

@@ -0,0 +1,57 @@
+"""Окно и OpenGL-контекст"""
+import glfw
+from OpenGL.GL import *
+
+
+class Window:
+    def __init__(self, width, height, title, fullscreen, msaa_samples):
+        if not glfw.init():
+            raise RuntimeError("Failed to initialize GLFW")
+        
+        glfw.window_hint(glfw.CONTEXT_VERSION_MAJOR, 4)
+        glfw.window_hint(glfw.CONTEXT_VERSION_MINOR, 6)
+        glfw.window_hint(glfw.OPENGL_PROFILE, glfw.OPENGL_CORE_PROFILE)
+        glfw.window_hint(glfw.SAMPLES, msaa_samples)
+        
+        monitor = glfw.get_primary_monitor() if fullscreen else None
+        self._handle = glfw.create_window(width, height, title, monitor, None)
+        
+        if not self._handle:
+            glfw.terminate()
+            raise RuntimeError("Failed to create window")
+        
+        glfw.make_context_current(self._handle)
+        glfw.swap_interval(1)  # vsync
+        
+        # OpenGL state
+        glEnable(GL_DEPTH_TEST)
+        glEnable(GL_MULTISAMPLE)
+        glEnable(GL_CULL_FACE)
+        glCullFace(GL_BACK)
+        
+        # Viewport
+        self.width = width
+        self.height = height
+        glViewport(0, 0, width, height)
+        
+        print(f"[Window] Created: {width}x{height} (OpenGL {glGetString(GL_VERSION).decode()})")
+    
+    def should_close(self) -> bool:
+        return glfw.window_should_close(self._handle)
+    
+    def swap_buffers(self):
+        glfw.swap_buffers(self._handle)
+    
+    def poll_events(self):
+        glfw.poll_events()
+    
+    def set_title(self, title: str):
+        glfw.set_window_title(self._handle, title)
+    
+    def destroy(self):
+        glfw.destroy_window(self._handle)
+        glfw.terminate()
+    
+    @property
+    def handle(self):
+        return self._handle

aether/graphics/camera.py

@@ -0,0 +1,69 @@
+"""Камера"""
+import numpy as np
+
+
+class Camera:
+    def __init__(self, position=(0, 2, 10), yaw=-90, pitch=0, fov=60):
+        self.position = np.array(position, dtype=np.float32)
+        self.yaw = yaw
+        self.pitch = pitch
+        self.fov = fov
+        self.near = 0.1
+        self.far = 1000.0
+        self.speed = 5.0
+        self.sensitivity = 0.1
+        
+        self._update_vectors()
+    
+    def _update_vectors(self):
+        front = np.array([
+            np.cos(np.radians(self.yaw)) * np.cos(np.radians(self.pitch)),
+            np.sin(np.radians(self.pitch)),
+            np.sin(np.radians(self.yaw)) * np.cos(np.radians(self.pitch))
+        ], dtype=np.float32)
+        self.front = front / np.linalg.norm(front)
+        self.right = np.cross(self.front, np.array([0, 1, 0], dtype=np.float32))
+        self.up = np.cross(self.right, self.front)
+    
+    def get_view_matrix(self) -> np.ndarray:
+        target = self.position + self.front
+        f = target - self.position
+        f = f / np.linalg.norm(f)
+        s = np.cross(f, np.array([0, 1, 0], dtype=np.float32))
+        s = s / np.linalg.norm(s)
+        u = np.cross(s, f)
+        
+        view = np.identity(4, dtype=np.float32)
+        view[0, :3] = s
+        view[1, :3] = u
+        view[2, :3] = -f
+        view[3, :3] = -np.array([np.dot(s, self.position), np.dot(u, self.position), np.dot(-f, self.position)])
+        return view
+    
+    def get_projection_matrix(self, aspect_ratio: float) -> np.ndarray:
+        f = 1.0 / np.tan(np.radians(self.fov) / 2)
+        return np.array([
+            [f / aspect_ratio, 0, 0, 0],
+            [0, f, 0, 0],
+            [0, 0, (self.far + self.near) / (self.near - self.far), 
+             (2 * self.far * self.near) / (self.near - self.far)],
+            [0, 0, -1, 0]
+        ], dtype=np.float32)
+    
+    def move_forward(self, dt):
+        self.position += self.front * self.speed * dt
+    
+    def move_backward(self, dt):
+        self.position -= self.front * self.speed * dt
+    
+    def move_left(self, dt):
+        self.position -= self.right * self.speed * dt
+    
+    def move_right(self, dt):
+        self.position += self.right * self.speed * dt
+    
+    def rotate(self, dx, dy):
+        self.yaw += dx * self.sensitivity
+        self.pitch -= dy * self.sensitivity
+        self.pitch = max(-89.0, min(89.0, self.pitch))
+        self._update_vectors()

aether/graphics/framebuffer.py

@@ -0,0 +1,119 @@
+"""Framebuffer Object для рендеринга в текстуру"""
+from OpenGL.GL import *
+from typing import Optional
+
+
+class Framebuffer:
+    """OpenGL Framebuffer Object"""
+    
+    def __init__(self, width: int, height: int, 
+                 color_attachments: int = 1,
+                 depth_attachment: bool = True,
+                 samples: int = 0):
+        self.width = width
+        self.height = height
+        self.samples = samples
+        
+        self.fbo = glGenFramebuffers(1)
+        self.color_textures = []
+        self.depth_texture = None
+        self.depth_rbo = None
+        
+        glBindFramebuffer(GL_FRAMEBUFFER, self.fbo)
+        
+        # Создаём цветовые аттачменты
+        for i in range(color_attachments):
+            tex = self._create_texture(GL_COLOR_ATTACHMENT0 + i)
+            self.color_textures.append(tex)
+        
+        # Буфер глубины
+        if depth_attachment:
+            if samples > 0:
+                self.depth_rbo = self._create_depth_rbo()
+            else:
+                self.depth_texture = self._create_depth_texture()
+        
+        # Проверка
+        if glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE:
+            raise RuntimeError("Framebuffer is not complete!")
+        
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+    
+    def _create_texture(self, attachment) -> int:
+        """Создаёт текстуру для цветового аттачмента"""
+        tex = glGenTextures(1)
+        glBindTexture(GL_TEXTURE_2D, tex)
+        
+        if self.samples > 0:
+            glTexImage2DMultisample(GL_TEXTURE_2D_MULTISAMPLE, self.samples,
+                                    GL_RGBA16F, self.width, self.height, GL_TRUE)
+        else:
+            glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F,
+                        self.width, self.height, 0, GL_RGBA, GL_FLOAT, None)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+            glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+        
+        glFramebufferTexture2D(GL_FRAMEBUFFER, attachment,
+                               GL_TEXTURE_2D_MULTISAMPLE if self.samples > 0 else GL_TEXTURE_2D,
+                               tex, 0)
+        
+        return tex
+    
+    def _create_depth_texture(self) -> int:
+        """Создаёт текстуру глубины"""
+        tex = glGenTextures(1)
+        glBindTexture(GL_TEXTURE_2D, tex)
+        glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24,
+                    self.width, self.height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, None)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE)
+        glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE)
+        
+        glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                              GL_TEXTURE_2D, tex, 0)
+        
+        return tex
+    
+    def _create_depth_rbo(self) -> int:
+        """Создаёт Renderbuffer для глубины (мультисэмплинг)"""
+        rbo = glGenRenderbuffers(1)
+        glBindRenderbuffer(GL_RENDERBUFFER, rbo)
+        glRenderbufferStorageMultisample(GL_RENDERBUFFER, self.samples,
+                                        GL_DEPTH_COMPONENT24,
+                                        self.width, self.height)
+        glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+                                 GL_RENDERBUFFER, rbo)
+        return rbo
+    
+    def bind(self):
+        """Привязывает Framebuffer"""
+        glBindFramebuffer(GL_FRAMEBUFFER, self.fbo)
+        glViewport(0, 0, self.width, self.height)
+    
+    @staticmethod
+    def unbind():
+        """Отвязывает Framebuffer (возвращает рендеринг на экран)"""
+        glBindFramebuffer(GL_FRAMEBUFFER, 0)
+    
+    def resize(self, width: int, height: int):
+        """Изменяет размер Framebuffer"""
+        self.cleanup()
+        self.__init__(width, height)
+    
+    def cleanup(self):
+        """Очищает ресурсы"""
+        for tex in self.color_textures:
+            glDeleteTextures(1, [tex])
+        if self.depth_texture:
+            glDeleteTextures(1, [self.depth_texture])
+        if self.depth_rbo:
+            glDeleteRenderbuffers(1, [self.depth_rbo])
+        glDeleteFramebuffers(1, [self.fbo])
+    
+    @property
+    def color_texture(self) -> int:
+        """Возвращает первую цветовую текстуру"""
+        return self.color_textures[0] if self.color_textures else 0