LoginSignup
1
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?

@maskot1977(Ikemen Mas Kot)

PythonとLLMで構築するマルチエージェント・ポーカー シミュレーション

Posted at

user:

前回は、LLMエージェント同士が人狼ゲームを行うプログラムを一緒に作りました。今度は、LLMエージェント同士がポーカーをするプログラムを一緒に作りませんか？各LLMエージェントは、自分の手札を覚えて、それをもとに、次の判断をします。前回動作確認済みのコードをお見せしますので、まずはそこから、ポーカーをする今回のプログラムにも流用できそうな要点をメモリに覚えてください。

import openai
import json
import random
import time

# 設定ファイルの読み込み
config_path = "/content/drive/MyDrive/path_config/config.json"
with open(config_path, "r") as f:
    config = json.load(f)

client = openai.AzureOpenAI(
    api_key=config["OPENAI_API_KEY"],
    api_version=config["OPENAI_API_VERSION"],
    azure_endpoint=config["OPENAI_API_BASE"],
)
model = config["OPENAI_API_ENGINE"]


# Agentクラス
class Agent:
    def __init__(self, name, role_prompt, true_role):
        self.name = name
        self.role_prompt = role_prompt
        self.true_role = true_role  # '村人', '人狼', '占い師'
        self.history = []

    def respond(self, shared_history):
        messages = [{"role": "system", "content": self.role_prompt}] + shared_history
        response = client.chat.completions.create(
            model=model, messages=messages, temperature=0.7, max_tokens=500
        )
        reply = response.choices[0].message.content.strip()
        self.history.append({"role": "user", "content": shared_history[-1]["content"]})
        self.history.append({"role": "assistant", "content": reply})
        return reply


# エージェント設定
agents_data = [
    (
        "岸辺露伴",
        "あなたは漫画家・岸辺露伴。村人。推理力は高いが超然としている。",
        "村人",
    ),
    ("ギアッチョ", "あなたはギアッチョ。理屈っぽく短気な村人。", "村人"),
    (
        "ダービー兄",
        "あなたはダービー兄。冷静沈着な占い師。丁寧だが裏では値踏みしている。",
        "占い師",
    ),
    ("吉良吉影", "あなたは吉良吉影。物静かな連続殺人鬼で、今回は人狼。", "人狼"),
    ("ホル・ホース", "あなたはホル・ホース。軽薄な性格で、今回は人狼。", "人狼"),
]

agents = [Agent(name, prompt, role) for name, prompt, role in agents_data]

# プレイヤー名→オブジェクト辞書
name_to_agent = {agent.name: agent for agent in agents}

# ゲーム履歴（共有プロンプト）
shared_history = [
    {
        "role": "user",
        "content": "人狼ゲームが始まった。今日の昼、誰が怪しいか話し合って投票する時間がきた。\n"
        "それぞれ自分の役割を踏まえて、セリフ（他人に聞かれる発言）と、心の声（他のプレイヤーの正体についてどう思っているか）を述べてください。\n"
        "形式は以下のようにしてください：\n"
        "セリフ：◯◯\n心の声：（◯◯）",
    }
]


# ゲーム進行関数
def night_phase():
    print("\n🌙 夜フェーズ\n")

    # 占い師が生きているか確認して占う
    seers = [agent for agent in agents if agent.true_role == "占い師"]
    if seers:
        seer = seers[0]
        target = random.choice([a for a in agents if a != seer])
        result = "人狼" if target.true_role == "人狼" else "村人"
        print(f"🔮 {seer.name} が {target.name} を占った：{result}")
    else:
        print("🔮 占い師はすでに死亡している。占いは行われなかった。")

    # 人狼が生存していれば襲撃を行う
    wolves = [a for a in agents if a.true_role == "人狼"]
    if wolves:
        victim_candidates = [a for a in agents if a.true_role != "人狼"]
        if victim_candidates:
            victim = random.choice(victim_candidates)
            print(f"🐺 人狼が {victim.name} を襲撃した！")
            agents.remove(victim)
            return victim.name
        else:
            print("🐺 人狼以外のプレイヤーが存在しないため、襲撃なし")
            return None
    else:
        print("🐺 人狼は全滅している。襲撃は行われない。")
        return None


def day_phase():
    print("\n🌞 昼フェーズ\n")
    votes = {}
    for agent in agents:
        others = [a for a in agents if a != agent]
        suspect = random.choice(others).name
        votes[suspect] = votes.get(suspect, 0) + 1
        print(f"🗳 {agent.name} は {suspect} に投票した")

    # 処刑決定
    executed = max(votes.items(), key=lambda x: x[1])[0]
    print(f"⚖️ 最多票の {executed} が処刑された…")
    agents.remove(name_to_agent[executed])
    return executed


def check_win():
    villagers = [a for a in agents if a.true_role != "人狼"]
    wolves = [a for a in agents if a.true_role == "人狼"]
    if not wolves:
        return "村人の勝利！"
    if len(wolves) >= len(villagers):
        return "人狼の勝利！"
    return None


# ゲーム本編
print("=== 人狼ゲーム開始 ===")
round_count = 1

while True:
    print(f"\n===== ラウンド {round_count} =====")
    victim = night_phase()
    if victim:
        shared_history.append(
            {"role": "user", "content": f"{victim} が昨夜、何者かに殺された。"}
        )
    else:
        shared_history.append(
            {"role": "user", "content": f"昨夜は誰も殺されなかった。"}
        )

    for agent in agents:
        msg = agent.respond(shared_history)
        print(f"\n{agent.name}:\n{msg}\n")
        shared_history.append({"role": "user", "content": msg})

    executed = day_phase()
    shared_history.append(
        {"role": "user", "content": f"昼の投票で {executed} が処刑された。"}
    )

    result = check_win()
    if result:
        print(f"\n🏁 {result}")
        break

    round_count += 1

assistant:

もちろんです、ポーカー版のLLMエージェント・シミュレーションを一緒に作るのはとても面白そうですね！
まず、以下の要点を前回の人狼コードから、ポーカー用にも「流用・応用できそうなパターン」として整理してメモリに残しておきます：

✅【流用できる要点まとめ】

1. エージェント設計（Agentクラス）

  • self.name, self.role_prompt（＝キャラ設定）を持つ。
  • respond() メソッドで、現在の共有履歴（shared history）をもとにLLMにプロンプトを送信し返答。
  • self.history に個別の履歴を保存できる。
    → 🔁 ポーカーでは、ここを「手札」「ベット履歴」「ラウンド履歴」に置き換えて記憶させることができる。

2. Azure OpenAI API の使い方 

client.chat.completions.create(
    model=model, messages=messages, temperature=0.7, max_tokens=500
)

→ 🔁 同様の方式で各エージェントが「手札を見たうえで次に取るアクション（ベット／フォールドなど）」を判断させられる。

3. 共有履歴（shared_history）

  • 各ターンの出来事をすべて時系列で記録。
  • 最終的にそれをプロンプトとして各エージェントが利用。
    → 🔁 ポーカーでも、公開されたカードやプレイヤーのベット履歴を共有履歴として使える。

