aether-engine 1.0.0__py3-none-any.whl

aether/core/achievement_system.py

@@ -0,0 +1,304 @@
+"""Система достижений"""
+from typing import Dict, List, Callable, Any, Optional
+from enum import Enum
+import json
+import time
+from pathlib import Path
+
+
+class AchievementState(Enum):
+    LOCKED = 0
+    UNLOCKED = 1
+    HIDDEN = 2
+
+
+class Achievement:
+    """Достижение"""
+    
+    def __init__(self,
+                 achievement_id: str,
+                 name: str,
+                 description: str = "",
+                 icon: str = "",
+                 hidden: bool = False,
+                 points: int = 10):
+        
+        self.id = achievement_id
+        self.name = name
+        self.description = description
+        self.icon = icon
+        self.hidden = hidden
+        self.points = points
+        
+        self.state = AchievementState.HIDDEN if hidden else AchievementState.LOCKED
+        self.unlock_time: Optional[float] = None
+        self.progress = 0.0  # 0.0 - 1.0
+        self.progress_max = 1.0
+        
+        # Условие разблокировки
+        self.unlock_condition: Optional[Callable] = None
+        
+        # Статистика
+        self.unlock_count = 0
+    
+    def check_unlock(self, context: Dict[str, Any] = None) -> bool:
+        """Проверяет условие разблокировки"""
+        if self.state == AchievementState.UNLOCKED:
+            return True
+        
+        if self.unlock_condition:
+            try:
+                if self.unlock_condition(context or {}):
+                    self.unlock()
+                    return True
+            except Exception:
+                pass
+        
+        return False
+    
+    def unlock(self):
+        """Разблокирует достижение"""
+        if self.state != AchievementState.UNLOCKED:
+            self.state = AchievementState.UNLOCKED
+            self.unlock_time = time.time()
+            self.progress = self.progress_max
+            self.unlock_count += 1
+    
+    def update_progress(self, amount: float):
+        """Обновляет прогресс"""
+        if self.state == AchievementState.UNLOCKED:
+            return
+        
+        self.progress = min(self.progress_max, self.progress + amount)
+        
+        if self.progress >= self.progress_max:
+            self.unlock()
+    
+    def reset(self):
+        """Сбрасывает достижение"""
+        self.state = AchievementState.HIDDEN if self.hidden else AchievementState.LOCKED
+        self.unlock_time = None
+        self.progress = 0.0
+    
+    def to_dict(self) -> dict:
+        return {
+            'id': self.id,
+            'state': self.state.value,
+            'unlock_time': self.unlock_time,
+            'progress': self.progress,
+            'unlock_count': self.unlock_count,
+        }
+    
+    @classmethod
+    def from_dict(cls, data: dict, achievement_def: 'Achievement') -> 'Achievement':
+        ach = Achievement(
+            achievement_def.id,
+            achievement_def.name,
+            achievement_def.description,
+            achievement_def.icon,
+            achievement_def.hidden,
+            achievement_def.points
+        )
+        ach.state = AchievementState(data.get('state', 0))
+        ach.unlock_time = data.get('unlock_time')
+        ach.progress = data.get('progress', 0.0)
+        ach.unlock_count = data.get('unlock_count', 0)
+        ach.unlock_condition = achievement_def.unlock_condition
+        return ach
+
+
+class AchievementCategory:
+    """Категория достижений"""
+    
+    def __init__(self, name: str, icon: str = ""):
+        self.name = name
+        self.icon = icon
+        self.achievements: Dict[str, Achievement] = {}
+
+
+class AchievementSystem:
+    """Система достижений"""
+    
+    _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._categories: Dict[str, AchievementCategory] = {}
+        self._achievements: Dict[str, Achievement] = {}
+        self._unlocked_queue: List[Achievement] = []
+        
+        # Статистика игрока
+        self.stats: Dict[str, Any] = {
+            'play_time': 0.0,
+            'deaths': 0,
+            'kills': 0,
+            'distance_traveled': 0.0,
+            'items_collected': 0,
+            'quests_completed': 0,
+            'total_score': 0,
+        }
+        
+        # Коллбэки
+        self.on_achievement_unlocked: List[Callable] = []
+        
+        # Сохранение
+        self._save_path = Path("./achievements.json")
+        
+        print("[AchievementSystem] Initialized")
+    
+    def create_category(self, name: str, icon: str = "") -> AchievementCategory:
+        """Создаёт категорию"""
+        category = AchievementCategory(name, icon)
+        self._categories[name] = category
+        return category
+    
+    def register_achievement(self,
+                            achievement_id: str,
+                            name: str,
+                            description: str = "",
+                            category: str = "General",
+                            icon: str = "",
+                            hidden: bool = False,
+                            points: int = 10,
+                            unlock_condition: Optional[Callable] = None) -> Achievement:
+        """Регистрирует достижение"""
+        if category not in self._categories:
+            self.create_category(category)
+        
+        achievement = Achievement(
+            achievement_id, name, description,
+            icon, hidden, points
+        )
+        achievement.unlock_condition = unlock_condition
+        
+        self._categories[category].achievements[achievement_id] = achievement
+        self._achievements[achievement_id] = achievement
+        
+        return achievement
+    
+    def get_achievement(self, achievement_id: str) -> Optional[Achievement]:
+        """Получает достижение по ID"""
+        return self._achievements.get(achievement_id)
+    
+    def is_unlocked(self, achievement_id: str) -> bool:
+        """Проверяет, разблокировано ли достижение"""
+        ach = self.get_achievement(achievement_id)
+        return ach.state == AchievementState.UNLOCKED if ach else False
+    
+    def update_stat(self, stat_name: str, value: Any):
+        """Обновляет статистику"""
+        if stat_name in self.stats:
+            if isinstance(self.stats[stat_name], (int, float)):
+                self.stats[stat_name] += value
+            else:
+                self.stats[stat_name] = value
+        
+        # Проверяем достижения
+        self._check_achievements()
+    
+    def increment_stat(self, stat_name: str, amount: float = 1.0):
+        """Увеличивает статистику"""
+        if stat_name in self.stats:
+            if isinstance(self.stats[stat_name], (int, float)):
+                self.stats[stat_name] += amount
+        
+        self._check_achievements()
+    
+    def _check_achievements(self):
+        """Проверяет все достижения"""
+        context = {'stats': self.stats, 'achievements': self._achievements}
+        
+        for achievement in self._achievements.values():
+            if achievement.state != AchievementState.UNLOCKED:
+                if achievement.check_unlock(context):
+                    self._unlocked_queue.append(achievement)
+                    
+                    # Вызываем коллбэки
+                    for callback in self.on_achievement_unlocked:
+                        callback(achievement)
+                    
+                    print(f"[Achievement] Unlocked: {achievement.name} (+{achievement.points} points)")
+                    
+                    self.stats['total_score'] += achievement.points
+    
+    def get_unlocked_queue(self) -> List[Achievement]:
+        """Возвращает очередь разблокированных достижений"""
+        queue = self._unlocked_queue.copy()
+        self._unlocked_queue.clear()
+        return queue
+    
+    def get_progress(self, achievement_id: str) -> float:
+        """Возвращает прогресс достижения"""
+        ach = self.get_achievement(achievement_id)
+        return ach.progress / ach.progress_max if ach else 0.0
+    
+    def save(self, path: str = None):
+        """Сохраняет достижения"""
+        save_path = Path(path) if path else self._save_path
+        
+        data = {
+            'achievements': {},
+            'stats': self.stats,
+        }
+        
+        for ach_id, ach in self._achievements.items():
+            data['achievements'][ach_id] = ach.to_dict()
+        
+        try:
+            with open(save_path, 'w') as f:
+                json.dump(data, f, indent=2)
+            print(f"[AchievementSystem] Saved to {save_path}")
+        except Exception as e:
+            print(f"[AchievementSystem] Failed to save: {e}")
+    
+    def load(self, path: str = None):
+        """Загружает достижения"""
+        load_path = Path(path) if path else self._save_path
+        
+        if not load_path.exists():
+            return
+        
+        try:
+            with open(load_path, 'r') as f:
+                data = json.load(f)
+            
+            self.stats = data.get('stats', self.stats)
+            
+            ach_data = data.get('achievements', {})
+            for ach_id, ach_state in ach_data.items():
+                if ach_id in self._achievements:
+                    self._achievements[ach_id] = Achievement.from_dict(
+                        ach_state, self._achievements[ach_id]
+                    )
+            
+            print(f"[AchievementSystem] Loaded from {load_path}")
+        except Exception as e:
+            print(f"[AchievementSystem] Failed to load: {e}")
+    
+    def reset_all(self):
+        """Сбрасывает все достижения"""
+        for achievement in self._achievements.values():
+            achievement.reset()
+        self.stats = {k: 0 if isinstance(v, (int, float)) else v 
+                     for k, v in self.stats.items()}
+        print("[AchievementSystem] All achievements reset")
+    
+    def get_categories(self) -> Dict[str, AchievementCategory]:
+        return self._categories.copy()
+    
+    def get_all_achievements(self) -> List[Achievement]:
+        return list(self._achievements.values())
+    
+    def get_unlocked_count(self) -> int:
+        return sum(1 for ach in self._achievements.values() 
+                  if ach.state == AchievementState.UNLOCKED)
+    
+    def get_total_points(self) -> int:
+        return sum(ach.points for ach in self._achievements.values()
+                  if ach.state == AchievementState.UNLOCKED)

