player and game abstraction, moved message level control to player

src/agent_interfaces.py

@@ -21,10 +21,15 @@ class BaseAgentInterface:
 
     def __init__(
             self,
-            agent_id: str = None
+            agent_id: str = None,
+            log_messages: bool = True
     ):
         self.id = agent_id
+        """The id of the agent."""
+        self.log_messages = log_messages
+        """Whether to log messages or not."""
         self.messages = []
+        """The message history of the agent."""
 
     @property
     def is_ai(self):
@@ -33,7 +38,8 @@ class BaseAgentInterface:
     def add_message(self, message: Message):
         """Adds a message to the message history, without generating a response."""
         bound_message = AgentMessage.from_message(message, self.id, len(self.messages))
-        save(bound_message)
+        if self.log_messages:
+            save(bound_message)
         self.messages.append(bound_message)
 
     # Respond To methods - These take a message as input and generate a response
@@ -166,10 +172,6 @@ class HumanAgentInterface(BaseAgentInterface):
 
 class HumanAgentCLI(HumanAgentInterface):
     """A Human agent that uses the command line interface to generate responses."""
-
-    def __init__(self, agent_id: str):
-        super().__init__(agent_id)
-
     def add_message(self, message: Message):
         super().add_message(message)
         if message.type == "verbose":

src/app.py

@@ -3,7 +3,7 @@ from typing import Type
 import streamlit as st
 from streamlit import session_state
 
-from game import ChameleonGame
+from game_chameleon import ChameleonGame
 from agent_interfaces import HumanAgentInterface
 from message import Message
 from prompts import fetch_prompt, format_prompt
@@ -81,7 +81,7 @@ class StreamlitChameleonGame(ChameleonGame):
             self.game_message("All players have spoken. The Chameleon will now guess the secret animal...")
             player_responses = self.format_animal_descriptions(exclude=self.chameleon)
             self.game_message(format_prompt("chameleon_guess_animal", player_responses=player_responses), self.chameleon)
-            if self.players[self.human_index].role == "chameleon":
+            if self.human_player().role == "chameleon":
                 if not session_state.awaiting_human_input:
                     session_state.awaiting_human_input = True
                 else:
@@ -141,7 +141,7 @@ with center:
 
 if user_input:
     if "game" not in st.session_state:
-        st.session_state.game = StreamlitChameleonGame(human_name=user_input, verbose=True, human_interface=StreamlitInterface)
+        st.session_state.game = StreamlitChameleonGame.from_human_name(user_input, StreamlitInterface)
     session_state.user_input = user_input
     st.session_state.game.run_game()
 

src/game.py

@@ -1,92 +1,33 @@
-import os
-from datetime import datetime
-from typing import Optional, Type
-
-from colorama import Fore, Style
+from typing import Optional, Type, List
 
 from game_utils import *
-from output_formats import *
 from player import Player
-from prompts import fetch_prompt, format_prompt
-from message import Message
+from message import Message, MessageType
 from agent_interfaces import HumanAgentCLI, OpenAIAgentInterface, HumanAgentInterface
 
-# Default Values
-NUMBER_OF_PLAYERS = 6
-WINNING_SCORE = 3
-
 
 # Abstracting the Game Class is a WIP so that future games can be added
 class Game:
     """Base class for all games."""
-    def __init__(self, verbose: bool = False, debug: bool = False):
-        self.game_id = game_id()
-        """The unique id of the game."""
-        self.start_time = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
-        """The time the game was started."""
-        self.verbose = verbose
-        """If True, the game will display verbose messages to the player."""
-        self.debug = debug
-        """If True, the game will display debug messages to the player."""
-        self.winner_id: str | None = None
-        """The id of the player who has won the game."""
 
-
-class ChameleonGame(Game):
-    """The main game class, handles the game logic and player interactions."""
-
-    winning_score = WINNING_SCORE
-    """The Number of points required to win the game."""
+    number_of_players: int
+    """The number of players in the game."""
 
     def __init__(
             self,
-            number_of_players: int = NUMBER_OF_PLAYERS,
-            human_name: str = None,
-            human_interface: Type[HumanAgentInterface] = HumanAgentCLI,
-            verbose: bool = False,
-            debug: bool = False
+            game_id: str,
+            players: List[Player],
+            observer: Optional[Player] = None
     ):