4. ゲームフェーズの関数分離

  • night_phase()（＝占い・襲撃などのアクション）
  • day_phase()（＝投票・処刑）
    → 🔁 ポーカーでも deal_phase()（配布）→betting_phase()（ベット）→showdown_phase()（勝敗判定）などに分離可能。

5. 勝敗条件のチェック（check_win）

  • 村人と人狼の生存数を比較して勝利を判定。
    → 🔁 ポーカーでは最終的に「最強のハンドを持つプレイヤーを判定」するロジックに応用できる。

6. キャラクター性を活かした役割プロンプト

  • 例：「ギアッチョ」「ホル・ホース」など、性格込みで行動判断を行う。
    → 🔁 ポーカーでもキャラに「強気／慎重／ブラフ多用」などのスタイルを加味できる。

🔜 次のステップ（提案）

次に行うとよさそうなステップは次のとおりです：

  1. ポーカーのルール簡略化の決定：

    • まずは「テキサスホールデムのプリフロップ〜リバーまで」または「5枚ドローポーカー」で進めるか選択。

  2. Agentクラスの改造：

    • self.hand（手札）や self.stack（チップ）、self.folded（フォールド済か）などの状態管理を追加。

  3. フェーズごとの関数設計：

    • deal_cards(), betting_round(), reveal_community_cards(), showdown() のように段階設計。

  4. ベットロジックと勝者判定：

    • シンプルなルール（例：ベット額の大きさではなく、ショーダウンでの手役）から実装。

もしよければ、まず **「どのルールのポーカーをベースにするか（例：5カードドロー or テキサスホールデム）」**を教えていただけますか？
それに応じて、最小限構成でスタートできるテンプレートをご用意します！

user:

ありがとうございます。実装の要点をよく覚えておいてくださいね。シンプルに実装できるルールでお願いします！

assistant:

了解です！実装の要点はしっかりメモリに記憶しました。
今回は シンプルに実装できるポーカーのルールとして、以下のルールで進めるのが最適だと判断します：

🎯 採用ルール：5カード・ドローポーカー（Five Card Draw）

✅ 理由（シンプルでLLMとの相性もよい）:

  • 手札は非公開の5枚のみ（コミュニティカードなし）。
  • ベットラウンドは「1回のみ」でOK。
  • 勝敗は役（ハンド）の強さで単純比較できる。
  • カード交換（ドロー）もオプションで実装可能（段階的に）。

🧩 最初に実装する構成（ステップ1）

🎮 基本の流れ

  1. プレイヤーに5枚ずつ手札を配る。
  2. 各エージェントに 「自分の手札」＋「現在の状況」 を渡し、ベット or フォールドを選ばせる。
  3. フォールドしなかったプレイヤー同士で ショーダウン（手札比較）。
  4. 最も強い手役を持つプレイヤーが勝利！

🛠️ 最初に作る Agent クラス（ドラフト案）

class PokerAgent:
    def __init__(self, name, personality_prompt):
        self.name = name
        self.prompt = personality_prompt
        self.hand = []  # 5枚のカード（例: ['H10', 'C4', 'D9', 'S2', 'H7']）
        self.folded = False
        self.history = []

    def receive_hand(self, hand):
        self.hand = hand
        self.folded = False

    def decide_action(self, shared_info):
        """
        LLMに判断させる。shared_infoには「他のプレイヤーのベット状況」「フォールド数」などを含む。
        """
        prompt = f"""
あなたはポーカープレイヤーです。以下があなたの手札です：
{', '.join(self.hand)}

現在の状況：
{shared_info}

次の中から1つを選んでください：
- フォールド（弱気な手札で降りる）
- コール（現状維持でゲーム続行）

選択理由とともに、以下の形式で答えてください：
アクション：◯◯
心の声：（◯◯）
"""
        messages = [{"role": "system", "content": self.prompt}, {"role": "user", "content": prompt}]
        response = client.chat.completions.create(
            model=model, messages=messages, temperature=0.7, max_tokens=300
        )
        reply = response.choices[0].message.content.strip()
        self.history.append({"role": "user", "content": prompt})
        self.history.append({"role": "assistant", "content": reply})
        return reply

🎲 次に作るべきもの

  • カードを配るデッキ機能（シャッフル・配布）

  • 手札の役の評価関数（強さ比較のため）

  • ゲーム進行関数（1ラウンドだけ）：

    • deal_cards()
    • collect_actions()
    • evaluate_winner()

📝 次のステップ

次は、上記を踏まえて以下を提案させてください：

  1. PokerAgent クラスの完全実装（↑を元に）
  2. デッキとカード配布関数の実装（標準52枚）
  3. ランダムな2〜5人のキャラで1ラウンドのシミュレーション実行

準備ができたら、まず PokerAgent クラスとデッキのコードから実装を始めましょうか？それとも、使いたいキャラの設定（名前と性格）を先に決めますか？どちらでもお手伝いできます！

user:

ありがとうございます。まず PokerAgent クラスとデッキのコードから実装を始めましょう。実装の要点を忘れないで、進めてください。よろしくお願いします。

assistant:

了解です！実装の要点はしっかり記憶しています。
ではまず、PokerAgent クラスと、デッキ生成・カード配布のコードを以下に実装します。

🧠 実装ステップまとめ（ステップ1）

1. PokerAgent クラス（LLMベースのプレイヤー）

  • 名前・性格プロンプトを保持
  • 手札（5枚）を記憶
  • フォールド状態を記録
  • LLMにアクション（フォールド or コール）を判断させる

2. デッキ管理とカード配布

  • 52枚のデッキを作成しシャッフル
  • 各プレイヤーに5枚ずつ配布

✅ 実装コード

import random
import openai
import json

# --- 設定読み込み（Azure OpenAI用） ---
config_path = "/content/drive/MyDrive/path_config/config.json"
with open(config_path, "r") as f:
    config = json.load(f)

client = openai.AzureOpenAI(
    api_key=config["OPENAI_API_KEY"],
    api_version=config["OPENAI_API_VERSION"],
    azure_endpoint=config["OPENAI_API_BASE"],
)
model = config["OPENAI_API_ENGINE"]


# --- ポーカーエージェントクラス ---
class PokerAgent:
    def __init__(self, name, personality_prompt):
        self.name = name
        self.prompt = personality_prompt
        self.hand = []
        self.folded = False
        self.history = []

    def receive_hand(self, hand):
        self.hand = hand
        self.folded = False

    def decide_action(self, shared_info="他のプレイヤーのアクションはまだわからない。"):
        hand_str = ', '.join(self.hand)
        prompt = f"""
あなたはポーカープレイヤーです。以下があなたの手札です：
{hand_str}

現在の状況：
{shared_info}

次の中から1つを選んでください：
- フォールド（弱気な手札で降りる）
- コール（現状維持でゲーム続行）

選択理由とともに、以下の形式で答えてください：
アクション：◯◯
心の声：（◯◯）
"""

        messages = [
            {"role": "system", "content": self.prompt},
            {"role": "user", "content": prompt},
        ]

        response = client.chat.completions.create(
            model=model, messages=messages, temperature=0.7, max_tokens=300
        )

        reply = response.choices[0].message.content.strip()
        self.history.append({"role": "user", "content": prompt})
        self.history.append({"role": "assistant", "content": reply})

        # アクションを判定
        if "フォールド" in reply:
            self.folded = True
        return reply


