Upload clashcr/game/elixir_tracker.py with huggingface_hub

clashcr/game/elixir_tracker.py

@@ -0,0 +1,123 @@
+"""Elixir tracker: estimate opponent elixir from wall-clock regen and confirmed plays.
+
+Regen schedule:
+- Single elixir: 1 elixir per 2.8 seconds
+- Double elixir: starts at 2:00 (1 elixir per 1.4 seconds)
+- Triple elixir: starts at 3:00 (1 elixir per 0.933 seconds)
+- Overtime: varies by mode; we use double/triple based on game mode hint.
+
+Uncertainty bounds tracked explicitly.
+"""
+from __future__ import annotations
+
+import logging
+import time
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional
+
+from clashcr.utils.card_registry import CardRegistry
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class ElixirState:
+    current: float
+    max_elixir: float = 10.0
+    uncertainty_low: float = 0.0
+    uncertainty_high: float = 0.0
+    mode: str = "single"  # single, double, triple
+    last_update: float = 0.0
+
+
+class ElixirTracker:
+    """Tracks opponent elixir using wall-clock regeneration."""
+
+    BASE_REGEN_PER_SECOND = 1.0 / 2.8
+    MODE_MULTIPLIERS = {
+        "single": 1.0,
+        "double": 2.0,
+        "triple": 3.0,
+        "overtime_double": 2.0,
+        "overtime_triple": 3.0,
+    }
+
+    def __init__(self, registry: Optional[CardRegistry] = None):
+        self.registry = registry or CardRegistry()
+        if not self.registry.cards:
+            self.registry.load()
+        self.state = ElixirState(current=5.0, last_update=time.monotonic())
+        self._history: List[Dict] = []
+        self._match_start_time: Optional[float] = None
+        self._mode_schedule = [
+            (0.0, "single"),
+            (120.0, "double"),
+            (180.0, "triple"),
+        ]
+
+    def start_match(self) -> None:
+        self.state = ElixirState(current=5.0, last_update=time.monotonic())
+        self._history = []
+        self._match_start_time = time.monotonic()
+        logger.info("Elixir tracker reset for new match")
+
+    def _get_mode(self, elapsed: float) -> str:
+        mode = "single"
+        for threshold, m in self._mode_schedule:
+            if elapsed >= threshold:
+                mode = m
+        return mode
+
+    def update(self, force_mode: Optional[str] = None) -> ElixirState:
+        now = time.monotonic()
+        elapsed = now - self.state.last_update
+        if self._match_start_time:
+            match_elapsed = now - self._match_start_time
+            mode = force_mode or self._get_mode(match_elapsed)
+        else:
+            mode = force_mode or "single"
+
+        multiplier = self.MODE_MULTIPLIERS.get(mode, 1.0)
+        regen = elapsed * self.BASE_REGEN_PER_SECOND * multiplier
+
+        self.state.current = min(self.state.max_elixir, self.state.current + regen)
+        self.state.mode = mode
+        self.state.last_update = now
+
+        # Uncertainty grows with time since last confirmed event
+        self.state.uncertainty_high = min(2.0, elapsed * 0.5)
+        self.state.uncertainty_low = 0.0
+        return self.state
+
+    def deduct(self, card_key: str, confidence: float = 1.0) -> None:
+        """Deduct elixir for a confirmed opponent card play."""
+        if card_key == "UNKNOWN" or confidence < 0.5:
+            logger.debug("Skipping elixir deduction for %s (confidence=%.2f)", card_key, confidence)
+            return
+
+        cost = self.registry.get_cost(card_key)
+        if cost < 0:
+            logger.warning("Unknown elixir cost for %s", card_key)
+            cost = 0
+
+        self.update()
+        old = self.state.current
+        self.state.current = max(0.0, self.state.current - cost)
+        self.state.uncertainty_low = 0.0
+        self.state.uncertainty_high = 0.0
+
+        self._history.append({
+            "timestamp": time.monotonic(),
+            "card": card_key,
+            "cost": cost,
+            "before": old,
+            "after": self.state.current,
+        })
+        logger.debug("Deducted %d elixir for %s (%.1f -> %.1f)", cost, card_key, old, self.state.current)
+
+    def get_state(self) -> ElixirState:
+        return self.update()
+
+    def set_mode_schedule(self, schedule: List[tuple]) -> None:
+        """Override default mode schedule. List of (seconds, mode)."""
+        self._mode_schedule = schedule