empire-core 0.7.3__py3-none-any.whl

empire_core/_archive/events/base.py

@@ -0,0 +1,153 @@
+from typing import Any, Dict, List
+
+from empire_core.state.world_models import MapObject
+from pydantic import BaseModel, ConfigDict
+
+
+class Event(BaseModel):
+    """Base class for all events."""
+
+    model_config = ConfigDict(arbitrary_types_allowed=True)
+
+
+class PacketEvent(Event):
+    """
+    Raw event triggered when a packet is received.
+    Useful for debugging or catching unhandled commands.
+    """
+
+    command_id: str
+    payload: Any
+    is_xml: bool
+
+
+# ============================================================
+# Map Events
+# ============================================================
+
+
+class MapChunkParsedEvent(Event):
+    """Triggered when a map chunk is parsed."""
+
+    kingdom_id: int
+    map_objects: List[MapObject]
+
+
+# ============================================================
+# Movement Events
+# ============================================================
+
+
+class MovementEvent(Event):
+    """Base class for all movement-related events."""
+
+    movement_id: int
+    movement_type: int
+    movement_type_name: str
+    source_area_id: int
+    target_area_id: int
+    is_incoming: bool
+    is_outgoing: bool
+
+
+class MovementStartedEvent(MovementEvent):
+    """
+    Triggered when a new movement is detected.
+    This includes both our outgoing movements and incoming attacks from others.
+    """
+
+    total_time: int  # Total travel time in seconds
+    unit_count: int  # Total units in movement
+
+
+class MovementUpdatedEvent(MovementEvent):
+    """
+    Triggered when a movement's progress is updated.
+    """
+
+    progress_time: int  # Time elapsed
+    total_time: int  # Total travel time
+    time_remaining: int  # Time left
+    progress_percent: float
+
+
+class MovementArrivedEvent(MovementEvent):
+    """
+    Triggered when a movement arrives at its destination.
+    """
+
+    was_incoming: bool  # True if it was incoming to us
+    was_outgoing: bool  # True if it was our movement
+
+
+class MovementCancelledEvent(MovementEvent):
+    """
+    Triggered when a movement is cancelled/recalled.
+    """
+
+    pass
+
+
+class IncomingAttackEvent(Event):
+    """
+    Triggered specifically when an incoming attack is detected.
+    This is a high-priority alert event.
+    """
+
+    movement_id: int
+    attacker_id: int
+    attacker_name: str
+    target_area_id: int
+    target_name: str
+    time_remaining: int
+    unit_count: int
+    source_x: int
+    source_y: int
+
+
+class ReturnArrivalEvent(Event):
+    """
+    Triggered when returning troops arrive back.
+    Useful for tracking loot from attacks.
+    """
+
+    movement_id: int
+    castle_id: int
+    units: Dict[int, int]  # UnitID -> Count
+    resources_wood: int
+    resources_stone: int
+    resources_food: int
+    total_loot: int
+
+
+# ============================================================
+# Attack/Battle Events
+# ============================================================
+
+
+class AttackSentEvent(Event):
+    """Triggered when we send an attack."""
+
+    movement_id: int
+    origin_castle_id: int
+    target_area_id: int
+    units: Dict[int, int]
+
+
+class ScoutSentEvent(Event):
+    """Triggered when we send scouts."""
+
+    movement_id: int
+    origin_castle_id: int
+    target_area_id: int
+
+
+class TransportSentEvent(Event):
+    """Triggered when we send a transport."""
+
+    movement_id: int
+    origin_castle_id: int
+    target_castle_id: int
+    resources_wood: int
+    resources_stone: int
+    resources_food: int

empire_core/_archive/events/manager.py

