empire-core 0.7.3__py3-none-any.whl

empire_core/utils/battle_sim.py

@@ -0,0 +1,172 @@
+"""
+Battle simulation engine.
+"""
+
+import logging
+from dataclasses import dataclass
+from typing import Dict
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class UnitType:
+    """Unit type definition."""
+
+    id: int
+    name: str
+    attack: int
+    defense: int
+    health: int
+    speed: float
+    capacity: int
+    food_cost: int
+
+
+# Common unit definitions (example values - adjust based on actual game)
+UNIT_TYPES = {
+    620: UnitType(620, "Militia", 10, 10, 50, 20, 10, 1),
+    614: UnitType(614, "Swordsman", 30, 20, 100, 18, 20, 2),
+    611: UnitType(611, "Bowman", 25, 15, 80, 20, 15, 1),
+    629: UnitType(629, "Cavalry", 50, 30, 150, 30, 30, 3),
+    626: UnitType(626, "Archer", 35, 20, 90, 20, 15, 2),
+    637: UnitType(637, "Knight", 80, 50, 200, 25, 50, 5),
+}
+
+
+@dataclass
+class BattleResult:
+    """Result of a battle simulation."""
+
+    attacker_wins: bool
+    attacker_losses: Dict[int, int]
+    defender_losses: Dict[int, int]
+    attacker_survivors: Dict[int, int]
+    defender_survivors: Dict[int, int]
+    loot: Dict[str, int]
+    rounds: int
+
+
+class BattleSimulator:
+    """Simulate battles between armies."""
+
+    def __init__(self):
+        self.unit_types = UNIT_TYPES
+
+    def simulate(
+        self,
+        attacker_army: Dict[int, int],
+        defender_army: Dict[int, int],
+        attacker_bonus: float = 0.0,
+        defender_bonus: float = 0.0,
+        defender_wall_level: int = 0,
+    ) -> BattleResult:
+        """
+        Simulate a battle.
+
+        Args:
+            attacker_army: {unit_id: count}
+            defender_army: {unit_id: count}
+            attacker_bonus: Attack bonus % (0-100)
+            defender_bonus: Defense bonus % (0-100)
+            defender_wall_level: Wall level (adds defense)
+
+        Returns:
+            BattleResult
+        """
+        # Calculate total power
+        attacker_power = self._calculate_power(attacker_army, attacker_bonus)
+        defender_power = self._calculate_power(defender_army, defender_bonus)
+
+        # Add wall bonus
+        wall_bonus = defender_wall_level * 50  # 50 defense per level
+        defender_power += wall_bonus
+
+        # Determine winner
+        attacker_wins = attacker_power > defender_power
+
+        # Calculate losses (simplified)
+        if attacker_wins:
+            # Attacker wins - defender loses all, attacker loses some
+            power_ratio = defender_power / attacker_power if attacker_power > 0 else 0
+            attacker_losses = self._calculate_losses(attacker_army, power_ratio)
+            defender_losses = defender_army.copy()
+        else:
+            # Defender wins - attacker loses all, defender loses some
+            power_ratio = attacker_power / defender_power if defender_power > 0 else 0
+            attacker_losses = attacker_army.copy()
+            defender_losses = self._calculate_losses(defender_army, power_ratio)
+
+        # Calculate survivors
+        attacker_survivors = {uid: count - attacker_losses.get(uid, 0) for uid, count in attacker_army.items()}
+        defender_survivors = {uid: count - defender_losses.get(uid, 0) for uid, count in defender_army.items()}
+
+        # Calculate loot (if attacker wins)
+        loot = {}
+        if attacker_wins:
+            total_capacity = sum(
+                UNIT_TYPES.get(uid, UNIT_TYPES[620]).capacity * count for uid, count in attacker_survivors.items()
+            )
+            loot = {
+                "wood": int(total_capacity * 0.33),
+                "stone": int(total_capacity * 0.33),
+                "food": int(total_capacity * 0.34),
+            }
+
+        return BattleResult(
+            attacker_wins=attacker_wins,
+            attacker_losses=attacker_losses,
+            defender_losses=defender_losses,
+            attacker_survivors=attacker_survivors,
+            defender_survivors=defender_survivors,
+            loot=loot,
+            rounds=1,  # Simplified - single round
+        )
+
+    def _calculate_power(self, army: Dict[int, int], bonus: float = 0.0) -> float:
+        """Calculate total army power."""
+        total = 0.0
+
+        for unit_id, count in army.items():
+            unit = self.unit_types.get(unit_id)
+            if not unit:
+                continue
+
+            unit_power = (unit.attack + unit.defense + unit.health) / 3
+            total += unit_power * count
+
+        # Apply bonus
+        total *= 1 + bonus / 100
+
+        return total
+
+    def _calculate_losses(self, army: Dict[int, int], loss_ratio: float) -> Dict[int, int]:
+        """Calculate unit losses."""
+        losses = {}
+
+        for unit_id, count in army.items():
+            lost = int(count * loss_ratio)
+            if lost > 0:
+                losses[unit_id] = lost
+
+        return losses
+
+    def estimate_outcome(self, attacker_army: Dict[int, int], defender_army: Dict[int, int]) -> str:
+        """Quick estimate of battle outcome."""
+        att_power = self._calculate_power(attacker_army)
+        def_power = self._calculate_power(defender_army)
+
+        ratio = att_power / def_power if def_power > 0 else 999
+
+        if ratio > 2.0:
+            return "Easy Win"
+        elif ratio > 1.5:
+            return "Likely Win"
+        elif ratio > 1.0:
+            return "Close Win"
+        elif ratio > 0.75:
+            return "Close Loss"
+        elif ratio > 0.5:
+            return "Likely Loss"
+        else:
+            return "Heavy Loss"