-        super().__init__(verbose, debug)
-        # Instance Variables
-        self.chameleon_ids: List[str] = []
-        """Record of which player was the chameleon for each round."""
-        self.herd_animals: List[str] = []
-        """Record of what animal was the herd animal for each round."""
-        self.all_animal_descriptions: List[List[dict]] = []
-        """Record of the animal descriptions each player has given for each round."""
-        self.chameleon_guesses: List[str] = []
-        """Record of what animal the chameleon guessed for each round."""
-        self.herd_vote_tallies: List[List[dict]] = []
-        """Record of the votes of each herd member for the chameleon for each round."""
-
-        # Gather Player Names
-        if human_name:
-            ai_names = random_names(number_of_players - 1, human_name)
-            self.human_index = random_index(number_of_players)
-        else:
-            ai_names = random_names(number_of_players)
-            self.human_index = None
-
-        # Add Players
-        self.players = []
-
-        for i in range(0, number_of_players):
-            player_id = f"{self.game_id}-{i + 1}"
-
-            if self.human_index == i:
-                name = human_name
-                interface = human_interface(player_id)
-            else:
-                name = ai_names.pop()
-                interface = OpenAIAgentInterface(player_id)
-
-            self.players.append(Player(name, player_id, interface))
+        self.players: List[Player] = players
+        """The players in the game."""
+        self.observer: Optional[Player] = observer
+        """An observer who can see all public messages, but doesn't actually play."""
+        self.game_id = game_id
+        """The unique id of the game."""
 
-        # Add Observer - an Agent who can see all the messages, but doesn't actually play
-        if (self.verbose or self.debug) and self.human_index is None:
-            self.observer = human_interface(f"{self.game_id}-observer")
-        else:
-            self.observer = None
+        self.winner_id: str | None = None
+        """The id of the player who has won the game."""
 
     def player_from_id(self, player_id: str) -> Player:
         """Returns a player from their ID."""
@@ -96,236 +37,99 @@ class ChameleonGame(Game):
         """Returns a player from their name."""
         return next((player for player in self.players if player.name == name), None)
 
-    @property
-    def chameleon(self) -> Player:
-        """Returns the current chameleon."""
-        return self.player_from_id(self.chameleon_ids[-1])
-
-    @property
-    def herd_animal(self) -> str:
-        """Returns the current herd animal."""
-        return self.herd_animals[-1]
-
-    @property
-    def round_animal_descriptions(self) -> List[dict]:
-        """Returns the current animal descriptions."""
-        return self.all_animal_descriptions[-1]
-
-    @property
-    def chameleon_guess(self) -> str:
-        """Returns the current chameleon guess."""
-        return self.chameleon_guesses[-1]
-
-    @property
-    def herd_vote_tally(self) -> List[dict]:
-        """Returns the current herd vote tally."""
-        return self.herd_vote_tallies[-1]
-
-    @property
-    def round_number(self) -> int:
-        """Returns the current round number."""
-        return len(self.herd_animals)
-
-    def format_animal_descriptions(self, exclude: Player = None) -> str:
-        """Formats the animal description responses of the players into a single string."""
-        formatted_responses = ""
-        for response in self.round_animal_descriptions:
-            # Used to exclude the player who is currently responding, so they don't vote for themselves like a fool
-            if response["player_id"] != exclude.id:
-                player = self.player_from_id(response["player_id"])
-                formatted_responses += f" - {player.name}: {response['description']}\n"
-
-        return formatted_responses
-
-    def observer_message(self, message: Message):
-        """Sends a message to the observer if there is one."""
-        if self.observer:
-            self.observer.add_message(message)
+    def human_player(self) -> Player:
+        """Returns the human player."""
+        return next((player for player in self.players if player.interface.is_human), None)
 
     def game_message(
-            self, content: str,
+            self,
+            content: str,
             recipient: Optional[Player] = None,  # If None, message is broadcast to all players
-            exclude: bool = False  # If True, the message is broadcast to all players except the chosen player
+            exclude: bool = False,  # If True, the message is broadcast to all players except the chosen player
+            message_type: MessageType = "info"
     ):
-        """Sends a message to a player. No response is expected, however it will be included next time the player is prompted"""
-        message = Message(type="info", content=content)
+        """
+        Sends a message to a player or all players.
+        If no recipient is specified, the message is broadcast to all players.
+        If exclude is True, the message is broadcast to all players except the recipient.
+        Some message types are only available to player with access (e.g. verbose, debug).
+        """
+        message = Message(type=message_type, content=content)
 
         if exclude or not recipient:
-            for player in self.players:
-                if player != recipient:
+            for player in self.players + [self.observer] if self.observer else self.players:
+                if player != recipient and player.can_receive_message(message_type):
                     player.interface.add_message(message)
-            self.observer_message(message)
         else:
             recipient.interface.add_message(message)
 
-    def verbose_message(self, content: str):
-        """Sends a message for the human player to read. No response is expected."""
-        if self.verbose:
-            message = Message(type="verbose", content=content)
-            if self.human_index:
-                self.players[self.human_index].interface.add_message(message)
-            self.observer_message(message)
-
-    def debug_message(self, content: str):
-        """Sends a message for a human observer. These messages contain secret information about the players such as their role."""
-        if self.debug:
-            message = Message(type="debug", content=content)
-            if self.human_index:
-                self.players[self.human_index].interface.add_message(message)
-            self.observer_message(message)
+    def verbose_message(self, content: str, **kwargs):
+        """
+        Sends a verbose message to all players capable of receiving them.
+        Verbose messages are used to communicate in real time what is happening that cannot be seen publicly.
 
+        Ex: "Abby is thinking..."
+        """
+        self.game_message(content, **kwargs, message_type="verbose")
 
-    async def run_game(self):
-        """Sets up the game. This includes assigning roles and gathering player names."""
-        self.game_message(fetch_prompt("game_rules"))
+    def debug_message(self, content: str, **kwargs):
+        """
+        Sends a debug message to all players capable of receiving them.
+        Debug messages usually contain secret information and should only be sent when it wouldn't spoil the game.
 
-        self.setup_round()
+        Ex: "Abby is the chameleon."
+        """
+        self.game_message(content, **kwargs, message_type="debug")
 
-        self.run_round()
+    def run_game(self):
+        """Runs the game."""
+        raise NotImplementedError("The run_game method must be implemented by the subclass.")
 
-        self.resolve_round()
+    @classmethod
+    def from_human_name(
+            cls, human_name: str = None,
+            human_interface: Type[HumanAgentInterface] = HumanAgentCLI,
+            human_message_level: str = "verbose"
+    ):
+        """
+        Instantiates a game with a human player if a name is provided.
+        Otherwise, the game is instantiated with all AI players and an observer.
+        """
+        game_id = generate_game_id()
 
-        # # Log Game Info
-        # game_log = {
-        #     "game_id": self.game_id,
-        #     "start_time": self.start_time,
-        #     "number_of_players": len(self.players),
-        #     "human_player": self.players[self.human_index].id if self.human_index else "None",
-        # }
+        # Gather Player Names
+        if human_name:
+            ai_names = random_names(cls.number_of_players - 1, human_name)
+            human_index = random_index(cls.number_of_players)
+        else:
+            ai_names = random_names(cls.number_of_players)
+            human_index = None
 
-    def setup_round(self):
-        """Sets up the round. This includes assigning roles and gathering player names."""
-        # Choose Animal
-        herd_animal = random_animal()
-        self.herd_animals.append(herd_animal)
-        self.debug_message(f"The secret animal is {herd_animal}.")
+        # Add Players
+        players = []
 
-        # Assign Roles
-        chameleon_index = random_index(len(self.players))
-        self.chameleon_ids.append(self.players[chameleon_index].id)
+        for i in range(0, cls.number_of_players):
+            player_id = f"{game_id}-{i + 1}"
 
-        for i, player in enumerate(self.players):
-            if i == chameleon_index:
-                player.assign_role("chameleon")
-                self.game_message(fetch_prompt("assign_chameleon"), player)
-                self.debug_message(f"{player.name} is the Chameleon!")
+            if human_index == i:
+                name = human_name
+                interface = human_interface(player_id)
+                message_level = human_message_level
             else:
-                player.assign_role("herd")
-                self.game_message(format_prompt("assign_herd", herd_animal=herd_animal), player)
-
-        # Empty Animal Descriptions
-        self.all_animal_descriptions.append([])
-
-        # Empty Tally for Votes
-        self.herd_vote_tallies.append([])
-
-        self.game_message(f"Each player will now take turns describing themselves:")
-
-    def run_round(self):
-        """Starts the round."""
-        # Phase I: Collect Player Animal Descriptions
-        for current_player in self.players:
-            self.game_message(fetch_prompt("player_describe_animal"), current_player)
-            self.player_turn_animal_description(current_player)
-
-        # Phase II: Chameleon Guesses the Animal
-        self.game_message("All players have spoken. The Chameleon will now guess the secret animal...")
-        player_responses = self.format_animal_descriptions(exclude=self.chameleon)
-        self.game_message(format_prompt("chameleon_guess_animal", player_responses=player_responses), self.chameleon)
-        self.player_turn_chameleon_guess(self.chameleon)
-
-        # Phase III: The Herd Votes for who they think the Chameleon is
-        for current_player in self.players:
-            if current_player.role == "herd":
-                player_responses = self.format_animal_descriptions(exclude=current_player)
-                self.game_message(format_prompt("vote", player_responses=player_responses), current_player)
-                self.player_turn_herd_vote(current_player)
-
-    def player_turn_animal_description(self, player: Player):
-        """Handles a player's turn to describe themselves."""
-        if player.interface.is_ai:
-            self.verbose_message(f"{player.name} is thinking...")
-
-        prompt = fetch_prompt("player_describe_animal")
-
-        # Get Player Animal Description
-        response = player.interface.generate_formatted_response(AnimalDescriptionFormat)
-
-        self.round_animal_descriptions.append({"player_id": player.id, "description": response.description})
-
-        self.game_message(f"{player.name}: {response.description}", player, exclude=True)
-
-    def player_turn_chameleon_guess(self, chameleon: Player):
-        """Handles the Chameleon's turn to guess the secret animal."""
-
-        if chameleon.interface.is_ai or self.observer:
-            self.verbose_message("The Chameleon is thinking...")
-
-        response = chameleon.interface.generate_formatted_response(ChameleonGuessFormat)
-
-        self.game_message("The Chameleon has guessed the animal. Now the Herd will vote on who they think the chameleon is.")
-
-        self.chameleon_guesses.append(response.animal)
-
-    def player_turn_herd_vote(self, player: Player):
-        """Handles a player's turn to vote for the Chameleon."""
-        if player.interface.is_ai:
-            self.verbose_message(f"{player.name} is thinking...")
-
-        # Get Player Vote
-        additional_fields = {"player_names": [p.name for p in self.players if p != player]}
-        response = player.interface.generate_formatted_response(HerdVoteFormat, additional_fields=additional_fields)
-
-        if player.interface.is_ai:
-            self.debug_message(f"{player.name} voted for {response.vote}")
-
-        voted_for_player = self.player_from_name(response.vote)
-
-        # Add Vote to Player Votes
-        self.herd_vote_tally.append({"voter_id": player.id, "voted_for_id": voted_for_player.id})
-
-    def resolve_round(self):
-        """Resolves the round, assigns points, and prints the results."""
-        self.game_message("All players have voted!")
-        for vote in self.herd_vote_tally:
-            voter = self.player_from_id(vote["voter_id"])
-            voted_for = self.player_from_id(vote["voted_for_id"])
-            self.game_message(f"{voter.name} voted for {voted_for.name}")
-
-        accused_player_id = count_chameleon_votes(self.herd_vote_tally)
-
-        self.game_message(f"The round is over. Calculating results...")
-        self.game_message(
-            f"The Chameleon was {self.chameleon.name}, and they guessed the secret animal was {self.chameleon_guess}.")
-        self.game_message(f"The secret animal was actually was {self.herd_animal}.")
-
-        if accused_player_id:
-            accused_name = self.player_from_id(accused_player_id).name
-            self.game_message(f"The Herd voted for {accused_name} as the Chameleon.")
-        else:
-            self.game_message(f"The Herd could not come to a consensus.")
+                name = ai_names.pop()
+                # all AI players use the OpenAI interface for now - this can be changed in the future
+                interface = OpenAIAgentInterface(player_id)
+                message_level = "info"
 
-        # Point Logic
-        # If the Chameleon guesses the correct animal    =   +1 Point to the Chameleon
-        if self.chameleon_guess.lower() == self.herd_animal.lower():
-            self.chameleon.points += 1
+            players.append(Player(name, player_id, interface, message_level))
 
-        # If the Chameleon guesses the incorrect animal  =   +1 Point to each Herd player
+        # Add Observer - an Agent who can see all the messages, but doesn't actually play
+        if human_index is None:
+            observer = Player.observer(game_id, interface_type=human_interface)
         else:
-            for player in self.players:
-                if player.role == "herd":
-                    player.points += 1
-        # If a Herd player votes for the Chameleon       =   +1 Point to that player
-        for vote in self.herd_vote_tally:
-            if vote["voted_for_id"] == self.chameleon.id:
-                self.player_from_id(vote['voter_id']).points += 1
+            observer = None
 