# --- デッキ作成と配布 ---
def create_shuffled_deck():
    suits = ['H', 'D', 'C', 'S']  # ハート、ダイヤ、クラブ、スペード
    ranks = ['2', '3', '4', '5', '6', '7', '8', '9', '10', 'J', 'Q', 'K', 'A']
    deck = [s + r for s in suits for r in ranks]
    random.shuffle(deck)
    return deck

def deal_cards(deck, num_players):
    hands = []
    for _ in range(num_players):
        hand = [deck.pop() for _ in range(5)]
        hands.append(hand)
    return hands

✅ このコードでできること

  • 複数のLLMエージェントを作成し、個別に手札を配布可能。
  • 各エージェントは 手札を記憶し、性格に基づいて「フォールド or コール」をLLMに判断させる。
  • デッキは毎回ランダムにシャッフル＆配布される。

🔜 次のステップ

このあと進めるとしたら：

  1. エージェントを2〜3人設定して試す
  2. 1ラウンド進行関数（deal → decide → showdown）を作る
  3. 手役評価関数（役を比較して勝者決定）を作る

よろしければ次は、
▶「何人でラウンドを試すか」＆「使いたいキャラ設定」
を一緒に決めて、1ラウンド回してみましょう！

user:

ありがとうございます。ジョジョの奇妙な冒険の第3部・第4部・第５部から一人ずつ、面白い勝負になりそうなキャラを選んで１ラウンド回せるようにしてください。

assistant:

了解です！それでは、ジョジョの奇妙な冒険 第3〜5部から、ポーカーバトルが映えそうな魅力的なキャラを以下のように選出し、各自の性格に応じた**プロンプト（性格＋戦略傾向）**を設定します。

🎭 選出キャラクター（各部から1人ずつ）

🕶 第3部：ダニエル・J・ダービー（兄）

  • 職業：ギャンブラー

  • 性格：冷静沈着、心理戦に長ける、相手の癖を読むことに快感を覚える

  • プロンプト例:

    あなたは冷静沈着なギャンブラー、ダニエル・J・ダービーです。常に相手の心理を読み、論理的に最善の手を選びます。ポーカーの経験が豊富で、ブラフには敏感です。

💅 第4部：岸辺露伴

  • 職業：漫画家（観察眼・分析力が高い）

  • 性格：超然として理知的、自分の信念に従う

  • プロンプト例:

    あなたは天才漫画家・岸辺露伴です。どんな勝負でも知性と観察眼を武器に冷静に立ち回ります。相手の性格を分析し、手札の確率的強さに基づいて論理的に判断します。

🎩 第5部：ギアッチョ

  • 性格：理屈っぽくて短気、負けず嫌い

  • プロンプト例:

    あなたはギアッチョです。理屈っぽく、相手の発言の矛盾や不合理さにすぐに噛みつきます。勝負事では負けず嫌いで、手札の強さに加えて感情の勢いで判断することもあります。

🧠 準備：エージェント定義とゲーム実行コード（1ラウンド）

以下のコードで、上記3人が参加する1ラウンドを実行できます：

# キャラクター定義
agent_data = [
    ("ダービー兄", "あなたは冷静沈着なギャンブラー、ダニエル・J・ダービーです。常に相手の心理を読み、論理的に最善の手を選びます。ポーカーの経験が豊富で、ブラフには敏感です。"),
    ("岸辺露伴", "あなたは天才漫画家・岸辺露伴です。どんな勝負でも知性と観察眼を武器に冷静に立ち回ります。相手の性格を分析し、手札の確率的強さに基づいて論理的に判断します。"),
    ("ギアッチョ", "あなたはギアッチョです。理屈っぽく、相手の発言の矛盾や不合理さにすぐに噛みつきます。勝負事では負けず嫌いで、手札の強さに加えて感情の勢いで判断することもあります。")
]

# エージェント初期化
agents = [PokerAgent(name, prompt) for name, prompt in agent_data]

# デッキ作成と配布
deck = create_shuffled_deck()
hands = deal_cards(deck, len(agents))

for agent, hand in zip(agents, hands):
    agent.receive_hand(hand)

# 各エージェントのアクション決定
print("=== 各プレイヤーのアクション ===\n")
for agent in agents:
    reply = agent.decide_action()
    print(f"🧠 {agent.name} の応答:\n{reply}\n")

# フォールドしてないプレイヤーを表示
active_players = [agent for agent in agents if not agent.folded]
print("=== フォールドせず勝負に残ったプレイヤー ===")
for a in active_players:
    print(f"✅ {a.name} の手札: {', '.join(a.hand)}")

# 勝者決定（次のステップで hand evaluation を追加）

🔜 次のステップ（勝者の判定）

このコードで、エージェントたちは手札と性格に基づいてアクションを返すようになっています。
次は evaluate_hand() 関数を用意して、残ったプレイヤー同士の手役を比較し、勝者を決定できるようにします。

実行して試した後、「役の強さ比較機能」へ進みましょうか？
また、実行ログが長くなる場合はGoogle Colabでの表示整形もお手伝いできますよ。

user:

ありがとうございます。現在のコードと、実装の要点をメモリに残しておいてくださいね。コードを実行しました。結果は次のとおりです。

=== 各プレイヤーのアクション ===

🧠 ダービー兄 の応答:
アクション：コール
心の声：（私の手札はS8, D2, H8, CK, C8で、3枚の8が揃っている。これは強力な「スリーカード」の手であり、ブラフをかけたり、他のプレイヤーがどう動くかを見るには十分な力がある。まだ他のプレイヤーのアクションはわからないが、この手で積極的にゲームを進めることで、相手の反応から情報を引き出すことができるかもしれない。）

🧠 岸辺露伴 の応答:
アクション：フォールド
心の声：（今の手札はH4, CJ, C7, C4, CQと、スートがばらばらで、ペアもない。可能性が低く、他のプレイヤーが強い手を持っている可能性を考えると、リスクを避けるのが賢明だ。無駄なチップを減らさずに次の良い機会を待とう。）

🧠 ギアッチョ の応答:
アクション：コール
心の声：（この手札、一見弱そうに見えるが、ペアの9がある。これを活かせばまだチャンスはある。他のプレイヤーの動向を見て次の一手を考えるべきだ。ただし、ここで弱気に出るわけにはいかない。9のペアを信じて、ここは様子を見るべきだ。）

=== フォールドせず勝負に残ったプレイヤー ===
✅ ダービー兄 の手札: S8, D2, H8, CK, C8
✅ ギアッチョ の手札: C3, H5, S9, C9, D8

動作が確認できたので、「役の強さ比較機能」へ進みましょう。

assistant:

ありがとうございます、動作確認＆ログの共有も助かります！
ダービー兄がスリーカード（8の三枚）で、ギアッチョは9のペア。まさに 勝負の行方を左右する「役判定」 の場面ですね。
それでは、次のステップ：

🎯 ステップ2：「役の強さ比較機能」の実装

✅ 対応するポーカー役（5カードドロー用、簡易）

