aether-engine 1.0.0__py3-none-any.whl

aether/core/console.py

@@ -0,0 +1,366 @@
+"""Система консольных команд"""
+from typing import Dict, List, Callable, Any, Optional
+import inspect
+import shlex
+
+
+class ConsoleCommand:
+    """Консольная команда"""
+    
+    def __init__(self, 
+                 name: str, 
+                 func: Callable, 
+                 description: str = "",
+                 usage: str = "",
+                 category: str = "General"):
+        self.name = name
+        self.func = func
+        self.description = description
+        self.usage = usage or name
+        self.category = category
+    
+    def execute(self, args: List[str]) -> str:
+        """Выполняет команду"""
+        try:
+            return str(self.func(*args))
+        except Exception as e:
+            return f"Error: {e}"
+
+
+class ConsoleVariable:
+    """Консольная переменная"""
+    
+    def __init__(self, 
+                 name: str, 
+                 default_value: Any,
+                 description: str = "",
+                 min_value: Optional[float] = None,
+                 max_value: Optional[float] = None,
+                 callback: Optional[Callable] = None):
+        self.name = name
+        self._value = default_value
+        self.default_value = default_value
+        self.description = description
+        self.min_value = min_value
+        self.max_value = max_value
+        self.callback = callback
+    
+    @property
+    def value(self) -> Any:
+        return self._value
+    
+    @value.setter
+    def value(self, new_value: Any):
+        # Проверка типа
+        if isinstance(self._value, bool):
+            if isinstance(new_value, str):
+                new_value = new_value.lower() in ('true', '1', 'yes', 'on')
+            else:
+                new_value = bool(new_value)
+        elif isinstance(self._value, int):
+            new_value = int(new_value)
+        elif isinstance(self._value, float):
+            new_value = float(new_value)
+        
+        # Проверка диапазона
+        if isinstance(new_value, (int, float)):
+            if self.min_value is not None:
+                new_value = max(self.min_value, new_value)
+            if self.max_value is not None:
+                new_value = min(self.max_value, new_value)
+        
+        old_value = self._value
+        self._value = new_value
+        
+        # Вызываем callback
+        if self.callback and old_value != new_value:
+            self.callback(old_value, new_value)
+    
+    def toggle(self):
+        """Переключает булеву переменную"""
+        if isinstance(self._value, bool):
+            self.value = not self._value
+    
+    def reset(self):
+        """Сбрасывает к значению по умолчанию"""
+        self.value = self.default_value
+
+
+class Console:
+    """Консоль движка"""
+    
+    _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._commands: Dict[str, ConsoleCommand] = {}
+        self._variables: Dict[str, ConsoleVariable] = {}
+        self._history: List[str] = []
+        self._history_index = -1
+        self._max_history = 100
+        
+        # Состояние
+        self.visible = False
+        self._input_buffer = ""
+        self._output_lines: List[str] = []
+        self._max_output_lines = 200
+        
+        # Регистрируем встроенные команды
+        self._register_default_commands()
+        self._register_default_variables()
+        
+        print("[Console] Initialized")
+    
+    def _register_default_commands(self):
+        """Регистрирует стандартные команды"""
+        self.register_command("help", self._cmd_help, "Shows available commands")
+        self.register_command("list", self._cmd_list, "Lists all commands and variables")
+        self.register_command("clear", self._cmd_clear, "Clears the console")
+        self.register_command("echo", self._cmd_echo, "Prints a message")
+        self.register_command("quit", self._cmd_quit, "Exits the engine")
+        self.register_command("fps", self._cmd_fps, "Shows FPS")
+        self.register_command("time_scale", self._cmd_time_scale, "Sets time scale")
+    
+    def _register_default_variables(self):
+        """Регистрирует стандартные переменные"""
+        self.register_variable("r_wireframe", False, "Toggle wireframe mode")
+        self.register_variable("r_vsync", True, "Toggle VSync")
+        self.register_variable("r_msaa", 4, "MSAA samples", 0, 16)
+        self.register_variable("g_gravity", -9.81, "Gravity value")
+        self.register_variable("g_time_scale", 1.0, "Time scale", 0.0, 10.0)
+        self.register_variable("dbg_show_colliders", False, "Show collider debug")
+        self.register_variable("dbg_show_fps", True, "Show FPS counter")
+        self.register_variable("s_volume_master", 1.0, "Master volume", 0.0, 1.0)
+        self.register_variable("s_volume_sfx", 1.0, "SFX volume", 0.0, 1.0)
+        self.register_variable("s_volume_music", 0.8, "Music volume", 0.0, 1.0)
+    
+    def register_command(self, 
+                        name: str, 
+                        func: Callable, 
+                        description: str = "",
+                        usage: str = "",
+                        category: str = "General"):
+        """Регистрирует команду"""
+        cmd = ConsoleCommand(name, func, description, usage, category)
+        self._commands[name.lower()] = cmd
+    
+    def unregister_command(self, name: str):
+        """Удаляет команду"""
+        if name.lower() in self._commands:
+            del self._commands[name.lower()]
+    
+    def register_variable(self,
+                         name: str,
+                         default_value: Any,
+                         description: str = "",
+                         min_value: Optional[float] = None,
+                         max_value: Optional[float] = None,
+                         callback: Optional[Callable] = None):
+        """Регистрирует переменную"""
+        var = ConsoleVariable(name, default_value, description, 
+                             min_value, max_value, callback)
+        self._variables[name.lower()] = var
+    
+    def get_variable(self, name: str) -> Any:
+        """Получает значение переменной"""
+        var = self._variables.get(name.lower())
+        return var.value if var else None
+    
+    def set_variable(self, name: str, value: Any):
+        """Устанавливает значение переменной"""
+        var = self._variables.get(name.lower())
+        if var:
+            var.value = value
+            self._output(f"Set {name} = {var.value}")
+        else:
+            self._output(f"Unknown variable: {name}")
+    
+    def execute(self, input_str: str) -> str:
+        """Выполняет команду или устанавливает переменную"""
+        if not input_str.strip():
+            return ""
+        
+        # Добавляем в историю
+        self._history.append(input_str)
+        if len(self._history) > self._max_history:
+            self._history.pop(0)
+        self._history_index = len(self._history)
+        
+        # Парсим
+        try:
+            parts = shlex.split(input_str)
+        except ValueError:
+            parts = input_str.split()
+        
+        if not parts:
+            return ""
+        
+        command = parts[0].lower()
+        args = parts[1:]
+        
+        # Проверяем, это команда или переменная
+        if command in self._commands:
+            result = self._commands[command].execute(args)
+            self._output(f"> {input_str}")
+            if result:
+                self._output(result)
+            return result
+        
+        elif command in self._variables:
+            if args:
+                # Установка значения
+                self.set_variable(command, args[0])
+            else:
+                # Получение значения
+                value = self.get_variable(command)
+                self._output(f"{command} = {value}")
+            return str(self.get_variable(command))
+        
+        else:
+            msg = f"Unknown command: {command}. Type 'help' for available commands."
+            self._output(f"> {input_str}")
+            self._output(msg)
+            return msg
+    
+    def _output(self, text: str):
+        """Добавляет строку в вывод"""
+        self._output_lines.append(text)
+        if len(self._output_lines) > self._max_output_lines:
+            self._output_lines.pop(0)
+    
+    def get_output(self) -> List[str]:
+        """Возвращает вывод консоли"""
+        return self._output_lines.copy()
+    
+    def get_history(self) -> List[str]:
+        """Возвращает историю команд"""
+        return self._history.copy()
+    
+    # ---- ВСТРОЕННЫЕ КОМАНДЫ ----
+    
+    def _cmd_help(self, *args) -> str:
+        """Показывает справку"""
+        if args:
+            cmd_name = args[0].lower()
+            if cmd_name in self._commands:
+                cmd = self._commands[cmd_name]
+                return f"{cmd.name}: {cmd.description}\nUsage: {cmd.usage}"
+            else:
+                return f"Unknown command: {cmd_name}"
+        
+        categories = {}
+        for cmd in self._commands.values():
+            if cmd.category not in categories:
+                categories[cmd.category] = []
+            categories[cmd.category].append(cmd)
+        
+        output = ["Available commands:\n"]
+        for category, cmds in sorted(categories.items()):
+            output.append(f"[{category}]")
+            for cmd in cmds:
+                output.append(f"  {cmd.name:<20} {cmd.description}")
+        
+        return "\n".join(output)
+    
+    def _cmd_list(self, *args) -> str:
+        """Список всех команд и переменных"""
+        output = ["Commands:"]
+        for cmd in sorted(self._commands.values(), key=lambda c: c.name):
+            output.append(f"  {cmd.name:<20} {cmd.description}")
+        
+        output.append("\nVariables:")
+        for name, var in sorted(self._variables.items()):
+            output.append(f"  {name:<20} = {var.value} ({var.description})")
+        
+        return "\n".join(output)
+    
+    def _cmd_clear(self, *args) -> str:
+        """Очищает консоль"""
+        self._output_lines.clear()
+        return ""
+    
+    def _cmd_echo(self, *args) -> str:
+        """Выводит сообщение"""
+        return " ".join(args)
+    
+    def _cmd_quit(self, *args) -> str:
+        """Выход из движка"""
+        # Здесь должен быть вызов engine.shutdown()
+        return "Quitting..."
+    
+    def _cmd_fps(self, *args) -> str:
+        """Показывает FPS"""
+        from aether.core.engine import Engine
+        engine = Engine()
+        return f"FPS: {engine.time.fps:.1f}"
+    
+    def _cmd_time_scale(self, *args) -> str:
+        """Устанавливает масштаб времени"""
+        if args:
+            try:
+                scale = float(args[0])
+                self.set_variable("g_time_scale", scale)
+                return f"Time scale set to {scale}"
+            except ValueError:
+                return "Invalid time scale value"
+        return f"Time scale: {self.get_variable('g_time_scale')}"
+    
+    def toggle(self):
+        """Переключает видимость консоли"""
+        self.visible = not self.visible
+        if self.visible:
+            self._input_buffer = ""
+    
+    def handle_input(self, char: str):
+        """Обрабатывает ввод символа"""
+        if char == '\n':  # Enter
+            self.execute(self._input_buffer)
+            self._input_buffer = ""
+        elif char == '\b':  # Backspace
+            self._input_buffer = self._input_buffer[:-1]
+        elif char == '\t':  # Tab (автодополнение)
+            self._autocomplete()
+        else:
+            self._input_buffer += char
+    
+    def _autocomplete(self):
+        """Автодополнение команд"""
+        if not self._input_buffer:
+            return
+        
+        matches = []
+        
+        for cmd_name in self._commands:
+            if cmd_name.startswith(self._input_buffer.lower()):
+                matches.append(cmd_name)
+        
+        for var_name in self._variables:
+            if var_name.startswith(self._input_buffer.lower()):
+                matches.append(var_name)
+        
+        if len(matches) == 1:
+            self._input_buffer = matches[0]
+        elif len(matches) > 1:
+            # Показываем варианты
+            common_prefix = self._input_buffer
+            for i in range(len(self._input_buffer), len(matches[0])):
+                char = matches[0][i]
+                if all(m.startswith(common_prefix + char) for m in matches):
+                    common_prefix += char
+                else:
+                    break
+            
+            self._input_buffer = common_prefix
+            
+            if len(matches) <= 10:
+                self._output("  ".join(matches))
+    
+    @property
+    def input_text(self) -> str:
+        return self._input_buffer

