streamlit game updates

src/agent_interfaces.py

@@ -63,11 +63,15 @@ class BaseAgentInterface:
 
     # Generate response methods - These do not take a message as input and only use the current message history
 
-    def generate_response(self) -> Message:
+    def generate_response(self) -> Message | None:
         """Generates a response based on the current messages in the history."""
-        response = Message(type="agent", content=self._generate())
-        self.add_message(response)
-        return response
+        content = self._generate()
+        if content:
+            response = Message(type="agent", content=content)
+            self.add_message(response)
+            return response
+        else:
+            return None
 
     def generate_formatted_response(
             self,
@@ -158,14 +162,18 @@ class HumanAgentInterface(BaseAgentInterface):
             output_format: Type[OutputFormatModel],
             additional_fields: dict = None,
             max_retries: int = 3
-    ) -> OutputFormatModel:
+    ) -> OutputFormatModel | None:
         """For Human agents, we can trust them enough to format their own responses... for now"""
         response = self.generate_response()
-        # only works because current outputs have only 1 field...
-        fields = {output_format.model_fields.copy().popitem()[0]: response.content}
-        if additional_fields:
-            fields.update(additional_fields)
-        output = output_format.model_validate(fields)
+
+        if response:
+            # only works because current outputs have only 1 field...
+            fields = {output_format.model_fields.copy().popitem()[0]: response.content}
+            if additional_fields:
+                fields.update(additional_fields)
+            output = output_format.model_validate(fields)
+        else:
+            output = None
 
         return output
 

src/app.py

@@ -22,8 +22,7 @@ def display_message(message: Message):
 
 if "messages" not in session_state:
     session_state.messages = []
-    session_state.awaiting_human_input = False
-    session_state.game_state = "game_start"
+    session_state.user_input = None
 
 
 class StreamlitInterface(HumanAgentInterface):
@@ -33,7 +32,9 @@ class StreamlitInterface(HumanAgentInterface):
         display_message(message)
 
     def _generate(self) -> str:
-        return session_state.user_input
+        response = session_state.user_input
+        session_state.user_input = None
+        return response
 
 
 class StreamlitChameleonGame(ChameleonGame):
@@ -42,76 +43,50 @@ class StreamlitChameleonGame(ChameleonGame):
     def run_game(self):
         """Starts the game."""
 
-        if session_state.game_state == "game_start":
+        if self.game_state == "game_start":
             self.game_message(fetch_prompt("game_rules"))
-            session_state.game_state = "setup_round"
-        if session_state.game_state == "setup_round":
+            self.game_state = "setup_round"
+        if self.game_state == "setup_round":
             self.setup_round()
-            session_state.game_state = "animal_description"
-        if session_state.game_state in ["animal_description", "chameleon_guess", "herd_vote"]:
+            self.game_state = "animal_description"
+        if self.game_state in ["animal_description", "chameleon_guess", "herd_vote"]:
             self.run_round()
-        if session_state.game_state == "resolve_round":
+        if self.game_state == "resolve_round":
             self.resolve_round()
-            session_state.game_state = "setup_round"
+            self.game_state = "setup_round"
 
     def run_round(self):
         """Starts the round."""
 
         # Phase I: Collect Player Animal Descriptions
-        if session_state.game_state == "animal_description":
+        if self.game_state == "animal_description":
             for current_player in self.players:
                 if current_player.id not in [animal_description['player_id'] for animal_description in self.round_animal_descriptions]:
-                    if current_player.interface.is_human:
-                        if not session_state.awaiting_human_input:
-                            self.game_message(fetch_prompt("player_describe_animal"), current_player)
-                            session_state.awaiting_human_input = True
-                            break
-                        else:
-                            self.player_turn_animal_description(current_player)
-                            session_state.awaiting_human_input = False
-                    else:
-                        self.game_message(fetch_prompt("player_describe_animal"), current_player)
-                        self.player_turn_animal_description(current_player)
+
+                    response = self.player_turn_animal_description(current_player)
+
+                    if not response:
+                        break
+
             if len(self.round_animal_descriptions) == len(self.players):
-                session_state.game_state = "chameleon_guess"
-                session_state.awaiting_human_input = False
+                self.game_state = "chameleon_guess"
 
         # Phase II: Chameleon Guesses the Animal
-        if session_state.game_state == "chameleon_guess":
-            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.human_player().role == "chameleon":
-                if not session_state.awaiting_human_input:
-                    session_state.awaiting_human_input = True
-                else:
-                    self.player_turn_chameleon_guess(self.chameleon)
-                    session_state.awaiting_human_input = False
-            else:
-                self.player_turn_chameleon_guess(self.chameleon)
-                session_state.awaiting_human_input = False
-
-            session_state.game_state = "herd_vote"
+        if self.game_state == "chameleon_guess":
+            self.player_turn_chameleon_guess(self.chameleon)
 
         # Phase III: The Herd Votes for who they think the Chameleon is