-        # If the Herd fails to accuse the Chameleon      =   +1 Point to the Chameleon
-        if not accused_player_id or accused_player_id != self.chameleon.id:
-            self.chameleon.points += 1
+        return cls(game_id, players, observer)
 
-        # Print Scores
-        player_points = "\n".join([f"{player.name}: {player.points}" for player in self.players])
-        self.game_message(f"Current Game Score:\n{player_points}")
 
 

src/game_chameleon.py

@@ -0,0 +1,237 @@
+from typing import Optional, Type
+
+from game_utils import random_index
+from game_utils_chameleon import *
+from output_formats import *
+from player import ChameleonPlayer, Player
+from prompts import fetch_prompt, format_prompt
+from message import Message, MessageType
+from agent_interfaces import HumanAgentCLI, OpenAIAgentInterface, HumanAgentInterface
+from game import Game
+
+# Default Values
+NUMBER_OF_PLAYERS = 6
+WINNING_SCORE = 3
+
+
+class ChameleonGame(Game):
+    """The main game class, handles the game logic and player interactions."""
+
+    number_of_players = NUMBER_OF_PLAYERS
+
+    winning_score = WINNING_SCORE
+    """The Number of points required to win the game."""
+
+    def __init__(self, *args, **kwargs):
+
+        super().__init__(*args, **kwargs)
+
+        # Convert the Players to ChameleonPlayers
+        self.players: List[ChameleonPlayer] = [ChameleonPlayer.from_player(player) for player in self.players]
+
+        # Instance Variables
+        self.chameleon_ids: List[str] = []
+        """Record of which player was the chameleon for each round."""
+        self.herd_animals: List[str] = []
+        """Record of what animal was the herd animal for each round."""
+        self.all_animal_descriptions: List[List[dict]] = []
+        """Record of the animal descriptions each player has given for each round."""
+        self.chameleon_guesses: List[str] = []
+        """Record of what animal the chameleon guessed for each round."""
+        self.herd_vote_tallies: List[List[dict]] = []
+        """Record of the votes of each herd member for the chameleon for each round."""
+
+
+
+    @property
+    def chameleon(self) -> ChameleonPlayer:
+        """Returns the current chameleon."""
+        return self.player_from_id(self.chameleon_ids[-1])
+
+    @property
+    def herd_animal(self) -> str:
+        """Returns the current herd animal."""
+        return self.herd_animals[-1]
+
+    @property
+    def round_animal_descriptions(self) -> List[dict]:
+        """Returns the current animal descriptions."""
+        return self.all_animal_descriptions[-1]
+
+    @property
+    def chameleon_guess(self) -> str:
+        """Returns the current chameleon guess."""
+        return self.chameleon_guesses[-1]
+
+    @property
+    def herd_vote_tally(self) -> List[dict]:
+        """Returns the current herd vote tally."""
+        return self.herd_vote_tallies[-1]
+
+    @property
+    def round_number(self) -> int:
+        """Returns the current round number."""
+        return len(self.herd_animals)
+
+    def format_animal_descriptions(self, exclude: Player = None) -> str:
+        """Formats the animal description responses of the players into a single string."""
+        formatted_responses = ""
+        for response in self.round_animal_descriptions:
+            # Used to exclude the player who is currently responding, so they don't vote for themselves like a fool
+            if response["player_id"] != exclude.id:
+                player = self.player_from_id(response["player_id"])
+                formatted_responses += f" - {player.name}: {response['description']}\n"
+
+        return formatted_responses
+
+    async def run_game(self):
+        """Sets up the game. This includes assigning roles and gathering player names."""
+        self.game_message(fetch_prompt("game_rules"))
+
+        self.setup_round()
+
+        self.run_round()
+
+        self.resolve_round()
+
+        # # Log Game Info
+        # game_log = {
+        #     "game_id": self.game_id,
+        #     "start_time": self.start_time,
+        #     "number_of_players": len(self.players),
+        #     "human_player": self.players[self.human_index].id if self.human_index else "None",
+        # }
+
+    def setup_round(self):
+        """Sets up the round. This includes assigning roles and gathering player names."""
+        # Choose Animal
+        herd_animal = random_animal()
+        self.herd_animals.append(herd_animal)
+        self.debug_message(f"The secret animal is {herd_animal}.")
+
+        # Assign Roles
+        chameleon_index = random_index(len(self.players))
+        self.chameleon_ids.append(self.players[chameleon_index].id)
+
+        for i, player in enumerate(self.players):
+            if i == chameleon_index:
+                player.assign_role("chameleon")
+                self.game_message(fetch_prompt("assign_chameleon"), player)
+                self.debug_message(f"{player.name} is the Chameleon!")
+            else:
+                player.assign_role("herd")
+                self.game_message(format_prompt("assign_herd", herd_animal=herd_animal), player)
+
+        # Empty Animal Descriptions
+        self.all_animal_descriptions.append([])
+
+        # Empty Tally for Votes
+        self.herd_vote_tallies.append([])
+
+        self.game_message(f"Each player will now take turns describing themselves:")
+
+    def run_round(self):
+        """Starts the round."""
+        # Phase I: Collect Player Animal Descriptions
+        for current_player in self.players:
+            self.game_message(fetch_prompt("player_describe_animal"), current_player)
+            self.player_turn_animal_description(current_player)
+
+        # Phase II: Chameleon Guesses the Animal
+        self.game_message("All players have spoken. The Chameleon will now guess the secret animal...")
+        player_responses = self.format_animal_descriptions(exclude=self.chameleon)
+        self.game_message(format_prompt("chameleon_guess_animal", player_responses=player_responses), self.chameleon)
+        self.player_turn_chameleon_guess(self.chameleon)
+
+        # Phase III: The Herd Votes for who they think the Chameleon is
+        for current_player in self.players:
+            if current_player.role == "herd":
+                player_responses = self.format_animal_descriptions(exclude=current_player)
+                self.game_message(format_prompt("vote", player_responses=player_responses), current_player)
+                self.player_turn_herd_vote(current_player)
+
+    def player_turn_animal_description(self, player: Player):
+        """Handles a player's turn to describe themselves."""
+        if player.interface.is_ai:
+            self.verbose_message(f"{player.name} is thinking...")
+
+        prompt = fetch_prompt("player_describe_animal")
+
+        # Get Player Animal Description
+        response = player.interface.generate_formatted_response(AnimalDescriptionFormat)
+
+        self.round_animal_descriptions.append({"player_id": player.id, "description": response.description})
+
+        self.game_message(f"{player.name}: {response.description}", player, exclude=True)
+
+    def player_turn_chameleon_guess(self, chameleon: Player):
+        """Handles the Chameleon's turn to guess the secret animal."""
+
+        if chameleon.interface.is_ai or self.observer:
+            self.verbose_message("The Chameleon is thinking...")
+
+        response = chameleon.interface.generate_formatted_response(ChameleonGuessFormat)
+
+        self.game_message("The Chameleon has guessed the animal. Now the Herd will vote on who they think the chameleon is.")
+
+        self.chameleon_guesses.append(response.animal)
+
+    def player_turn_herd_vote(self, player: Player):
+        """Handles a player's turn to vote for the Chameleon."""
+        if player.interface.is_ai:
+            self.verbose_message(f"{player.name} is thinking...")
+
+        # Get Player Vote
+        additional_fields = {"player_names": [p.name for p in self.players if p != player]}
+        response = player.interface.generate_formatted_response(HerdVoteFormat, additional_fields=additional_fields)
+
+        self.debug_message(f"{player.name} voted for {response.vote}", recipient=player, exclude=True)
+
+        voted_for_player = self.player_from_name(response.vote)
+
+        # Add Vote to Player Votes
+        self.herd_vote_tally.append({"voter_id": player.id, "voted_for_id": voted_for_player.id})
+
+    def resolve_round(self):
+        """Resolves the round, assigns points, and prints the results."""
+        self.game_message("All players have voted!")
+        for vote in self.herd_vote_tally:
+            voter = self.player_from_id(vote["voter_id"])
+            voted_for = self.player_from_id(vote["voted_for_id"])
+            self.game_message(f"{voter.name} voted for {voted_for.name}")
+
+        accused_player_id = count_chameleon_votes(self.herd_vote_tally)
+
+        self.game_message(f"The round is over. Calculating results...")
+        self.game_message(
+            f"The Chameleon was {self.chameleon.name}, and they guessed the secret animal was {self.chameleon_guess}.")
+        self.game_message(f"The secret animal was actually was {self.herd_animal}.")
+
+        if accused_player_id:
+            accused_name = self.player_from_id(accused_player_id).name
+            self.game_message(f"The Herd voted for {accused_name} as the Chameleon.")
+        else:
+            self.game_message(f"The Herd could not come to a consensus.")
+
+        # Point Logic
+        # If the Chameleon guesses the correct animal    =   +1 Point to the Chameleon
+        if self.chameleon_guess.lower() == self.herd_animal.lower():
+            self.chameleon.points += 1
+
+        # If the Chameleon guesses the incorrect animal  =   +1 Point to each Herd player
+        else:
+            for player in self.players:
+                if player.role == "herd":
+                    player.points += 1
+        # If a Herd player votes for the Chameleon       =   +1 Point to that player
+        for vote in self.herd_vote_tally:
+            if vote["voted_for_id"] == self.chameleon.id:
+                self.player_from_id(vote['voter_id']).points += 1
+
+        # If the Herd fails to accuse the Chameleon      =   +1 Point to the Chameleon
+        if not accused_player_id or accused_player_id != self.chameleon.id:
+            self.chameleon.points += 1
+
+        # Print Scores
+        player_points = "\n".join([f"{player.name}: {player.points}" for player in self.players])
+        self.game_message(f"Current Game Score:\n{player_points}")