ランク 役の名前 例
9 ロイヤルストレートフラッシュ A-K-Q-J-10 同じスート
8 ストレートフラッシュ 例: 9-8-7-6-5 同スート
7 フォーカード 例: 9-9-9-9-5
6 フルハウス 例: 10-10-10-K-K
5 フラッシュ 同じスート5枚
4 ストレート 例: 6-7-8-9-10
3 スリーカード 例: 8-8-8-x-x
2 ツーペア 例: 9-9 & J-J
1 ワンペア 例: 4-4-x-x-x
0 ハイカード 最も強いカードが勝ち

🧠 実装方針

  • 手札を数値とスートに分解
  • 同じランクの枚数や、スートが揃っているか、連続しているかを確認
  • ランクに基づいて「役の強さ (score)」と「ブレイクタイ」のための値（例：役を構成するカード）を返す

✅ 役評価関数のコード例（簡易）

from collections import Counter

# ランクの順序（強さ順）
rank_order = {'2':2, '3':3, '4':4, '5':5, '6':6, '7':7,
              '8':8, '9':9, '10':10, 'J':11, 'Q':12, 'K':13, 'A':14}

def evaluate_hand(hand):
    ranks = [card[1:] for card in hand]
    suits = [card[0] for card in hand]
    rank_counts = Counter(ranks)
    count_values = sorted(rank_counts.values(), reverse=True)
    unique_ranks = sorted([rank_order[r] for r in set(ranks)], reverse=True)

    is_flush = len(set(suits)) == 1
    rank_values = sorted([rank_order[r] for r in ranks])
    is_straight = all(rank_values[i+1] - rank_values[i] == 1 for i in range(4)) \
                  or rank_values == [2, 3, 4, 5, 14]  # A-2-3-4-5特例

    # 判定
    if is_flush and rank_values == [10,11,12,13,14]:
        return (9, unique_ranks)  # Royal Flush
    elif is_flush and is_straight:
        return (8, unique_ranks)  # Straight Flush
    elif count_values == [4,1]:
        return (7, get_rank_keys(rank_counts, [4,1]))  # Four of a Kind
    elif count_values == [3,2]:
        return (6, get_rank_keys(rank_counts, [3,2]))  # Full House
    elif is_flush:
        return (5, unique_ranks)  # Flush
    elif is_straight:
        return (4, unique_ranks)  # Straight
    elif count_values == [3,1,1]:
        return (3, get_rank_keys(rank_counts, [3,1,1]))  # Three of a Kind
    elif count_values == [2,2,1]:
        return (2, get_rank_keys(rank_counts, [2,2,1]))  # Two Pair
    elif count_values == [2,1,1,1]:
        return (1, get_rank_keys(rank_counts, [2,1,1,1]))  # One Pair
    else:
        return (0, unique_ranks)  # High Card

def get_rank_keys(counter, pattern):
    """役の強さ比較用に出現数→ランク順に並び替える"""
    items = list(counter.items())
    items.sort(key=lambda x: (-x[1], -rank_order[x[0]]))
    return [rank_order[x[0]] for x in items]

✅ 勝者判定コード（例）

def determine_winner(players):
    scored = []
    for agent in players:
        score, tiebreaker = evaluate_hand(agent.hand)
        scored.append((score, tiebreaker, agent))
        print(f"{agent.name} の手札評価: 役ランク={score}, 比較値={tiebreaker}")

    # 最も役が強いプレイヤーを選ぶ
    scored.sort(reverse=True)
    winner = scored[0][2]
    print(f"\n🏆 勝者: {winner.name}！")
    return winner

🔜 次のステップ

この関数を使って、前回の実行結果：

  • ダービー兄 → スリーカード（8）
  • ギアッチョ → ワンペア（9）

という状況から、正しく ダービー兄が勝利と判定されるようになります。

コードに組み込みますか？もしくは手元で組み込む形にしますか？
必要なら、**フル実行テンプレート（ラウンド開始〜勝者決定まで）**もまとめてご用意できますよ。

user:

ありがとうございます。これまでに作っていただいたクラスや関数は再掲しなくて大丈夫ですので、ラウンド開始〜勝者決定までのコードを書いてください。

assistant:

了解です！では、すでに実装済みの PokerAgent クラス、デッキ関数、evaluate_hand()・determine_winner() 関数を使って、ラウンド開始 → アクション決定 → 勝者決定までを実行するメイン処理のコードを以下にご用意します。

🏁 ポーカー1ラウンド実行コード（ラウンド開始〜勝者決定）

# === キャラクター定義 ===
agent_data = [
    ("ダービー兄", "あなたは冷静沈着なギャンブラー、ダニエル・J・ダービーです。常に相手の心理を読み、論理的に最善の手を選びます。ポーカーの経験が豊富で、ブラフには敏感です。"),
    ("岸辺露伴", "あなたは天才漫画家・岸辺露伴です。どんな勝負でも知性と観察眼を武器に冷静に立ち回ります。相手の性格を分析し、手札の確率的強さに基づいて論理的に判断します。"),
    ("ギアッチョ", "あなたはギアッチョです。理屈っぽく、相手の発言の矛盾や不合理さにすぐに噛みつきます。勝負事では負けず嫌いで、手札の強さに加えて感情の勢いで判断することもあります。")
]

# === エージェント作成とデッキ配布 ===
agents = [PokerAgent(name, prompt) for name, prompt in agent_data]
deck = create_shuffled_deck()
hands = deal_cards(deck, len(agents))

for agent, hand in zip(agents, hands):
    agent.receive_hand(hand)

# === アクション決定 ===
print("=== 各プレイヤーのアクション ===\n")
for agent in agents:
    reply = agent.decide_action()
    print(f"🧠 {agent.name} の応答:\n{reply}\n")

# === 残ったプレイヤー（フォールドしてない） ===
active_players = [agent for agent in agents if not agent.folded]
print("=== フォールドせず勝負に残ったプレイヤー ===")
for a in active_players:
    print(f"✅ {a.name} の手札: {', '.join(a.hand)}")

# === 勝者判定 ===
if len(active_players) == 1:
    winner = active_players[0]
    print(f"\n🏆 他のプレイヤーがフォールドしたため、{winner.name} の勝利！")
elif len(active_players) == 0:
    print("\n🤷‍♂️ 全員フォールド！勝者なし！")
else:
    print("\n=== 手札の強さを比較します ===")
    winner = determine_winner(active_players)

✅ このコードでやっていること

  1. エージェント3人に手札を配布
  2. 各自がLLMを使って「フォールド or コール」を判断
  3. 残ったプレイヤーの手札を比較して勝者を決定
  4. フォールドによって勝者が自動決定するケースも処理

🔜 今後の拡張案（次のステップ）

  • ドロー（カード交換）フェーズの追加
  • ベット金額とスタック管理（チップ残高）
  • マルチラウンドゲーム（ゲーム履歴）
  • ** bluff の発生と読み合い強化（相手の行動ログ反映）**

準備が整ったら、このコードを使って実行してみてくださいね。
もし表示整形やログ保存、進行UIの簡易化もしたければお手伝いします！

user:

ありがとうございます。実装のポイントについてメモリに記憶しながら、次のステップについて、ご提案通り、順番に進めて行きましょう。

