empire-core 0.7.3__py3-none-any.whl

empire_core/state/manager.py

@@ -0,0 +1,398 @@
+"""
+GameState - Tracks game state from server packets.
+"""
+
+import logging
+import time
+from concurrent.futures import ThreadPoolExecutor
+from typing import Any, Callable, Dict, List, Optional, Set
+
+from empire_core.state.models import Alliance, Castle, Player
+from empire_core.state.unit_models import Army
+from empire_core.state.world_models import MapObject, Movement, MovementResources
+
+logger = logging.getLogger(__name__)
+
+
+class GameState:
+    """
+    Manages game state parsed from server packets.
+
+    This is a simplified sync version - no async, no event emission.
+    State is updated directly and can be queried at any time.
+
+    Callbacks are dispatched in a thread pool to avoid blocking the receive loop.
+    This allows callbacks to make blocking calls (like waiting for responses).
+    """
+
+    def __init__(self):
+        self.local_player: Optional[Player] = None
+        self.players: Dict[int, Player] = {}
+        self.castles: Dict[int, Castle] = {}
+
+        # World State
+        self.map_objects: Dict[int, MapObject] = {}  # AreaID -> MapObject
+        self.movements: Dict[int, Movement] = {}  # MovementID -> Movement
+
+        # Track movement IDs we've seen (for delta detection)
+        self._previous_movement_ids: Set[int] = set()
+
+        # Armies (castle_id -> Army)
+        self.armies: Dict[int, Army] = {}
+
+        # Callbacks for specific events (optional)
+        self.on_incoming_attack: Optional[Callable[[Movement], None]] = None
+        self.on_movement_recalled: Optional[Callable[[Movement], None]] = None
+
+        # Track movements that arrived normally (vs recalled)
+        self._arrived_movement_ids: Set[int] = set()
+
+        # Thread pool for dispatching callbacks (avoids blocking receive loop)
+        self._callback_executor: ThreadPoolExecutor = ThreadPoolExecutor(
+            max_workers=4, thread_name_prefix="gge_callback"
+        )
+
+    def shutdown(self) -> None:
+        """Shutdown the callback executor. Call on disconnect."""
+        self._callback_executor.shutdown(wait=False)
+
+    def _dispatch_callback(self, callback: Callable, *args: Any, **kwargs: Any) -> None:
+        """Dispatch a callback in the thread pool."""
+
+        def wrapped():
+            try:
+                callback(*args, **kwargs)
+            except Exception as e:
+                logger.error(f"Callback error: {e}")
+
+        self._callback_executor.submit(wrapped)
+
+    def update_from_packet(self, cmd_id: str, payload: Dict[str, Any]) -> None:
+        """
+        Central update router - parses packet and updates state.
+        """
+        if cmd_id == "gbd":
+            self._handle_gbd(payload)
+        elif cmd_id == "lli":
+            # Login response contains the same data as gbd
+            self._handle_gbd(payload)
+        elif cmd_id == "gam":
+            self._handle_gam(payload)
+        elif cmd_id == "dcl":
+            self._handle_dcl(payload)
+        elif cmd_id == "mov":
+            self._handle_mov(payload)
+        elif cmd_id == "atv":
+            self._handle_atv(payload)
+        elif cmd_id == "ata":
+            self._handle_ata(payload)
+        elif cmd_id == "mrm":
+            self._handle_mrm(payload)
+
+    def _handle_gbd(self, data: Dict[str, Any]) -> None:
+        """Handle 'Get Big Data' packet - initial login data."""
+        # Player Info
+        gpi = data.get("gpi", {})
+        if gpi:
+            pid = gpi.get("PID")
+            if pid:
+                if pid not in self.players:
+                    self.players[pid] = Player(**gpi)
+                self.local_player = self.players[pid]
+                logger.info(f"Local player: {self.local_player.name} (ID: {pid})")
+
+        # XP/Level
+        gxp = data.get("gxp", {})
+        if self.local_player and gxp:
+            self.local_player.LVL = gxp.get("LVL", self.local_player.LVL)
+            self.local_player.XP = gxp.get("XP", self.local_player.XP)
+
+        # Currencies
+        gcu = data.get("gcu", {})
+        if self.local_player and gcu:
+            self.local_player.gold = gcu.get("C1", 0)
+            self.local_player.rubies = gcu.get("C2", 0)
+
+        # Alliance
+        gal = data.get("gal", {})
+        if gal and self.local_player and gal.get("AID"):
+            try:
+                self.local_player.alliance = Alliance(**gal)
+                self.local_player.AID = gal.get("AID")
+                logger.info(f"Alliance: {self.local_player.alliance.name}")
+            except Exception as e:
+                logger.warning(f"Could not parse alliance: {e}")
+
+        # Castles
+        gcl = data.get("gcl", {})
+        if gcl and self.local_player:
+            kingdoms = gcl.get("C", [])
+            for k_data in kingdoms:
+                kid = k_data.get("KID", 0)
+                area_infos = k_data.get("AI", [])
+                for area_entry in area_infos:
+                    raw_ai = area_entry.get("AI")
+                    if isinstance(raw_ai, list) and len(raw_ai) > 10:
+                        # AI array format from lli: [type, x, y, area_id, owner_id, ...]
+                        # Index 10 contains the castle name
+                        x = raw_ai[1]
+                        y = raw_ai[2]
+                        area_id = raw_ai[3]
+                        owner_id = raw_ai[4]
+                        name = raw_ai[10]
+
+                        if owner_id == self.local_player.id:
+                            castle = Castle(OID=area_id, N=name, KID=kid, X=x, Y=y)
+                            self.castles[area_id] = castle
+                            self.local_player.castles[area_id] = castle
+
+            logger.info(f"Parsed {len(self.local_player.castles)} castles")
+
+    def _handle_gam(self, data: Dict[str, Any]) -> None:
+        """Handle 'Get Army Movements' response."""
+        movements_list = data.get("M", [])
+        owners_list = data.get("O", [])  # Owner info array
+        current_ids: Set[int] = set()
+
+        # Build owner lookup: OID -> {name, alliance_name}
+        owner_info: Dict[int, Dict[str, str]] = {}
+        for owner in owners_list:
+            if isinstance(owner, dict):
+                oid = owner.get("OID")
+                if oid:
+                    owner_info[oid] = {
+                        "name": owner.get("N", ""),
+                        "alliance_name": owner.get("AN", ""),
+                    }
+
+        for m_wrapper in movements_list:
+            if not isinstance(m_wrapper, dict):
+                continue
+
+            m_data = m_wrapper.get("M", {})
+            if not m_data:
+                continue
+
+            mid = m_data.get("MID")
+            if not mid:
+                continue
+
+            current_ids.add(mid)
+            mov = self._parse_movement(m_data, m_wrapper, owner_info)
+            if not mov:
+                continue
+
+            is_new = mid not in self._previous_movement_ids
+            logger.debug(
+                f"gam: MID={mid}, is_new={is_new}, T={mov.T}, is_attack={mov.is_attack}, "
+                f"callback_set={self.on_incoming_attack is not None}"
+            )
+            if is_new:
+                mov.created_at = time.time()
+
+                # Trigger callback for attacks (server pushes gam for alliance attacks)
+                # Don't filter by is_incoming - that's relative to local player
+                # Dispatch in thread pool to avoid blocking receive loop
+                if mov.is_attack and self.on_incoming_attack:
+                    logger.info(f"gam: Dispatching callback for MID={mid}")
+                    self._dispatch_callback(self.on_incoming_attack, mov)
+
+            self.movements[mid] = mov
+
+        # Don't remove movements here - wait for explicit arrival (atv/ata) or recall (mrm)
+        # packets so we can properly dispatch callbacks with full movement data
+        self._previous_movement_ids = current_ids
+
+    def _handle_dcl(self, data: Dict[str, Any]) -> None:
+        """Handle 'Detailed Castle List' response."""
+        kingdoms = data.get("C", [])
+
+        for k_data in kingdoms:
+            area_infos = k_data.get("AI", [])
+            for castle_data in area_infos:
+                if not isinstance(castle_data, dict):
+                    continue
+
+                aid = castle_data.get("AID")
+                if aid and aid in self.castles:
+                    castle = self.castles[aid]
+
+                    # Update resources
+                    res = castle.resources
+                    res.wood = int(castle_data.get("W", res.wood))
+                    res.stone = int(castle_data.get("S", res.stone))
+                    res.food = int(castle_data.get("F", res.food))
+
+    def _handle_mov(self, data: Dict[str, Any]) -> None:
+        """Handle real-time movement update."""
+        m_data = data.get("M", data)
+
+        if isinstance(m_data, list):
+            for item in m_data:
+                if isinstance(item, dict):
+                    self._update_single_movement(item)
+        elif isinstance(m_data, dict):
+            self._update_single_movement(m_data)
+
+    def _handle_atv(self, data: Dict[str, Any]) -> None:
+        """Handle movement arrival."""
+        mid = data.get("MID")
+        if mid:
+            self._arrived_movement_ids.add(mid)  # Mark as arrived, not recalled
+            self.movements.pop(mid, None)
+            self._previous_movement_ids.discard(mid)
+
+    def _handle_ata(self, data: Dict[str, Any]) -> None:
+        """Handle attack arrival."""
+        mid = data.get("MID")
+        if mid:
+            self._arrived_movement_ids.add(mid)  # Mark as arrived, not recalled
+            self.movements.pop(mid, None)
+            self._previous_movement_ids.discard(mid)
+
+    def _handle_mrm(self, data: Dict[str, Any]) -> None:
+        """Handle movement recall (mrm = Move Recall Movement)."""
+        mid = data.get("MID")
+        if mid:
+            recalled_mov = self.movements.get(mid)
+            if recalled_mov and self.on_movement_recalled:
+                self._dispatch_callback(self.on_movement_recalled, recalled_mov)
+            self.movements.pop(mid, None)
+            self._previous_movement_ids.discard(mid)
+
+    def _parse_movement(
+        self,
+        m_data: Dict[str, Any],
+        m_wrapper: Optional[Dict[str, Any]] = None,
+        owner_info: Optional[Dict[int, Dict[str, str]]] = None,
+    ) -> Optional[Movement]:
+        """Parse a Movement from packet data."""
+        mid = m_data.get("MID")
+        if not mid:
+            return None
+
+        try:
+            mov = Movement(**m_data)
+            mov.last_updated = time.time()
+
+            # Extract target coords
+            if mov.target_area and isinstance(mov.target_area, list) and len(mov.target_area) >= 5:
+                mov.target_x = mov.target_area[1]
+                mov.target_y = mov.target_area[2]
+                mov.target_area_id = mov.target_area[3]
+                if len(mov.target_area) > 10:
+                    mov.target_name = str(mov.target_area[10]) if mov.target_area[10] else ""
+
+            # Extract source coords
+            if mov.source_area and isinstance(mov.source_area, list) and len(mov.source_area) >= 3:
+                mov.source_x = mov.source_area[1]
+                mov.source_y = mov.source_area[2]
+                if len(mov.source_area) >= 4:
+                    mov.source_area_id = mov.source_area[3]
+
+            # Extract units from wrapper (GA = Garrison Army at wrapper level)
+            if m_wrapper:
+                ga_data = m_wrapper.get("GA", {})
+
+                # GA contains unit arrays in L (left), M (melee), R (ranged), RW (ranged wall)
+                # Each is a list of [unit_id, count] pairs
+                for key in ("L", "M", "R", "RW"):
+                    unit_list = ga_data.get(key, [])
+                    if isinstance(unit_list, list):
+                        for item in unit_list:
+                            if isinstance(item, (list, tuple)) and len(item) >= 2:
+                                try:
+                                    unit_id = int(item[0])
+                                    count = int(item[1])
+                                    mov.units[unit_id] = mov.units.get(unit_id, 0) + count
+                                except (ValueError, TypeError):
+                                    pass
+
+                # Extract resources or estimated size from GS field
+                # GS is an int when army not visible (estimated size)
+                # GS is a dict when transporting resources
+                gs_data = m_wrapper.get("GS")
+                if isinstance(gs_data, int):
+                    mov.estimated_size = gs_data
+                elif isinstance(gs_data, dict):
+                    mov.resources = MovementResources(
+                        W=gs_data.get("W", 0),
+                        S=gs_data.get("S", 0),
+                        F=gs_data.get("F", 0),
+                    )
+
+            # Extract owner names and alliances from owner_info
+            if owner_info:
+                # Attacker info (OID = owner of the movement)
+                attacker_id = mov.OID
+                if attacker_id in owner_info:
+                    mov.source_player_name = owner_info[attacker_id].get("name", "")
+                    mov.source_alliance_name = owner_info[attacker_id].get("alliance_name", "")
+
+                # Defender info (TID = target player)
+                defender_id = mov.TID
+                if defender_id in owner_info:
+                    mov.target_player_name = owner_info[defender_id].get("name", "")
+                    mov.target_alliance_name = owner_info[defender_id].get("alliance_name", "")
+
+            return mov
+        except Exception as e:
+            logger.debug(f"Failed to parse movement {mid}: {e}")
+            return None
+
+    def _update_single_movement(self, m_data: Dict[str, Any]) -> None:
+        """Update a single movement from real-time packet."""
+        mid = m_data.get("MID")
+        if not mid:
+            return
+
+        existing = self.movements.get(mid)
+        mov = self._parse_movement(m_data)
+        if not mov:
+            return
+
+        is_new = existing is None
+        if is_new:
+            mov.created_at = time.time()
+            self._previous_movement_ids.add(mid)
+
+            # Trigger callback for new incoming attacks
+            # Dispatch in thread pool to avoid blocking receive loop
+            if mov.is_incoming and mov.is_attack and self.on_incoming_attack:
+                self._dispatch_callback(self.on_incoming_attack, mov)
+        elif existing:
+            # Preserve metadata from existing movement that real-time packets don't include
+            mov.created_at = existing.created_at
+            mov.source_player_name = existing.source_player_name or mov.source_player_name
+            mov.source_alliance_name = existing.source_alliance_name or mov.source_alliance_name
+            mov.target_player_name = existing.target_player_name or mov.target_player_name
+            mov.target_alliance_name = existing.target_alliance_name or mov.target_alliance_name
+            # Preserve units if the update doesn't have them
+            if not mov.units and existing.units:
+                mov.units = existing.units
+
+        self.movements[mid] = mov
+
+    # ============================================================
+    # Query Methods
+    # ============================================================
+
+    def get_all_movements(self) -> List[Movement]:
+        """Get all tracked movements."""
+        return list(self.movements.values())
+
+    def get_incoming_movements(self) -> List[Movement]:
+        """Get all incoming movements."""
+        return [m for m in self.movements.values() if m.is_incoming]
+
+    def get_outgoing_movements(self) -> List[Movement]:
+        """Get all outgoing movements."""
+        return [m for m in self.movements.values() if m.is_outgoing]
+
+    def get_incoming_attacks(self) -> List[Movement]:
+        """Get all incoming attack movements."""
+        return [m for m in self.movements.values() if m.is_incoming and m.is_attack]
+
+    def get_movement_by_id(self, movement_id: int) -> Optional[Movement]:
+        """Get a specific movement by ID."""
+        return self.movements.get(movement_id)

