Too Many Dice SDK

npm install too-many-dice

Copy

import { TooManyDiceRoom } from "too-many-dice";

// 1. Create a room
const room = await TooManyDiceRoom.create("myapp.partykit.dev", {
  playerLimit: 4,
  diceConfig: [{ type: "d6" }, { type: "d6" }],
  callbacks: {
    onPlayerJoined: (player) => console.log(`${player.name} joined`),
    onPlayerLeft: (player) => console.log(`${player.name} left`),
    onResult: (results) => console.log("Roll results:", results),
  },
});

console.log("Room code:", room.roomCode); // Share with players

// 2. Players open the TooManyDice app and enter the room code.

// 3. Trigger a roll once players are connected
const results = await room.roll();

// 4. Clean up
await room.destroy();

Copy

create() → share roomCode → players join via app → orchestrate gameplay → destroy()

const room = await TooManyDiceRoom.create("myapp.partykit.dev", {
  playerLimit: 4,
  diceConfig: [{ id: "atk", type: "d20" }],
  callbacks: { onPlayerJoined, onPlayerLeft, onResult, onFormSubmit },
});

Copy

await room.setDice([
  { id: "strength", type: "d20" },
  { id: "bonus", type: "d4" },
]);

Copy

// First available player handles the physics
const results = await room.roll();

// Specific player handles the physics
const results = await room.roll(room.players[0]);

Copy

const results = await room.waitForRoll(room.players[0]);

// With custom timeout (60 seconds)
const results = await room.waitForRoll(room.players[0], 60000);

Copy

await room.closeAccess();

Copy

await room.openAccess();

Copy

await room.enableSwipeGestures(false); // disable
await room.enableSwipeGestures(true);  // re-enable

Copy

await room.destroy();

Copy

const room = await TooManyDiceRoom.create(host, {
  callbacks: {
    onPlayerJoined(player) {
      console.log(`${player.name} (${player.playerId}) joined`);
    },
    onPlayerLeft(player) {
      console.log(`${player.name} left`);
    },
    onResult(results) {
      for (const r of results) {
        console.log(`Die ${r.diceId} (${r.dieType}): ${r.value}`);
      }
    },
    onFormSubmit({ formId, playerId, answers }) {
      console.log(`Player ${playerId} submitted form ${formId}:`, answers);
    },
  },
});

Copy

import { TextForm, PickerForm, CheckboxForm } from "too-many-dice";

await room.sendSubmitForms([
  {
    formId: "character-setup",
    targetPlayer: room.players[0],
    fields: [
      new TextForm("name", "Character name", {
        placeholder: "Enter name",
        required: true,
      }),
      new PickerForm("class", "Class", ["Warrior", "Mage", "Rogue"]),
      new CheckboxForm("veteran", "Veteran player?"),
    ],
    submitButton: { label: "Confirm" },
  },
]);

// Results arrive via callbacks.onFormSubmit
// answers: { name: "Elara", class: "Mage", veteran: true }

Copy

await room.clearSubmitForms();

Copy

await room.setFormErrors("character-setup", room.players[0], [
  "Name must be at least 3 characters",
]);

Copy

import { SliderForm, MultiSelectForm } from "too-many-dice";

let currentStrength = 10;
let selectedPerks = [];

const handle = await room.sendCallbackForm({
  targetPlayer: room.players[0],
  fields: [
    {
      field: new SliderForm("str", "Strength", 1, 20, 1),
      onChange: (value) => { currentStrength = value; },
    },
    {
      field: new MultiSelectForm("perks", "Perks", [
        "Shield", "Haste", "Berserk",
      ]),
      onChange: (value) => { selectedPerks = value; },
    },
  ],
  buttons: [
    {
      label: "Confirm Build",
      onClick: (playerId) => {
        console.log(`${playerId} confirmed: str=${currentStrength}`);
        handle.clear();
      },
    },
  ],
});

// Dismiss manually at any time:
await handle.clear();

Copy

new CheckboxForm("agree", "I agree to the rules");
new CheckboxForm("agree", "I agree to the rules", { required: true });

Copy

new TextForm("username", "Your name");
new TextForm("username", "Your name", {
  placeholder: "e.g. Gandalf",
  required: true,
});

Copy

new PickerForm("difficulty", "Difficulty", ["Easy", "Normal", "Hard"]);
new PickerForm("difficulty", "Difficulty", ["Easy", "Normal", "Hard"], {
  required: true,
});

Copy

new MultiSelectForm("skills", "Choose skills", [
  "Fireball", "Shield", "Haste",
]);
new MultiSelectForm("skills", "Choose skills", [
  "Fireball", "Shield", "Haste",
], { required: true });

Copy

// (id, label, min, max, step, options?)
new SliderForm("hp", "Hit Points", 1, 100, 5);
new SliderForm("hp", "Hit Points", 1, 100, 5, { required: true });

Copy

new DpadForm("move", "Move Direction");
new DpadForm("move", "Move", {
  up: { visibility: "enabled" },
  down: { visibility: "disabled" },
  left: { visibility: "hidden" },
  required: true,
});

Copy

import type {
  DiceConfig,
  DiceResult,
  DieType,
  TooManyDiceCallbacks,
  CreateRoomOptions,
  SubmitFormGroup,
  CallbackField,
  CallbackButton,
  CallbackFormOptions,
  CallbackFormHandle,
  TmdForm,
  DpadVisibility,
  DpadDirectionConfig,
  DpadFieldDef,
  DpadFormOptions,
} from "too-many-dice";

Copy

type DieType = "d4" | "d6" | "d8" | "d10" | "d12" | "d20";

interface DiceConfig {
  id?: string;
  type: DieType;
}

interface DiceResult {
  diceId: string;
  value: number;
  dieType: DieType;
}

import {
  TooManyDiceRoom, TextForm, PickerForm, SliderForm,
} from "too-many-dice";

const HOST = "myapp.partykit.dev";

async function runGame() {
  const characters = new Map();

  const room = await TooManyDiceRoom.create(HOST, {
    playerLimit: 2,
    callbacks: {
      onPlayerJoined: (p) =>
        console.log(`${p.name} joined (${room.players.length}/2)`),
      onFormSubmit: ({ playerId, answers }) => {
        characters.set(playerId, answers);
      },
    },
  });

  console.log("Share this code with players:", room.roomCode);

  // Wait for 2 players
  await new Promise((resolve) => {
    const interval = setInterval(() => {
      if (room.players.length === 2) {
        clearInterval(interval);
        resolve();
      }
    }, 500);
  });

  await room.closeAccess();

  // Send each player a character setup form
  await room.sendSubmitForms(
    room.players.map((p) => ({
      formId: `char-${p.playerId}`,
      targetPlayer: p,
      fields: [
        new TextForm("name", "Character name", { required: true }),
        new PickerForm("class", "Class", ["Warrior", "Mage", "Rogue"]),
        new SliderForm("level", "Starting level", 1, 10, 1),
      ],
      submitButton: { label: "Ready!" },
    })),
  );

  // Wait for submissions
  await new Promise((resolve) => {
    const interval = setInterval(() => {
      if (characters.size === 2) {
        clearInterval(interval);
        resolve();
      }
    }, 200);
  });
  await room.clearSubmitForms();

  // Play turns
  await room.setDice([{ id: "atk", type: "d20" }]);
  for (const player of room.players) {
    console.log(`${player.name}'s turn — rolling d20...`);
    const results = await room.roll(player);
    console.log("Result:", results);
  }

  await room.destroy();
}

runGame().catch(console.error);

Copy