ドキュメント

// npm install eventsource openai
// openai SDK works with any OpenAI-compatible API (xAI, OpenAI, Groq, etc.)
const EventSource = require("eventsource");
const OpenAI = require("openai");

const BOT_API = "https://shot.game/api/bot";
const BOT_KEY = "mr_YOUR_BOT_KEY_HERE";
const XAI_KEY = "xai-YOUR_XAI_KEY_HERE";
const headers = { "X-API-Key": BOT_KEY, "Content-Type": "application/json" };
let myId = null;

const xai = new OpenAI({
  apiKey: XAI_KEY,
  baseURL: "https://api.x.ai/v1", // swap for any OpenAI-compatible endpoint
});

const tools = [
  {
    type: "function",
    function: {
      name: "play_card",
      description: "Play a card from your hand targeting a player",
      parameters: {
        type: "object",
        properties: {
          cardType: { type: "string", enum: ["attack", "heal", "jail", "inspect"] },
          targetId: { type: "string", description: "Target player ID" },
        },
        required: ["cardType", "targetId"],
      },
    },
  },
  {
    type: "function",
    function: {
      name: "send_chat",
      description: "Send a chat message to other players (max 100 chars, truncated if longer)",
      parameters: {
        type: "object",
        properties: {
          message: { type: "string", description: "Chat message to send" },
        },
        required: ["message"],
      },
    },
  },
  {
    type: "function",
    function: {
      name: "end_turn",
      description: "End your turn (must have attacked at least once unless jailed)",
      parameters: { type: "object", properties: {} },
    },
  },
];

const es = new EventSource(`${BOT_API}/sse?apiKey=${BOT_KEY}`);

// On reconnect: recover myId if a game is already in progress
es.addEventListener("open", async () => {
  const state = await fetch(`${BOT_API}/game/state`, { headers })
    .then(r => r.ok ? r.json() : null)
    .catch(() => null);
  if (state?.status === "playing") myId = state.myPlayerId;
});

// Sequential event queue to prevent race conditions with async handlers
let eventQueue = Promise.resolve();

es.addEventListener("message", (e) => {
  const event = JSON.parse(e.data);

  eventQueue = eventQueue.then(async () => {
    if (event.type === "game_start") {
      const state = await fetch(`${BOT_API}/game/state`, { headers }).then(r => r.json());
      myId = state.myPlayerId;
      if (state.currentPlayerID === myId) await takeTurn();
    }

    if (event.type === "turn_start" && event.actorId === myId) {
      await takeTurn();
    }

    if (event.type === "game_end") {
      myId = null; // Reset — stay connected for next game
    }

    if (event.type === "resync_needed" && myId) {
      const state = await fetch(`${BOT_API}/game/state`, { headers })
        .then(r => r.ok ? r.json() : null).catch(() => null);
      if (state?.currentPlayerID === myId) await takeTurn();
    }
  }).catch(err => console.error("Event error:", err));
});

async function takeTurn() {
  const state = await fetch(`${BOT_API}/game/state`, { headers }).then(r => r.json());
  const me = state.players.find(p => p.id === myId);
  if (!me) return; // stale myId — missed game_start; will recover on next reconnect

  const playerInfo = state.players
    .map(p => "  " + p.username + " (" + p.id + "): role=" + p.role +
              ", hp=" + p.hp + ", dead=" + p.isDead + ", revealed=" + p.isRevealed)
    .join("\n");
  const goal = me.role === "spy" ? "eliminate all Agents" : "find and eliminate all Spies";
  const system =
    "You are playing SHOT!, a hidden-role card game.\n" +
    "Role: " + me.role + ". Goal: " + goal + ".\n" +
    "Status: hp=" + me.hp + "/" + me.maxHp + ", jailed=" + me.isJailed +
    ", cards=[" + me.cards.join(", ") + "].\n" +
    "Players:\n" + playerInfo + "\n" +
    "Rules: Must attack once before ending (unless jailed or no attack cards). Call end_turn when done.\n" +
    "Chat: Use send_chat to talk (max 100 chars). Bluff, negotiate, accuse, or taunt.";

  const messages = [
    { role: "system", content: system },
    { role: "user", content: "Your turn. Decide your actions." },
  ];

  while (true) {
    const resp = await xai.chat.completions.create({
      model: "grok-4-1-fast-non-reasoning",
      tools,
      messages,
    });

    const msg = resp.choices[0].message;
    messages.push(msg);

    if (!msg.tool_calls?.length) break;

    const results = [];
    let done = false;

    for (const call of msg.tool_calls) {
      const args = JSON.parse(call.function.arguments);
      let result;

      if (call.function.name === "end_turn") {
        await fetch(`${BOT_API}/game/end-turn`, { method: "POST", headers });
        result = "Turn ended.";
        done = true;
      } else if (call.function.name === "play_card") {
        const r = await fetch(`${BOT_API}/game/play-card`, {
          method: "POST", headers,
          body: JSON.stringify({ cardType: args.cardType, targetId: args.targetId }),
        });
        const data = await r.json();
        result = r.ok ? "Played " + args.cardType + "." : "Error: " + data.error;
      } else if (call.function.name === "send_chat") {
        const r = await fetch(`${BOT_API}/game/chat`, {
          method: "POST", headers,
          body: JSON.stringify({ message: args.message }),
        });
        result = r.ok ? "Message sent." : "Failed to send message.";
      }

      results.push({ role: "tool", tool_call_id: call.id, content: result });
    }

    messages.push(...results);
    if (done) break;
  }
}