empire_core/utils/calculations.py

@@ -0,0 +1,170 @@
+"""
+Game calculation utilities.
+"""
+
+import math
+from typing import Tuple
+
+
+def calculate_distance(x1: int, y1: int, x2: int, y2: int) -> float:
+    """
+    Calculate distance between two coordinates.
+
+    Args:
+        x1, y1: First coordinate
+        x2, y2: Second coordinate
+
+    Returns:
+        float: Distance
+    """
+    return math.sqrt((x2 - x1) ** 2 + (y2 - y1) ** 2)
+
+
+def calculate_travel_time(distance: float, speed: float = 20.0, speed_bonus: float = 0.0) -> int:
+    """
+    Calculate travel time for army movement.
+
+    Args:
+        distance: Distance to travel
+        speed: Base speed (default 20)
+        speed_bonus: Speed bonus percentage (0-100)
+
+    Returns:
+        int: Travel time in seconds
+    """
+    effective_speed = speed * (1 + speed_bonus / 100)
+    return int(distance / effective_speed * 60)  # Convert to seconds
+
+
+def calculate_resource_production(production_rate: float, hours: float) -> int:
+    """
+    Calculate resource production over time.
+
+    Args:
+        production_rate: Resources per hour
+        hours: Number of hours
+
+    Returns:
+        int: Total resources produced
+    """
+    return int(production_rate * hours)
+
+
+def calculate_building_cost(base_cost: int, level: int, multiplier: float = 1.5) -> int:
+    """
+    Calculate building upgrade cost.
+
+    Args:
+        base_cost: Base cost at level 1
+        level: Target level
+        multiplier: Cost multiplier per level
+
+    Returns:
+        int: Total cost
+    """
+    return int(base_cost * (multiplier ** (level - 1)))
+
+
+def calculate_unit_power(unit_stats: dict, count: int) -> int:
+    """
+    Calculate total unit power.
+
+    Args:
+        unit_stats: Dict with attack, defense, health
+        count: Number of units
+
+    Returns:
+        int: Total power
+    """
+    attack = unit_stats.get("attack", 0)
+    defense = unit_stats.get("defense", 0)
+    health = unit_stats.get("health", 0)
+
+    base_power = (attack + defense + health) / 3
+    return int(base_power * count)
+
+
+def is_within_range(x1: int, y1: int, x2: int, y2: int, max_range: float) -> bool:
+    """
+    Check if coordinates are within range.
+
+    Args:
+        x1, y1: First coordinate
+        x2, y2: Second coordinate
+        max_range: Maximum range
+
+    Returns:
+        bool: True if within range
+    """
+    distance = calculate_distance(x1, y1, x2, y2)
+    return distance <= max_range
+
+
+def format_time(seconds: int) -> str:
+    """
+    Format seconds to human readable time.
+
+    Args:
+        seconds: Time in seconds
+
+    Returns:
+        str: Formatted time (e.g., "1h 30m 45s")
+    """
+    if seconds < 0:
+        return "0s"
+
+    hours = seconds // 3600
+    minutes = (seconds % 3600) // 60
+    secs = seconds % 60
+
+    parts = []
+    if hours > 0:
+        parts.append(f"{hours}h")
+    if minutes > 0:
+        parts.append(f"{minutes}m")
+    if secs > 0 or not parts:
+        parts.append(f"{secs}s")
+
+    return " ".join(parts)
+
+
+def calculate_coordinates_in_radius(center_x: int, center_y: int, radius: float) -> list[Tuple[int, int]]:
+    """
+    Get all coordinates within radius.
+
+    Args:
+        center_x: Center X coordinate
+        center_y: Center Y coordinate
+        radius: Radius
+
+    Returns:
+        list: List of (x, y) tuples
+    """
+    coords = []
+    r = int(math.ceil(radius))
+
+    for x in range(center_x - r, center_x + r + 1):
+        for y in range(center_y - r, center_y + r + 1):
+            if calculate_distance(center_x, center_y, x, y) <= radius:
+                coords.append((x, y))
+
+    return coords
+
+
+def calculate_loot_capacity(unit_capacities: dict, unit_counts: dict) -> int:
+    """
+    Calculate total loot capacity.
+
+    Args:
+        unit_capacities: Dict of {unit_id: capacity}
+        unit_counts: Dict of {unit_id: count}
+
+    Returns:
+        int: Total capacity
+    """
+    total = 0
+    for unit_id, count in unit_counts.items():
+        capacity = unit_capacities.get(unit_id, 0)
+        total += capacity * count
+
+    return total

