empire-core 0.7.3__py3-none-any.whl

empire_core/_archive/commands.py

@@ -0,0 +1,201 @@
+"""
+Additional game commands.
+"""
+
+import asyncio
+import logging
+from typing import TYPE_CHECKING, Any, Dict
+
+from empire_core.exceptions import ActionError
+from empire_core.protocol.packet import Packet
+
+if TYPE_CHECKING:
+    from empire_core.client.client import EmpireClient
+
+logger = logging.getLogger(__name__)
+
+
+class GameCommandsMixin:
+    """Mixin for additional game commands."""
+
+    async def _send_command_generic(
+        self,
+        command: str,
+        payload: Dict[str, Any],
+        action_name: str,
+        wait_for_response: bool = False,
+        timeout: float = 5.0,
+    ) -> Any:
+        """
+        Send a command packet.
+
+        Args:
+            command: Command ID
+            payload: Command payload
+            action_name: Human-readable name for logging/errors
+            wait_for_response: If True, waits for server response
+            timeout: Timeout for response in seconds
+
+        Returns:
+            True if successful (fire-and-forget), or response payload if waiting
+
+        Raises:
+            ActionError: If command fails
+            TimeoutError: If response times out
+        """
+        # self is EmpireClient
+        client: "EmpireClient" = self  # type: ignore
+
+        if wait_for_response:
+            client.response_awaiter.create_waiter(command)
+
+        packet = Packet.build_xt(client.config.default_zone, command, payload)
+        try:
+            await client.connection.send(packet)
+            logger.info(f"{action_name} sent")
+
+            if wait_for_response:
+                try:
+                    response = await client.response_awaiter.wait_for(command, timeout=timeout)
+
+                    # Check for Packet object with error code
+                    if hasattr(response, "error_code"):
+                        if response.error_code != 0:
+                            raise ActionError(f"{action_name} failed with error code {response.error_code}")
+
+                        logger.info(f"{action_name} response received (OK)")
+                        return response.payload
+
+                    # Legacy/fallback behavior (if response is just payload)
+                    logger.info(f"{action_name} response received")
+                    return response
+
+                except asyncio.TimeoutError:
+                    raise ActionError(f"{action_name} timed out waiting for response")
+
+            return True
+        except Exception as e:
+            logger.error(f"Failed to {action_name.lower()}: {e}")
+            raise ActionError(f"{action_name} failed: {e}")
+
+    async def cancel_building(self, castle_id: int, queue_id: int) -> bool:
+        """Cancel building upgrade."""
+        return await self._send_command_generic(
+            "cbu",
+            {"AID": castle_id, "QID": queue_id},
+            f"Cancel building in castle {castle_id}",
+        )
+
+    async def speed_up_building(self, castle_id: int, queue_id: int) -> bool:
+        """Speed up building with rubies."""
+        return await self._send_command_generic(
+            "sbu",
+            {"AID": castle_id, "QID": queue_id},
+            f"Speed up building in castle {castle_id}",
+        )
+
+    async def collect_quest_reward(self, quest_id: int) -> bool:
+        """Collect quest reward."""
+        return await self._send_command_generic("cqr", {"QID": quest_id}, f"Collect quest {quest_id} reward")
+
+    async def recall_army(self, movement_id: int) -> bool:
+        """Recall/cancel army movement."""
+        return await self._send_command_generic("cam", {"MID": movement_id}, f"Recall movement {movement_id}")
+
+    async def get_battle_reports(self, count: int = 10) -> bool:
+        """Get battle reports."""
+        return await self._send_command_generic("rep", {"C": count}, f"Get {count} battle reports")
+
+    async def get_battle_report_details(self, report_id: int) -> bool:
+        """Get detailed battle report."""
+        return await self._send_command_generic("red", {"RID": report_id}, f"Get battle report {report_id} details")
+
+    async def send_message(self, player_id: int, subject: str, message: str) -> bool:
+        """Send message to player."""
+        return await self._send_command_generic(
+            "smg",
+            {"RID": player_id, "S": subject, "M": message},
+            f"Send message to player {player_id}",
+        )
+
+    async def read_mail(self, mail_id: int) -> bool:
+        """Mark mail as read."""
+        return await self._send_command_generic("rma", {"MID": mail_id}, f"Read mail {mail_id}")
+
+    async def delete_mail(self, mail_id: int) -> bool:
+        """Delete mail."""
+        return await self._send_command_generic("dma", {"MID": mail_id}, f"Delete mail {mail_id}")
+
+    async def send_direct_message(self, recipient_name: str, subject: str, body: str) -> bool:
+        """
+        Send a direct message (mail) to a player by name.
+
+        Args:
+            recipient_name: Name of the player
+            subject: Subject of the message
+            body: Message content
+
+        Returns:
+            True if command sent successfully and confirmed by server
+        """
+        # This command requires verification
+        await self._send_command_generic(
+            "sms",
+            {"RN": recipient_name, "MH": subject, "TXT": body},
+            f"Send DM to '{recipient_name}'",
+            wait_for_response=True,
+        )
+
+        return True
+
+    async def search_player(self, name: str) -> bool:
+        """
+        Search for a player by name.
+
+        Args:
+            name: Player name to search for
+
+        Returns:
+            True if command sent successfully
+        """
+        return await self._send_command_generic("wsp", {"PN": name}, f"Search player '{name}'")
+
+    async def get_player_details(self, player_id: int) -> bool:
+        """
+        Get detailed public profile of a player.
+
+        Args:
+            player_id: Player ID
+
+        Returns:
+            True if command sent successfully
+        """
+        return await self._send_command_generic("gdi", {"PID": player_id}, f"Get details for player {player_id}")
+
+    async def get_attack_info(self, origin_id: int, target_id: int, units: Dict[int, int]) -> bool:
+        """
+        Get attack pre-calculation info (travel time, loot, etc.).
+
+        Args:
+            origin_id: Origin castle ID
+            target_id: Target castle/area ID
+            units: Unit dictionary {unit_id: count}
+
+        Returns:
+            True if command sent successfully
+        """
+        return await self._send_command_generic(
+            "gai", {"OID": origin_id, "TID": target_id, "UN": units}, f"Get attack info from {origin_id} to {target_id}"
+        )
+
+    async def get_castle_defense_info(self, target_id: int) -> bool:
+        """
+        Get defense information for a target castle.
+
+        Args:
+            target_id: Target castle/area ID
+
+        Returns:
+            True if command sent successfully
+        """
+        return await self._send_command_generic("aci", {"TID": target_id}, f"Get defense info for {target_id}")