aether/core/engine.py

@@ -0,0 +1,50 @@
+def run(self):
+    """Главный игровой цикл"""
+    self._running = True
+    print("[Aether] Starting game loop...")
+    
+    from aether.utils.profiler import Profiler, ScopedProfiler
+    profiler = Profiler()
+    
+    while self._running and not self.window.should_close():
+        profiler.begin_frame()
+        
+        with ScopedProfiler("Input"):
+            self.time.update()
+            dt = min(self.time.delta_time, 0.1)
+            self.input.update()
+            
+            if self.input.get_key(glfw.KEY_ESCAPE):
+                self.event_bus.emit('engine_quit')
+            
+            if self.input.get_key_down(glfw.KEY_P):
+                self.event_bus.emit('engine_pause', paused=not self._paused)
+            
+            # Профилировщик по F3
+            if self.input.get_key_down(glfw.KEY_F3):
+                profiler.print_report()
+        
+        if not self._paused:
+            with ScopedProfiler("Physics"):
+                self._update_physics(dt)
+            
+            with ScopedProfiler("Scene Update"):
+                if self.scene:
+                    self.scene.update(dt)
+                
+                self._on_update(dt)
+        
+        with ScopedProfiler("Render"):
+            self._render()
+        
+        with ScopedProfiler("Window"):
+            self.window.swap_buffers()
+            self.window.poll_events()
+            
+            if self._frame_count % 60 == 0:
+                self._update_title()
+        
+        profiler.end_frame()
+        self._frame_count += 1
+    
+    self.shutdown()

