【AI Agent教程】【MetaGPT】案例拆解：使用MetaGPT实现“狼人杀“游戏（1）- 整体框架解析

def main(
    investment: float = 20.0,
    n_round: int = 16, // 修改这里！ 修改这里 ！ 修改这里 ！
    shuffle: bool = True,
    add_human: bool = False,
    use_reflection: bool = True,
    use_experience: bool = False,
    use_memory_selection: bool = False,
    new_experience_version: str = "",
):

pip install llama-index-vector-stores-postgres -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install llama-index-vector-stores-chroma -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install llama-index-vector-stores-elasticsearch -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install llama-index-vector-stores-faiss -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install llama-index-retrievers-bm25 -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install llama-index-embeddings-azure-openai -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install llama-index-embeddings-gemini -i https://pypi.tuna.tsinghua.edu.cn/simple
pip install llama-index-embeddings-ollama -i https://pypi.tuna.tsinghua.edu.cn/simple

class RoleType(Enum):
    VILLAGER = "Villager" # 村民
    WEREWOLF = "Werewolf" # 狼人
    GUARD = "Guard" # 守卫
    SEER = "Seer" # 先知
    WITCH = "Witch" # 巫师
    MODERATOR = "Moderator" # 主持人

class BasePlayer(Role):
    name: str = "PlayerXYZ"
    profile: str = "BasePlayer"
    special_action_names: list[str] = []
    use_reflection: bool = True
    use_experience: bool = False
    use_memory_selection: bool = False
    new_experience_version: str = ""
    status: RoleState = RoleState.ALIVE
    special_actions: list[SerializeAsAny[Action]] = Field(default=[], validate_default=True)
    experiences: list[RoleExperience] = []
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        # 技能和监听配置
        self._watch([InstructSpeak])  # 监听Moderator的指令以做行动
        special_actions = [ACTIONS[action_name] for action_name in self.special_action_names]
        capable_actions = [Speak] + special_actions
        self.set_actions(capable_actions)  # 给角色赋予行动技能
        self.special_actions = special_actions
        if not self.use_reflection and self.use_experience:
            logger.warning("You must enable use_reflection before using experience")
            self.use_experience = False

class Moderator(BasePlayer):
    name: str = RoleType.MODERATOR.value
    profile: str = RoleType.MODERATOR.value
    def __init__(self, **kwargs):
        super().__init__(**kwargs)
        self._watch([UserRequirement, InstructSpeak, ParseSpeak])
        self.set_actions([InstructSpeak, ParseSpeak, AnnounceGameResult])

