empire-core 0.7.3__py3-none-any.whl

empire_core/state/report_models.py

@@ -0,0 +1,115 @@
+"""
+Models for battle reports and events.
+"""
+
+from datetime import datetime
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class BattleParticipant(BaseModel):
+    """A participant in a battle."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    player_id: int
+    player_name: str
+    alliance_id: Optional[int] = None
+    alliance_name: Optional[str] = None
+
+    # Units before battle
+    units_before: Dict[int, int] = Field(default_factory=dict)
+    # Units after battle
+    units_after: Dict[int, int] = Field(default_factory=dict)
+    # Losses
+    losses: Dict[int, int] = Field(default_factory=dict)
+
+
+class BattleReport(BaseModel):
+    """Battle report."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    RID: int = Field(default=-1)  # Report ID
+    T: int = Field(default=0)  # Type
+    TS: int = Field(default=0)  # Timestamp
+    READ: bool = Field(default=False)  # Read status
+
+    # Battle details
+    attacker: Optional[BattleParticipant] = None
+    defender: Optional[BattleParticipant] = None
+
+    # Results
+    winner: Optional[str] = None  # "attacker" or "defender"
+    loot: Dict[str, int] = Field(default_factory=dict)  # Resources looted
+
+    # Location
+    target_x: int = 0
+    target_y: int = 0
+    target_name: Optional[str] = None
+
+    @property
+    def report_id(self) -> int:
+        return self.RID
+
+    @property
+    def report_type(self) -> int:
+        return self.T
+
+    @property
+    def timestamp(self) -> int:
+        return self.TS
+
+    @property
+    def is_read(self) -> bool:
+        return self.READ
+
+    @property
+    def datetime(self) -> datetime:
+        """Convert timestamp to datetime."""
+        return datetime.fromtimestamp(self.TS)
+
+
+class EventReport(BaseModel):
+    """Generic event report (building complete, etc.)."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    event_id: int
+    event_type: str
+    timestamp: int
+    message: str
+    data: Dict[str, Any] = Field(default_factory=dict)
+
+
+class ReportManager:
+    """Manages reports and events."""
+
+    def __init__(self):
+        self.battle_reports: Dict[int, BattleReport] = {}
+        self.event_reports: Dict[int, EventReport] = {}
+        self.unread_count: int = 0
+
+    def add_battle_report(self, report: BattleReport):
+        """Add a battle report."""
+        self.battle_reports[report.report_id] = report
+        if not report.is_read:
+            self.unread_count += 1
+
+    def mark_as_read(self, report_id: int):
+        """Mark report as read."""
+        if report_id in self.battle_reports:
+            report = self.battle_reports[report_id]
+            if not report.is_read:
+                report.READ = True
+                self.unread_count = max(0, self.unread_count - 1)
+
+    def get_unread_reports(self) -> List[BattleReport]:
+        """Get all unread reports."""
+        return [r for r in self.battle_reports.values() if not r.is_read]
+
+    def get_recent_reports(self, count: int = 10) -> List[BattleReport]:
+        """Get most recent reports."""
+        sorted_reports = sorted(self.battle_reports.values(), key=lambda r: r.timestamp, reverse=True)
+        return sorted_reports[:count]

empire_core/state/unit_models.py

@@ -0,0 +1,75 @@
+"""
+Models for units and armies.
+"""
+
+from typing import Dict
+
+from pydantic import BaseModel, ConfigDict, Field
+
+
+class UnitStats(BaseModel):
+    """Unit statistics."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    unit_id: int
+    attack: int = 0
+    defense: int = 0
+    health: int = 0
+    speed: float = 20.0
+    capacity: int = 0  # Loot capacity
+    food_consumption: int = 0
+
+
+class Army(BaseModel):
+    """Army composition."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    units: Dict[int, int] = Field(default_factory=dict)  # {unit_id: count}
+
+    def add_unit(self, unit_id: int, count: int):
+        """Add units to army."""
+        if unit_id in self.units:
+            self.units[unit_id] += count
+        else:
+            self.units[unit_id] = count
+
+    def remove_unit(self, unit_id: int, count: int):
+        """Remove units from army."""
+        if unit_id in self.units:
+            self.units[unit_id] = max(0, self.units[unit_id] - count)
+            if self.units[unit_id] == 0:
+                del self.units[unit_id]
+
+    @property
+    def total_units(self) -> int:
+        """Total number of units."""
+        return sum(self.units.values())
+
+    @property
+    def is_empty(self) -> bool:
+        """Check if army is empty."""
+        return len(self.units) == 0
+
+
+class UnitProduction(BaseModel):
+    """Unit production/training queue."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    unit_id: int
+    count: int
+    finish_time: int  # Timestamp
+    castle_id: int
+
+
+# Common unit IDs (may vary by game version)
+UNIT_IDS = {
+    "MILITIA": 620,
+    "SWORDSMAN": 614,
+    "BOWMAN": 611,
+    "CAVALRY": 629,
+    "ARCHER": 626,
+    "KNIGHT": 637,
+}