empire_core/state/models.py

@@ -0,0 +1,215 @@
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+class Coordinate(BaseModel):
+    x: int
+    y: int
+
+
+class Resources(BaseModel):
+    """Resources in a castle."""
+
+    # Basic resources
+    wood: int = 0
+    stone: int = 0
+    food: int = 0
+
+    # Capacity (from dcl packet)
+    wood_cap: int = 0  # MRW (Max Resource Wood)
+    stone_cap: int = 0  # MRS (Max Resource Stone)
+    food_cap: int = 0  # MRF (Max Resource Food)
+
+    # Production rates (from dcl packet)
+    wood_rate: float = 0.0  # RS1
+    stone_rate: float = 0.0  # RS2
+    food_rate: float = 0.0  # RS3
+
+    # Safe storage
+    wood_safe: float = 0.0  # SAFE_W
+    stone_safe: float = 0.0  # SAFE_S
+    food_safe: float = 0.0  # SAFE_F
+
+    # Special resources
+    iron: int = 0  # MRI
+    honey: int = 0  # MRHONEY
+    mead: int = 0  # MRMEAD
+    beef: int = 0  # MRBEEF
+    glass: int = 0  # MRG
+    ash: int = 0  # MRA
+
+
+class Troop(BaseModel):
+    """Represents a troop type definition or a specific troop count."""
+
+    # This might be too generic. Renaming to Unit
+    unit_id: int
+    count: int = 0
+
+
+class Building(BaseModel):
+    """Represents a building in a castle."""
+
+    id: int
+    level: int = 0
+
+    # Building status (if available)
+    upgrading: bool = False
+    upgrade_finish_time: Optional[int] = None
+
+
+class Alliance(BaseModel):
+    """Represents an alliance/guild."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    AID: int = Field(default=-1)  # Alliance ID
+    N: str = Field(default="")  # Alliance Name
+    SA: str = Field(default="")  # Short/Abbreviation (server sends 0 if none)
+    R: int = Field(default=0)  # Rank
+
+    @field_validator("SA", mode="before")
+    @classmethod
+    def coerce_sa_to_str(cls, v: Any) -> str:
+        """Server sends 0 when there's no abbreviation."""
+        if v is None or v == 0:
+            return ""
+        return str(v)
+
+    @property
+    def id(self) -> int:
+        return self.AID
+
+    @property
+    def name(self) -> str:
+        return self.N
+
+    @property
+    def abbreviation(self) -> str:
+        return self.SA
+
+    @property
+    def rank(self) -> int:
+        return self.R
+
+
+class Castle(BaseModel):
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    OID: int = Field(default=-1)  # Object ID / Area ID (AID)
+    N: str = Field(default="Unknown")  # Name
+    KID: int = Field(default=0)  # Kingdom ID
+    X: int = Field(default=0)  # X coordinate
+    Y: int = Field(default=0)  # Y coordinate
+
+    # Castle details (from dcl packet)
+    P: int = Field(default=0)  # Population
+    NDP: int = Field(default=0)  # Next Day Population
+    MC: int = Field(default=0)  # Max Castellans
+    B: int = Field(default=0)  # Has Barracks
+    WS: int = Field(default=0)  # Has Workshop
+    DW: int = Field(default=0)  # Has Dwelling
+    H: int = Field(default=0)  # Has Harbour
+
+    # Python-friendly aliases
+    @property
+    def id(self) -> int:
+        return self.OID
+
+    @property
+    def name(self) -> str:
+        return self.N
+
+    @property
+    def x(self) -> int:
+        return self.X
+
+    @property
+    def y(self) -> int:
+        return self.Y
+
+    @property
+    def kingdom_id(self) -> int:
+        return self.KID
+
+    @property
+    def population(self) -> int:
+        return self.P
+
+    @property
+    def max_castellans(self) -> int:
+        return self.MC
+
+    resources: Resources = Field(default_factory=Resources)
+    buildings: List[Building] = Field(default_factory=list)
+    units: Dict[int, int] = Field(default_factory=dict)
+
+    raw_data: Dict[str, Any] = Field(default_factory=dict, exclude=True)
+
+    @classmethod
+    def from_game_data(cls, data: Dict[str, Any]) -> "Castle":
+        # Mapping logic for 'gcl' (Global Castle List) / 'gbd' payload
+        return cls(**data)
+
+
+class Player(BaseModel):
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    PID: int = Field(default=-1)
+    PN: str = Field(default="Unknown")
+    AID: Optional[int] = Field(default=None)
+
+    # Levels
+    LVL: int = Field(default=0)
+    XP: int = Field(default=0)
+    LL: int = Field(default=0)  # Legendary Level
+    XPFCL: int = Field(default=0)  # XP for current level
+    XPTNL: int = Field(default=0)  # XP to next level
+
+    # Resources
+    gold: int = 0  # C1 from gcu
+    rubies: int = 0  # C2 from gcu
+
+    # Alliance
+    alliance: Optional[Alliance] = None
+
+    # Python-friendly properties
+    @property
+    def id(self) -> int:
+        return self.PID
+
+    @property
+    def name(self) -> str:
+        return self.PN
+
+    @property
+    def alliance_id(self) -> Optional[int]:
+        return self.AID
+
+    @property
+    def level(self) -> int:
+        return self.LVL
+
+    @property
+    def xp(self) -> int:
+        return self.XP
+
+    @property
+    def legendary_level(self) -> int:
+        return self.LL
+
+    @property
+    def xp_progress(self) -> float:
+        """Returns XP progress as a percentage (0-100)."""
+        if self.XPTNL > 0:
+            return (self.XPFCL / self.XPTNL) * 100
+        return 0.0
+
+    castles: Dict[int, Castle] = Field(default_factory=dict)
+
+    E: Optional[str] = Field(default=None)
+
+    @property
+    def email(self) -> Optional[str]:
+        return self.E