empire_core/utils/crypto.py

@@ -0,0 +1,8 @@
+import hashlib
+
+
+def hash_password(password: str) -> str:
+    """
+    Hashes the password using MD5, which is the standard for this SFS implementation.
+    """
+    return hashlib.md5(password.encode("utf-8")).hexdigest()

empire_core/utils/decorators.py

@@ -0,0 +1,69 @@
+import asyncio
+import functools
+import logging
+from typing import Callable, Optional, Tuple, Type
+
+
+def handle_errors(
+    logger: Optional[logging.Logger] = None,
+    log_msg: Optional[str] = None,
+    re_raise: bool = True,
+    cleanup_method: Optional[str] = None,
+    ignore: Optional[Tuple[Type[BaseException], ...]] = None,
+):
+    """
+    Decorator to centralize error handling, logging, and cleanup.
+
+    Args:
+        logger: The logger instance to use. If None, tries to get 'logger' from instance or module.
+        log_msg: Custom message to prefix the error log with.
+        re_raise: Whether to re-raise the caught exception.
+        cleanup_method: Name of a method on 'self' to call if an exception occurs (for instance methods).
+        ignore: Tuple of exception types to ignore (not log as error, just debug/pass).
+    """
+
+    def decorator(func: Callable):
+        @functools.wraps(func)
+        async def wrapper(*args, **kwargs):
+            # Determine logger
+            _logger = logger
+            if _logger is None:
+                # Try to get 'self.logger' or module level logger
+                if args and hasattr(args[0], "logger"):
+                    _logger = args[0].logger
+                else:
+                    _logger = logging.getLogger(func.__module__)
+
+            try:
+                return await func(*args, **kwargs)
+            except asyncio.CancelledError as e:
+                # CancelledError is usually control flow, maybe just re-raise
+                if ignore and asyncio.CancelledError in ignore:
+                    pass
+                else:
+                    _logger.debug(f"{func.__name__} cancelled.")
+                raise e
+            except Exception as e:
+                if ignore and isinstance(e, ignore):
+                    _logger.debug(f"Ignored error in {func.__name__}: {e}")
+                    return
+
+                msg = log_msg or f"Error in {func.__name__}"
+                _logger.error(f"{msg}: {e}", exc_info=True)
+
+                # Cleanup logic
+                if cleanup_method and args:
+                    self_obj = args[0]
+                    if hasattr(self_obj, cleanup_method):
+                        cleanup = getattr(self_obj, cleanup_method)
+                        if asyncio.iscoroutinefunction(cleanup):
+                            await cleanup()
+                        else:
+                            cleanup()
+
+                if re_raise:
+                    raise e
+
+        return wrapper
+
+    return decorator