src/game_utils.py

@@ -1,54 +1,26 @@
-"""
-Utilities for the game including random selections and prompts.
-"""
-import random
 import string
-import json
-from collections import Counter
+import random
 
+# Utilities
 ALPHABET = string.ascii_lowercase + string.digits
 ID_LENGTH = 8
+AVAILABLE_NAMES = ["Jack", "Jill", "Bob", "Courtney", "Fizz", "Mallory"]
 
 
-def game_id():
-    return ''.join(random.choices(ALPHABET, k=ID_LENGTH)) # Using this instead of uuid for shorter game ids
-
-
-def random_animal():
-    return random.choice(available_animals)
+def generate_game_id():
+    """Generates a unique game id."""
+    alphabet = string.ascii_lowercase + string.digits
+    id_length = 8
 
-
-available_animals = ["Giraffe", "Elephant", "Lion", "Zebra", "Monkey", "Gorilla"]
+    return ''.join(random.choices(alphabet, k=id_length))  # Using this instead of uuid for shorter game ids
 
 
 def random_names(number_of_samples: int, human_name: str = None) -> list[str]:
     """Returns a list of random names, excluding the one of the human player (if provided)"""
-    if human_name and human_name in available_names:
-        available_names.remove(human_name)
-    return random.sample(available_names, number_of_samples)
-
-
-available_names = ["Jack", "Jill", "Bob", "Courtney", "Fizz", "Mallory"]
-
-
-def random_index(number_of_players : int) -> int:
-    return random.randint(0, number_of_players - 1)
-
-
-def count_chameleon_votes(player_votes: list[dict]) -> str | None:
-    """Counts the votes for each player."""
-    votes = [vote['voted_for_id'] for vote in player_votes]
-
-    freq = Counter(votes)
-    most_voted_player, number_of_votes = freq.most_common()[0]
-
-    # If one player has more than 50% of the votes, the herd accuses them of being the chameleon
-    if number_of_votes / len(player_votes) >= 0.5:
-        return most_voted_player
-    else:
-        return None
+    if human_name and human_name in AVAILABLE_NAMES:
+        AVAILABLE_NAMES.remove(human_name)
+    return random.sample(AVAILABLE_NAMES, number_of_samples)
 
 
-def log(log_object, log_file):
-    with open(log_file, "a+") as f:
-        f.write(json.dumps(log_object) + "\n")
+def random_index(number_of_players: int) -> int:
+    return random.randint(0, number_of_players - 1)

