kaggle-environments 1.20.1__py3-none-any.whl → 1.21.0__py3-none-any.whl

kaggle_environments/envs/werewolf/game/protocols/base.py

@@ -0,0 +1,242 @@
+import json
+import re
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Sequence, Tuple
+
+from kaggle_environments.envs.werewolf.game.actions import Action, BidAction, ChatAction
+from kaggle_environments.envs.werewolf.game.base import PlayerID
+from kaggle_environments.envs.werewolf.game.consts import EventName
+from kaggle_environments.envs.werewolf.game.records import ChatDataEntry, RequestVillagerToSpeakDataEntry
+from kaggle_environments.envs.werewolf.game.roles import Player
+from kaggle_environments.envs.werewolf.game.states import GameState
+
+
+def _extract_player_ids_from_string(text: str, all_player_ids: List[PlayerID]) -> List[PlayerID]:
+    """Extracts player IDs mentioned in a string."""
+    if not all_player_ids:
+        return []
+    # Create a regex pattern to find any of the player IDs as whole words
+    # Using a set for faster lookups and to handle duplicates from the regex
+    pattern = r"\b(" + "|".join(re.escape(pid) for pid in all_player_ids) + r")\b"
+    # Use a set to automatically handle duplicates found by the regex
+    found_ids = set(re.findall(pattern, text))
+    return sorted(list(found_ids))  # sorted for deterministic order
+
+
+def _find_mentioned_players(text: str, all_player_ids: List[PlayerID]) -> List[PlayerID]:
+    """
+    Finds player IDs mentioned in a string of text, ordered by their first appearance.
+    Player IDs are treated as whole words.
+    Example: "I think gpt-4 is suspicious, what do you think John?" -> ["gpt-4", "John"]
+    """
+    if not text or not all_player_ids:
+        return []
+
+    # Sort by length descending to handle substrings correctly.
+    sorted_player_ids = sorted(all_player_ids, key=len, reverse=True)
+    pattern = r"\b(" + "|".join(re.escape(pid) for pid in sorted_player_ids) + r")\b"
+
+    matches = re.finditer(pattern, text)
+
+    # Deduplicate while preserving order of first appearance
+    ordered_mentioned_ids = []
+    seen = set()
+    for match in matches:
+        player_id = match.group(1)
+        if player_id not in seen:
+            ordered_mentioned_ids.append(player_id)
+            seen.add(player_id)
+
+    return ordered_mentioned_ids
+
+
+class GameProtocol(ABC):
+    @property
+    def display_name(self) -> str:
+        return self.__class__.__name__
+
+    @property
+    @abstractmethod
+    def rule(self) -> str:
+        """Human-readable format of rule."""
+
+
+class VotingProtocol(GameProtocol):
+    """Collects, validates, and tallies votes."""
+
+    @abstractmethod
+    def begin_voting(self, state: GameState, alive_voters: Sequence[Player], potential_targets: Sequence[Player]):
+        """Initialize for a new voting round."""
+
+    @abstractmethod
+    def get_voting_prompt(self, state: GameState, player_id: PlayerID) -> str:
+        """
+        Returns a string prompt for the specified player, potentially including current tally.
+        """
+
+    @abstractmethod
+    def collect_vote(self, vote_action: Action, state: GameState):  # Changed to Action, will check type
+        """Collect an individual vote."""
+
+    @abstractmethod
+    def collect_votes(self, player_actions: Dict[str, Action], state: GameState, expected_voters: List[PlayerID]):
+        """Collect a batch of votes."""
+
+    @abstractmethod
+    def get_current_tally_info(self, state: GameState) -> Dict[PlayerID, PlayerID]:
+        """
+        Return the current tally by a map, where key is player, value is target.
+        """
+
+    @abstractmethod
+    def get_next_voters(self) -> List[PlayerID]:
+        """get the next batch of voters"""
+
+    @abstractmethod
+    def done(self):
+        """Check if voting is done."""
+
+    @abstractmethod
+    def get_valid_targets(self) -> List[PlayerID]:
+        """get a list of targets"""
+
+    @abstractmethod
+    def get_elected(self) -> Optional[PlayerID]:
+        """get the final elected individual, or None if no one was elected."""
+
+    @abstractmethod
+    def reset(self) -> None:
+        """Resets the protocol to its initial state."""
+        pass
+
+
+class BiddingProtocol(GameProtocol):
+    """Drives one auction round and returns the winner(s)."""
+
+    @property
+    @abstractmethod
+    def bids(self) -> Dict[PlayerID, int]:
+        """return a snapshot of the current bids"""
+
+    @staticmethod
+    def get_last_mentioned(state: GameState) -> Tuple[List[PlayerID], str]:
+        """get the players that were mentioned in last player message."""
+        last_chat_message = ""
+        sorted_days = sorted(state.history.keys(), reverse=True)
+        for day in sorted_days:
+            for entry in reversed(state.history[day]):
+                if entry.event_name == EventName.DISCUSSION and isinstance(entry.data, ChatDataEntry):
+                    last_chat_message = entry.data.message
+                    break
+            if last_chat_message:
+                break
+        players = _find_mentioned_players(last_chat_message, state.all_player_ids)
+        return players, last_chat_message
+
+    @abstractmethod
+    def begin(self, state: GameState) -> None: ...
+
+    @abstractmethod
+    def accept(self, bid: BidAction, state: GameState) -> None: ...
+
+    @abstractmethod
+    def process_incoming_bids(self, actions: List[Action], state: GameState) -> None:
+        """Processes a batch of actions, handling BidActions by calling self.accept()."""
+
+    @abstractmethod
+    def is_finished(self, state: GameState) -> bool: ...
+
+    @abstractmethod
+    def outcome(self, state: GameState) -> list[PlayerID]:
+        """
+        Return list of player-ids, ordered by bid strength.
+        Could be 1 winner (sealed-bid) or a full ranking (Dutch auction).
+        """
+
+    @abstractmethod
+    def reset(self) -> None:
+        """Resets the protocol to its initial state."""
+
+
+class DiscussionProtocol(GameProtocol):
+    """Drives the order/shape of daytime conversation."""
+
+    @abstractmethod
+    def begin(self, state: GameState) -> None:
+        """Optional hook – initialise timers, round counters…"""
+
+    @abstractmethod
+    def speakers_for_tick(self, state: GameState) -> Sequence[PlayerID]:
+        """
+        Return the IDs that are *allowed to send a chat action* this tick.
+        Return an empty sequence when the discussion phase is over.
+        """
+
+    @abstractmethod
+    def is_discussion_over(self, state: GameState) -> bool:
+        """Returns True if the entire discussion (including any preliminary phases like bidding) is complete."""
+        pass
+
+    @abstractmethod
+    def reset(self) -> None:
+        """Resets the protocol to its initial state."""
+        pass
+
+    def process_actions(self, actions: List[Action], expected_speakers: Sequence[PlayerID], state: GameState) -> None:
+        """
+        Processes a batch of actions. Depending on the protocol's state (e.g., bidding or chatting),
+        it will handle relevant actions (like BidAction or ChatAction) from expected_speakers.
+        """
+        for act in actions:
+            if isinstance(act, ChatAction):
+                all_player_ids = [p.id for p in state.players]
+                mentioned_ids = _extract_player_ids_from_string(act.message, all_player_ids)
+                if expected_speakers and act.actor_id in expected_speakers:
+                    data = ChatDataEntry(
+                        actor_id=act.actor_id,
+                        message=act.message,
+                        reasoning=act.reasoning,
+                        mentioned_player_ids=mentioned_ids,
+                        perceived_threat_level=act.perceived_threat_level,
+                        action=act,
+                    )
+                    state.push_event(
+                        description=f'Player "{act.actor_id}" (chat): {act.message}',
+                        # Make public for general discussion
+                        event_name=EventName.DISCUSSION,
+                        public=True,
+                        source=act.actor_id,
+                        data=data,
+                    )
+                else:
+                    state.push_event(
+                        description=f'Player "{act.actor_id}" (chat, out of turn): {act.message}',
+                        event_name=EventName.DISCUSSION,  # Or a specific "INVALID_CHAT" type
+                        visible_to=[act.actor_id],
+                        public=False,
+                        source=act.actor_id,
+                    )
+
+    def call_for_actions(self, speakers: Sequence[PlayerID]) -> List[str]:
+        """prepare moderator call for action for each player."""
+        return [f'Player "{speaker_id}", it is your turn to speak.' for speaker_id in speakers]
+
+    def prompt_speakers_for_tick(self, state: GameState, speakers: Sequence[PlayerID]) -> None:
+        """
+        Allows the protocol to make specific announcements or prompts to the current speakers for this tick.
+        This method is called by the Moderator after speakers_for_tick() returns a non-empty list of speakers,
+        and before process_actions().
+        Implementations should use state.push_event() to make announcements.
+        These announcements are typically visible only to the speakers, unless they are general status updates.
+        """
+        call_for_actions = self.call_for_actions(speakers)
+        for speaker_id, call_for_action in zip(speakers, call_for_actions):
+            data = RequestVillagerToSpeakDataEntry(action_json_schema=json.dumps(ChatAction.schema_for_player()))
+            state.push_event(
+                description=call_for_action,
+                event_name=EventName.CHAT_REQUEST,
+                public=False,
+                visible_to=[speaker_id],
+                data=data,
+                visible_in_ui=False,
+            )