class InstructSpeak(Action):
    name: str = "InstructSpeak"
    async def run(self, step_idx, living_players, werewolf_players, player_hunted, player_current_dead):
        instruction_info = STEP_INSTRUCTIONS.get(
            step_idx, {"content": "Unknown instruction.", "send_to": {}, "restricted_to": {}}
        )
        content = instruction_info["content"]
        if "{living_players}" in content and "{werewolf_players}" in content:
            content = content.format(
                living_players=living_players, werewolf_players=werewolf_players, werewolf_num=len(werewolf_players)
            )
        if "{living_players}" in content:
            content = content.format(living_players=living_players)
        if "{werewolf_players}" in content:
            content = content.format(werewolf_players=werewolf_players)
        if "{player_hunted}" in content:
            content = content.format(player_hunted=player_hunted)
        if "{player_current_dead}" in content:
            player_current_dead = "No one" if not player_current_dead else player_current_dead
            content = content.format(player_current_dead=player_current_dead)
        return content, instruction_info["send_to"], instruction_info["restricted_to"

class AnnounceGameResult(Action):
    async def run(self, winner: str, win_reason: str):
        return f"Game over! {win_reason}. The winner is the {winner}"

"send_to": {RoleType.MODERATOR.value},  # for moderator to continue speaking

class Villager(BasePlayer):
    name: str = RoleType.VILLAGER.value
    profile: str = RoleType.VILLAGER.value
    special_action_names: list[str] = []

class Werewolf(BasePlayer):
    name: str = RoleType.WEREWOLF.value
    profile: str = RoleType.WEREWOLF.value
    special_action_names: list[str] = ["Hunt"]
    async def _think(self):
        """狼人白天发言时需要伪装，与其他角色不同，因此需要重写_think"""
        await super()._think()
        if isinstance(self.rc.todo, Speak):
            self.rc.todo = Impersonate()

class Hunt(NighttimeWhispers):
    name: str = "Hunt"

class Impersonate(Speak):
    """Action: werewolf impersonating a good guy in daytime speak"""
    STRATEGY: str = """
    Try continuously impersonating a role, such as Seer, Guard, Villager, etc., in order to mislead
    other players, make them trust you, and thus hiding your werewolf identity. However, pay attention to what your werewolf partner said, 
    DONT claim the same role as your werewolf partner. Remmber NOT to reveal your real identity as a werewolf!
    """
    name: str = "Impersonate"
• 10

class Guard(BasePlayer):
    name: str = RoleType.GUARD.value
    profile: str = RoleType.GUARD.value
    special_action_names: list[str] = ["Protect"]

class Protect(NighttimeWhispers):
    name: str = "Protect"

class Seer(BasePlayer):
    name: str = RoleType.SEER.value
    profile: str = RoleType.SEER.value
    special_action_names: list[str] = ["Verify"]

class Verify(NighttimeWhispers):
    name: str = "Verify"

class Witch(BasePlayer):
    name: str = RoleType.WITCH.value
    profile: str = RoleType.WITCH.value
    special_action_names: list[str] = ["Save", "Poison"]

class Save(NighttimeWhispers):
    name: str = "Save"

class Poison(NighttimeWhispers):
    STRATEGY: str = """
    Only poison a player if you are confident he/she is a werewolf. Don't poison a player randomly or at first night.
    If someone claims to be the witch, poison him/her, because you are the only witch, he/she can only be a werewolf.
    """
    name: str = "Poison"

class WerewolfGame(Team):
    """Use the "software company paradigm" to hold a werewolf game"""
    env: Optional[WerewolfEnv] = None
    def __init__(self, context: Context = None, **data: Any):
        super(Team, self).__init__(**data)
        ctx = context or Context()
        if not self.env:
            self.env = WerewolfEnv(context=ctx)
        else:
            self.env.context = ctx  # The `env` object is allocated by deserialization

class WerewolfEnv(WerewolfExtEnv, Environment):
    round_cnt: int = Field(default=0)
class WerewolfExtEnv(ExtEnv):
    model_config = ConfigDict(arbitrary_types_allowed=True)
    players_state: dict[str, tuple[str, RoleState]] = Field(
        default_factory=dict, description="the player's role type and state by player_name"
    )
    round_idx: int = Field(default=0)  # the current round
    step_idx: int = Field(default=0)  # the current step of current round
    eval_step_idx: list[int] = Field(default=[])
    per_round_steps: int = Field(default=len(STEP_INSTRUCTIONS))
    # game global states
    game_setup: str = Field(default="", description="game setup including role and its num")
    special_role_players: list[str] = Field(default=[])
    winner: Optional[str] = Field(default=None)
    win_reason: Optional[str] = Field(default=None)
    witch_poison_left: int = Field(default=1, description="should be 1 or 0")
    witch_antidote_left: int = Field(default=1, description="should be 1 or 0")
    # game current round states, a round is from closing your eyes to the next time you close your eyes
    round_hunts: dict[str, str] = Field(default_factory=dict, description="nighttime wolf hunt result")
    round_votes: dict[str, str] = Field(
        default_factory=dict, description="daytime all players vote result, key=voter, value=voted one"
    )
    player_hunted: Optional[str] = Field(default=None)
    player_protected: Optional[str] = Field(default=None)
    is_hunted_player_saved: bool = Field(default=False)
    player_poisoned: Optional[str] = Field(default=None)
    player_current_dead: list[str] = Field(default=[])