Upload clashcr/game/deck_tracker.py with huggingface_hub

clashcr/game/deck_tracker.py

@@ -0,0 +1,104 @@
+"""Deck and cycle inference.
+
+- Do not require knowing opponent deck in advance.
+- Build opponent deck as cards are confirmed.
+- Use deck/cycle inference only as a secondary prior, never as the main detector.
+- Optionally use RoyaleAPI meta deck data after first 4-8 confirmed cards.
+- Never emit a card solely because it fits a meta deck.
+"""
+from __future__ import annotations
+
+import logging
+from dataclasses import dataclass, field
+from typing import Dict, List, Optional, Set
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DeckState:
+    confirmed_cards: List[str] = field(default_factory=list)
+    deck: Set[str] = field(default_factory=set)  # unique cards seen
+    cycle: List[str] = field(default_factory=list)  # last 4 played
+    hand_prediction: List[str] = field(default_factory=list)
+    cards_played: int = 0
+
+
+class DeckTracker:
+    """Tracks opponent deck and card cycle from confirmed plays."""
+
+    DECK_SIZE = 8
+    CYCLE_SIZE = 4
+
+    def __init__(self):
+        self.state = DeckState()
+        self._meta_prior: Dict[str, float] = {}  # card -> likelihood from meta
+
+    def reset(self) -> None:
+        self.state = DeckState()
+        self._meta_prior = {}
+
+    def register_play(self, card_key: str, confidence: float = 1.0) -> None:
+        if card_key == "UNKNOWN" or confidence < 0.5:
+            return
+
+        self.state.confirmed_cards.append(card_key)
+        self.state.deck.add(card_key)
+        self.state.cards_played += 1
+
+        # Update cycle
+        if card_key in self.state.cycle:
+            self.state.cycle.remove(card_key)
+        self.state.cycle.append(card_key)
+        if len(self.state.cycle) > self.CYCLE_SIZE:
+            self.state.cycle.pop(0)
+
+        self._update_hand_prediction()
+
+    def _update_hand_prediction(self) -> None:
+        if len(self.state.deck) < 5:
+            self.state.hand_prediction = []
+            return
+
+        # Standard cycle logic: hand = deck \ cycle
+        hand = [c for c in self.state.deck if c not in self.state.cycle]
+        self.state.hand_prediction = hand
+
+    def get_hand_prediction(self) -> List[str]:
+        return self.state.hand_prediction
+
+    def get_likely_remaining(self) -> List[str]:
+        """Return cards likely still in deck, sorted by meta prior if available."""
+        if len(self.state.deck) < self.DECK_SIZE:
+            # Unknown cards
+            return []
+
+        remaining = [c for c in self.state.deck if c not in self.state.confirmed_cards[-self.CYCLE_SIZE:]]
+        if self._meta_prior:
+            remaining.sort(key=lambda c: self._meta_prior.get(c, 0.0), reverse=True)
+        return remaining
+
+    def load_meta_prior(self, meta_decks: List[List[str]]) -> None:
+        """Load popular deck data from RoyaleAPI to build priors.
+
+        Args:
+            meta_decks: List of 8-card deck lists.
+        """
+        from collections import Counter
+        card_counts = Counter()
+        for deck in meta_decks:
+            for card in deck:
+                card_counts[card] += 1
+
+        total = len(meta_decks)
+        self._meta_prior = {
+            card: count / total
+            for card, count in card_counts.items()
+        }
+        logger.info("Loaded meta prior for %d cards from %d decks", len(self._meta_prior), total)
+
+    def is_new_card_plausible(self, card_key: str) -> bool:
+        """Check if a never-seen card is plausible given current deck size."""
+        if len(self.state.deck) < self.DECK_SIZE:
+            return True
+        return card_key in self.state.deck