@@ -0,0 +1,85 @@
+import asyncio
+import inspect
+import logging
+from typing import (
+    Any,
+    Callable,
+    Coroutine,
+    Dict,
+    List,
+    Type,
+)
+
+from empire_core.events.base import Event
+
+logger = logging.getLogger(__name__)
+
+EventHandler = Callable[[Any], Coroutine[Any, Any, None]]
+
+
+class EventManager:
+    def __init__(self):
+        # Map EventType -> List[Handler]
+        self._listeners: Dict[Type[Event], List[EventHandler]] = {}
+
+    def subscribe(self, event_type: Type[Event], handler: EventHandler):
+        if event_type not in self._listeners:
+            self._listeners[event_type] = []
+        self._listeners[event_type].append(handler)
+        logger.debug(f"Registered handler {handler.__name__} for {event_type.__name__}")
+
+    def listen(self, func: EventHandler):
+        """
+        Decorator to register an event handler.
+        Infers the event type from the first argument's type hint.
+        """
+        sig = inspect.signature(func)
+        params = list(sig.parameters.values())
+
+        if not params:
+            raise ValueError(f"Handler {func.__name__} must have at least one argument (the event).")
+
+        # Get type hint of first arg
+        event_arg = params[0]
+        if event_arg.annotation is inspect.Parameter.empty:
+            raise ValueError(
+                f"Handler {func.__name__} argument '{event_arg.name}' must have a type hint (e.g. 'event: AttackEvent')."
+            )
+
+        event_type = event_arg.annotation
+
+        # Verify it's an Event subclass (or valid type)
+        # We accept any type for flexibility, but ideally it's an Event
+        self.subscribe(event_type, func)
+        return func
+
+    async def emit(self, event: Event):
+        event_type = type(event)
+        # Dispatch to specific listeners
+        handlers = self._listeners.get(event_type, [])
+
+        # Also dispatch to listeners of parent classes?
+        # (e.g. PacketEvent listeners might want all PacketEvents)
+        # For simplicity, currently exact match.
+        # But to support 'Event' (all events), we can check mro.
+
+        # Check MRO for polymorphism
+        for cls in event_type.mro():
+            if cls in self._listeners:
+                if cls is not event_type:
+                    handlers.extend(self._listeners[cls])
+
+        # Dedup handlers?
+        handlers = list(set(handlers))
+
+        if not handlers:
+            # logger.debug(f"No listeners for {event_type.__name__}")
+            return
+
+        # Run all listeners in parallel
+        tasks: List[Coroutine] = []
+        for func in handlers:
+            tasks.append(func(event))
+
+        if tasks:
+            await asyncio.gather(*tasks, return_exceptions=True)

empire_core/accounts.py