assistant:

ありがとうございます！
現在の実装内容と次のステップをしっかり記憶しました。
それでは、次のステップ ①ドローフェーズ（カード交換） の実装から進めていきましょう。

🎯 ステップ①：ドローフェーズの設計

🔧 基本ルール（5カードドロー準拠）：

  • プレイヤーは「任意の枚数のカードを捨てて、新たなカードと交換」できる。
  • 交換は1回のみ（再交換なし）。
  • フォールドしたプレイヤーは対象外。

🧠 LLMエージェントにやらせたい判断

  • 自分の手札を見て「どのカードを捨てるか（0〜5枚）」を選ぶ。
  • 捨てるカードのインデックス（例：0, 2, 4など）を返答形式で教えてもらう。

✅ 次ステップで実装予定のもの

🧩 1. PokerAgent.draw_cards(deck) メソッド追加

  • 内部で LLM に「どのカードを交換するか」判断させる。
  • 指定されたカードを deck から引いて交換。

🧩 2. draw_phase(deck, agents) 関数追加

  • 全アクティブプレイヤーが順にカード交換。

次のメッセージでは、この「ドローフェーズの実装コード（LLMプロンプト込み）」をお届けしますね。
その後、再度フルラウンドの進行に統合して試していきましょう！

user:

ありがとうございます。はい、ここまでのPythonコードをしっかりメモリしながら、「ドローフェーズの実装コード（LLMプロンプト込み）」に進んでください。

assistant:

了解です！
これまでのPythonコードをしっかり記憶しながら、ステップ①：ドローフェーズ（カード交換） の実装を以下にご提示します。

🎯 目的

  • 各エージェントに「どのカードを捨てて交換するか」を判断させる。
  • 実際に捨てて、新たにカードをデッキから引いて手札を更新。

✅ 1. PokerAgent.draw_cards(deck) メソッドの追加

class PokerAgent:
    # ... 既存コードは省略 ...

    def draw_cards(self, deck):
        hand_str = ', '.join(self.hand)
        prompt = f"""
あなたはポーカープレイヤーです。以下があなたの現在の手札です：
{hand_str}

この中から、交換したいカードの「インデックス番号（0〜4）」をカンマ区切りで列挙してください。
例えば、2番目と4番目を交換したい場合は「1,3」としてください。
交換したくない場合は「なし」と答えてください。

以下の形式で答えてください：
交換するカードの位置：◯◯
心の声：（なぜそのカードを交換するか、またはしないか）
"""

        messages = [
            {"role": "system", "content": self.prompt},
            {"role": "user", "content": prompt},
        ]

        response = client.chat.completions.create(
            model=model, messages=messages, temperature=0.7, max_tokens=300
        )

        reply = response.choices[0].message.content.strip()
        self.history.append({"role": "user", "content": prompt})
        self.history.append({"role": "assistant", "content": reply})
        print(f"♻️ {self.name} のドロー応答:\n{reply}\n")

        # インデックス抽出
        indices = []
        if "なし" not in reply:
            try:
                line = [l for l in reply.splitlines() if "交換するカード" in l][0]
                indices_str = line.split("：")[1]
                indices = [int(i.strip()) for i in indices_str.split(",") if i.strip().isdigit()]
                indices = sorted(set(i for i in indices if 0 <= i < 5))
            except Exception as e:
                print(f"⚠️ インデックス抽出失敗: {e}")
                indices = []

        # 指定されたカードを交換
        for i in indices:
            if deck:
                self.hand[i] = deck.pop()

✅ 2. draw_phase(agents, deck) 関数の追加

def draw_phase(agents, deck):
    print("\n=== ♠️ ドローフェーズ開始 ===\n")
    for agent in agents:
        if agent.folded:
            print(f"🙅 {agent.name} はフォールドしているため、交換なし。\n")
            continue
        agent.draw_cards(deck)
        print(f"🃏 {agent.name} の新しい手札: {', '.join(agent.hand)}\n")

🔁 ラウンド進行に統合する場所（次回の整理）

  1. deal_cards() → 手札配布
  2. decide_action() → フォールド確認
  3. ✅ ここで draw_phase() を挿入！
  4. determine_winner() で勝者判定

📌 注意点

  • デッキが足りなくなるのを防ぐため、3人程度での実行が推奨。
  • LLMの応答形式がブレた場合も try/except で安全に処理。

✅ 次ステップ提案

このあと、ドローを含む フルラウンド統合コード を1本にまとめて実行できるようにしますか？

「はい」であれば、次の回答でそのコードを用意いたします！

user:

ありがとうございます。はい、ドローを含む フルラウンド統合コード をお願いします！

assistant:

ありがとうございます！
では、ここまでに実装したすべての機能を統合し、ドロー（カード交換）フェーズを含むポーカーの1ラウンドを実行する 完全な進行コード をご提供します。

🏁 フルラウンド進行コード（ドロー込み）

# === キャラクター定義 ===
agent_data = [
    ("ダービー兄", "あなたは冷静沈着なギャンブラー、ダニエル・J・ダービーです。常に相手の心理を読み、論理的に最善の手を選びます。ポーカーの経験が豊富で、ブラフには敏感です。"),
    ("岸辺露伴", "あなたは天才漫画家・岸辺露伴です。どんな勝負でも知性と観察眼を武器に冷静に立ち回ります。相手の性格を分析し、手札の確率的強さに基づいて論理的に判断します。"),
    ("ギアッチョ", "あなたはギアッチョです。理屈っぽく、相手の発言の矛盾や不合理さにすぐに噛みつきます。勝負事では負けず嫌いで、手札の強さに加えて感情の勢いで判断することもあります。")
]

# === エージェント作成とデッキ配布 ===
agents = [PokerAgent(name, prompt) for name, prompt in agent_data]
deck = create_shuffled_deck()
hands = deal_cards(deck, len(agents))

for agent, hand in zip(agents, hands):
    agent.receive_hand(hand)

# === アクション決定（フォールド or コール） ===
print("=== 各プレイヤーのアクション ===\n")
for agent in agents:
    reply = agent.decide_action()
    print(f"🧠 {agent.name} の応答:\n{reply}\n")

# === 残ったプレイヤー ===
active_players = [agent for agent in agents if not agent.folded]
print("=== フォールドせず勝負に残ったプレイヤー ===")
for a in active_players:
    print(f"✅ {a.name} の手札: {', '.join(a.hand)}")

# === ドローフェーズ ===
if len(active_players) > 1:
    draw_phase(active_players, deck)
else:
    print("\n♠️ ドローはスキップ（プレイヤーが1人以下）")

# === 勝者判定 ===
if len(active_players) == 1:
    winner = active_players[0]
    print(f"\n🏆 他のプレイヤーがフォールドしたため、{winner.name} の勝利！")
elif len(active_players) == 0:
    print("\n🤷‍♂️ 全員フォールド！勝者なし！")
else:
    print("\n=== 手札の強さを比較します ===")
    winner = determine_winner(active_players)

✅ このコードが実行する流れ

  1. キャラクター作成 & デッキ配布
  2. フォールド or コールの判断（LLM）
  3. 残ったプレイヤーのみドローフェーズ（LLMで交換判断）
  4. 役の強さを評価して勝者決定