src/game_utils_chameleon.py

@@ -0,0 +1,28 @@
+"""
+Utilities for the game including random selections and prompts.
+"""
+import random
+import string
+import json
+from collections import Counter
+
+
+def random_animal():
+    return random.choice(available_animals)
+
+
+available_animals = ["Giraffe", "Elephant", "Lion", "Zebra", "Monkey", "Gorilla"]
+
+
+def count_chameleon_votes(player_votes: list[dict]) -> str | None:
+    """Counts the votes for each player."""
+    votes = [vote['voted_for_id'] for vote in player_votes]
+
+    freq = Counter(votes)
+    most_voted_player, number_of_votes = freq.most_common()[0]
+
+    # If one player has more than 50% of the votes, the herd accuses them of being the chameleon
+    if number_of_votes / len(player_votes) >= 0.5:
+        return most_voted_player
+    else:
+        return None

src/main.py

@@ -1,4 +1,4 @@
-from game import ChameleonGame
+from game_chameleon import ChameleonGame
 from player import Player
 import asyncio
 from player import Player
@@ -7,10 +7,7 @@ def main():
     print("Please Enter your name, or leave blank to run an AI only game")
     name = input()
 
-    if name:
-        game = ChameleonGame(human_name=name, verbose=True)
-    else:
-        game = ChameleonGame(verbose=True)
+    game = ChameleonGame.from_human_name(name)
 
     asyncio.run(game.run_game())
 