empire_core/_archive/connection_async.py

@@ -0,0 +1,228 @@
+import asyncio
+import logging
+from typing import Awaitable, Callable, Dict, Optional, Set, Tuple, Union
+
+import aiohttp
+from empire_core.protocol.packet import Packet
+from empire_core.utils.decorators import handle_errors
+
+logger = logging.getLogger(__name__)
+
+
+class SFSConnection:
+    """
+    Manages the WebSocket connection to the SmartFoxServer.
+    Handles async reading, writing, and packet dispatching.
+    """
+
+    def __init__(self, url: str):
+        self.url = url
+        self._session: Optional[aiohttp.ClientSession] = None
+        self._ws: Optional[aiohttp.ClientWebSocketResponse] = None
+        self._read_task: Optional[asyncio.Task] = None
+        self._disconnecting = False
+
+        # Waiters: cmd_id -> Set of (Future, Predicate)
+        self._waiters: Dict[str, Set[Tuple[asyncio.Future, Callable[[Packet], bool]]]] = {}
+
+        # Callbacks
+        self.packet_handler: Optional[Callable[[Packet], Awaitable[None]]] = None
+        self.on_close: Optional[Callable[[], Awaitable[None]]] = None
+
+    @property
+    def connected(self) -> bool:
+        return self._ws is not None and not self._ws.closed
+
+    @handle_errors(log_msg="Connection failed", cleanup_method="_close_resources")
+    async def connect(self):
+        if self.connected:
+            return
+
+        logger.info(f"Connecting to {self.url}...")
+
+        # Ensure previous resources are cleaned up
+        await self._close_resources()
+
+        self._session = aiohttp.ClientSession()
+        try:
+            # Add timeout to connection attempt
+            self._ws = await asyncio.wait_for(self._session.ws_connect(self.url, heartbeat=30.0), timeout=10.0)
+            self._read_task = asyncio.create_task(self._read_loop())
+            logger.info("Connected.")
+        except Exception as e:
+            await self._close_resources()
+            raise e
+
+    async def disconnect(self):
+        """Cleanly disconnect and close resources."""
+        if self._disconnecting:
+            return
+
+        self._disconnecting = True
+        logger.info("Disconnecting...")
+
+        try:
+            if self._read_task and not self._read_task.done():
+                self._read_task.cancel()
+                try:
+                    # Wait for read loop to finish its finally block
+                    await asyncio.wait_for(self._read_task, timeout=2.0)
+                except (asyncio.CancelledError, asyncio.TimeoutError):
+                    pass
+
+            await self._close_resources()
+            self._cancel_all_waiters()
+            logger.info("Disconnected.")
+        finally:
+            self._disconnecting = False
+
+    async def _close_resources(self):
+        """Close WebSocket and Session with timeouts."""
+        if self._ws:
+            try:
+                if not self._ws.closed:
+                    await asyncio.wait_for(self._ws.close(), timeout=2.0)
+            except Exception:
+                pass
+            self._ws = None
+
+        if self._session:
+            try:
+                if not self._session.closed:
+                    await asyncio.wait_for(self._session.close(), timeout=2.0)
+            except Exception:
+                pass
+            self._session = None
+
+    def _cancel_all_waiters(self):
+        """Cancel all pending futures with a descriptive exception."""
+        for waiters in list(self._waiters.values()):
+            for fut, _ in list(waiters):
+                if not fut.done():
+                    fut.set_exception(asyncio.CancelledError("Connection closed"))
+        self._waiters.clear()
+
+    async def send(self, data: Union[bytes, str]):
+        """Send data to the server."""
+        if not self.connected:
+            raise RuntimeError("Not connected")
+
+        if self._ws is None:
+            raise RuntimeError("WebSocket not initialized")
+
+        if isinstance(data, bytes):
+            data = data.decode("utf-8")
+
+        if data.endswith("\x00"):
+            data = data[:-1]
+
+        try:
+            await self._ws.send_str(data)
+        except Exception as e:
+            logger.error(f"Error sending data: {e}")
+            # Don't call disconnect() here to avoid potential recursion if disconnect calls send
+            # Instead, let the read loop handle the failure or the next operation
+            raise e
+
+    def create_waiter(self, cmd_id: str, predicate: Optional[Callable[[Packet], bool]] = None) -> asyncio.Future:
+        """Create a future that will be resolved when a matching packet arrives."""
+        loop = asyncio.get_running_loop()
+        fut = loop.create_future()
+
+        if cmd_id not in self._waiters:
+            self._waiters[cmd_id] = set()
+
+        if predicate is None:
+
+            def predicate(p):
+                return True
+
+        entry = (fut, predicate)
+        self._waiters[cmd_id].add(entry)
+
+        def _cleanup(_):
+            if cmd_id in self._waiters:
+                try:
+                    self._waiters[cmd_id].remove(entry)
+                    if not self._waiters[cmd_id]:
+                        del self._waiters[cmd_id]
+                except (KeyError, ValueError):
+                    pass
+
+        fut.add_done_callback(_cleanup)
+        return fut
+
+    async def wait_for(
+        self,
+        cmd_id: str,
+        predicate: Optional[Callable[[Packet], bool]] = None,
+        timeout: float = 5.0,
+    ) -> Packet:
+        """Wait for a specific packet from the server."""
+        fut = self.create_waiter(cmd_id, predicate)
+        try:
+            return await asyncio.wait_for(fut, timeout)
+        except asyncio.TimeoutError:
+            from empire_core.exceptions import TimeoutError
+
+            raise TimeoutError(f"Timed out waiting for command '{cmd_id}'")
+
+    async def _read_loop(self):
+        """Continuous loop reading from the WebSocket."""
+        logger.debug("Read loop started.")
+
+        try:
+            if not self._ws:
+                return
+
+            async for msg in self._ws:
+                if msg.type == aiohttp.WSMsgType.TEXT:
+                    await self._process_message(msg.data.encode("utf-8"))
+                elif msg.type == aiohttp.WSMsgType.BINARY:
+                    await self._process_message(msg.data)
+                elif msg.type == aiohttp.WSMsgType.ERROR:
+                    logger.error("WS connection error: %s", self._ws.exception())
+                    break
+                elif msg.type in (aiohttp.WSMsgType.CLOSED, aiohttp.WSMsgType.CLOSING):
+                    break
+        except Exception as e:
+            if not isinstance(e, asyncio.CancelledError):
+                logger.error(f"Error in read loop: {e}")
+        finally:
+            logger.warning("Connection lost.")
+            await self._close_resources()
+            self._cancel_all_waiters()
+
+            # Notify client of disconnection in a safe way
+            if self.on_close and not self._disconnecting:
+
+                async def _trigger_close():
+                    try:
+                        if self.on_close:
+                            await self.on_close()
+                    except Exception as e:
+                        logger.error(f"Error in on_close callback: {e}")
+
+                asyncio.create_task(_trigger_close())
+
+    @handle_errors(log_msg="Failed to parse packet", re_raise=False)
+    async def _process_message(self, data: bytes):
+        packet = Packet.from_bytes(data)
+        await self._dispatch_packet(packet)
+
+    @handle_errors(log_msg="Error dispatching packet", re_raise=False)
+    async def _dispatch_packet(self, packet: Packet):
+        # 1. Notify Waiters
+        if packet.command_id and packet.command_id in self._waiters:
+            current_waiters = list(self._waiters[packet.command_id])
+            for fut, predicate in current_waiters:
+                if not fut.done():
+                    try:
+                        if predicate(packet):
+                            fut.set_result(packet)
+                    except Exception as e:
+                        logger.error(f"Error in waiter predicate: {e}")
+
+        # 2. Global Handler
+        if self.packet_handler:
+            await self.packet_handler(packet)