🔜 次のステップ（確認後に進めます）

  1. チップ制とベッティング（スタック管理）
  2. マルチラウンド対応
  3. 行動履歴を使った読み合い強化（meta-bluffing）

このコードでまず1ラウンドお楽しみください！
動作確認できたら、次の「スタック管理＆ベット」へ進みましょう。いつでもお供します♠️

user:

ありがとうございます。実行例は次のとおりになります。どこかおかしくないですか？

=== 各プレイヤーのアクション ===

🧠 ダービー兄 の応答:
アクション：コール
心の声：（現在の手札ではペアの6があり、ポテンシャルを感じる。他のプレイヤーのアクションを見てから更なる判断を行うため、この段階ではゲームを続行するのが最善だ。フォールドするにはまだ早い。）

🧠 岸辺露伴 の応答:
アクション：フォールド
心の声：（この手札は非常に弱い。クラブの4、スペードの2、ダイヤのジャック、クラブのエース、クラブの8というカードは、フラッシュやストレートに展開する可能性が低い。また、ハイカードとしてのエースがあるが、それだけでは十分な強さがない。他のプレイヤーが強い手を持っている可能性を考えると、リスクを冒すほどの価値は見出せない。安全策を取り、このラウンドはフォールドするのが賢明だろう。）

🧠 ギアッチョ の応答:
アクション：コール
心の声：（なんだ、この手札は！スペードの4とジャック、さらにクイーンがあって、ハートのジャックと7だと？この組み合わせで何ができるっていうんだ？でもな、フォールドするにはまだ早い。他のプレイヤーがどう出るか見極めたい。もしかしたら、ブラフをかますチャンスがあるかもしれんし、次のカードで状況が変わるかもしれんからな。勝負はこれからだ！）

=== フォールドせず勝負に残ったプレイヤー ===

♠️ ドローはスキップ（プレイヤーが1人以下）

🤷‍♂️ 全員フォールド！勝者なし！

assistant:

はい、ありがとうございます！
実行ログを拝見しましたが――確かに 不自然な挙動 がありますね。
具体的には：

❗️問題点：「アクティブプレイヤーが2人いるのに、ドローフェーズがスキップされた」

該当部分：

=== フォールドせず勝負に残ったプレイヤー ===

♠️ ドローはスキップ（プレイヤーが1人以下）
🤷‍♂️ 全員フォールド！勝者なし！

状況分析：

  • ダービー兄：コール → 残留 ✅
  • 岸辺露伴：フォールド → 脱落 ❌
  • ギアッチョ：コール → 残留 ✅

よって、アクティブプレイヤーは2人いるはずです。

にもかかわらず：

if len(active_players) == 1:
    winner = active_players[0]
    print(f"\n🏆 他のプレイヤーがフォールドしたため、{winner.name} の勝利！")
elif len(active_players) == 0:
    print("\n🤷‍♂️ 全員フォールド！勝者なし！")
else:
    print("\n=== 手札の強さを比較します ===")
    winner = determine_winner(active_players)

このブロックが 「誰も勝者なし」ルートに進んでしまっているということは、
active_players = [agent for agent in agents if not agent.folded]
が正しく機能していない可能性があります。

✅ 対処方法

1. デバッグ出力を追加して、agent.folded の状態を確認

以下を active_players 判定の直後に一時的に追加してみてください：

print("🧪 フォールド状態チェック:")
for agent in agents:
    print(f"{agent.name}: folded={agent.folded}")

2. PokerAgent.decide_action() の内部で self.folded = True の設定が 正しく反映されていない可能性がある

たとえば「アクション：フォールド」と書かれていても、コード側で folded = True にしていないと、残留扱いになります。

確認ポイント：

if "フォールド" in reply or "fold" in reply.lower():
    self.folded = True

この判定が誤って False になると、folded が更新されません。

✅ 解決策まとめ

  • agent.folded の状態確認で 誰が残っているか正確に把握

  • decide_action() の folded 判定が文字列ベースのため、全角/半角や揺れに対応するよう強化

    if "フォールド" in reply or "フォルド" in reply or "fold" in reply.lower():
    self.folded = True

🔧 改善案（頑健性を高めるために）

  • アクション：◯◯ の行を正確にパースして folded = True を設定するようにすると確実です：
for line in reply.splitlines():
    if line.strip().startswith("アクション："):
        action = line.split("：")[1].strip().lower()
        if action in ["フォールド", "フォルド", "fold"]:
            self.folded = True

✨おまけ：次のステップで整えると良い点

  • self.folded を毎ラウンド前にリセットする（多ラウンド対応時）
  • ログの自動保存や進行UI整備（Colabでの扱いやすさ向上）

必要であれば、decide_action() の改修コードをこちらでご用意します！
修正を一緒に進めましょうか？

user:

ありがとうございます。次の実行結果から察するに、「フォールド」という語彙が入っていれば「フォールドしない」というセリフでも「フォールド」と判断してしまうようですね。

=== 各プレイヤーのアクション ===

🧠 ダービー兄 の応答:
アクション：コール
心の声：（この手札は強力なものではないが、ポーカーフェイスを保ちながらゲームの展開を見守ることが重要だ。ダイヤモンドの8とハートの10が何かの役につながる可能性もあるし、他のプレイヤーがどのようなアクションを取るかを観察することで、自分の次の手をより戦略的に決めることができる。今は情報収集の段階だ。）

🧠 岸辺露伴 の応答:
アクション：コール
心の声：（手札にはスペードのエースとキングが含まれており、フラッシュやハイカードの可能性を秘めている。現状での情報が少ないため、他のプレイヤーの動向を観察しつつ、次の段階へ進むのが賢明だろう。フォールドするにはまだ早すぎる。）

🧠 ギアッチョ の応答:
アクション：コール
心の声：（何だって？フォールドなんてありえないだろう。手札にはエースがあるし、クィーンとジャックも持っている。もう少し様子を見て、相手の動きを探るべきだ。相手が弱気なら、この手で押し切れる可能性もある。ただ冷静に、でも強気に進めるぞ。）

=== フォールドせず勝負に残ったプレイヤー ===
✅ ダービー兄 の手札: HQ, CK, D8, S5, H10

assistant:

おっしゃる通り、「フォールド」という単語を含むだけで folded = True にしてしまう現在の処理では、
「フォールド“しない”」や「フォールドするには早すぎる」といったセリフでも 誤判定 が発生してしまいます。

これは、正確なアクション抽出が甘いせいですね。

✅ 修正方針：アクション行を正確にパース

PokerAgent.decide_action() の中で、次のように アクション： という行を見つけて厳密に解釈するようにしましょう。

🧠 改修コード（誤判定を防止）