aether/core/event_bus.py

@@ -0,0 +1,24 @@
+"""Система событий (Observer pattern)"""
+from typing import Callable, Dict, List
+
+
+class EventBus:
+    def __init__(self):
+        self._listeners: Dict[str, List[Callable]] = {}
+    
+    def subscribe(self, event_type: str, callback: Callable):
+        if event_type not in self._listeners:
+            self._listeners[event_type] = []
+        self._listeners[event_type].append(callback)
+    
+    def unsubscribe(self, event_type: str, callback: Callable):
+        if event_type in self._listeners:
+            self._listeners[event_type].remove(callback)
+    
+    def emit(self, event_type: str, **data):
+        if event_type in self._listeners:
+            for callback in self._listeners[event_type]:
+                callback(data)
+    
+    def clear(self):
+        self._listeners.clear()

aether/core/input.py

@@ -0,0 +1,58 @@
+"""Обработка ввода: клавиатура, мышь, геймпад"""
+import glfw
+
+
+class Input:
+    def __init__(self, window):
+        self.window = window
+        self._keys = {}
+        self._keys_prev = {}
+        self._mouse_buttons = {}
+        self._mouse_buttons_prev = {}
+        self.mouse_x = 0.0
+        self.mouse_y = 0.0
+        self.mouse_dx = 0.0
+        self.mouse_dy = 0.0
+        self._first_mouse = True
+        
+        # Коллбэки
+        glfw.set_key_callback(window.handle, self._key_callback)
+        glfw.set_mouse_button_callback(window.handle, self._mouse_button_callback)
+        glfw.set_cursor_pos_callback(window.handle, self._cursor_callback)
+    
+    def _key_callback(self, window, key, scancode, action, mods):
+        self._keys[key] = (action == glfw.PRESS or action == glfw.REPEAT)
+    
+    def _mouse_button_callback(self, window, button, action, mods):
+        self._mouse_buttons[button] = (action == glfw.PRESS)
+    
+    def _cursor_callback(self, window, xpos, ypos):
+        if self._first_mouse:
+            self.mouse_x = xpos
+            self.mouse_y = ypos
+            self._first_mouse = False
+        self.mouse_dx = xpos - self.mouse_x
+        self.mouse_dy = ypos - self.mouse_y
+        self.mouse_x = xpos
+        self.mouse_y = ypos
+    
+    def update(self):
+        self._keys_prev = self._keys.copy()
+        self._mouse_buttons_prev = self._mouse_buttons.copy()
+        self.mouse_dx = 0.0
+        self.mouse_dy = 0.0
+    
+    def get_key(self, key) -> bool:
+        return self._keys.get(key, False)
+    
+    def get_key_down(self, key) -> bool:
+        return self._keys.get(key, False) and not self._keys_prev.get(key, False)
+    
+    def get_key_up(self, key) -> bool:
+        return not self._keys.get(key, False) and self._keys_prev.get(key, False)
+    
+    def get_mouse_button(self, button) -> bool:
+        return self._mouse_buttons.get(button, False)
+    
+    def get_mouse_button_down(self, button) -> bool:
+        return self._mouse_buttons.get(button, False) and not self._mouse_buttons_prev.get(button, False)