empire_core/_archive/defense.py

@@ -0,0 +1,156 @@
+"""
+Defense management mixin for deploying defense units and tools.
+"""
+
+import logging
+from typing import TYPE_CHECKING, Dict, List, Optional
+
+# Assuming GameCommandsMixin provides _send_command_generic
+
+if TYPE_CHECKING:
+    from empire_core.client.client import EmpireClient
+
+logger = logging.getLogger(__name__)
+
+
+class DefenseService:
+    """Service for managing castle defenses."""
+
+    def __init__(self, client: "EmpireClient"):
+        self.client = client
+
+    def _build_defense_slot_payload(self, items: Optional[Dict[int, int]]) -> List[List[int]]:
+        """Helper to build tool/unit list for defense payloads."""
+        if not items:
+            # Common pattern is to send [[-1, 0]] for empty slots or specific padding
+            # Assuming up to 5 slots based on khan.py example for dfw
+            return [[-1, 0]] * 5
+
+        payload = []
+        for item_id, count in items.items():
+            payload.append([item_id, count])
+
+        # Pad with [-1, 0] if less than expected slots
+        while len(payload) < 5:  # Assuming 5 slots based on typical defense setups
+            payload.append([-1, 0])
+
+        return payload[:5]  # Ensure max 5 items for wall slots
+
+    async def set_wall_defense(
+        self,
+        castle_id: int,
+        castle_x: int,
+        castle_y: int,
+        left_tools: Optional[Dict[int, int]] = None,
+        middle_tools: Optional[Dict[int, int]] = None,
+        right_tools: Optional[Dict[int, int]] = None,
+        left_units_up: int = 0,  # UP field, assuming Units Placed
+        left_units_count: int = 0,  # UC field, assuming Unit Count
+        middle_units_up: int = 0,
+        middle_units_count: int = 0,
+        right_units_up: int = 0,
+        right_units_count: int = 0,
+        wait_for_response: bool = False,
+        timeout: float = 5.0,
+    ) -> bool:
+        """
+        Deploy defense tools and units on castle walls.
+
+        Args:
+            castle_id: ID of the castle.
+            castle_x: Castle's X coordinate.
+            castle_y: Castle's Y coordinate.
+            left_tools: Tools for the left wall flank ({tool_id: count}).
+            middle_tools: Tools for the middle wall flank.
+            right_tools: Tools for the right wall flank.
+            left_units_up: Units Placed on left wall (UP).
+            left_units_count: Units Count on left wall (UC).
+            middle_units_up: Units Placed on middle wall (UP).
+            middle_units_count: Units Count on middle wall (UC).
+            right_units_up: Units Placed on right wall (UP).
+            right_units_count: Units Count on right wall (UC).
+            wait_for_response: Whether to wait for server confirmation.
+            timeout: Response timeout in seconds.
+
+        Returns:
+            bool: True if defense set successfully.
+
+        Raises:
+            ActionError: If setting defense fails.
+        """
+        logger.info(f"Setting wall defense for castle {castle_id} at ({castle_x},{castle_y})")
+
+        payload = {
+            "CX": castle_x,
+            "CY": castle_y,
+            "AID": castle_id,
+            "L": {
+                "S": self._build_defense_slot_payload(left_tools),
+                "UP": left_units_up,
+                "UC": left_units_count,
+            },
+            "M": {
+                "S": self._build_defense_slot_payload(middle_tools),
+                "UP": middle_units_up,
+                "UC": middle_units_count,
+            },
+            "R": {
+                "S": self._build_defense_slot_payload(right_tools),
+                "UP": right_units_up,
+                "UC": right_units_count,
+            },
+        }
+
+        # Use client's command sender
+        await self.client._send_command_generic("dfw", payload, "Set Wall Defense", wait_for_response, timeout)
+
+        # Use client's response parser if available or implemented here?
+        # The Mixin had _parse_action_response as a stub.
+        # Checking if client has it. GameActionsMixin usually has it.
+        # If not, we just return True for now if response is valid.
+        return True
+
+    async def set_moat_defense(
+        self,
+        castle_id: int,
+        castle_x: int,
+        castle_y: int,
+        left_slots: Optional[Dict[int, int]] = None,
+        middle_slots: Optional[Dict[int, int]] = None,
+        right_slots: Optional[Dict[int, int]] = None,
+        wait_for_response: bool = False,
+        timeout: float = 5.0,
+    ) -> bool:
+        """
+        Deploy defense tools in castle moat/field.
+
+        Args:
+            castle_id: ID of the castle.
+            castle_x: Castle's X coordinate.
+            castle_y: Castle's Y coordinate.
+            left_slots: Tools for the left moat/field flank ({tool_id: count}).
+            middle_slots: Tools for the middle moat/field flank.
+            right_slots: Tools for the right moat/field flank.
+            wait_for_response: Whether to wait for server confirmation.
+            timeout: Response timeout in seconds.
+
+        Returns:
+            bool: True if defense set successfully.
+
+        Raises:
+            ActionError: If setting defense fails.
+        """
+        logger.info(f"Setting moat defense for castle {castle_id} at ({castle_x},{castle_y})")
+
+        payload = {
+            "CX": castle_x,
+            "CY": castle_y,
+            "AID": castle_id,
+            "LS": self._build_defense_slot_payload(left_slots),
+            "MS": self._build_defense_slot_payload(middle_slots),
+            "RS": self._build_defense_slot_payload(right_slots),
+        }
+
+        await self.client._send_command_generic("dfm", payload, "Set Moat Defense", wait_for_response, timeout)
+
+        return True

empire_core/_archive/events/__init__.py

@@ -0,0 +1,35 @@
+from empire_core.events.base import (
+    # Action events
+    AttackSentEvent,
+    Event,
+    IncomingAttackEvent,
+    MovementArrivedEvent,
+    MovementCancelledEvent,
+    # Movement events
+    MovementEvent,
+    MovementStartedEvent,
+    MovementUpdatedEvent,
+    PacketEvent,
+    ReturnArrivalEvent,
+    ScoutSentEvent,
+    TransportSentEvent,
+)
+from empire_core.events.manager import EventManager
+
+__all__ = [
+    "Event",
+    "PacketEvent",
+    "EventManager",
+    # Movement events
+    "MovementEvent",
+    "MovementStartedEvent",
+    "MovementUpdatedEvent",
+    "MovementArrivedEvent",
+    "MovementCancelledEvent",
+    "IncomingAttackEvent",
+    "ReturnArrivalEvent",
+    # Action events
+    "AttackSentEvent",
+    "ScoutSentEvent",
+    "TransportSentEvent",
+]