src/message.py

@@ -3,6 +3,7 @@ from pydantic import BaseModel, computed_field
 
 MessageType = Literal["prompt", "info", "agent", "retry", "error", "format", "verbose", "debug"]
 
+
 class Message(BaseModel):
     """A generic message, these are used to communicate between the game and the players."""
 

src/player.py

@@ -1,38 +1,87 @@
-from typing import Literal
-import logging
+from typing import Literal, List, Type
 
-from agent_interfaces import AgentInterface
+from agent_interfaces import AgentInterface, HumanAgentCLI, BaseAgentInterface
+from message import MessageType
 
 Role = Literal["chameleon", "herd"]
 
-logging.basicConfig(level=logging.WARNING)
-logger = logging.getLogger("chameleon")
-
 
+# Abstraction is a WIP and a little premature, but I'd like to reuse this framework to create more Games in the future
 class Player:
+    """Base class for a player"""
 
-    role: Role | None = None
-    """The role of the player in the game. Can be "chameleon" or "herd". This changes every round."""
-    rounds_played_as_chameleon: int = 0
-    """The number of times the player has been the Chameleon."""
-    rounds_played_as_herd: int = 0
-    """The number of times the player has been in the Herd."""
-    points: int = 0
-    """The number of points the player has."""
-
-    def __init__(
-            self,
-            name: str,
-            player_id: str,
-            interface: AgentInterface
-    ):
+    def __init__(self,
+                 name: str,
+                 player_id: str,
+                 interface: BaseAgentInterface,
+                 message_level: str = "info"
+                 ):
         self.name = name
+        """The name of the player."""
         self.id = player_id
+        """The id of the player."""
         self.interface = interface
+        """The interface used by the agent controlling the player to communicate with the game."""
+        self.message_level = message_level
+        """The level of messages that the player will receive. Can be "info", "verbose", or "debug"."""
+
+    def can_receive_message(self, message_type: MessageType) -> bool:
+        """Returns True if the player can receive a message of the type."""
+        if message_type == "verbose" and self.message_level not in ["verbose", "debug"]:
+            return False
+        elif message_type == "debug" and self.message_level != "debug":
+            return False
+        else:
+            return True
+
+    @classmethod
+    def observer(
+            cls,
+            game_id: str,
+            message_level: str = "verbose",
+            interface_type: Type[BaseAgentInterface] = HumanAgentCLI,
+            log_messages: bool = False
+    ):
+        """Creates an observer player."""
+        name = "Observer"
+        player_id = f"{game_id}_observer"
+        interface = interface_type(player_id, log_messages)
+
+        return cls(name, player_id, interface, message_level)
+
+
+class PlayerSubclass(Player):
+    @classmethod
+    def from_player(cls, player: Player):
+        """Creates a new instance of the subclass from a player instance."""
+        return cls(player.name, player.id, player.interface, player.message_level)
+
+
+class ChameleonPlayer(PlayerSubclass):
+    """A player in the game Chameleon"""
+
+    def __init__(self, *args, **kwargs):
+        super().__init__(*args, **kwargs)
+
+        self.points: int = 0
+        """The number of points the player has."""
+        self.roles: List[Role] = []
+        """The role of the player in the game. Can be "chameleon" or "herd". This changes every round."""
 
     def assign_role(self, role: Role):
-        self.role = role
-        if role == "chameleon":
-            self.rounds_played_as_chameleon += 1
-        elif role == "herd":
-            self.rounds_played_as_herd += 1
+        self.roles.append(role)
+
+    @property
+    def role(self) -> Role:
+        """The current role of the player."""
+        return self.roles[-1]
+
+    @property
+    def rounds_played_as_chameleon(self) -> int:
+        """The number of times the player has been the Chameleon."""
+        return self.roles.count("chameleon")
+
+    @property
+    def rounds_played_as_herd(self) -> int:
+        """The number of times the player has been in the Herd."""
+        return self.roles.count("herd")