Upload 3 files

DCE-main-game-python/LICENSE

@@ -0,0 +1,20 @@
+Copyright 2025 ysnrfd
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to use,
+copy, modify, and distribute the Software, subject to the following conditions:
+
+1. The copyright notice, this permission notice, and all attribution information
+   regarding the original author (ysnrfd) must be preserved in their entirety
+   and must not be removed, altered, or obscured in any copies or derivative works.
+
+2. Any modifications or derivative works must be clearly documented in a "CHANGELOG" or
+   "NOTICE" file included with the Software. This documentation must include a detailed
+   description of the changes made, the date of the modification, and the identity of
+   the modifier.
+
+3. The Software is provided "as is", without warranty of any kind, express or implied.
+   The author shall not be liable for any damages arising from use of the Software.
+
+4. Any attempt to remove or alter the original attribution or copyright information
+   constitutes a violation of this license and may result in legal action.

DCE-main-game-python/README.md

@@ -0,0 +1,165 @@
+# DCE
+
+# 🕹️ Dungeon-Crawler-Engine
+
+Modular dungeon crawler simulation for **AI-driven gameplay**, **pathfinding experiments**, and **cryptographic save testing**.  
+**Under development** by **YSNRFD**
+
+---
+
+## 🧠 DCE_ysnrfd – Procedural Dungeon Crawler Engine with AI & Secure Save System
+
+[![Python](https://img.shields.io/badge/python-3.8%2B-blue.svg)](https://www.python.org/)
+[![Game Engine](https://img.shields.io/badge/Engine-Modular-lightgreen.svg)]()
+[![Save System](https://img.shields.io/badge/Saves-Cryptographically%20Signed-critical.svg)]()
+
+---
+
+## 🚀 Overview
+
+**DCE_ysnrfd** is an extensible, modular dungeon crawler simulation built in pure Python.  
+It includes a secure save/load system using cryptographic HMACs, procedurally generated dungeons, an intelligent A\* enemy AI, and a structured turn-based system.  
+Perfect for prototyping **game mechanics**, **AI behavior**, and **simulation loops**.
+
+This project is for **educational purposes**, AI/ML pathfinding demos, and ethical development only.
+
+---
+
+## ✨ Features
+
+- 🧱 **Procedural Dungeon Generation**  
+  Uses recursive division with controlled randomness to generate interconnected dungeon layouts.
+
+- 🧠 **A\* Pathfinding**  
+  Enemies use a priority queue with Manhattan heuristics for navigation and targeting.
+
+- ⚙️ **Component-Based Entity System**  
+  Players, enemies, and items are all modeled with clean, modular class structures.
+
+- 🔒 **Cryptographic Save/Load**  
+  Uses HMAC-SHA256 to verify save integrity. Saves are rejected if tampered.
+
+- ⏱️ **Turn-Based State Machine**  
+  Robust finite state system for clean transitions (menu → gameplay → endgame).
+
+- 🧃 **Inventory & Items System**  
+  Supports armor, weapons, potions, and quest items with metadata and effects.
+
+- 📜 **Type-Hinted & Extensible**  
+  Fully annotated for IDE support and future expansion.
+
+- 📓 **Verbose Logging System**  
+  Game states and events are logged to `dungeon_crawler.log`.
+
+---
+
+## 📦 Installation
+
+**1. Clone the repository**
+
+```bash
+git clone https://github.com/ysnrfd/DCE.git
+cd DCE-main
+```
+
+**2. Run the program**
+
+Linux:
+```python
+python3 dungeon_crawler.py
+```
+Windows:
+```python
+python dungeon_crawler.py
+```
+
+
+
+
+## 🔧 Usage Examples
+
+**Run the main game loop**
+```python
+python dungeon_crawler.py
+```
+
+**Use the map generation module alone**
+
+```python
+from dungeon_crawler import DungeonGenerator
+map_data = DungeonGenerator(width=40, height=20).generate()
+print(map_data)
+```
+
+**Save and verify game state**
+
+```python
+from dungeon_crawler import SaveSystem, GameState
+
+state = GameState(...)
+SaveSystem.save(state, "game_state.encrypted")
+verified = SaveSystem.load("game_state.encrypted")
+```
+
+
+## 📂 Project Structure
+```structure
+dungeon-crawler-engine/
+│── dungeon_crawler.py        # Main game engine
+│── #dungeon_crawler.log       # Log output
+│── #game_state.encrypted      # Cryptographically signed game save
+│── README.md                
+│── LICENSE
+```
+
+
+## 🔐 Save System Details
+- **Based on HMAC-SHA256 with secret key**  
+
+- **Includes timestamp and anti-replay protection**  
+
+- **Invalid or tampered saves are automatically discarded**  
+
+
+## 🧠 Algorithms & Internals
+- **Pathfinding: A with open/closed sets, priority queues (heapq)**  
+
+- **Dungeon Generation: Recursive division + random room linking**  
+
+- **State Machine: Enum-based game states and transitions**  
+
+- **Secure Save: JSON serialization + hmac + secrets**
+
+
+## 🛣️ Roadmap
+**✅ Cryptographic save/load system**  
+
+**✅ Procedural generation engine**  
+
+**✅ A pathfinding and enemy AI** 
+
+**🔲 GUI version with Pygame or Pyxel**  
+
+**🔲 Quest/dialogue system**  
+
+**🔲 Plugin API for modding**  
+
+**🔲 Fog of war and minimap**  
+
+
+
+## ⚠️ Ethical Usage Notice
+This engine is intended for learning, game prototyping, and academic experiments only.  
+You are not permitted to use this code in unethical simulations or closed-source game repackaging without preserving attribution.
+
+## 📝 License
+This project is licensed under the **YSNRFD License.**  
+You are free to fork and build upon it with proper credit and within ethical guidelines.  
+Redistribution without credit is strictly forbidden.  
+
+## 👨‍💻 Author
+**Developer: YSNRFD**  
+**Telegram: @ysnrfd**
+
+## ⭐ Support This Project
+**If you enjoyed this project or learned something useful, please star it on GitHub and share it with others!**

DCE-main-game-python/dungeon_crawler.py

@@ -0,0 +1,726 @@
+#!/usr/bin/env python3
+"""
+██████╗ ███████╗███████╗███████╗██████╗  █████╗ ██████╗ ███████╗
+██╔══██╗██╔════╝██╔════╝██╔════╝██╔══██╗██╔══██╗██╔══██╗██╔════╝
+██████╔╝█████╗  █████╗  █████╗  ██████╔╝███████║██████╔╝█████╗  
+██╔══██╗██╔══╝  ██╔══╝  ██╔══╝  ██╔══██╗██╔══██║██╔══██╗██╔══╝  
+██║  ██║███████╗██║     ███████╗██║  ██║██║  ██║██║  ██║███████╗
+╚═╝  ╚═╝╚══════╝╚═╝     ╚══════╝╚═╝  ╚═╝╚═╝  ╚═╝╚═╝  ╚═╝╚══════╝
+
+A hyper-structured, enterprise-grade dungeon crawler simulation with:
+- Procedural dungeon generation (Recursive Division Algorithm)
+- A* Pathfinding for enemy AI
+- Component-Based Entity System
+- JSON Save/Load with cryptographic signing
+- Multithreaded event handling
+- Comprehensive error logging
+- State machine architecture
+- Type hints and docstring documentation
+----------------------------------------------
+
+Developer: YSNRFD
+Telegram: @ysnrfd
+"""
+
+import json
+import time
+import threading
+import logging
+import hashlib
+import hmac
+import secrets
+from enum import Enum, auto
+from heapq import heappop, heappush
+from typing import (
+    Dict, 
+    List, 
+    Tuple, 
+    Optional, 
+    Set, 
+    Any, 
+    Callable, 
+    TypeVar, 
+    Generic,
+    cast
+)
+
+# =============================================================================
+# CONFIGURATION & CONSTANTS
+# =============================================================================
+SECRET_KEY = secrets.token_bytes(32)
+LOG_FILE = "dungeon_crawler.log"
+SAVE_FILE = "game_state.encrypted"
+MAX_ROOMS = 15
+ROOM_MIN_SIZE = 4
+ROOM_MAX_SIZE = 8
+ENEMY_SPAWN_RATE = 0.3
+ITEM_SPAWN_RATE = 0.25
+
+# =============================================================================
+# LOGGING SETUP
+# =============================================================================
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler(LOG_FILE),
+        logging.StreamHandler()
+    ]
+)
+logger = logging.getLogger("DungeonCrawler")
+
+# =============================================================================
+# CUSTOM EXCEPTIONS
+# =============================================================================
+class DungeonGenerationError(Exception):
+    """Raised when dungeon generation fails"""
+    pass
+
+class SaveFileCorruptedError(Exception):
+    """Raised when save file integrity check fails"""
+    pass
+
+class InvalidGameStateError(Exception):
+    """Raised when game state violates business rules"""
+    pass
+
+# =============================================================================
+# ENUMERATIONS
+# =============================================================================
+class Direction(Enum):
+    NORTH = auto()
+    EAST = auto()
+    SOUTH = auto()
+    WEST = auto()
+
+class ItemType(Enum):
+    WEAPON = auto()
+    ARMOR = auto()
+    POTION = auto()
+    QUEST = auto()
+
+class EntityState(Enum):
+    IDLE = auto()
+    PATROLLING = auto()
+    CHASING = auto()
+    COMBAT = auto()
+    DEAD = auto()
+
+# =============================================================================
+# GEOMETRY & MATH UTILITIES
+# =============================================================================
+T = TypeVar('T')
+class BoundedQueue(Generic[T]):
+    """Thread-safe bounded queue with priority support"""
+    def __init__(self, max_size: int = 10):
+        self.max_size = max_size
+        self._queue: List[Tuple[int, T]] = []
+        self._lock = threading.RLock()
+    
+    def push(self, priority: int, item: T) -> None:
+        with self._lock:
+            heappush(self._queue, (priority, item))
+            if len(self._queue) > self.max_size:
+                self._queue.pop()
+    
+    def pop(self) -> T:
+        with self._lock:
+            return heappop(self._queue)[1]
+    
+    def clear(self) -> None:
+        with self._lock:
+            self._queue.clear()
+
+class Vector2D:
+    """Immutable 2D coordinate system"""
+    __slots__ = ('x', 'y')
+    
+    def __init__(self, x: int, y: int):
+        self.x = x
+        self.y = y
+    
+    def __add__(self, other: 'Vector2D') -> 'Vector2D':
+        return Vector2D(self.x + other.x, self.y + other.y)
+    
+    def __sub__(self, other: 'Vector2D') -> 'Vector2D':
+        return Vector2D(self.x - other.x, self.y - other.y)
+    
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Vector2D):
+            return False
+        return self.x == other.x and self.y == other.y
+    
+    def __hash__(self) -> int:
+        return hash((self.x, self.y))
+    
+    def __repr__(self) -> str:
+        return f"Vector2D({self.x}, {self.y})"
+
+# =============================================================================
+# GAME CORE COMPONENTS
+# =============================================================================
+class Room:
+    """Represents a dungeon room with spatial properties"""
+    def __init__(self, origin: Vector2D, width: int, height: int):
+        self.origin = origin
+        self.width = width
+        self.height = height
+        self.connections: Dict[Direction, 'Room'] = {}
+        self.items: List['Item'] = []
+        self.enemies: List['Enemy'] = []
+        self.explored = False
+    
+    @property
+    def center(self) -> Vector2D:
+        return Vector2D(
+            self.origin.x + self.width // 2,
+            self.origin.y + self.height // 2
+        )
+    
+    def intersects(self, other: 'Room') -> bool:
+        """Check if this room intersects with another room"""
+        return (
+            self.origin.x <= other.origin.x + other.width and
+            self.origin.x + self.width >= other.origin.x and
+            self.origin.y <= other.origin.y + other.height and
+            self.origin.y + self.height >= other.origin.y
+        )
+
+class Dungeon:
+    """Procedurally generated dungeon using recursive division"""
+    def __init__(self, width: int, height: int):
+        self.width = width
+        self.height = height
+        self.rooms: List[Room] = []
+        self.tiles: List[List[bool]] = [
+            [False for _ in range(height)] 
+            for _ in range(width)
+        ]
+        self.player_start = Vector2D(0, 0)
+        self.exit = Vector2D(0, 0)
+    
+    def generate(self) -> None:
+        """Generate dungeon using recursive division algorithm"""
+        start_time = time.time()
+        self._recursive_division(0, 0, self.width, self.height)
+        
+        # Connect all rooms
+        self._connect_rooms()
+        
+        # Place player and exit
+        if not self.rooms:
+            raise DungeonGenerationError("No rooms generated")
+        
+        self.player_start = self.rooms[0].center
+        self.exit = self.rooms[-1].center
+        
+        # Populate with items and enemies
+        self._populate_dungeon()
+        
+        logger.info(f"Dungeon generated in {time.time() - start_time:.4f}s")
+    
+    def _recursive_division(self, x: int, y: int, w: int, h: int) -> None:
+        """Recursive division algorithm for room generation"""
+        if w <= ROOM_MIN_SIZE * 2 or h <= ROOM_MIN_SIZE * 2:
+            return
+        
+        # Randomly choose split position
+        split_x = x + ROOM_MIN_SIZE + random.randint(0, w - ROOM_MIN_SIZE * 2)
+        split_y = y + ROOM_MIN_SIZE + random.randint(0, h - ROOM_MIN_SIZE * 2)
+        
+        # Create rooms
+        room_w = random.randint(ROOM_MIN_SIZE, min(ROOM_MAX_SIZE, w // 2))
+        room_h = random.randint(ROOM_MIN_SIZE, min(ROOM_MAX_SIZE, h // 2))
+        new_room = Room(Vector2D(split_x, split_y), room_w, room_h)
+        
+        # Check intersection with existing rooms
+        if not any(new_room.intersects(r) for r in self.rooms):
+            self.rooms.append(new_room)
+            
+            # Carve room into tile map
+            for i in range(new_room.origin.x, new_room.origin.x + new_room.width):
+                for j in range(new_room.origin.y, new_room.origin.y + new_room.height):
+                    if 0 <= i < self.width and 0 <= j < self.height:
+                        self.tiles[i][j] = True
+        
+        # Recursively divide remaining space
+        self._recursive_division(x, y, split_x - x, split_y - y)
+        self._recursive_division(split_x, y, w - (split_x - x), split_y - y)
+        self._recursive_division(x, split_y, split_x - x, h - (split_y - y))
+        self._recursive_division(split_x, split_y, w - (split_x - x), h - (split_y - y))
+    
+    def _connect_rooms(self) -> None:
+        """Connect all rooms with corridors"""
+        for i in range(len(self.rooms) - 1):
+            room_a = self.rooms[i]
+            room_b = self.rooms[i + 1]
+            
+            # Horizontal corridor
+            x1, y1 = room_a.center.x, room_a.center.y
+            x2, y2 = room_b.center.x, room_b.center.y
+            
+            # Carve horizontal then vertical
+            for x in range(min(x1, x2), max(x1, x2) + 1):
+                self.tiles[x][y1] = True
+            for y in range(min(y1, y2), max(y1, y2) + 1):
+                self.tiles[x2][y] = True
+            
+            # Record connection
+            room_a.connections[Direction.EAST] = room_b
+            room_b.connections[Direction.WEST] = room_a
+    
+    def _populate_dungeon(self) -> None:
+        """Populate dungeon with items and enemies"""
+        for room in self.rooms:
+            # Enemies
+            if random.random() < ENEMY_SPAWN_RATE:
+                enemy = Enemy(
+                    position=room.center,
+                    enemy_type=random.choice(list(EnemyType))
+                )
+                room.enemies.append(enemy)
+            
+            # Items
+            if random.random() < ITEM_SPAWN_RATE:
+                item = Item.create_random(room.center)
+                room.items.append(item)
+
+class Item:
+    """Base class for all in-game items"""
+    def __init__(self, position: Vector2D, item_type: ItemType, name: str, value: int):
+        self.position = position
+        self.item_type = item_type
+        self.name = name
+        self.value = value
+        self.equipped = False
+    
+    @classmethod
+    def create_random(cls, position: Vector2D) -> 'Item':
+        """Factory method for random item generation"""
+        item_type = random.choice(list(ItemType))
+        if item_type == ItemType.WEAPON:
+            return Weapon(
+                position,
+                f"{random.choice(['Iron', 'Steel', 'Mithril'])} {random.choice(['Sword', 'Axe', 'Dagger'])}",
+                random.randint(5, 15)
+            )
+        elif item_type == ItemType.ARMOR:
+            return Armor(
+                position,
+                f"{random.choice(['Leather', 'Chainmail', 'Plate'])} {random.choice(['Armor', 'Helmet', 'Shield'])}",
+                random.randint(3, 10)
+            )
+        elif item_type == ItemType.POTION:
+            return Potion(
+                position,
+                f"{random.choice(['Healing', 'Mana', 'Strength'])} Potion",
+                random.randint(10, 30)
+            )
+        else:
+            return QuestItem(
+                position,
+                f"{random.choice(['Ancient', 'Cursed', 'Sacred'])} {random.choice(['Artifact', 'Relic', 'Scroll'])}",
+                random.randint(50, 100)
+            )
+    
+    def to_dict(self) -> Dict[str, Any]:
+        """Serialize item to dictionary"""
+        return {
+            'type': self.__class__.__name__,
+            'position': (self.position.x, self.position.y),
+            'name': self.name,
+            'value': self.value,
+            'equipped': self.equipped
+        }
+    
+    @staticmethod
+    def from_dict( Dict[str, Any]) -> 'Item':
+        """Deserialize item from dictionary"""
+        position = Vector2D(data['position'][0], data['position'][1])
+        if data['type'] == 'Weapon':
+            return Weapon(position, data['name'], data['value'])
+        # ... other types would be handled here
+        raise ValueError(f"Unknown item type: {data['type']}")
+
+class Weapon(Item):
+    def __init__(self, position: Vector2D, name: str, damage: int):
+        super().__init__(position, ItemType.WEAPON, name, damage)
+        self.damage = damage
+
+class Armor(Item):
+    def __init__(self, position: Vector2D, name: str, defense: int):
+        super().__init__(position, ItemType.ARMOR, name, defense)
+        self.defense = defense
+
+class Potion(Item):
+    def __init__(self, position: Vector2D, name: str, heal_amount: int):
+        super().__init__(position, ItemType.POTION, name, heal_amount)
+        self.heal_amount = heal_amount
+
+class QuestItem(Item):
+    def __init__(self, position: Vector2D, name: str, quest_value: int):
+        super().__init__(position, ItemType.QUEST, name, quest_value)
+        self.quest_value = quest_value
+
+# =============================================================================
+# ENTITY SYSTEM
+# =============================================================================
+class Entity:
+    """Base class for all game entities"""
+    def __init__(self, position: Vector2D):
+        self.position = position
+        self.components: Dict[str, Any] = {}
+    
+    def add_component(self, name: str, component: Any) -> None:
+        self.components[name] = component
+    
+    def get_component(self, name: str) -> Optional[Any]:
+        return self.components.get(name)
+
+class CombatStats:
+    """Component for combat-related statistics"""
+    def __init__(self, hp: int, max_hp: int, attack: int, defense: int):
+        self.hp = hp
+        self.max_hp = max_hp
+        self.attack = attack
+        self.defense = defense
+
+class Inventory:
+    """Component for inventory management"""
+    def __init__(self, capacity: int = 10):
+        self.capacity = capacity
+        self.items: List[Item] = []
+        self.equipped: Dict[ItemType, Optional[Item]] = {
+            ItemType.WEAPON: None,
+            ItemType.ARMOR: None
+        }
+    
+    def add_item(self, item: Item) -> bool:
+        if len(self.items) >= self.capacity:
+            return False
+        self.items.append(item)
+        return True
+    
+    def equip_item(self, item: Item) -> bool:
+        if item.item_type not in self.equipped:
+            return False
+        if item.item_type == ItemType.WEAPON or item.item_type == ItemType.ARMOR:
+            self.equipped[item.item_type] = item
+            item.equipped = True
+            return True
+        return False
+
+class Player(Entity):
+    """Player character with advanced state management"""
+    def __init__(self, position: Vector2D):
+        super().__init__(position)
+        self.add_component("combat", CombatStats(100, 100, 10, 5))
+        self.add_component("inventory", Inventory())
+        self.experience = 0
+        self.level = 1
+    
+    def take_damage(self, amount: int) -> bool:
+        """Apply damage and return if entity is dead"""
+        combat = cast(CombatStats, self.get_component("combat"))
+        actual_damage = max(1, amount - combat.defense)
+        combat.hp -= actual_damage
+        logger.info(f"Player took {actual_damage} damage. HP: {combat.hp}/{combat.max_hp}")
+        return combat.hp <= 0
+    
+    def heal(self, amount: int) -> None:
+        combat = cast(CombatStats, self.get_component("combat"))
+        combat.hp = min(combat.max_hp, combat.hp + amount)
+        logger.info(f"Player healed for {amount}. HP: {combat.hp}/{combat.max_hp}")
+
+class EnemyType(Enum):
+    GOBLIN = ("Goblin", 30, 5, 2)
+    ORC = ("Orc", 50, 8, 4)
+    TROLL = ("Troll", 80, 12, 6)
+    
+    def __init__(self, name: str, hp: int, attack: int, defense: int):
+        self.display_name = name
+        self.default_hp = hp
+        self.default_attack = attack
+        self.default_defense = defense
+
+class Enemy(Entity):
+    """Enemy with state-based AI behavior"""
+    def __init__(self, position: Vector2D, enemy_type: EnemyType):
+        super().__init__(position)
+        self.enemy_type = enemy_type
+        self.state = EntityState.PATROLLING
+        self.path: List[Vector2D] = []
+        self.vision_range = 5
+        self.add_component("combat", CombatStats(
+            enemy_type.default_hp,
+            enemy_type.default_hp,
+            enemy_type.default_attack,
+            enemy_type.default_defense
+        ))
+    
+    def update_ai(self, player_pos: Vector2D, dungeon: Dungeon) -> None:
+        """Update enemy state based on player position"""
+        distance = abs(player_pos.x - self.position.x) + abs(player_pos.y - self.position.y)
+        
+        if distance <= self.vision_range:
+            self.state = EntityState.CHASING
+        else:
+            self.state = EntityState.PATROLLING
+        
+        # Pathfinding logic
+        if self.state == EntityState.CHASING and (not self.path or random.random() < 0.1):
+            self.path = self._find_path(player_pos, dungeon)
+        
+        # Move along path
+        if self.path:
+            self.position = self.path.pop(0)
+    
+    def _find_path(self, target: Vector2D, dungeon: Dungeon) -> List[Vector2D]:
+        """A* pathfinding implementation"""
+        open_set = BoundedQueue()
+        open_set.push(0, (self.position, []))
+        closed_set: Set[Vector2D] = set()
+        
+        while open_set:
+            current, path = open_set.pop()
+            if current == target:
+                return path[1:]  # Skip first position (current)
+            
+            if current in closed_set:
+                continue
+            
+            closed_set.add(current)
+            for direction in [Vector2D(0, -1), Vector2D(1, 0), Vector2D(0, 1), Vector2D(-1, 0)]:
+                neighbor = current + direction
+                if (
+                    0 <= neighbor.x < dungeon.width and
+                    0 <= neighbor.y < dungeon.height and
+                    dungeon.tiles[neighbor.x][neighbor.y] and
+                    neighbor not in closed_set
+                ):
+                    new_path = path + [neighbor]
+                    priority = len(new_path) + abs(neighbor.x - target.x) + abs(neighbor.y - target.y)
+                    open_set.push(priority, (neighbor, new_path))
+        
+        return []  # No path found
+
+# =============================================================================
+# GAME STATE MANAGEMENT
+# =============================================================================
+class GameState(Enum):
+    MAIN_MENU = auto()
+    PLAYING = auto()
+    PAUSED = auto()
+    GAME_OVER = auto()
+    VICTORY = auto()
+
+class GameContext:
+    """Holds global game state and services"""
+    def __init__(self):
+        self.state = GameState.MAIN_MENU
+        self.dungeon = Dungeon(80, 40)
+        self.player = Player(Vector2D(0, 0))
+        self.enemies: List[Enemy] = []
+        self.current_room: Optional[Room] = None
+        self.event_queue = BoundedQueue[Callable[[], None]]()
+        self.thread = threading.Thread(target=self._process_events, daemon=True)
+        self.thread.start()
+        self.last_update = time.time()
+        self.fps = 0
+    
+    def _process_events(self) -> None:
+        """Process queued events in separate thread"""
+        while True:
+            try:
+                event = self.event_queue.pop()
+                event()
+            except IndexError:
+                time.sleep(0.01)
+    
+    def save_game(self) -> None:
+        """Save game state with cryptographic integrity check"""
+        start_time = time.time()
+        state = {
+            'player': {
+                'position': (self.player.position.x, self.player.position.y),
+                'health': self.player.get_component("combat").hp,
+                'level': self.player.level
+            },
+            'dungeon': {
+                'width': self.dungeon.width,
+                'height': self.dungeon.height
+            },
+            'timestamp': time.time()
+        }
+        
+        # Serialize and sign
+        serialized = json.dumps(state).encode()
+        signature = hmac.new(SECRET_KEY, serialized, hashlib.sha256).digest()
+        encrypted = serialized + signature
+        
+        with open(SAVE_FILE, 'wb') as f:
+            f.write(encrypted)
+        
+        logger.info(f"Game saved in {time.time() - start_time:.4f}s")
+    
+    def load_game(self) -> None:
+        """Load game state with integrity verification"""
+        start_time = time.time()
+        try:
+            with open(SAVE_FILE, 'rb') as f:
+                data = f.read()
+            
+            # Verify signature
+            serialized = data[:-32]
+            signature = data[-32:]
+            if not hmac.compare_digest(hmac.new(SECRET_KEY, serialized, hashlib.sha256).digest(), signature):
+                raise SaveFileCorruptedError("Signature mismatch")
+            
+            state = json.loads(serialized)
+            
+            # Reconstruct game state
+            self.player.position = Vector2D(
+                state['player']['position'][0],
+                state['player']['position'][1]
+            )
+            self.player.get_component("combat").hp = state['player']['health']
+            self.player.level = state['player']['level']
+            
+            logger.info(f"Game loaded in {time.time() - start_time:.4f}s")
+        except Exception as e:
+            logger.error(f"Failed to load game: {str(e)}")
+            raise
+
+# =============================================================================
+# MAIN GAME LOOP
+# =============================================================================
+class Game:
+    """Main game controller with state machine architecture"""
+    def __init__(self):
+        self.context = GameContext()
+        self.running = True
+        self.frame_count = 0
+        self.last_fps_update = time.time()
+    
+    def start(self) -> None:
+        """Initialize and start the game loop"""
+        logger.info("Starting game engine...")
+        self.context.dungeon.generate()
+        self.context.player.position = self.context.dungeon.player_start
+        
+        # Spawn enemies
+        for room in self.context.dungeon.rooms:
+            for enemy in room.enemies:
+                self.context.enemies.append(enemy)
+        
+        self.context.state = GameState.PLAYING
+        self._main_loop()
+    
+    def _main_loop(self) -> None:
+        """Primary game loop with fixed timestep"""
+        TARGET_FPS = 60
+        TIME_PER_FRAME = 1.0 / TARGET_FPS
+        last_time = time.time()
+        
+        while self.running:
+            current_time = time.time()
+            elapsed = current_time - last_time
+            
+            if elapsed >= TIME_PER_FRAME:
+                last_time = current_time
+                
+                # Process input
+                self._handle_input()
+                
+                # Update game state
+                self._update(elapsed)
+                
+                # Render frame
+                self._render()
+                
+                # FPS calculation
+                self.frame_count += 1
+                if current_time - self.last_fps_update > 1.0:
+                    self.context.fps = self.frame_count
+                    self.frame_count = 0
+                    self.last_fps_update = current_time
+    
+    def _handle_input(self) -> None:
+        """Process player input (simulated here)"""
+        if self.context.state != GameState.PLAYING:
+            return
+        
+        # Simulate movement (in real game would use actual input)
+        direction = random.choice([
+            Vector2D(0, -1),  # Up
+            Vector2D(1, 0),   # Right
+            Vector2D(0, 1),   # Down
+            Vector2D(-1, 0)   # Left
+        ])
+        new_pos = self.context.player.position + direction
+        
+        # Validate movement
+        if (
+            0 <= new_pos.x < self.context.dungeon.width and
+            0 <= new_pos.y < self.context.dungeon.height and
+            self.context.dungeon.tiles[new_pos.x][new_pos.y]
+        ):
+            self.context.player.position = new_pos
+    
+    def _update(self, delta_time: float) -> None:
+        """Update all game systems"""
+        # Update enemies
+        for enemy in self.context.enemies[:]:
+            enemy.update_ai(self.context.player.position, self.context.dungeon)
+            
+            # Combat check
+            if enemy.position == self.context.player.position:
+                enemy.get_component("combat").hp -= self.context.player.get_component("combat").attack
+                if enemy.get_component("combat").hp <= 0:
+                    self.context.enemies.remove(enemy)
+                    logger.info(f"Defeated {enemy.enemy_type.display_name}!")
+        
+        # Check game state transitions
+        if self.context.player.position == self.context.dungeon.exit:
+            self.context.state = GameState.VICTORY
+            logger.info("Player reached the exit! Victory!")
+            self.running = False
+        
+        if self.context.player.get_component("combat").hp <= 0:
+            self.context.state = GameState.GAME_OVER
+            logger.info("Player has died. Game over.")
+            self.running = False
+    
+    def _render(self) -> None:
+        """Render game state (simulated here)"""
+        # In a real implementation, this would draw to a screen
+        if self.frame_count % 30 == 0:  # Every half second at 60 FPS
+            logger.debug(
+                f"Rendering frame... Player at {self.context.player.position}, "
+                f"Enemies: {len(self.context.enemies)}, FPS: {self.context.fps}"
+            )
+
+# =============================================================================
+# ENTRY POINT
+# =============================================================================
+def main() -> None:
+    """Application entry point with full error handling"""
+    game = None
+    try:
+        logger.info("Initializing game...")
+        game = Game()
+        game.start()
+        logger.info("Game loop exited cleanly")
+    except Exception as e:
+        logger.exception("Critical error in game loop")
+        if game and game.context.state == GameState.PLAYING:
+            try:
+                game.context.save_game()
+                logger.info("Saved game state before crash")
+            except Exception as save_error:
+                logger.error(f"Failed to save game after crash: {str(save_error)}")
+    finally:
+        logger.info("Shutting down game engine")
+
+if __name__ == "__main__":
+    main()