detect and resolve battle tie with influence_token

src/warchron/model/tie_manager.py

@@ -1,46 +1,108 @@
+from typing import List, Dict
+
+from warchron.constants import ContextType
+from warchron.model.exception import ForbiddenOperation
 from warchron.model.war import War
-from warchron.model.war_event import InfluenceSpent
-
-
-class ResolutionContext:
-    def __init__(self, context_type: str, context_id: str, participant_ids: list[str]):
-        self.context_type = context_type
-        self.context_id = context_id
-        self.participant_ids = participant_ids
-
-        self.current_bids: dict[str, int] = {}
-        self.round_index: int = 0
-        self.is_resolved: bool = False
+from warchron.model.round import Round
+from warchron.model.battle import Battle
+from warchron.model.war_event import InfluenceSpent, TieResolved
 
 
 class TieResolver:
 
     @staticmethod
-    def resolve(
+    def find_round_ties(round: Round, war: War) -> List[Battle]:
+        ties = []
+        for battle in round.battles.values():
+            if not battle.is_draw():
+                continue
+            resolved = any(
+                isinstance(e, TieResolved)
+                and e.context_type == ContextType.BATTLE
+                and e.context_id == battle.sector_id
+                for e in war.events
+            )
+            if not resolved:
+                ties.append(battle)
+        return ties
+
+    @staticmethod
+    def apply_bids(
         war: War,
-        context: ResolutionContext,
-        bids: dict[str, int],
-    ) -> str | None:
-        # verify available token for each player
-        for pid, amount in bids.items():
-            participant = war.participants[pid]
-            if participant.influence_tokens() < amount:
-                raise ValueError("Not enough influence tokens")
-        # apply spending
-        for pid, amount in bids.items():
-            if amount > 0:
-                war.participants[pid].events.append(
-                    InfluenceSpent(
-                        participant_id=pid,
-                        amount=amount,
-                        context=context.context_type,
-                    )
+        context_type: ContextType,
+        context_id: str,
+        bids: Dict[str, bool],  # war_participant_id -> spend?
+    ) -> None:
+        for war_part_id, spend in bids.items():
+            if not spend:
+                continue
+            if war.get_influence_tokens(war_part_id) < 1:
+                raise ForbiddenOperation("Not enough tokens")
+            war.events.append(
+                InfluenceSpent(
+                    participant_id=war_part_id,
+                    amount=1,
+                    context_type=context_type,
                 )
-        # determine winner
-        max_bid = max(bids.values())
-        winners = [pid for pid, b in bids.items() if b == max_bid]
-        if len(winners) == 1:
-            context.is_resolved = True
-            return winners[0]
-        # persisting tie → None
+            )
+
+    @staticmethod
+    def try_tie_break(
+        war: War,
+        context_type: ContextType,
+        context_id: str,
+        participants: List[str],  # war_participant_ids
+    ) -> bool:
+        spent: Dict[str, int] = {}
+        for war_part_id in participants:
+            spent[war_part_id] = sum(
+                e.amount
+                for e in war.events
+                if isinstance(e, InfluenceSpent)
+                and e.participant_id == war_part_id
+                and e.context_type == context_type
+            )
+        values = set(spent.values())
+        if values == {0}:  # no bid = confirmed draw
+            war.events.append(
+                TieResolved(
+                    participant_id=None,
+                    context_type=context_type,
+                    context_id=context_id,
+                )
+            )
+            return True
+        if len(values) == 1:  # tie again, continue
+            return False
+        winner = max(spent.items(), key=lambda item: item[1])[0]
+        war.events.append(
+            TieResolved(
+                participant_id=winner,
+                context_type=context_type,
+                context_id=context_id,
+            )
+        )
+        return True
+
+    @staticmethod
+    def can_tie_be_resolved(war: War, participants: List[str]) -> bool:
+        return any(war.get_influence_tokens(pid) > 0 for pid in participants)
+
+    @staticmethod
+    def get_effective_winner_id(
+        war: War,
+        context_type: ContextType,
+        context_id: str,
+        base_winner_id: str | None,
+    ) -> str | None:
+        if base_winner_id is not None:
+            return base_winner_id
+        for ev in reversed(war.events):
+            if (
+                isinstance(ev, TieResolved)
+                and ev.context_type == context_type
+                and ev.context_id == context_id
+            ):
+                return ev.participant_id  # None if confirmed draw
+
         return None