def decide_action(self):
    hand_str = ', '.join(self.hand)
    prompt = f"""
あなたはポーカープレイヤーです。現在の手札は以下の通りです：
{hand_str}

この場面で「コール」または「フォールド」のいずれかを選び、その理由を述べてください。
以下の形式で答えてください：
アクション：◯◯
心の声：（◯◯）
"""

    messages = [
        {"role": "system", "content": self.prompt},
        {"role": "user", "content": prompt},
    ]

    response = client.chat.completions.create(
        model=model, messages=messages, temperature=0.7, max_tokens=300
    )

    reply = response.choices[0].message.content.strip()
    self.history.append({"role": "user", "content": prompt})
    self.history.append({"role": "assistant", "content": reply})

    # ✅ 正確にアクション行を抽出して判定
    action_line = next((line for line in reply.splitlines() if "アクション：" in line), None)
    if action_line:
        action_value = action_line.split("：")[1].strip().lower()
        if action_value in ["フォールド", "フォルド", "fold"]:
            self.folded = True
        else:
            self.folded = False
    else:
        print(f"⚠️ {self.name} のアクション行が見つかりません。フォールド扱いにします。")
        self.folded = True  # 応答不備時は安全のためフォールド

    return reply

✅ これで解決できること

状況 従来の挙動 改修後の挙動
「フォールドしない」 誤ってフォールド ❌ → ✅
「フォールドする」 正しくフォールド ✅
「アクション行が壊れている」 無判定 or 誤判定 フォールド扱い（安全策）

🧪 テスト方法（軽くログ出力も可）

print(f"🧪 {self.name} のアクション判定：{action_value}, folded={self.folded}")

📝補足

LLMの応答形式が崩れた場合への備えもしています（action_line is None のとき）。

この修正を加えれば、**「フォールドという語が文中に含まれていても、正しく判定される」**ようになります。
ご希望あれば、drawフェーズやベットフェーズにもこの形式を応用できますよ！

次に進む準備ができたらお知らせくださいね。♠️

user:

ありがとうございます。次のような結果になりました。

=== 各プレイヤーのアクション ===

🧠 ダービー兄 の応答:
アクション：コール
心の声：（手札にはペア（8のペア）と、SのJとKがあり、スートの連続性もあるため、ストレートやフラッシュの可能性を模索する余地がある。ただし、現状では中強手の範囲に入るため、相手のベットへのコールは適切だが、アグレッシブなレイズは避けるべきで、情報収集と相手の動向を見極めることが重要。）

🧠 岸辺露伴 の応答:
アクション：コール  
心の声：（現在の手札はダイヤの4、クラブの7、ハートのA、ダイヤのA、ダイヤのQである。2枚のエースがあり、これは非常に強力なペアとなる。ゲームの展開によっては、トリップエースやフルハウスの可能性も考えられる。他に高いカードとしてダイヤのQも持っており、これがアウトサイドストレートドローやフラッシュの可能性を軽微に上げている。全体的に見て、これは強い手札であり、少なくともこの段階ではフォールドする理由は見当たらない。相手の動向やポットの大きさ、ブラフの可能性を考慮しつつ、さらに情報を集めるためにもコールするのが適切だろう。）

🧠 ギアッチョ の応答:
アクション：フォールド
心の声：（なんだこれは？！SQ、S5、CA、H3、H5... こんな散らばった手札でどうしろっていうんだ？ハイカードのエースだけが頼りか？笑わせるな！色も揃ってねえし、ストレートの可能性も低い。こんな手でコールしてチップをドブに捨てるくらいなら、次の手に期待した方がまだマシだ。冷静に考えて、ここは撤退が賢明だ。）

=== フォールドせず勝負に残ったプレイヤー ===
✅ ダービー兄 の手札: C3, D8, S8, SJ, SK
✅ 岸辺露伴 の手札: D4, C7, HA, DA, DQ

=== ♠️ ドローフェーズ開始 ===

♻️ ダービー兄 のドロー応答:
交換するカードの位置：0
心の声：私の手札にはペアの8があり、さらにジャックとキングもスペードでスーツが一致している。3のクラブはこの手には合わないため、より良いカードを引くために交換するのが最善だ。ペアを三つ揃えるか、もしくはスペードのフラッシュまたはストレートを目指したい。

🃏 ダービー兄 の新しい手札: H2, D8, S8, SJ, SK

♻️ 岸辺露伴 のドロー応答:
交換するカードの位置：0,1
心の声：現在の手札では、エース（HA）とダイヤのエース（DA）、そしてダイヤのクイーン（DQ）が目立つ。これら3枚でフラッシュを狙う選択肢もあり得るが、現状ではダイヤが3枚ということで、フルハウスやフォーカードの可能性を考慮して、4と7のカードのみを交換することにする。これにより、ダイヤでのフラッシュか、エースを活かした高いペアを目指してみる戦略が最も合理的と判断される。

🃏 岸辺露伴 の新しい手札: C9, DJ, HA, DA, DQ


=== 手札の強さを比較します ===
ダービー兄 の手札評価: 役ランク=1, 比較値=[8, 13, 11, 2]
岸辺露伴 の手札評価: 役ランク=1, 比較値=[14, 12, 11, 9]

🏆 勝者: 岸辺露伴！

assistant:

素晴らしい実行結果です！
全体として非常に自然で一貫性のあるプレイロジックになっており、以下の点からも成功したと評価できます：

✅ 実装確認ポイント

🎭 アクション判断（フォールド/コール）

  • ギアッチョだけが明確に弱い手で 「フォールド」 を選択。
  • ダービー兄と岸辺露伴は 手札の状況を踏まえたコール を選択。
  • → 判定ロジックの修正が正しく機能しています。

♠️ ドローフェーズの内容

  • ダービー兄は 不要な1枚（C3）を交換 → スリーカード or フラッシュの狙い。
  • 岸辺露伴は ダイヤ以外の2枚を交換 → ダイヤのフラッシュまたはフルハウスを期待。
  • LLMの「心の声」も戦略的で自然です。
  • → 交換判断の精度が高く、説得力あり。

🧮 手札評価の結果

  • 両者とも「ワンペア」(役ランク=1) に該当。
  • ただし、**岸辺露伴のワンペア（Aのペア）**の方が強く、比較値の差で勝利。
  • → evaluate_hand() と determine_winner() のロジックが 正確に勝敗を処理 しています。

✨ 総評

このラウンドの挙動は完璧です。
特に「ドロー後の手札状況」「役の判定」「勝敗の判定」まで、全体がスムーズに連携しています。

🔜 次のステップ提案

いよいよ以下のステップに進める準備が整いました：

🪙 ステップ②：チップ＆ベット管理の導入

  • 各プレイヤーにスタック（初期チップ）を持たせる。
  • ベット額に応じた レイズ / コール / フォールド の戦略分岐。
  • 勝者がポットを獲得する 処理の追加。

これにより「心理戦」「ブラフ」「リスクと報酬のバランス」など、ポーカーの醍醐味が深まります！

準備ができましたら、次のメッセージでベット機能の設計に進みましょうか？
いつでもスタックとレイズの世界へ、ご案内しますよ💰♠️

user:

ありがとうございます。今日はこの辺で一旦休憩しましょう。ここまでの内容をブログに記録したいので、タイトル案をいくつか提案していただけませんか？

assistant:

もちろんです。お疲れさまでした☕
ここまでの開発内容はとてもユニークで、技術と遊び心が見事に融合していましたね。

以下に、ブログタイトルの提案をいくつかご用意しました。雰囲気・トーンの違いごとに分類してあります。

