empire-core 0.7.3__py3-none-any.whl

empire_core/_archive/automation/alliance_tools.py

@@ -0,0 +1,266 @@
+"""
+Alliance management and chat tools.
+"""
+
+import logging
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, Any, Callable, Dict, List, Optional
+
+from empire_core.protocol.packet import Packet
+
+if TYPE_CHECKING:
+    from empire_core.client.client import EmpireClient
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AllianceMember:
+    """Alliance member info."""
+
+    player_id: int
+    name: str
+    level: int = 0
+    rank: str = "member"
+    online: bool = False
+    last_seen: int = 0
+    castle_count: int = 0
+
+
+@dataclass
+class ChatMessage:
+    """A chat message."""
+
+    timestamp: int
+    player_name: str
+    player_id: int
+    message: str
+    channel: str = "global"
+
+
+class AllianceService:
+    """Service for alliance operations."""
+
+    def __init__(self, client: "EmpireClient"):
+        self.client = client
+        self.alliance_members: Dict[int, AllianceMember] = {}
+        self._alliance_callbacks: List[Callable[[List[AllianceMember]], None]] = []
+
+    @property
+    def alliance(self):
+        """Get current alliance info from player state."""
+        if self.client.state.local_player:
+            return self.client.state.local_player.alliance
+        return None
+
+    @property
+    def alliance_id(self) -> Optional[int]:
+        """Get alliance ID."""
+        if self.client.state.local_player:
+            return self.client.state.local_player.AID
+        return None
+
+    @property
+    def is_in_alliance(self) -> bool:
+        """Check if player is in an alliance."""
+        return self.alliance_id is not None and self.alliance_id > 0
+
+    async def refresh_members(self) -> bool:
+        """Refresh alliance member list from server."""
+        if not self.is_in_alliance:
+            logger.warning("Not in an alliance")
+            return False
+
+        packet = Packet.build_xt(self.client.config.default_zone, "gal", {})
+        await self.client.connection.send(packet)
+        return True
+
+    async def send_alliance_chat(self, message: str) -> bool:
+        """Send message to alliance chat."""
+        if not self.is_in_alliance:
+            logger.warning("Not in an alliance")
+            return False
+
+        packet = Packet.build_xt(self.client.config.default_zone, "sam", {"M": message})
+        await self.client.connection.send(packet)
+        logger.info(f"Sent alliance message: {message[:50]}...")
+        return True
+
+    async def coordinate_attack(self, target_x: int, target_y: int, target_name: str = "Target") -> bool:
+        """Send attack coordination message to alliance."""
+        message = f"⚔️ Attack: {target_name} at ({target_x}, {target_y})"
+        return await self.send_alliance_chat(message)
+
+    async def request_support(self, castle_id: int, castle_name: str, reason: str = "under attack") -> bool:
+        """Request support from alliance members."""
+        message = f"🛡️ Need support at {castle_name} (ID: {castle_id}) - {reason}"
+        return await self.send_alliance_chat(message)
+
+    async def donate_resources(
+        self,
+        alliance_id: int,
+        kingdom_id: int = 0,
+        wood: int = 0,
+        stone: int = 0,
+        food: int = 0,
+        wait_for_response: bool = False,
+        timeout: float = 5.0,
+    ) -> bool:
+        """
+        Donate resources to the alliance.
+
+        Args:
+            alliance_id: ID of the alliance to donate to.
+            kingdom_id: Kingdom ID (KID, default 0).
+            wood: Amount of wood to donate.
+            stone: Amount of stone to donate.
+            food: Amount of food to donate.
+            wait_for_response: Whether to wait for server confirmation.
+            timeout: Response timeout in seconds.
+
+        Returns:
+            bool: True if donation sent successfully.
+        """
+        if wood <= 0 and stone <= 0 and food <= 0:
+            raise ValueError("Must specify at least one resource to donate.")
+
+        logger.info(f"Donating {wood}W/{stone}S/{food}F to alliance {alliance_id} in K{kingdom_id}")
+
+        payload = {
+            "AID": alliance_id,
+            "KID": kingdom_id,
+            "RV": {
+                "O": wood,  # Wood
+                "G": stone,  # Stone
+                "C": food,  # Food
+            },
+        }
+
+        response = await self.client._send_command_generic(
+            "ado", payload, "Alliance Donation", wait_for_response, timeout
+        )
+
+        return response
+
+    def get_online_members(self) -> List[AllianceMember]:
+        """Get online alliance members."""
+        return [m for m in self.alliance_members.values() if m.online]
+
+    def get_members_by_rank(self, rank: str) -> List[AllianceMember]:
+        """Get members by rank."""
+        return [m for m in self.alliance_members.values() if m.rank.lower() == rank.lower()]
+
+    def get_member(self, player_id: int) -> Optional[AllianceMember]:
+        """Get specific member by ID."""
+        return self.alliance_members.get(player_id)
+
+    def get_member_count(self) -> int:
+        """Get total member count."""
+        return len(self.alliance_members)
+
+    def update_members(self, members_data: List[Dict[str, Any]]):
+        """Update member list from server data."""
+        self.alliance_members.clear()
+        for m_data in members_data:
+            member = AllianceMember(
+                player_id=m_data.get("PID", 0),
+                name=m_data.get("N", "Unknown"),
+                level=m_data.get("L", 0),
+                rank=m_data.get("R", "member"),
+                online=m_data.get("O", False),
+                last_seen=m_data.get("LS", 0),
+                castle_count=m_data.get("CC", 0),
+            )
+            self.alliance_members[member.player_id] = member
+
+        logger.info(f"Updated {len(self.alliance_members)} alliance members")
+
+        # Notify callbacks
+        for callback in self._alliance_callbacks:
+            try:
+                callback(list(self.alliance_members.values()))
+            except Exception as e:
+                logger.error(f"Member callback error: {e}")
+
+    def on_members_updated(self, callback: Callable[[List[AllianceMember]], None]):
+        """Register callback for when member list updates."""
+        self._alliance_callbacks.append(callback)
+
+
+class ChatService:
+    """Service for chat functionality."""
+
+    MAX_HISTORY = 100
+
+    def __init__(self, client: "EmpireClient"):
+        self.client = client
+        self.chat_history: List[ChatMessage] = []
+        self._chat_callbacks: List[Callable[[ChatMessage], None]] = []
+
+    async def send_global_chat(self, message: str) -> bool:
+        """Send message to global chat."""
+        return await self._send_chat(message, "global")
+
+    async def send_kingdom_chat(self, message: str, kingdom_id: int = 0) -> bool:
+        """Send message to kingdom chat."""
+        return await self._send_chat(message, f"kingdom_{kingdom_id}")
+
+    async def send_private_message(self, player_id: int, message: str) -> bool:
+        """Send private message to a player."""
+        packet = Packet.build_xt(
+            self.client.config.default_zone,
+            "spm",
+            {"RID": player_id, "M": message},
+        )
+        await self.client.connection.send(packet)
+        logger.info(f"Sent PM to {player_id}")
+        return True
+
+    async def _send_chat(self, message: str, channel: str) -> bool:
+        """Send chat message to channel."""
+        packet = Packet.build_xt(
+            self.client.config.default_zone,
+            "sct",
+            {"M": message, "C": channel},
+        )
+        await self.client.connection.send(packet)
+        logger.debug(f"Sent to {channel}: {message[:50]}...")
+        return True
+
+    def on_chat_message(self, callback: Callable[[ChatMessage], None]):
+        """Register callback for incoming messages."""
+        self._chat_callbacks.append(callback)
+
+    def handle_incoming_chat(self, data: Dict[str, Any]):
+        """Handle incoming chat message from server."""
+        msg = ChatMessage(
+            timestamp=data.get("T", 0),
+            player_name=data.get("N", ""),
+            player_id=data.get("PID", 0),
+            message=data.get("M", ""),
+            channel=data.get("C", "global"),
+        )
+        self.chat_history.append(msg)
+
+        # Trim history
+        if len(self.chat_history) > self.MAX_HISTORY:
+            self.chat_history = self.chat_history[-self.MAX_HISTORY :]
+
+        # Notify callbacks
+        for callback in self._chat_callbacks:
+            try:
+                callback(msg)
+            except Exception as e:
+                logger.error(f"Chat callback error: {e}")
+
+    def get_chat_history(self, channel: Optional[str] = None, limit: int = 50) -> List[ChatMessage]:
+        """Get chat history, optionally filtered by channel."""
+        messages = self.chat_history
+        if channel:
+            messages = [m for m in messages if m.channel == channel]
+        return messages[-limit:]
+
+    def search_chat_history(self, keyword: str) -> List[ChatMessage]:
+        """Search chat history for keyword."""
+        keyword_lower = keyword.lower()
+        return [m for m in self.chat_history if keyword_lower in m.message.lower()]

