remove legacy code, fix voted out message

Author: Luncenok

scripts/main.py

@@ -10,7 +10,7 @@
 import os
 import argparse
 
-def main(reset=False, always_kill=False, remove_last_n=0):
+def main(reset=False, greedy=False, remove_last_n=0):
     """Runs the game with manual LLM control."""
     game_config = GameConfig(
         num_tasks=2,
@@ -83,11 +83,11 @@ def main(reset=False, always_kill=False, remove_last_n=0):
             # Here, you would insert your custom LLM call and log probability logic.
             action_taken = random.choice(actions_player_can_take)
             kill_actions = [action for action in actions_player_can_take if action.type == ActionType.KILL]
-            task_actions = [action for action in actions_player_can_take if action.type == ActionType.TASK]
-            if current_player.role == PlayerRole.IMPOSTOR and kill_actions and always_kill:
+            task_or_report_actions = [action for action in actions_player_can_take if action.type == ActionType.TASK or action.type == ActionType.REPORT]
+            if current_player.role == PlayerRole.IMPOSTOR and kill_actions and greedy:
                 action_taken = random.choice(kill_actions)
-            elif current_player.role == PlayerRole.CREWMATE and task_actions:
-                action_taken = random.choice(task_actions)
+            elif current_player.role == PlayerRole.CREWMATE and task_or_report_actions and greedy:
+                action_taken = random.choice(task_or_report_actions)
             llm_response, cot = action_taken.command_perspective, "<think>Was thinking about this option: " + action_taken.command_perspective + "</think>"
         except KeyboardInterrupt:
             action_idx, llm_response, cot, _ = prompt_manual_fallback_action(actions_player_can_take)
@@ -118,13 +118,13 @@ def parse_args():
     parser = argparse.ArgumentParser(description="Run Among Them game with custom options.")
     parser.add_argument("--reset", action="store_true", 
                         help="Remove the state file and start a new game")
-    parser.add_argument("--always-kill", action="store_true",
-                        help="Impostors will always choose to kill when possible")
-    parser.add_argument("--remove-last-n", type=int, default=0,
+    parser.add_argument("--greedy", action="store_true",
+                        help="Impostors will always choose to kill when possible and crewmates will always choose to task/report when possible")
+    parser.add_argument("-n", type=int, default=0,
                         help="Remove the last N entries from history and start from there")
     return parser.parse_args()
 
 
 if __name__ == "__main__":
     args = parse_args()
-    main(reset=args.reset, always_kill=args.always_kill, remove_last_n=args.remove_last_n)
+    main(reset=args.reset, greedy=args.greedy, remove_last_n=args.n)

scripts/random_game.py

@@ -331,11 +331,6 @@ def load_game_state(file_path, last_modified_time) -> Tuple[List[History], List[
                     task_complete = game_config.num_tasks - len(tasks)
                     task_total = game_config.num_tasks
 
-                    # Count completed tasks
-                    for task in tasks:
-                        if hasattr(task, 'completed') and task.completed:
-                            task_complete += 1
-                    
                     # Show progress bar
                     st.progress(task_complete / task_total)
                     st.write(f"{task_complete}/{task_total} tasks completed")
@@ -344,14 +339,13 @@ def load_game_state(file_path, last_modified_time) -> Tuple[List[History], List[
                     for task in tasks:
                         task_name = task.name if hasattr(task, 'name') else str(task)
                         task_location = task.location.value if hasattr(task, 'location') and task.location else "Unknown"
-                        task_status = "✅" if hasattr(task, 'completed') and task.completed else "⏳"
 
                         # If it's a long task, show turns left
                         turns_info = ""
                         if hasattr(task, 'turns_left'):
                             turns_info = f" ({task.turns_left} turns left)"
 
-                        st.write(f"{task_status} {task_name} at {task_location}{turns_info}")
+                        st.write(f"TODO: {task_name} at {task_location}{turns_info}")
 
     with tabs[3]:  # Player Network
         st.header("Player Interaction Network")

scripts/streamlit.py

@@ -1,7 +1,6 @@
 import json
 import random
 from typing import List, Optional
-import copy
 
 from among_them.config import STATE_FILE
 from among_them.game_jsonencoder import GameJSONEncoder, game_object_hook

src/among_them/game_engine.py

@@ -43,12 +43,16 @@ def set_stories(self):
             self.command_perspective = f"report the dead body of {str(self.target_player_name)}"
             self.agent_perspective = f"You reported the dead body of {str(self.target_player_name)} and started a discussion."
             self.observer_perspective = f"You saw {self.player_name} report the dead body of {str(self.target_player_name)} to everyone. Discussion started."
-            self.global_perspective = f"A dead body was reported by {self.player_name}. Discussion started."
+            self.global_perspective = f"{self.player_name} reported the dead body of {str(self.target_player_name)}. Discussion started."
         elif self.type == ActionType.KILL:
             self.command_perspective = f"kill {str(self.target_player_name)}"
             self.agent_perspective = f"You killed {str(self.target_player_name)}."
             self.observer_perspective = f"You witnessed {self.player_name} kill {str(self.target_player_name)}!"
-            self.global_perspective = f"{str(self.target_player_name)} was killed."
+            self.global_perspective = f"{self.player_name} killed {str(self.target_player_name)}."
+            if getattr(self, "target_message", None) and self.player_name == "System":
+                self.agent_perspective = f"System said: {self.target_message}"
+                self.observer_perspective = f"System said: {self.target_message}"
+                self.global_perspective = f"System said: {self.target_message}"
         elif self.type == ActionType.VOTE:
             self.command_perspective = f"vote for {str(self.target_player_name)}"
             self.agent_perspective = f"You voted for {str(self.target_player_name)}."

src/among_them/main.py

@@ -1,4 +1,3 @@
-from enum import Enum
 import random
 from typing import Optional
 
@@ -7,21 +6,12 @@
 
 
 class Task:
-    def __init__(self, name: str, location: Optional[Location], completed: bool = False):
+    def __init__(self, name: str, location: Optional[Location]):
         self.name = name
-        self.completed = completed
         self.location = location
 
-    def complete(self, location: Location) -> str:
-        if self.completed:
-            return f"Task {self.name} already completed!"
-        if self.location != location:
-            return f"Task {self.name} cannot be completed in {location.value}!"
-        self.completed = True
-        return f"Task {self.name} completed!"
-
     def __str__(self):
-        return f"{'[DONE]' if self.completed else '[TODO]'} | {self.name}"
+        return f"TODO: {self.name}"
 
     def __repr__(self):
         return self.name

src/among_them/models/action.py

@@ -49,7 +49,7 @@ def get_task_phase_actions(
 
     # actions for tasks TASK
     for task in history[-1].tasks_left_to_do[player.name]:
-        if player.role == PlayerRole.CREWMATE and task.location == location and not task.completed:
+        if player.role == PlayerRole.CREWMATE and task.location == location:
             actions.append(
                 Action(type=ActionType.TASK, player_name=player.name, target_task=task)
             )

src/among_them/models/tasks.py

@@ -1,5 +1,5 @@
 
-from typing import List, Optional
+from typing import List
 from among_them.models.player import Player
 from among_them.game_config import GameConfig
 from among_them.models.history import History
@@ -9,7 +9,6 @@
 from among_them.models.action_type import ActionType
 from among_them.models.phase import GamePhase
 from among_them.models.tasks import get_impostor_tasks, get_crewmate_tasks
-from among_them.utils.player_utils import get_players_in_room, get_last_player_action
 
 def initialize_history(players: List[Player], game_config: GameConfig) -> List[History]:
     """Create first history entry – a system message that the game started (TASK phase)."""
@@ -72,94 +71,3 @@ def create_system_message(
         votes_before_this_discussion_message={},
         alive_player_names=alive_player_names.copy(),
     )
-
-def get_action_history_str(history: List[History], players: List[Player], player: Player, game_config: GameConfig, phase: Optional[GamePhase] = None) -> str:
-    """
-    DEPRECATED: see prompt_utils.py
-    Returns all actions seen by agent and actions that agent saw/spectated in history in order.
-    """
-    phase = history[-1].phase
-    players_in_room = get_players_in_room(history, players, player)
-    alive_players = [p for p in players if p.name in history[-1].alive_player_names]
-    location = get_last_player_action(history, player).location
-
-    # Agent description
-    history_str = "<player_info>\n"
-    history_str += f"<player_name>{player.name}</player_name>\n<current_role>{player.role.value}</current_role>\n<current_location>{location.value}</current_location>\n"
-    other_impostors = [p for p in alive_players if p.role == PlayerRole.IMPOSTOR and p.name != player.name]
-    if player.role == PlayerRole.IMPOSTOR:
-        other_crewmates = [p for p in alive_players if p.role == PlayerRole.CREWMATE and p.name != player.name]
-        if other_impostors:
-            history_str += "<other_impostors>\n"
-            for imp in other_impostors:
-                history_str += f"<impostor>{imp.name}</impostor>\n"
-            history_str += "</other_impostors>\n"
-        else:
-            history_str += "<other_impostors>none</other_impostors>\n"
-        
-        if other_crewmates:
-            history_str += "<crewmates>\n"
-            for crew in other_crewmates:
-                history_str += f"<crewmate>{crew.name}</crewmate>\n"
-            history_str += "</crewmates>\n"
-    else:
-        other_players = [p.name for p in alive_players if p.name != player.name]
-        history_str += f"<impostor_count>{len(other_impostors)}</impostor_count>\n"
-        history_str += "<potential_impostors>\n"
-        for other_player in other_players:
-            history_str += f"<player>{other_player}</player>\n"
-        history_str += "</potential_impostors>\n"
-    
-    # Tasks left
-    tasks_left = []
-    for h in history:
-        if player.name in h.tasks_left_to_do:
-            tasks_left = h.tasks_left_to_do[player.name]
-            break
-    
-    if tasks_left:
-        history_str += "<tasks_left>\n"
-        for task in tasks_left:
-            history_str += f"<task><name>{task.name}</name><location>{task.location.value if task.location else 'N/A'}</location></task>\n"
-        history_str += "</tasks_left>\n"
-    history_str += "</player_info>\n\n"
-
-    # Game history
-    history_str += "<game_history>\n"
-    for h in history:
-        if h.action_taken:
-            if h.action_taken.player_name == player.name:
-                if hasattr(h, 'llm_cot') and h.llm_cot:
-                    cot_without_think_tags = h.llm_cot.replace("<think>", "<thought>").replace("</think>", "</thought>")
-                    history_str += f"<player_thought>{cot_without_think_tags}</player_thought>\n"
-                if h.action_taken.type == ActionType.SPEAK:
-                    history_str += f"<action type=\"player_message\">{h.action_taken.agent_perspective}</action>\n"
-                else:
-                    history_str += f"<action type=\"player_action\">{h.action_taken.agent_perspective}</action>\n"
-            elif player.name in h.spectators_who_saw:
-                if h.action_taken.type == ActionType.SPEAK:
-                    history_str += f"<action type=\"discussion\">{h.action_taken.observer_perspective}</action>\n"
-                elif h.action_taken.type != ActionType.VOTE: # players cannot see others voting
-                    history_str += f"<action type=\"observed\">{h.action_taken.observer_perspective}</action>\n"
-    history_str += "</game_history>\n\n"
-
-    # Current game state
-    history_str += "<current_state>\n"
-    other_players = [p.name for p in players_in_room if p.name != player.name]
-    if phase == GamePhase.TASKS:
-        if len(other_players) == 0:
-            history_str += "<companions>none</companions>\n"
-            history_str += f"<location>{location.value}</location>\n"
-        else:
-            history_str += "<companions>\n"
-            for other_player in other_players:
-                history_str += f"<player>{other_player}</player>\n"
-            history_str += "</companions>\n"
-            history_str += f"<location>{location.value}</location>\n"
-        history_str += "<phase>Task</phase>\n<note>You cannot speak during this phase.</note>\n"
-    elif phase == GamePhase.VOTING:
-        history_str += "<phase>Voting</phase>\n"
-    else:
-        history_str += "<phase>Discussion</phase>\n<note>You can speak now. Respond to the crewmates.</note>\n"
-    history_str += "</current_state>\n"
-    return history_str

src/among_them/utils/action_utils.py

@@ -2,35 +2,9 @@
 from typing import List, Optional, Tuple
 
 from among_them.config import LLMBackend, LLM_BACKEND, OPENROUTER_API_KEY, OPENROUTER_MODEL_NAME, HUGGINGFACE_MODEL_NAME
-from among_them.llm_prompts import UNIVERSAL_SYSTEM_PROMPT
 from among_them.models.action import Action, ActionType
 
 
-def create_llm_prompts(actions: List[Action], history_str: str) -> Tuple[str, str]:
-    """Constructs the prompt for the LLM.
-    Args:
-        actions: List of available actions
-        history_str: String representation of game history
-    Returns:
-        Tuple of (system_prompt, user_prompt)
-    """
-    system_prompt = UNIVERSAL_SYSTEM_PROMPT
-    prompt = history_str
-
-    # Add available actions to prompt if needed
-    if actions and actions[0].type != ActionType.SPEAK:
-        actions_text = "<available_actions>\n" + "\n".join(f"<action>{action.text}</action>" for action in actions) + "\n</available_actions>"
-        prompt += f"\n\n{actions_text}\n"
-        if actions[0].type == ActionType.VOTE:
-            prompt += "\n\nChoose one action. Please put your final answer within <action></action> xml tags"
-        else:
-            prompt += "\n\nChoose one action. Please put your final vote within <action></action> xml tags"
-    elif actions and actions[0].type == ActionType.SPEAK:
-        prompt += "\n\nIt is discussion phase now. Respond to others. Please put your message between <message></message> xml tags"
-    
-    return system_prompt, prompt
-
-
 def invoke_llm(system_prompt: str, prompt: str, model_name: str) -> Tuple[str, Optional[str]]:
     """
     Invoke the LLM with the given prompts and handle exceptions.
@@ -193,7 +167,6 @@ def parse_llm_response_to_action(
     """
     Parses the raw LLM response to determine the chosen action index and response text.
     """
-    from among_them.models.action import ActionType
 
     if not actions:
         raise ValueError("Cannot parse LLM response without a list of available actions.")