#!/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()