empire_core/_archive/automation/battle_reports.py

@@ -0,0 +1,196 @@
+"""
+Battle report automation for analyzing combat outcomes.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Any, Dict, List
+
+from empire_core.state.report_models import BattleReport, ReportManager
+
+if TYPE_CHECKING:
+    from empire_core.client.client import EmpireClient
+
+logger = logging.getLogger(__name__)
+
+
+class BattleReportService:
+    """Service for battle report fetching and analysis."""
+
+    def __init__(self, client: "EmpireClient"):
+        self.client = client
+
+    @property
+    def reports_manager(self) -> ReportManager:
+        """Get the report manager from state."""
+        return self.client.state.reports
+
+    async def fetch_recent_reports(self, count: int = 10) -> bool:
+        """Fetch recent battle reports from server."""
+        # Using client method
+        return await self.client.get_battle_reports(count)
+
+    async def fetch_report_details(self, report_id: int) -> bool:
+        """Fetch detailed data for a specific battle report."""
+        # Using client method
+        return await self.client.get_battle_report_details(report_id)
+
+    def get_recent_reports(self, count: int = 10) -> List[BattleReport]:
+        """Get most recent battle reports."""
+        return self.reports_manager.get_recent_reports(count)
+
+    def get_unread_reports(self) -> List[BattleReport]:
+        """Get all unread battle reports."""
+        return self.reports_manager.get_unread_reports()
+
+    def mark_report_read(self, report_id: int):
+        """Mark a battle report as read."""
+        self.reports_manager.mark_as_read(report_id)
+
+    def get_report_summary(self, report: BattleReport) -> Dict[str, Any]:
+        """Get a summary of a battle report."""
+        summary = {
+            "report_id": report.report_id,
+            "timestamp": report.timestamp,
+            "datetime": report.datetime.isoformat(),
+            "is_read": report.is_read,
+            "report_type": report.report_type,
+            "target": {
+                "name": report.target_name,
+                "x": report.target_x,
+                "y": report.target_y,
+            },
+            "winner": report.winner,
+            "loot": report.loot,
+        }
+
+        # Add participant info if available
+        if report.attacker:
+            summary["attacker"] = {
+                "player_id": report.attacker.player_id,
+                "player_name": report.attacker.player_name,
+                "alliance_name": report.attacker.alliance_name,
+                "units_before": report.attacker.units_before,
+                "units_after": report.attacker.units_after,
+                "losses": report.attacker.losses,
+            }
+
+        if report.defender:
+            summary["defender"] = {
+                "player_id": report.defender.player_id,
+                "player_name": report.defender.player_name,
+                "alliance_name": report.defender.alliance_name,
+                "units_before": report.defender.units_before,
+                "units_after": report.defender.units_after,
+                "losses": report.defender.losses,
+            }
+
+        return summary
+
+    def analyze_battle_efficiency(self, report: BattleReport) -> Dict[str, Any]:
+        """Analyze the efficiency of a battle."""
+        loot_total = sum(report.loot.values())
+        analysis = {
+            "report_id": report.report_id,
+            "victory": report.winner == "attacker",
+            "loot_total": loot_total,
+            "loot_breakdown": report.loot,
+        }
+
+        # Calculate losses if we have participant data
+        if report.attacker and report.defender:
+            attacker_losses = sum(report.attacker.losses.values())
+            defender_losses = sum(report.defender.losses.values())
+
+            analysis.update(
+                {
+                    "attacker_losses": attacker_losses,
+                    "defender_losses": defender_losses,
+                    "total_losses": attacker_losses + defender_losses,
+                }
+            )
+
+            # Calculate efficiency metrics
+            if attacker_losses > 0:
+                loot_per_loss = loot_total / attacker_losses
+                analysis["loot_per_attacker_loss"] = loot_per_loss
+
+                # Simple efficiency rating (higher is better)
+                if loot_per_loss > 100:
+                    analysis["efficiency"] = "excellent"
+                elif loot_per_loss > 50:
+                    analysis["efficiency"] = "good"
+                elif loot_per_loss > 20:
+                    analysis["efficiency"] = "fair"
+                else:
+                    analysis["efficiency"] = "poor"
+
+        return analysis
+
+    def get_battle_stats(self, reports: List[BattleReport]) -> Dict[str, Any]:
+        """Get aggregate statistics from multiple battle reports."""
+        if not reports:
+            return {"total_battles": 0}
+
+        total_battles = len(reports)
+        victories = 0
+        defeats = 0
+        total_loot = {"wood": 0, "stone": 0, "food": 0}
+        total_losses = 0
+
+        for report in reports:
+            if report.winner == "attacker":
+                victories += 1
+            else:
+                defeats += 1
+
+            # Sum loot
+            for resource, amount in report.loot.items():
+                if resource in total_loot:
+                    total_loot[resource] += amount
+
+            # Sum losses (if available)
+            if report.attacker:
+                total_losses += sum(report.attacker.losses.values())
+
+        win_rate = victories / total_battles if total_battles > 0 else 0
+
+        return {
+            "total_battles": total_battles,
+            "victories": victories,
+            "defeats": defeats,
+            "total_loot": total_loot,
+            "total_losses": total_losses,
+            "win_rate": win_rate,
+        }
+
+    async def auto_fetch_and_analyze(self, count: int = 10, wait_time: float = 1.0) -> Dict[str, Any]:
+        """
+        Fetch recent reports and return analysis.
+
+        Args:
+            count: Number of reports to fetch
+            wait_time: Time to wait for server response
+
+        Returns:
+            Dict with stats and analyses
+        """
+        import asyncio
+
+        # Fetch reports
+        await self.fetch_recent_reports(count)
+        await asyncio.sleep(wait_time)  # Wait for response
+
+        # Get reports
+        reports = self.get_recent_reports(count)
+
+        # Analyze each report
+        analyses = [self.analyze_battle_efficiency(report) for report in reports]
+
+        # Get aggregate stats
+        stats = self.get_battle_stats(reports)
+
+        return {
+            "stats": stats,
+            "reports_analyzed": len(analyses),
+            "analyses": analyses[:5],  # Return top 5 analyses
+        }

empire_core/_archive/automation/building_queue.py

@@ -0,0 +1,242 @@
+"""
+Building queue management and automation.
+"""
+
+import asyncio
+import logging
+from dataclasses import dataclass
+from enum import IntEnum
+from typing import TYPE_CHECKING, Any, Dict, List
+
+if TYPE_CHECKING:
+    from empire_core.client.client import EmpireClient
+
+logger = logging.getLogger(__name__)
+
+
+class BuildingType(IntEnum):
+    """Common building type IDs."""
+
+    # Resource production
+    WOODCUTTER = 1
+    QUARRY = 2
+    FARM = 3
+
+    # Storage
+    WAREHOUSE = 4
+
+    # Military
+    BARRACKS = 5
+    ARCHERY_RANGE = 6
+    STABLE = 7
+    SIEGE_WORKSHOP = 8
+    DEFENSE_WORKSHOP = 9
+
+    # Other
+    KEEP = 10
+    TAVERN = 11
+    MARKETPLACE = 12
+    HOSPITAL = 13
+    WALL = 14
+
+
+@dataclass
+class BuildingTask:
+    """A building task in the queue."""
+
+    castle_id: int
+    building_id: int
+    target_level: int = 1
+    priority: int = 1
+    description: str = ""
+
+
+class BuildingManager:
+    """
+    Manages building and upgrade queues for castles.
+
+    Features:
+    - Queue buildings for automatic upgrade.
+    - Priority-based build order.
+    - Monitor build progress.
+    - Building recommendations.
+    """
+
+    def __init__(self, client: "EmpireClient"):
+        self.client = client
+        self.queue: List[BuildingTask] = []
+        self.in_progress: Dict[int, BuildingTask] = {}  # castle_id -> current task
+        self.is_running = False
+
+    def queue_upgrade(self, castle_id: int, building_id: int, target_level: int = 1, priority: int = 1):
+        """Add a building to the upgrade queue."""
+        task = BuildingTask(
+            castle_id=castle_id,
+            building_id=building_id,
+            target_level=target_level,
+            priority=priority,
+            description=f"Upgrade building {building_id} to level {target_level}",
+        )
+        self.queue.append(task)
+        self._sort_queue()
+        logger.info(f"Queued building {building_id} for castle {castle_id} (priority: {priority})")
+
+    def cancel_task(self, castle_id: int, building_id: int):
+        """Remove a task from the queue."""
+        self.queue = [t for t in self.queue if not (t.castle_id == castle_id and t.building_id == building_id)]
+        logger.info(f"Cancelled build task for building {building_id} in castle {castle_id}")
+
+    async def process_queue(self):
+        """Check queue and start next available build tasks."""
+        if not self.queue:
+            return
+
+        # Check each castle's availability
+        # Note: In this game, usually one build slot per castle (unless rubies/premium)
+        active_castles = set(self.in_progress.keys())
+
+        for task in list(self.queue):
+            if task.castle_id in active_castles:
+                continue
+
+            # Attempt to start build
+            success = await self._start_build(task)
+            if success:
+                self.in_progress[task.castle_id] = task
+                self.queue.remove(task)
+                logger.info(f"Started building {task.building_id} in castle {task.castle_id}")
+
+    async def _start_build(self, task: BuildingTask) -> bool:
+        """Internal: Send build command to server."""
+        try:
+            # Command: bui (Build)
+            # Needs implementation in GameActionsMixin/EmpireClient
+            success = await self.client.upgrade_building(
+                castle_id=task.castle_id,
+                building_id=task.building_id,
+            )
+            return bool(success)
+        except Exception as e:
+            logger.error(f"Failed to start build: {e}")
+            return False
+
+    async def refresh_status(self):
+        """Update status of in-progress builds."""
+        # Refresh state from server
+        await self.client.get_detailed_castle_info()
+
+        # Check if in-progress buildings are finished
+        player = self.client.state.local_player
+        if not player:
+            return
+
+        finished_castles = []
+        for castle_id, task in self.in_progress.items():
+            castle = player.castles.get(castle_id)
+            if not castle:
+                continue
+
+            # Check if building reached target level
+            # In this game, buildings list in dcl contains current level
+            is_finished = False
+            for building in castle.buildings:
+                if building.id == task.building_id and building.level >= task.target_level:
+                    is_finished = True
+                    break
+
+            if is_finished:
+                finished_castles.append(castle_id)
+                logger.info(f"Build finished: {task.description} in castle {castle_id}")
+
+        for cid in finished_castles:
+            del self.in_progress[cid]
+
+    async def start_automation(self, interval: int = 60):
+        """Start automatic build queue processing."""
+        self.is_running = True
+        logger.info("Building automation started")
+
+        while self.is_running:
+            try:
+                await self.refresh_status()
+                await self.process_queue()
+            except Exception as e:
+                logger.error(f"Building automation error: {e}")
+
+            await asyncio.sleep(interval)
+
+    def stop_automation(self):
+        """Stop automatic build queue processing."""
+        self.is_running = False
+        logger.info("Building automation stopped")
+
+    def get_status(self) -> Dict[str, Any]:
+        """Get current status of queue and active builds."""
+        return {
+            "queue_size": len(self.queue),
+            "queue_by_castle": {
+                castle_id: len([t for t in self.queue if t.castle_id == castle_id])
+                for castle_id in set(t.castle_id for t in self.queue)
+            },
+            "in_progress": list(self.in_progress.keys()),
+        }
+
+    def _sort_queue(self):
+        """Sort queue by priority (highest first)."""
+        self.queue.sort(key=lambda t: t.priority, reverse=True)
+
+    def get_recommendations(self, castle_id: int, focus: str = "balanced") -> List[BuildingTask]:
+        """Get recommended buildings to build/upgrade."""
+        recommendations: List[BuildingTask] = []
+        castle = self.client.state.castles.get(castle_id)
+        if not castle:
+            return recommendations
+
+        # Get current building levels
+        buildings = {b.id: b.level for b in castle.buildings}
+
+        # Define priority based on focus
+        priority_types: List[int] = []
+        if focus == "military":
+            priority_types = [
+                BuildingType.BARRACKS,
+                BuildingType.STABLE,
+                BuildingType.ARCHERY_RANGE,
+            ]
+        elif focus == "economy":
+            priority_types = [
+                BuildingType.WOODCUTTER,
+                BuildingType.QUARRY,
+                BuildingType.FARM,
+                BuildingType.WAREHOUSE,
+            ]
+        elif focus == "defense":
+            priority_types = [
+                BuildingType.WALL,
+                BuildingType.DEFENSE_WORKSHOP,
+                BuildingType.KEEP,
+            ]
+        else:  # balanced
+            priority_types = [
+                BuildingType.KEEP,
+                BuildingType.WOODCUTTER,
+                BuildingType.QUARRY,
+                BuildingType.FARM,
+                BuildingType.BARRACKS,
+            ]
+
+        # Find buildings that need upgrading
+        for i, building_type in enumerate(priority_types):
+            if building_type in buildings:
+                current_level = buildings[building_type]
+                if current_level < 10:  # Simple threshold
+                    recommendations.append(
+                        BuildingTask(
+                            castle_id=castle_id,
+                            building_id=building_type,
+                            target_level=current_level + 1,
+                            priority=len(priority_types) - i,  # Higher priority first
+                        )
+                    )
+
+        return recommendations