aether/core/application.py

@@ -0,0 +1,19 @@
+"""Базовый класс приложения — для быстрого создания игр"""
+from aether.core.engine import Engine
+from aether.scene.scene import Scene
+
+
+class Application:
+    """Наследуйся от этого класса для создания игры"""
+    
+    def __init__(self, width=1920, height=1080, title="Aether Game"):
+        self.engine = Engine(width, height, title)
+        self._setup()
+    
+    def _setup(self):
+        """Переопредели этот метод для настройки сцены"""
+        scene = Scene("Default Scene")
+        self.engine.load_scene(scene)
+    
+    def run(self):
+        self.engine.run()

aether/core/config.py

@@ -0,0 +1,75 @@
+"""Конфигурация движка — централизованные настройки"""
+import json
+import os
+from dataclasses import dataclass, field, asdict
+from typing import Dict, Any
+
+
+@dataclass
+class GraphicsConfig:
+    """Графические настройки"""
+    width: int = 1920
+    height: int = 1080
+    fullscreen: bool = False
+    vsync: bool = True
+    msaa_samples: int = 4
+    shadow_resolution: int = 2048
+    shadow_cascades: int = 4
+    bloom_enabled: bool = True
+    ssao_enabled: bool = True
+    hdr_enabled: bool = True
+
+
+@dataclass
+class PhysicsConfig:
+    """Настройки физики"""
+    gravity: tuple = (0.0, -9.81, 0.0)
+    fixed_timestep: float = 1.0 / 60.0
+    max_substeps: int = 8
+    solver_iterations: int = 10
+
+
+@dataclass
+class AudioConfig:
+    """Настройки звука"""
+    master_volume: float = 1.0
+    sfx_volume: float = 1.0
+    music_volume: float = 0.8
+    sample_rate: int = 44100
+    channels: int = 32
+
+
+@dataclass
+class EngineConfig:
+    """Главная конфигурация движка"""
+    app_name: str = "Aether Game"
+    graphics: GraphicsConfig = field(default_factory=GraphicsConfig)
+    physics: PhysicsConfig = field(default_factory=PhysicsConfig)
+    audio: AudioConfig = field(default_factory=AudioConfig)
+    asset_paths: list = field(default_factory=lambda: ["./assets", "./"])
+    
+    def save(self, path: str):
+        """Сохраняет конфиг в JSON"""
+        with open(path, 'w') as f:
+            json.dump(asdict(self), f, indent=2)
+    
+    @classmethod
+    def load(cls, path: str) -> 'EngineConfig':
+        """Загружает конфиг из JSON"""
+        with open(path, 'r') as f:
+            data = json.load(f)
+        
+        config = cls()
+        config.app_name = data.get('app_name', config.app_name)
+        
+        gfx = data.get('graphics', {})
+        config.graphics = GraphicsConfig(**gfx)
+        
+        phys = data.get('physics', {})
+        config.physics = PhysicsConfig(**phys)
+        
+        audio = data.get('audio', {})
+        config.audio = AudioConfig(**audio)
+        
+        config.asset_paths = data.get('asset_paths', config.asset_paths)
+        return config