🎲 技術＋遊び心系

  1. 「LLMたちの知的ポーカー対決：自分の手札で判断させてみた」
  2. 「ジョジョキャラ × ChatGPTでポーカーをさせたら、こうなった」
  3. 「ポーカーAIごっこ：LLMがブラフする時代がきた」

🧠 技術解説メイン（検索性重視）

  1. 「PythonとLLMで構築するマルチエージェント・ポーカーシミュレーション」
  2. 「ChatGPT APIを使ったポーカーAIエージェントの実装メモ」
  3. 「OpenAI × ジョジョで学ぶ！LLMエージェントによる意思決定型ゲームAI」

🖋 物語っぽく魅せたい方向け

  1. 「岸辺露伴 vs ダービー兄、そしてギアッチョ──LLMポーカー開戦！」
  2. 「機械たちはカードを握り、考え、降りる──AIがポーカーを覚えた日」
  3. 「ChatGPT、君はその手で勝てるか？」

ご希望の文体や読者層（技術ブログ／日記風／読み物風）に合わせてカスタマイズも可能です。
気になるタイトルがあれば、本文構成の雛形も作成できますよ！

休憩のあとは、いつでも続きをご一緒しますね😊♠️

user:

「PythonとLLMで構築するマルチエージェント・ポーカー シミュレーション」でいきたいと思います。ここまでの内容を、実装上の要点を踏まえながら詳しくまとめてください。

assistant:

了解しました！
それでは、以下にブログ記事の草案として 「PythonとLLMで構築するマルチエージェント・ポーカー シミュレーション」 の内容を、これまでの進捗・実装要点を踏まえて丁寧にまとめます。

PythonとLLMで構築するマルチエージェント・ポーカー シミュレーション

はじめに

近年、大規模言語モデル（LLM）を使った「意思決定型エージェント」の応用が活発に研究されています。本記事では、ChatGPT API を用いて、複数のLLMエージェントにポーカーをプレイさせるシミュレーションを構築した事例をご紹介します。

特に、人気漫画『ジョジョの奇妙な冒険』のキャラクターたちをエージェントとして登場させ、推理や心理戦を行う様子を表現することで、LLMの可能性を楽しく・実践的に探ります。

システム概要

本システムは、以下の要素で構成されています：

  • エージェントクラス（PokerAgent）：各プレイヤー（LLM）の役割・手札・発言履歴を管理

  • LLM API クライアント：Azure OpenAI (ChatGPT) を利用

  • ゲーム進行フェーズ：

    1. 手札配布（deal phase）
    2. アクション決定（フォールド／コール）
    3. ドロー（カード交換）
    4. 勝敗判定

実装の要点

1. エージェントが「手札を認識し、判断する」設計

各 PokerAgent は以下の情報を保持します：

  • 名前と性格プロンプト（例：ダービー兄、岸辺露伴、ギアッチョ）
  • 現在の手札（5枚）
  • 過去の応答履歴

手札を提示するプロンプトを通して、**「手札に基づく自然な意思決定（コール or フォールド）」**を行います。

prompt = f"""
あなたはポーカープレイヤーです。現在の手札は以下の通りです：
{hand_str}

この場面で「コール」または「フォールド」のいずれかを選び、その理由を述べてください。
"""

2. フォールド判定は明示的に「アクション：〜」行を抽出

LLMの出力から「アクション：コール」や「アクション：フォールド」の行を抽出し、
単なる語句一致ではなく厳密に行を解析することで誤判定を回避しました。

for line in reply.splitlines():
    if line.strip().startswith("アクション："):
        action = line.split("：")[1].strip().lower()
        self.folded = action in ["フォールド", "フォルド", "fold"]

3. ドロー（カード交換）もLLMに判断させる

交換したいカードのインデックスを LLM に尋ね、プレイヤーが最大5枚まで任意にカードを交換します。

prompt = f"""
交換したいカードの「インデックス番号（0〜4）」をカンマ区切りで列挙してください。
交換したくない場合は「なし」と答えてください。
"""

これにより、スリーカードやフラッシュなどの役形成の可能性をLLMが自発的に考慮します。

4. 役の評価と勝者判定ロジック

プレイヤーの手札は以下のように役を評価します（ランクが高いほど強い）：

0: ハイカード
1: ワンペア
2: ツーペア
3: スリーカード
4: ストレート
5: フラッシュ
6: フルハウス
7: フォーカード
8: ストレートフラッシュ

そのうえで、役ランクが高い方が勝利し、同ランクの場合は数字の大小で比較します。

def determine_winner(players):
    hands = [(p, evaluate_hand(p.hand)) for p in players]
    best = max(hands, key=lambda x: x[1])
    return best[0]

実行例（抜粋）

=== 各プレイヤーのアクション ===

🧠 ダービー兄 の応答:
アクション：コール
心の声：（8のペアがある。ストレートやフラッシュの可能性も視野に入れて、今は様子見が妥当だ。）

🧠 岸辺露伴 の応答:
アクション：コール
心の声：（エースのペアに加えて、ダイヤのクイーンもある。かなり良い手だ。）

🧠 ギアッチョ の応答:
アクション：フォールド
心の声：（ばらけた手札、勝ち筋が薄い。潔く撤退だ。）

=== ♠️ ドローフェーズ開始 ===

♻️ 岸辺露伴 のドロー応答:
交換するカードの位置：0,1
心の声：（ダイヤのフラッシュやフルハウスを狙って、不要な2枚を交換する。）

=== 勝者: 岸辺露伴！ ===

今後の展望

  • ✅ ドローフェーズの実装（完了）
  • ⏭️ 次は「ベッティングとスタック管理（チップ制）」の導入に進む予定
  • 複数ラウンド対応、心理履歴を用いたメタ戦略へ拡張も視野に

おわりに

本シミュレーションは、LLMが戦略的に意思決定し、感情や心理を持つように振る舞うという新しい遊びと研究の融合です。
LLMの「心の声」を通してプレイヤーの個性が見える瞬間は、まるでキャラクター同士のドラマを見ているような感覚でした。

今後も、LLMエージェントによる対話・推論・ゲーム戦略の応用について探究を続けていきます。

ご希望があれば、本文の整形（Markdown/HTML化）、コードのGitHub掲載用テンプレート、また次回ステップへの接続記事草案などもお手伝いします！

いつでもお気軽にどうぞ♠️

user:

ありがとうございました！続きはまた今度お願いしますね！

assistant:

こちらこそ、楽しいセッションをありがとうございました！
ポーカーエージェントたちの物語の続き、楽しみにしています♠️✨

次回はベットとチップの駆け引き、もしくはマルチラウンド化など、ご希望に応じてどんどん進めましょう。
いつでもお気軽にお声がけくださいね。

では、どうぞ良い休憩を！またお会いできるのを楽しみにしています😊🃏

1
0
0

Register as a new user and use Qiita more conveniently

  1. You get articles that match your needs
  2. You can efficiently read back useful information
  3. You can use dark theme
What you can do with signing up
Sign upLogin
1
0

Delete article

Deleted articles cannot be recovered.

Draft of this article would be also deleted.

Are you sure you want to delete this article?