-        if session_state.game_state == "herd_vote":
+        if self.game_state == "herd_vote":
             for current_player in self.players:
                 if current_player.role == "herd" and current_player.id not in [vote['voter_id'] for vote in self.herd_vote_tally]:
-                    player_responses = self.format_animal_descriptions(exclude=current_player)
-                    if current_player.interface.is_human:
-                        if not session_state.awaiting_human_input:
-                            self.game_message(format_prompt("vote", player_responses=player_responses), current_player)
-                            session_state.awaiting_human_input = True
-                            break
-                        else:
-                            self.player_turn_herd_vote(current_player)
-                            session_state.awaiting_human_input = False
-                    else:
-                        self.game_message(format_prompt("vote", player_responses=player_responses), current_player)
-                        self.player_turn_herd_vote(current_player)
+
+                    response = self.player_turn_herd_vote(current_player)
+
+                    if not response:
+                        break
 
             if len(self.herd_vote_tally) == len(self.players) - 1:
-                session_state.game_state = "resolve_round"
+                self.game_state = "resolve_round"
 
 
 # Streamlit App
@@ -142,7 +117,9 @@ with center:
 if user_input:
     if "game" not in st.session_state:
         st.session_state.game = StreamlitChameleonGame.from_human_name(user_input, StreamlitInterface)
-    session_state.user_input = user_input
+    else:
+        session_state.user_input = user_input
+
     st.session_state.game.run_game()
 
 st.markdown("#")

src/game.py

@@ -28,6 +28,9 @@ class Game:
 
         self.winner_id: str | None = None
         """The id of the player who has won the game."""
+        self.game_state: str = "game_start"
+        """Keeps track of the current state of the game."""
+        self.awaiting_input: bool = False
 
     def player_from_id(self, player_id: str) -> Player:
         """Returns a player from their ID."""

src/game_chameleon.py

@@ -152,45 +152,67 @@ class ChameleonGame(Game):
 
     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")
+        if not self.awaiting_input:
+            self.verbose_message(f"{player.name} is thinking...", recipient=player, exclude=True)
+            self.game_message(fetch_prompt("player_describe_animal"), player)
 
         # Get Player Animal Description
         response = player.interface.generate_formatted_response(AnimalDescriptionFormat)
 
-        self.round_animal_descriptions.append({"player_id": player.id, "description": response.description})
+        if response:
+            self.round_animal_descriptions.append({"player_id": player.id, "description": response.description})
+            self.game_message(f"{player.name}: {response.description}", player, exclude=True)
+            self.awaiting_input = False
+        else:
+            self.awaiting_input = True
 
-        self.game_message(f"{player.name}: {response.description}", player, exclude=True)
+        return response
 
     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...")
+        if not self.awaiting_input:
+            self.game_message("All players have spoken. The Chameleon will now guess the secret animal...")
+            self.verbose_message("The Chameleon is thinking...", recipient=chameleon, exclude=True)
+            player_responses = self.format_animal_descriptions(exclude=self.chameleon)
+            self.game_message(format_prompt("chameleon_guess_animal", player_responses=player_responses),
+                              self.chameleon)
 
         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)
+        if response:
+            self.chameleon_guesses.append(response.animal)
+            self.game_message(
+                "The Chameleon has guessed the animal. Now the Herd will vote on who they think the chameleon is.")
+            self.awaiting_input = False
+            self.game_state = "herd_vote"
+        else:
+            # Await input and do not proceed to the next phase
+            self.awaiting_input = True
 
     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...")
+        if not self.awaiting_input:
+            self.verbose_message(f"{player.name} is thinking...", recipient=player, exclude=True)
+            player_responses = self.format_animal_descriptions(exclude=player)
+            self.game_message(format_prompt("vote", player_responses=player_responses), player)
 
         # 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)
+        if response:
+            self.debug_message(f"{player.name} voted for {response.vote}", recipient=player, exclude=True)
+
+            voted_for_player = self.player_from_name(response.vote)
 
-        voted_for_player = self.player_from_name(response.vote)
+            player_vote = {"voter_id": player.id, "voted_for_id": voted_for_player.id}
+
+            self.herd_vote_tally.append(player_vote)
+            self.awaiting_input = False
+        else:
+            self.awaiting_input = True
 
-        # Add Vote to Player Votes
-        self.herd_vote_tally.append({"voter_id": player.id, "voted_for_id": voted_for_player.id})
+        return response
 
     def resolve_round(self):
         """Resolves the round, assigns points, and prints the results."""