kaggle_environments/envs/werewolf/game/protocols/bid.py

@@ -0,0 +1,248 @@
+from collections import Counter
+from typing import Dict, List
+
+from kaggle_environments.envs.werewolf.game.actions import Action, BidAction
+from kaggle_environments.envs.werewolf.game.base import PlayerID
+from kaggle_environments.envs.werewolf.game.consts import EventName
+from kaggle_environments.envs.werewolf.game.protocols.base import BiddingProtocol
+from kaggle_environments.envs.werewolf.game.records import BidDataEntry, ChatDataEntry
+from kaggle_environments.envs.werewolf.game.states import GameState
+
+from .factory import register_protocol
+
+
+@register_protocol()
+class SimpleBiddingProtocol(BiddingProtocol):
+    """
+    A straightforward bidding protocol where speaking priority is determined
+    solely by the bid amount.
+    - Agents bid with a numerical amount.
+    - Higher bids result in earlier speaking turns.
+    - Ties are broken deterministically by player ID (ascending).
+    """
+
+    def __init__(self):
+        self._bids: Dict[PlayerID, int] = {}
+        self._max_bid = 4
+        self.reset()
+
+    def reset(self) -> None:
+        """Resets the bids for a new round."""
+        self._bids = {}
+
+    @property
+    def display_name(self):
+        return "Simple Bidding"
+
+    @property
+    def rule(self) -> str:
+        """Provides a description of the bidding rules."""
+        return "\n".join(
+            (
+                "Players bid with an urgency level (0-4) to determine speaking order.",
+                "0: I would like to observe and listen for now.",
+                "1: I have some general thoughts to share with the group.",
+                "2: I have something critical and specific to contribute to this discussion.",
+                "3: It is absolutely urgent for me to speak next.",
+                "4: I must respond.",
+                "Higher bids speak earlier. Ties are broken by player name (A-Z).",
+            )
+        )
+
+    @property
+    def bids(self) -> Dict[PlayerID, int]:
+        """Returns a copy of the current bids."""
+        return dict(**self._bids)
+
+    def begin(self, state: GameState) -> None:
+        """Initializes a new bidding round."""
+        self.reset()
+
+    def accept(self, bid: BidAction, state: GameState) -> None:
+        """Accepts and records a single bid from a player."""
+        bid_amount = min(max(0, bid.amount), self._max_bid)
+        self._bids[bid.actor_id] = bid_amount
+
+        data = BidDataEntry(
+            actor_id=bid.actor_id,
+            reasoning=bid.reasoning,
+            perceived_threat_level=bid.perceived_threat_level,
+            bid_amount=bid_amount,
+            action=bid,
+        )
+        state.push_event(
+            description=f"Player {bid.actor_id} submitted a bid of {bid_amount}.",
+            event_name=EventName.BID_ACTION,
+            public=False,  # Bids are private until the outcome is announced
+            visible_to=[bid.actor_id],
+            data=data,
+            source=bid.actor_id,
+        )
+
+    def process_incoming_bids(self, actions: List[Action], state: GameState) -> None:
+        """Processes a list of actions, handling any BidActions."""
+        for act in actions:
+            if isinstance(act, BidAction):
+                self.accept(act, state)
+
+    def is_finished(self, state: GameState) -> bool:
+        """
+        Checks if the bidding phase is complete (i.e., all alive players have bid).
+        """
+        return len(self._bids) >= len(state.alive_players())
+
+    def outcome(self, state: GameState) -> list[str]:
+        """
+        Determines the final speaking order based on bids.
+
+        Returns:
+            A list of player IDs sorted by bid (descending) and then player ID (ascending).
+        """
+        if not self._bids:
+            # If no bids were made, return alive players in their default order.
+            return sorted([p.id for p in state.alive_players()])
+
+        # Sort by bid amount (descending) and then by player ID (ascending) for tie-breaking.
+        sorted_bidders = sorted(self._bids.items(), key=lambda item: (-item[1], item[0]))
+        return [player_id for player_id, bid_amount in sorted_bidders]
+
+
+@register_protocol()
+class UrgencyBiddingProtocol(BiddingProtocol):
+    """
+    A bidding protocol based on the Werewolf Arena paper.
+    - Agents bid with an urgency level (0-4).
+    - Highest bidder wins.
+    - Ties are broken by prioritizing players mentioned in the previous turn.
+    """
+
+    @property
+    def display_name(self) -> str:
+        return "Urgency Bidding"
+
+    @property
+    def rule(self) -> str:
+        return "\n".join(
+            [
+                "Urgency-based bidding. Players bid with an urgency level (0-4).",
+                "0: I would like to observe and listen for now.",
+                "1: I have some general thoughts to share with the group.",
+                "2: I have something critical and specific to contribute to this discussion.",
+                "3: It is absolutely urgent for me to speak next.",
+                "4: Someone has addressed me directly and I must respond.",
+                "Highest bidder wins."
+                "Ties are broken by the following priority: (1) players mentioned in the previous turn's chat, "
+                "(2) the least spoken player, (3) round robin order of the player list.",
+            ]
+        )
+
+    @property
+    def bids(self) -> Dict[PlayerID, int]:
+        return dict(**self._bids)
+
+    def __init__(self):
+        self._bids: Dict[PlayerID, int] = {}
+        self._mentioned_last_turn: List[PlayerID] = []
+
+    def reset(self) -> None:
+        self._bids = {}
+        self._mentioned_last_turn = []
+
+    def begin(self, state: GameState) -> None:
+        """Called at the start of a bidding round to identify recently mentioned players."""
+        self.reset()
+        # Find the very last chat entry in the history to check for mentions
+        self._mentioned_last_turn, last_chat_message = self.get_last_mentioned(state)
+
+        if last_chat_message:
+            if self._mentioned_last_turn:
+                state.push_event(
+                    description=f"Players mentioned last turn (priority in ties): {self._mentioned_last_turn}",
+                    event_name=EventName.BIDDING_INFO,
+                    public=True,  # So everyone knows who has priority
+                )
+
+    def accept(self, bid: BidAction, state: GameState) -> None:
+        if 0 <= bid.amount <= 4:
+            self._bids[bid.actor_id] = bid.amount
+            data = BidDataEntry(
+                actor_id=bid.actor_id,
+                reasoning=bid.reasoning,
+                perceived_threat_level=bid.perceived_threat_level,
+                bid_amount=bid.amount,
+                action=bid,
+            )
+            state.push_event(
+                description=f"Player {bid.actor_id} submitted bid=({bid.amount}).",
+                event_name=EventName.BID_ACTION,
+                public=False,
+                visible_to=[bid.actor_id],
+                data=data,
+                source=bid.actor_id,
+            )
+        else:
+            # Invalid bid amount is treated as a bid of 0
+            self._bids[bid.actor_id] = 0
+            state.push_event(
+                description=f"Player {bid.actor_id} submitted an invalid bid amount ({bid.amount}). Treated as 0.",
+                event_name=EventName.ERROR,
+                public=False,
+                visible_to=[bid.actor_id],
+            )
+
+    def process_incoming_bids(self, actions: List[Action], state: GameState) -> None:
+        for act in actions:
+            if isinstance(act, BidAction):
+                self.accept(act, state)
+
+    def is_finished(self, state: GameState) -> bool:
+        # This bidding round is considered "finished" when all alive players have bid.
+        return len(self._bids) >= len(state.alive_players())
+
+    def outcome(self, state: GameState) -> list[str]:
+        if not self._bids:
+            # If no one bids, deterministically pick the first alive player to speak.
+            alive_players = state.alive_players()
+            return [alive_players[0].id] if alive_players else []
+
+        max_bid = max(self._bids.values())
+        highest_bidders = sorted([pid for pid, amt in self._bids.items() if amt == max_bid])
+
+        if len(highest_bidders) == 1:
+            return highest_bidders
+
+        # Tie-breaking logic
+        candidates = highest_bidders
+
+        # Rule 1: Players mentioned in the last turn
+        mentioned_in_tie = [pid for pid in candidates if pid in self._mentioned_last_turn]
+        if mentioned_in_tie:
+            candidates = mentioned_in_tie
+
+        if len(candidates) == 1:
+            return candidates
+
+        # Rule 2: The least spoken individual
+        speech_counts = Counter(
+            entry.data.actor_id
+            for day_events in state.history.values()
+            for entry in day_events
+            if entry.event_name == EventName.DISCUSSION and isinstance(entry.data, ChatDataEntry)
+        )
+
+        candidate_speech_counts = {pid: speech_counts.get(pid, 0) for pid in candidates}
+        min_spoken = min(candidate_speech_counts.values())
+        least_spoken_candidates = sorted([pid for pid, count in candidate_speech_counts.items() if count == min_spoken])
+
+        if len(least_spoken_candidates) == 1:
+            return least_spoken_candidates
+
+        candidates = least_spoken_candidates
+
+        # Rule 3: Round robin order of the player list in state
+        for pid in state.all_player_ids:
+            if pid in candidates:
+                return [pid]
+
+        # This part should be unreachable if candidates is a subset of all_player_ids
+        return [candidates[0]] if candidates else []