empire_core/utils/enums.py

@@ -0,0 +1,111 @@
+from enum import IntEnum
+
+
+class MapObjectType(IntEnum):
+    EMPTY = 0
+    CASTLE = 1
+    DUNGEON = 2
+    CAPITAL = 3
+    OUTPOST = 4
+    TREASURE_DUNGEON = 7
+    TREASURE_CAMP = 8
+    SHADOW_AREA = 9
+    VILLAGE = 10
+    BOSS_DUNGEON = 11
+    KINGDOM_CASTLE = 12
+    EVENT_DUNGEON = 13
+    NO_LANDMARK = 14
+    FACTION_CAMP = 15
+    FACTION_VILLAGE = 16
+    FACTION_TOWER = 17
+    FACTION_CAPITAL = 18
+    PLAGUE_AREA = 19
+    TROOP_HOSTEL = 20
+    ALIEN_CAMP = 21
+    METRO = 22
+    KINGS_TOWER = 23
+    ISLE_RESOURCE = 24
+    ISLE_DUNGEON = 25
+    MONUMENT = 26
+    NOMAD_CAMP = 27
+    LABORATORY = 28
+    SAMURAI_CAMP = 29
+    FACTION_INVASION_CAMP = 30
+    DYNAMIC = 31
+    ROBBER_BARON_CASTLE = 32  # Added explicitly
+    SAMURAI_ALIEN_CAMP = 33
+    RED_ALIEN_CAMP = 34
+    ALLIANCE_NOMAD_CAMP = 35
+    DAIMYO_CASTLE = 37
+    DAIMYO_TOWNSHIP = 38
+    ABG_RESOURCE_TOWER = 40
+    ABG_TOWER = 41
+    WOLF_KING = 42
+    NO_OUTPOST = 99
+    UNKNOWN = -1
+
+    @property
+    def is_player(self) -> bool:
+        """Is this object a player-owned entity?"""
+        return self in (
+            MapObjectType.CASTLE,
+            MapObjectType.OUTPOST,
+            MapObjectType.CAPITAL,
+            MapObjectType.METRO,
+        )
+
+    @property
+    def is_npc(self) -> bool:
+        """Is this a permanent NPC/Robber Baron target?"""
+        return self in (
+            MapObjectType.DUNGEON,
+            MapObjectType.ROBBER_BARON_CASTLE,
+            MapObjectType.BOSS_DUNGEON,
+        )
+
+    @property
+    def is_event(self) -> bool:
+        """Is this a temporary event target (Nomad, Samurai, Alien)?"""
+        return self in (
+            MapObjectType.NOMAD_CAMP,
+            MapObjectType.SAMURAI_CAMP,
+            MapObjectType.ALIEN_CAMP,
+            MapObjectType.SAMURAI_ALIEN_CAMP,
+            MapObjectType.RED_ALIEN_CAMP,
+            MapObjectType.ALLIANCE_NOMAD_CAMP,
+            MapObjectType.EVENT_DUNGEON,
+        )
+
+    @property
+    def is_resource(self) -> bool:
+        """Is this a resource village or island?"""
+        return self in (
+            MapObjectType.VILLAGE,
+            MapObjectType.ISLE_RESOURCE,
+            MapObjectType.FACTION_VILLAGE,
+        )
+
+
+class KingdomType(IntEnum):
+    GREEN = 0
+    SANDS = 1
+    ICE = 2
+    FIRE = 3
+    STORM = 4
+
+
+class MovementType(IntEnum):
+    """Types of army movements."""
+
+    ATTACK = 1
+    SUPPORT = 2
+    TRANSPORT = 3
+    SPY = 4
+    RAID = 5
+    SETTLE = 6
+    CAMP = 7
+    TRADE = 8
+    ATTACK_CAMP = 9
+    RAID_CAMP = 10
+    RETURN = 11
+    UNKNOWN = -1