empire_core/state/quest_models.py

@@ -0,0 +1,60 @@
+"""
+Models for quests and achievements.
+"""
+
+from typing import Any, List
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class Quest(BaseModel):
+    """Represents a game quest."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    QID: int = Field(default=-1)  # Quest ID
+    P: List[int] = Field(default_factory=list)  # Progress
+
+    @property
+    def quest_id(self) -> int:
+        return self.QID
+
+    @property
+    def progress(self) -> List[int]:
+        return self.P
+
+
+class QuestReward(BaseModel):
+    """Quest reward."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    type: str  # "U" for units, "F" for food, etc.
+    value: Any  # Depends on type
+
+
+class DailyQuest(BaseModel):
+    """Daily quest with progress and rewards."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    PQL: int = Field(default=0)  # Player Quest Level?
+    RDQ: List[Quest] = Field(default_factory=list)  # Running Daily Quests
+    FDQ: List[int] = Field(default_factory=list)  # Finished Daily Quests
+    RS: List[List[Any]] = Field(default_factory=list)  # Rewards
+
+    @property
+    def level(self) -> int:
+        return self.PQL
+
+    @property
+    def active_quests(self) -> List[Quest]:
+        return self.RDQ
+
+    @property
+    def finished_quests(self) -> List[int]:
+        return self.FDQ
+
+    @property
+    def rewards(self) -> List[List[Any]]:
+        return self.RS