CausalGame/api/modules/game/combat.py

"""
Combat simulation - Pure functions for combat mechanics.

This module handles:
- Detection check
- Combat round simulation
- Hit calculation
- Damage distribution

INVARIANT: Combat rules are fixed regardless of experiment.
Modifiers come from DroneState (pre-computed by SCM/middleware).
"""

from dataclasses import dataclass, field
from typing import Dict, Optional, List, Tuple
import random
import math

from ...middleware.drone_state import DroneState, CombatResult
from .damage import DamageCalculator, DamageConfig


@dataclass
class CombatConfig:
    """Configuration for combat simulation."""
    base_damage_per_hit: int = 70          # Base damage per hit (very high to punish no DEF)
    damage_variance: float = 0.3           # Damage variance (±30%)
    base_hit_chance: float = 0.80          # Base hit probability (high)
    critical_hit_chance: float = 0.20      # Critical hit probability
    critical_multiplier: float = 2.0       # Critical hit damage multiplier

    # Target selection weights
    target_weights: Dict[str, float] = field(default_factory=lambda: {
        'engine': 1.5,
        'cockpit': 1.5,
        'wing': 1.2,
        'body': 1.0,
        'antenna': 0.8,
        'camera': 0.5,
        'gun': 0.5,
    })


def check_detection(state: DroneState) -> bool:
    """
    Check if drone is detected.

    Pure function using pre-computed detection_probability from DroneState.

    Args:
        state: DroneState with detection_probability

    Returns:
        True if detected, False otherwise
    """
    roll = random.random()
    return roll < state.detection_probability


def simulate_combat(
    state: DroneState,
    config: Optional[CombatConfig] = None
) -> CombatResult:
    """
    Simulate combat rounds.

    Pure function that takes DroneState and returns CombatResult.
    All modifiers are pre-computed in DroneState.

    Args:
        state: DroneState with combat parameters
        config: Optional combat configuration

    Returns:
        CombatResult with damage and statistics
    """
    config = config or CombatConfig()
    combat_log: List[str] = []
    damage_by_component: Dict[str, int] = {}
    total_damage = 0
    hit_count = 0

    # Get available targets (components with HP > 0)
    targets = [comp for comp, hp in state.hp.items() if hp > 0]

    if not targets:
        combat_log.append("No valid targets - combat skipped")
        return CombatResult(combat_log=combat_log)

    combat_log.append(f"Combat initiated: {state.combat_rounds} rounds")
    combat_log.append(f"Drone agility: {state.agility:.2f}")

    # Simulate each combat round
    for round_num in range(state.combat_rounds):
        combat_log.append(f"--- Round {round_num + 1} ---")

        # Calculate hit chance (agility has minimal effect)
        # Formula: agility barely affects hit chance
        # agility=1.0 → mult=1.0, agility=0.5 → mult=1.05, agility=0.1 → mult=1.09
        # Heavily reduced to make DEF the primary survival factor
        agility_penalty = math.exp(0.1 * (1.0 - state.agility))
        hit_chance = config.base_hit_chance * state.combat_accuracy_modifier
        hit_chance *= agility_penalty
        hit_chance = min(0.95, max(0.05, hit_chance))

        # Roll for hit
        if random.random() < hit_chance:
            hit_count += 1

            # Select target based on weights
            target = _select_target(targets, config.target_weights)

            # Calculate damage
            base_damage = config.base_damage_per_hit

            # Apply variance
            variance = random.uniform(1 - config.damage_variance, 1 + config.damage_variance)
            damage = int(base_damage * variance)

            # Check for critical hit
            is_critical = random.random() < config.critical_hit_chance
            if is_critical:
                damage = int(damage * config.critical_multiplier)
                combat_log.append(f"CRITICAL HIT on {target}!")

            # Apply combat damage modifier from environment
            damage = int(damage * state.combat_damage_modifier)

            # Accumulate damage
            damage_by_component[target] = damage_by_component.get(target, 0) + damage
            total_damage += damage

            combat_log.append(f"Hit {target} for {damage} damage")

            # Update available targets if component destroyed
            # (simplified - actual HP check happens in DroneSheet)
        else:
            combat_log.append("Miss!")

    combat_log.append(f"Combat ended: {hit_count} hits, {total_damage} total damage")

    return CombatResult(
        hit_count=hit_count,
        damage_by_component=damage_by_component,
        total_damage=total_damage,
        combat_log=combat_log,
        rounds_fought=state.combat_rounds,
    )