empire_core/state/world_models.py

@@ -0,0 +1,269 @@
+import time
+from typing import Any, Dict, List, Optional
+
+from pydantic import BaseModel, ConfigDict, Field
+
+from empire_core.utils.enums import MapObjectType, MovementType
+
+
+class MapObject(BaseModel):
+    """Represents an object on the world map (Castle, Resource, NPC)."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    area_id: int = Field(default=-1, alias="AID")
+    owner_id: int = Field(default=-1, alias="OID")
+    type: MapObjectType = Field(default=MapObjectType.UNKNOWN, alias="T")
+    level: int = Field(default=0, alias="L")
+
+    # Location - sometimes embedded or passed separately
+    x: int = Field(default=0, alias="X")
+    y: int = Field(default=0, alias="Y")
+    kingdom_id: int = Field(default=0, alias="KID")
+
+    # Metadata
+    name: str = Field(default="")
+    owner_name: str = Field(default="")
+    alliance_id: int = Field(default=-1)
+    alliance_name: str = Field(default="")
+
+    @property
+    def is_player(self) -> bool:
+        return self.type.is_player
+
+    @property
+    def is_npc(self) -> bool:
+        return self.type.is_npc
+
+    @property
+    def is_event(self) -> bool:
+        return self.type.is_event
+
+    @property
+    def is_resource(self) -> bool:
+        return self.type.is_resource
+
+    @property
+    def category(self) -> str:
+        if self.is_player:
+            return "Player"
+        if self.is_npc:
+            return "NPC"
+        if self.is_event:
+            return "Event"
+        if self.is_resource:
+            return "Resource"
+        return "Other"
+
+
+class Army(BaseModel):
+    """Represents troops in a movement or castle."""
+
+    model_config = ConfigDict(extra="ignore")
+    units: Dict[int, int] = Field(default_factory=dict)  # UnitID -> Count
+
+
+class MovementResources(BaseModel):
+    """Resources being transported in a movement."""
+
+    model_config = ConfigDict(extra="ignore")
+
+    wood: int = Field(default=0, alias="W")
+    stone: int = Field(default=0, alias="S")
+    food: int = Field(default=0, alias="F")
+
+    # Special resources
+    iron: int = Field(default=0, alias="I")
+    glass: int = Field(default=0, alias="G")
+    ash: int = Field(default=0, alias="A")
+    honey: int = Field(default=0, alias="HONEY")
+    mead: int = Field(default=0, alias="MEAD")
+    beef: int = Field(default=0, alias="BEEF")
+
+    @property
+    def total(self) -> int:
+        """Total resources in transport."""
+        return self.wood + self.stone + self.food + self.iron + self.glass + self.ash
+
+    @property
+    def is_empty(self) -> bool:
+        """Check if no resources are being transported."""
+        return self.total == 0
+
+
+class Movement(BaseModel):
+    """Represents a movement (Attack, Support, Transport, etc.)."""
+
+    model_config = ConfigDict(extra="ignore", populate_by_name=True)
+
+    MID: int = Field(default=-1)  # Movement ID
+    T: int = Field(default=0)  # Type (11=return, etc.)
+    PT: int = Field(default=0)  # Progress Time
+    TT: int = Field(default=0)  # Total Time
+    D: int = Field(default=0)  # Direction
+    TID: int = Field(default=-1)  # Target/Owner ID
+    KID: int = Field(default=0)  # Kingdom ID
+    SID: int = Field(default=-1)  # Source ID
+    OID: int = Field(default=-1)  # Owner ID
+    HBW: int = Field(default=-1)  # ?
+
+    # TA = Target Area (array with area details)
+    # SA = Source Area (array with area details)
+    target_area: Optional[List[Any]] = Field(default=None, alias="TA")
+    source_area: Optional[List[Any]] = Field(default=None, alias="SA")
+
+    # Extracted fields
+    target_area_id: int = Field(default=-1)
+    source_area_id: int = Field(default=-1)
+    target_x: int = Field(default=-1)
+    target_y: int = Field(default=-1)
+    source_x: int = Field(default=-1)
+    source_y: int = Field(default=-1)
+
+    # Units in movement (UnitID -> Count)
+    units: Dict[int, int] = Field(default_factory=dict)
+
+    # Estimated army size (GS field when army not visible)
+    estimated_size: int = Field(default=0)
+
+    # Resources being transported (for transport/return movements)
+    resources: MovementResources = Field(default_factory=MovementResources)
+
+    # Target/Source names (if available)
+    target_name: str = Field(default="")
+    source_name: str = Field(default="")
+    target_player_name: str = Field(default="")
+    source_player_name: str = Field(default="")
+    target_alliance_name: str = Field(default="")
+    source_alliance_name: str = Field(default="")
+
+    # Timestamps for tracking
+    created_at: float = Field(default_factory=time.time)  # When we first saw this movement
+    last_updated: float = Field(default_factory=time.time)  # Last update time
+
+    @property
+    def movement_id(self) -> int:
+        return self.MID
+
+    @property
+    def movement_type(self) -> int:
+        return self.T
+
+    @property
+    def movement_type_enum(self) -> MovementType:
+        """Get the MovementType enum value."""
+        try:
+            return MovementType(self.T)
+        except ValueError:
+            return MovementType.UNKNOWN
+
+    @property
+    def movement_type_name(self) -> str:
+        """Get the name of the movement type."""
+        try:
+            return MovementType(self.T).name
+        except ValueError:
+            return f"UNKNOWN_{self.T}"
+
+    @property
+    def progress_time(self) -> int:
+        return self.PT
+
+    @property
+    def total_time(self) -> int:
+        return self.TT
+
+    @property
+    def time_remaining(self) -> int:
+        return max(0, self.TT - self.PT)
+
+    @property
+    def progress_percent(self) -> float:
+        if self.TT > 0:
+            return (self.PT / self.TT) * 100
+        return 0.0
+
+    @property
+    def estimated_arrival(self) -> float:
+        """Estimated arrival timestamp (Unix time)."""
+        return self.last_updated + self.time_remaining
+
+    @property
+    def is_incoming(self) -> bool:
+        """Check if this movement is incoming to player."""
+        # Type 11 is typically return movement
+        return self.T != 11 and self.D == 0
+
+    @property
+    def is_outgoing(self) -> bool:
+        """Check if this movement is outgoing from player."""
+        return self.T != 11 and self.D == 1
+
+    @property
+    def is_returning(self) -> bool:
+        """Check if this is a return movement."""
+        return self.T == MovementType.RETURN
+
+    @property
+    def is_attack(self) -> bool:
+        """Check if this is an attack movement."""
+        # T=0 appears to be a standard attack on player castles
+        # T=1 is ATTACK, T=5 is RAID, T=9 is ATTACK_CAMP, T=10 is RAID_CAMP
+        return self.T in (
+            0,  # Standard attack (observed in gam packets)
+            MovementType.ATTACK,
+            MovementType.ATTACK_CAMP,
+            MovementType.RAID,
+            MovementType.RAID_CAMP,
+        )
+
+    @property
+    def is_transport(self) -> bool:
+        """Check if this is a transport movement."""
+        return self.T == MovementType.TRANSPORT
+
+    @property
+    def is_support(self) -> bool:
+        """Check if this is a support movement."""
+        return self.T == MovementType.SUPPORT
+
+    @property
+    def is_spy(self) -> bool:
+        """Check if this is a spy/scout movement."""
+        return self.T == MovementType.SPY
+
+    @property
+    def unit_count(self) -> int:
+        """Total number of units in this movement (includes all unit types)."""
+        return sum(self.units.values())
+
+    @property
+    def troop_count(self) -> int:
+        """Count of actual troops only (excludes equipment/tools)."""
+        from empire_core.utils.troops import count_troops
+
+        return count_troops(self.units)
+
+    def has_arrived(self) -> bool:
+        """Check if movement has arrived (time remaining <= 0)."""
+        return self.time_remaining <= 0
+
+    def format_time_remaining(self) -> str:
+        """Format time remaining as human-readable string."""
+        remaining = self.time_remaining
+        if remaining <= 0:
+            return "Arrived"
+
+        hours = remaining // 3600
+        minutes = (remaining % 3600) // 60
+        seconds = remaining % 60
+
+        if hours > 0:
+            return f"{hours}h {minutes}m {seconds}s"
+        elif minutes > 0:
+            return f"{minutes}m {seconds}s"
+        else:
+            return f"{seconds}s"
+
+    def __repr__(self) -> str:
+        return f"Movement(id={self.MID}, type={self.movement_type_name}, from={self.source_area_id}, to={self.target_area_id}, remaining={self.format_time_remaining()})"

empire_core/storage/__init__.py

@@ -0,0 +1 @@
+"""Storage modules."""

empire_core/storage/database.py

@@ -0,0 +1,237 @@
+"""
+Asynchronous Database storage using SQLModel and aiosqlite with Write Queue.
+"""
+
+import asyncio
+import logging
+from datetime import datetime
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from sqlalchemy import text
+from sqlalchemy.ext.asyncio import async_sessionmaker, create_async_engine
+from sqlmodel import Field, SQLModel, col, select
+
+logger = logging.getLogger(__name__)
+
+
+# === Models / Tables ===
+
+
+class PlayerSnapshot(SQLModel, table=True):
+    """Historical snapshot of player progress."""
+
+    __tablename__ = "player_snapshots"
+
+    id: Optional[int] = Field(default=None, primary_key=True)
+    player_id: int = Field(index=True)
+    timestamp: int = Field(default_factory=lambda: int(datetime.now().timestamp()))
+    level: int
+    gold: int
+    rubies: int
+
+
+class MapObjectRecord(SQLModel, table=True):
+    """Persistent record of a discovered world object."""
+
+    __tablename__ = "map_objects"
+
+    area_id: int = Field(primary_key=True)
+    kingdom_id: int = Field(index=True)
+    x: int
+    y: int
+    type: int
+    level: int
+    name: Optional[str] = None
+    owner_id: Optional[int] = None
+    owner_name: Optional[str] = None
+    alliance_id: Optional[int] = None
+    alliance_name: Optional[str] = None
+    last_updated: int = Field(default_factory=lambda: int(datetime.now().timestamp()))
+
+
+class ScannedChunkRecord(SQLModel, table=True):
+    """Record of a scanned map chunk."""
+
+    __tablename__ = "scanned_chunks"
+
+    kingdom_id: int = Field(primary_key=True)
+    chunk_x: int = Field(primary_key=True)
+    chunk_y: int = Field(primary_key=True)
+    last_scanned: int = Field(default_factory=lambda: int(datetime.now().timestamp()))
+
+
+# === Database Manager ===
+
+
+class GameDatabase:
+    """Async database manager with serialized write queue."""
+
+    def __init__(self, db_path: str = "empire_data.db"):
+        self.db_url = f"sqlite+aiosqlite:///{db_path}"
+        # Set timeout to 30s
+        self.engine = create_async_engine(self.db_url, echo=False, connect_args={"timeout": 30})
+        self.async_session_factory = async_sessionmaker(self.engine, expire_on_commit=False)
+
+        # Write Queue
+        self._write_queue: asyncio.Queue = asyncio.Queue()
+        self._writer_task: Optional[asyncio.Task] = None
+        self._running = False
+
+    async def initialize(self):
+        """Create tables and start writer loop."""
+        async with self.engine.begin() as conn:
+            await conn.execute(text("PRAGMA journal_mode=WAL;"))
+            await conn.execute(text("PRAGMA synchronous=NORMAL;"))
+            await conn.run_sync(SQLModel.metadata.create_all)
+
+        logger.info(f"Database initialized: {self.db_url} (WAL Mode)")
+        self._start_writer()
+
+    def _start_writer(self):
+        """Start the background writer task."""
+        if not self._running:
+            self._running = True
+            self._writer_task = asyncio.create_task(self._writer_loop())
+            logger.debug("Database writer loop started.")
+
+    async def close(self):
+        """Shutdown engine and writer."""
+        self._running = False
+        if self._writer_task:
+            # Wait for queue to drain
+            await self._write_queue.join()
+            self._writer_task.cancel()
+            try:
+                await self._writer_task
+            except asyncio.CancelledError:
+                pass
+
+        await self.engine.dispose()
+
+    async def _writer_loop(self):
+        """Consumes write operations from the queue and executes them serially."""
+        while self._running:
+            try:
+                # Get batch of operations
+                operation = await self._write_queue.get()
+                batch = [operation]
+
+                # Try to grab more if available (up to 50)
+                try:
+                    for _ in range(50):
+                        batch.append(self._write_queue.get_nowait())
+                except asyncio.QueueEmpty:
+                    pass
+
+                async with self.async_session_factory() as session:
+                    try:
+                        for op_type, data in batch:
+                            if op_type == "player_snapshot":
+                                session.add(data)
+                            elif op_type == "map_objects":
+                                for obj in data:
+                                    await session.merge(obj)
+                            elif op_type == "scanned_chunk":
+                                await session.merge(data)
+
+                        await session.commit()
+                    except Exception as e:
+                        logger.error(f"Database write error: {e}")
+                        await session.rollback()
+                    finally:
+                        for _ in batch:
+                            self._write_queue.task_done()
+
+            except asyncio.CancelledError:
+                break
+            except Exception as e:
+                logger.error(f"Critical error in writer loop: {e}")
+                await asyncio.sleep(1)
+
+    # === Write Operations (Queued) ===
+
+    async def save_player_snapshot(self, player: Any):
+        """Queue player snapshot save."""
+        snapshot = PlayerSnapshot(
+            player_id=player.id,
+            level=player.level,
+            gold=player.gold,
+            rubies=player.rubies,
+        )
+        await self._write_queue.put(("player_snapshot", snapshot))
+
+    async def save_map_objects(self, objects: List[Any]):
+        """Queue map objects save."""
+        if not objects:
+            return
+
+        records = [
+            MapObjectRecord(
+                area_id=obj.area_id,
+                kingdom_id=obj.kingdom_id,
+                x=obj.x,
+                y=obj.y,
+                type=int(obj.type),
+                level=obj.level,
+                name=obj.name,
+                owner_id=obj.owner_id,
+                owner_name=obj.owner_name,
+                alliance_id=obj.alliance_id,
+                alliance_name=obj.alliance_name,
+            )
+            for obj in objects
+        ]
+        await self._write_queue.put(("map_objects", records))
+
+    async def mark_chunk_scanned(self, kingdom_id: int, chunk_x: int, chunk_y: int):
+        """Queue chunk scanned mark."""
+        record = ScannedChunkRecord(kingdom_id=kingdom_id, chunk_x=chunk_x, chunk_y=chunk_y)
+        await self._write_queue.put(("scanned_chunk", record))
+
+    # === Read Operations (Direct) ===
+
+    async def get_scanned_chunks(self, kingdom_id: int) -> Set[Tuple[int, int]]:
+        """Get all scanned chunks for a kingdom."""
+        async with self.async_session_factory() as session:
+            statement = select(ScannedChunkRecord).where(ScannedChunkRecord.kingdom_id == kingdom_id)
+            results = await session.execute(statement)
+            return {(r.chunk_x, r.chunk_y) for r in results.scalars().all()}
+
+    async def find_targets(
+        self,
+        kingdom_id: int,
+        min_level: int = 0,
+        max_level: int = 999,
+        types: Optional[List[int]] = None,
+    ) -> List[MapObjectRecord]:
+        """Query world map from DB."""
+        async with self.async_session_factory() as session:
+            statement = select(MapObjectRecord).where(
+                MapObjectRecord.kingdom_id == kingdom_id,
+                MapObjectRecord.level >= min_level,
+                MapObjectRecord.level <= max_level,
+            )
+            if types:
+                statement = statement.where(col(MapObjectRecord.type).in_(types))
+
+            results = await session.execute(statement)
+            return list(results.scalars().all())
+
+    async def get_object_count(self) -> int:
+        """Total discovered objects."""
+        async with self.async_session_factory() as session:
+            # Simple way to get count in SQLModel
+            statement = select(MapObjectRecord)
+            results = await session.execute(statement)
+            return len(results.scalars().all())
+
+    async def get_object_counts_by_type(self) -> Dict[int, int]:
+        """Get counts of objects grouped by type."""
+        from sqlalchemy import func
+
+        async with self.async_session_factory() as session:
+            statement = select(col(MapObjectRecord.type), func.count(col(MapObjectRecord.area_id))).group_by(
+                col(MapObjectRecord.type)
+            )
+            results = await session.execute(statement)
+            return {row[0]: row[1] for row in results.all()}