@@ -0,0 +1,190 @@
+"""
+Account management and configuration system.
+Handles loading credentials from files, environment variables, and provides
+a robust interface for selecting accounts based on aliases or tags.
+"""
+
+import json
+import logging
+import os
+from typing import TYPE_CHECKING, List, Optional
+
+from dotenv import load_dotenv
+from pydantic import BaseModel, Field, ValidationError
+
+from empire_core.config import EmpireConfig
+
+if TYPE_CHECKING:
+    from empire_core.client.client import EmpireClient
+
+logger = logging.getLogger(__name__)
+
+# Load .env file if present
+load_dotenv()
+
+
+class Account(BaseModel):
+    """
+    Represents a single game account configuration.
+    Wraps credentials and metadata.
+    """
+
+    username: str
+    password: str = Field(..., description="Plain text password")
+    world: str = Field(default="EmpireEx_21", description="Game world/zone (e.g., EmpireEx_21)")
+    alias: Optional[str] = Field(None, description="Short name for this account (e.g., 'main', 'farmer1')")
+    tags: List[str] = Field(default_factory=list, description="Categorization tags (e.g., ['farmer', 'k1'])")
+    active: bool = Field(default=True, description="Whether this account should be used")
+
+    def to_empire_config(self) -> EmpireConfig:
+        """Convert to EmpireConfig for client usage."""
+        return EmpireConfig(username=self.username, password=self.password, default_zone=self.world)
+
+    def has_tag(self, tag: str) -> bool:
+        """Check if account has a specific tag (case-insensitive)."""
+        return tag.lower() in [t.lower() for t in self.tags]
+
+    def get_client(self) -> "EmpireClient":
+        """Create and return an EmpireClient for this account."""
+        from empire_core.client.client import EmpireClient
+
+        return EmpireClient(
+            username=self.username,
+            password=self.password,
+            config=self.to_empire_config(),
+        )
+
+
+class AccountRegistry:
+    """
+    Central registry for managing game accounts.
+    Sources accounts from:
+    1. accounts.json (local development)
+    2. Environment variables (production/CI)
+    """
+
+    def __init__(self):
+        self._accounts: List[Account] = []
+        self._loaded = False
+
+    def load(self, file_path: str = "accounts.json"):
+        """
+        Load accounts from all sources.
+        Prioritizes environment variables, then file.
+        """
+        self._accounts = []
+
+        # 1. Load from JSON file
+        self._load_from_file(file_path)
+
+        # 2. Load from Environment Variables (EMPIRE_ACCOUNTS_JSON or specific vars)
+        self._load_from_env()
+
+        self._loaded = True
+        logger.info(f"AccountRegistry loaded {len(self._accounts)} active accounts.")
+
+    def _load_from_file(self, path_str: str):
+        """Internal: Load from JSON file."""
+        # Resolve path similarly to the old loader
+        paths_to_check = [
+            path_str,
+            os.path.join("..", path_str),
+            os.path.join("..", "..", path_str),
+            os.path.join(os.getcwd(), path_str),
+        ]
+
+        target_path = None
+        for p in paths_to_check:
+            if os.path.exists(p):
+                target_path = p
+                break
+
+        if not target_path:
+            logger.debug(f"Account file '{path_str}' not found. Skipping file load.")
+            return
+
+        try:
+            with open(target_path, "r") as f:
+                data = json.load(f)
+
+            if not isinstance(data, list):
+                logger.warning(f"Invalid format in '{target_path}'. Expected a list of accounts.")
+                return
+
+            for entry in data:
+                try:
+                    account = Account(**entry)
+                    if account.active:
+                        self._accounts.append(account)
+                except ValidationError as e:
+                    logger.error(f"Skipping invalid account entry in {target_path}: {e}")
+
+        except Exception as e:
+            logger.error(f"Error reading '{target_path}': {e}")
+
+    def _load_from_env(self):
+        """
+        Internal: Load from environment variables.
+        Format: EMPIRE_ACCOUNT_<ALIAS>=<USERNAME>,<PASSWORD>,<WORLD>
+        """
+        for key, value in os.environ.items():
+            if key.startswith("EMPIRE_ACCOUNT_"):
+                # Simple parsing: ALIAS=USER,PASS,WORLD
+                # Example: EMPIRE_ACCOUNT_MAIN=myuser,mypass,EmpireEx_21
+                alias = key.replace("EMPIRE_ACCOUNT_", "").lower()
+                parts = value.split(",")
+
+                if len(parts) >= 2:
+                    username = parts[0].strip()
+                    password = parts[1].strip()
+                    world = parts[2].strip() if len(parts) > 2 else "EmpireEx_21"
+
+                    # Create account
+                    acc = Account(
+                        username=username, password=password, world=world, alias=alias, tags=["env"], active=True
+                    )
+                    self._accounts.append(acc)
+
+    # === Query Methods ===
+
+    def get_all(self) -> List[Account]:
+        """Get all active accounts."""
+        if not self._loaded:
+            self.load()
+        return self._accounts
+
+    def get_by_alias(self, alias: str) -> Optional[Account]:
+        """Find an account by its alias."""
+        if not self._loaded:
+            self.load()
+        for acc in self._accounts:
+            if acc.alias and acc.alias.lower() == alias.lower():
+                return acc
+        return None
+
+    def get_by_username(self, username: str) -> Optional[Account]:
+        """Find an account by username."""
+        if not self._loaded:
+            self.load()
+        for acc in self._accounts:
+            if acc.username.lower() == username.lower():
+                return acc
+        return None
+
+    def get_by_tag(self, tag: str) -> List[Account]:
+        """Get all accounts with a specific tag."""
+        if not self._loaded:
+            self.load()
+        return [acc for acc in self._accounts if acc.has_tag(tag)]
+
+    def get_default(self) -> Optional[Account]:
+        """Get the first available account (default)."""
+        if not self._loaded:
+            self.load()
+        if self._accounts:
+            return self._accounts[0]
+        return None
+
+
+# Global Singleton
+accounts = AccountRegistry()