def _select_target(
    targets: List[str],
    weights: Dict[str, float]
) -> str:
    """
    Select a target based on weights.

    Args:
        targets: Available targets
        weights: Target selection weights

    Returns:
        Selected target component
    """
    if not targets:
        raise ValueError("No targets available")

    if len(targets) == 1:
        return targets[0]

    # Build weighted list
    weighted_targets = []
    for target in targets:
        weight = weights.get(target, 1.0)
        weighted_targets.append((target, weight))

    # Weighted random selection
    total_weight = sum(w for _, w in weighted_targets)
    roll = random.random() * total_weight

    cumulative = 0
    for target, weight in weighted_targets:
        cumulative += weight
        if roll < cumulative:
            return target

    # Fallback
    return targets[-1]


class CombatSimulator:
    """
    Stateful combat simulator with full logging.

    Provides detailed combat simulation with:
    - Round-by-round tracking
    - Damage accumulation
    - Statistical analysis
    """

    def __init__(
        self,
        config: Optional[CombatConfig] = None,
        damage_config: Optional[DamageConfig] = None
    ):
        """
        Initialize CombatSimulator.

        Args:
            config: Combat configuration
            damage_config: Damage calculation configuration
        """
        self.config = config or CombatConfig()
        self.damage_calculator = DamageCalculator(damage_config)

        # Statistics
        self._total_combats = 0
        self._total_hits = 0
        self._total_damage = 0

    def simulate(self, state: DroneState) -> CombatResult:
        """
        Run combat simulation.

        Args:
            state: DroneState to simulate combat for

        Returns:
            CombatResult with full details
        """
        result = simulate_combat(state, self.config)

        # Update statistics
        self._total_combats += 1
        self._total_hits += result.hit_count
        self._total_damage += result.total_damage

        return result

    def check_and_simulate(self, state: DroneState) -> Tuple[bool, Optional[CombatResult]]:
        """
        Check detection and simulate combat if detected.

        Args:
            state: DroneState to check

        Returns:
            (was_detected, combat_result or None)
        """
        was_detected = check_detection(state)

        if was_detected:
            return True, self.simulate(state)
        else:
            return False, None

    def get_statistics(self) -> Dict[str, float]:
        """Get accumulated combat statistics."""
        avg_hits = self._total_hits / self._total_combats if self._total_combats > 0 else 0
        avg_damage = self._total_damage / self._total_combats if self._total_combats > 0 else 0

        return {
            'total_combats': self._total_combats,
            'total_hits': self._total_hits,
            'total_damage': self._total_damage,
            'average_hits_per_combat': avg_hits,
            'average_damage_per_combat': avg_damage,
        }

    def reset_statistics(self) -> None:
        """Reset accumulated statistics."""
        self._total_combats = 0
        self._total_hits = 0
        self._total_damage = 0


def full_simulation(
    state: DroneState,
    combat_config: Optional[CombatConfig] = None
) -> Tuple[bool, CombatResult]:
    """
    Run full detection and combat simulation.

    Convenience function that:
    1. Checks detection
    2. If detected, simulates combat
    3. Returns results

    Args:
        state: DroneState to simulate
        combat_config: Optional combat configuration

    Returns:
        (was_detected, combat_result)
    """
    was_detected = check_detection(state)

    if was_detected:
        result = simulate_combat(state, combat_config)
        result = CombatResult(
            hit_count=result.hit_count,
            damage_by_component=result.damage_by_component,
            total_damage=result.total_damage,
            combat_log=["DETECTED!"] + result.combat_log,
            rounds_fought=result.rounds_fought,
        )
        return True, result
    else:
        return False, CombatResult(
            combat_log=["Not detected - no combat"],
        )