aether/core/plugin_system.py

@@ -0,0 +1,93 @@
+"""Система плагинов — расширение движка без правки ядра"""
+from abc import ABC, abstractmethod
+from typing import List, Type, Dict
+import importlib
+import os
+import inspect
+
+
+class Plugin(ABC):
+    """Базовый класс для всех плагинов"""
+    
+    @abstractmethod
+    def on_register(self, engine):
+        """Вызывается при регистрации плагина"""
+        pass
+    
+    @abstractmethod
+    def on_unregister(self, engine):
+        """Вызывается при удалении плагина"""
+        pass
+    
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Уникальное имя плагина"""
+        pass
+    
+    @property
+    @abstractmethod
+    def version(self) -> str:
+        """Версия плагина"""
+        pass
+
+
+class PluginManager:
+    """Менеджер плагинов"""
+    
+    def __init__(self):
+        self._plugins: Dict[str, Plugin] = {}
+        self._plugin_dirs: List[str] = ["./plugins"]
+    
+    def add_plugin_dir(self, path: str):
+        """Добавляет директорию для поиска плагинов"""
+        self._plugin_dirs.append(path)
+    
+    def discover_plugins(self):
+        """Автоматически находит плагины в указанных директориях"""
+        for plugin_dir in self._plugin_dirs:
+            if not os.path.exists(plugin_dir):
+                continue
+            
+            for filename in os.listdir(plugin_dir):
+                if filename.endswith('.py') and not filename.startswith('_'):
+                    module_name = filename[:-3]
+                    spec = importlib.util.spec_from_file_location(
+                        module_name,
+                        os.path.join(plugin_dir, filename)
+                    )
+                    module = importlib.util.module_from_spec(spec)
+                    spec.loader.exec_module(module)
+                    
+                    for name, obj in inspect.getmembers(module):
+                        if (inspect.isclass(obj) and 
+                            issubclass(obj, Plugin) and 
+                            obj != Plugin):
+                            self.register_plugin(obj())
+    
+    def register_plugin(self, plugin: Plugin, engine=None):
+        """Регистрирует плагин"""
+        if plugin.name in self._plugins:
+            raise ValueError(f"Plugin {plugin.name} already registered!")
+        
+        self._plugins[plugin.name] = plugin
+        if engine:
+            plugin.on_register(engine)
+        print(f"[Plugin] Registered: {plugin.name} v{plugin.version}")
+    
+    def unregister_plugin(self, name: str, engine=None):
+        """Удаляет плагин"""
+        if name in self._plugins:
+            plugin = self._plugins[name]
+            if engine:
+                plugin.on_unregister(engine)
+            del self._plugins[name]
+    
+    def get_plugin(self, name: str) -> Plugin:
+        """Получает плагин по имени"""
+        return self._plugins.get(name)
+    
+    def initialize_all(self, engine):
+        """Инициализирует все плагины"""
+        for plugin in self._plugins.values():
+            plugin.on_register(engine)