Moddable Games Tools

Get a random chess puzzle. Filter by variant or difficulty. Variant puzzles have no themes and max rating 1400 — theme and hard difficulty filters only apply to standard puzzles.

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string",
      "description": "Chess variant slug, camelCase or kebab-case (e.g. antichess, almost-chess, atomic, chess960, standard). Returns only puzzles for this variant."
    },
    "difficulty": {
      "type": "string",
      "enum": [
        "easy",
        "medium",
        "hard"
      ],
      "description": "Puzzle difficulty (variant puzzles max at 1400, so hard returns nothing for variants)"
    },
    "theme": {
      "type": "string",
      "description": "Puzzle theme (fork, pin, skewer, mateIn2, etc). Only standard puzzles carry themes."
    }
  }
}

List available puzzle variants, themes, and per-variant counts from the puzzle pool

{
  "type": "object",
  "properties": {}
}

[DEPRECATED — use play_list_variants] List chess variants. Removal: v1.0.0.

{
  "type": "object",
  "properties": {
    "group": {
      "type": "string"
    }
  }
}

[DEPRECATED — use play_create_game + play_get_moves] Get legal moves for a chess position. Removal: v1.0.0.

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    }
  }
}

[DEPRECATED — use play_suggest_move] Analyse a chess position. Removal: v1.0.0.

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    },
    "depth": {
      "type": "number"
    }
  }
}

[DEPRECATED — use play_apply_move] Apply a move to a chess game. Removal: v1.0.0.

{
  "type": "object",
  "properties": {
    "move": {
      "type": "object"
    },
    "variant": {
      "type": "string"
    }
  },
  "required": [
    "move"
  ]
}

[DEPRECATED — use play_validate_move] Check if a chess move is legal. Removal: v1.0.0.

{
  "type": "object",
  "properties": {
    "move": {
      "type": "object"
    },
    "variant": {
      "type": "string"
    }
  },
  "required": [
    "move"
  ]
}

[DEPRECATED — use play_check_status] Get chess game status. Removal: v1.0.0.

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    }
  }
}

[DEPRECATED — use play_render_board] Render a chess position as SVG. Removal: v1.0.0.

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    },
    "fen": {
      "type": "string",
      "description": "FEN position string"
    },
    "highlights": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Squares to highlight (e.g. [\"e2\",\"e4\"])"
    }
  }
}

[DEPRECATED — use play_make_moves] Apply a sequence of chess moves. Removal: v1.0.0.

{
  "type": "object",
  "properties": {
    "moves": {
      "type": "array",
      "items": {
        "type": "object"
      }
    },
    "variant": {
      "type": "string"
    }
  },
  "required": [
    "moves"
  ]
}

[REMOVED — engine#98] Opening book resolution is broken in Worker context. No replacement.

{
  "type": "object",
  "properties": {
    "variant": {
      "type": "string"
    }
  }
}

List all available hex map game types with configuration options

{
  "type": "object",
  "properties": {}
}

Generate a hex map for a specific game and player count

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game type (nukes, colony, catan, age-of-steam, eclipse, twilight-imperium)"
    },
    "players": {
      "type": "number",
      "description": "Number of players (default: 2)"
    },
    "size": {
      "type": "number",
      "description": "Map size (default: game default)"
    },
    "seed": {
      "type": "string",
      "description": "Random seed for reproducibility"
    }
  },
  "required": [
    "game"
  ]
}

Generate a hex map and export as SVG

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game type"
    },
    "players": {
      "type": "number",
      "description": "Number of players"
    },
    "size": {
      "type": "number",
      "description": "Map size"
    },
    "seed": {
      "type": "string",
      "description": "Random seed"
    },
    "style": {
      "type": "string",
      "description": "Visual style"
    },
    "hexSize": {
      "type": "number",
      "description": "Hex size in pixels (default: 30)"
    }
  },
  "required": [
    "game"
  ]
}

Get info about a specific hex coordinate (terrain, neighbours, distance)

{
  "type": "object",
  "properties": {
    "q": {
      "type": "number",
      "description": "Hex Q coordinate (column)"
    },
    "r": {
      "type": "number",
      "description": "Hex R coordinate (row)"
    },
    "game": {
      "type": "string",
      "description": "Game context for terrain lookup"
    },
    "seed": {
      "type": "string",
      "description": "Map seed (to look up terrain from a generated map)"
    }
  },
  "required": [
    "q",
    "r"
  ]
}

Compute field of view from a hex position

{
  "type": "object",
  "properties": {
    "q": {
      "type": "number",
      "description": "Origin Q coordinate"
    },
    "r": {
      "type": "number",
      "description": "Origin R coordinate"
    },
    "range": {
      "type": "number",
      "description": "Vision range in hexes"
    },
    "game": {
      "type": "string",
      "description": "Game context for obstacle lookup"
    },
    "seed": {
      "type": "string",
      "description": "Map seed"
    }
  },
  "required": [
    "q",
    "r",
    "range"
  ]
}

Find shortest path between two hex coordinates

{
  "type": "object",
  "properties": {
    "startQ": {
      "type": "number",
      "description": "Start Q"
    },
    "startR": {
      "type": "number",
      "description": "Start R"
    },
    "endQ": {
      "type": "number",
      "description": "End Q"
    },
    "endR": {
      "type": "number",
      "description": "End R"
    },
    "game": {
      "type": "string",
      "description": "Game context for movement costs"
    },
    "seed": {
      "type": "string",
      "description": "Map seed"
    }
  },
  "required": [
    "startQ",
    "startR",
    "endQ",
    "endR"
  ]
}

List all playable game families supported by the engine (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)

{
  "type": "object",
  "properties": {}
}

List available variants for a game family. Each variant can be passed to play_create_game. Variants with flags (e.g. +random) can be requested as "slug+flag".

{
  "type": "object",
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    }
  },
  "required": [
    "family"
  ]
}

Get the full engine definition (topology, render config, pieces, setup FEN) for a game variant. Returns the resolved frontmatter used to render and play the game.

{
  "type": "object",
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug (default: standard)"
    }
  },
  "required": [
    "family"
  ]
}

Create a new game instance for a given family. Returns initial state to pass to subsequent calls. Variant can include flags like "grand+random" or "standard+drops".

{
  "type": "object",
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family name (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug, optionally with flags (e.g. \"grand\", \"grand+random\", \"standard+drops\")"
    },
    "rngSeed": {
      "type": "number",
      "description": "Optional RNG seed for deterministic games"
    }
  },
  "required": [
    "family"
  ]
}

Get all legal moves for the current position. Requires state from play_create_game or play_apply_move.

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object returned by play_create_game or play_apply_move"
    }
  },
  "required": [
    "state"
  ]
}

Apply a move to the game and return the new state. Pass the move object exactly as returned by play_get_moves (format varies by family: chess uses {from,to}, go uses {coord} or {action:"pass"}).

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or a previous play_apply_move"
    },
    "move": {
      "type": "object",
      "description": "Move object from play_get_moves (e.g. {from:\"e2\",to:\"e4\"} for chess, {coord:40} for go, {action:\"pass\"})"
    }
  },
  "required": [
    "state",
    "move"
  ]
}

Check the current game status: whose turn it is, whether the game is over, and who won.

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    }
  },
  "required": [
    "state"
  ]
}

Use AI to analyse the position and suggest the best move. Supports 5 difficulty levels across all 10 playable families.

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    },
    "difficulty": {
      "type": "string",
      "enum": [
        "beginner",
        "easy",
        "medium",
        "hard",
        "expert"
      ],
      "description": "AI difficulty level (default: medium)"
    }
  },
  "required": [
    "state"
  ]
}

Render the current board position as SVG for any playable family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game).

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    },
    "highlights": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "key": {
            "type": "integer"
          },
          "color": {
            "type": "string"
          }
        }
      },
      "description": "Optional cells to highlight (e.g. [{key: 52, color: \"#ff0\"}])"
    },
    "size": {
      "type": "integer",
      "description": "Board width in pixels for PNG output (default: 480, max: 2048)"
    }
  },
  "required": [
    "state"
  ]
}

Export the current board position as a FEN-style notation string. Works for all 10 families (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game).

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    }
  },
  "required": [
    "state"
  ]
}

Create a game state from a FEN-style position string. Works for all 10 families.

{
  "type": "object",
  "properties": {
    "family": {
      "type": "string",
      "description": "Game family (chess, draughts, go, reversi, shogi, xiangqi, mancala, morris, hex, landlords-game)"
    },
    "fen": {
      "type": "string",
      "description": "Position string in FEN-style notation for the family"
    },
    "variant": {
      "type": "string",
      "description": "Optional variant slug"
    }
  },
  "required": [
    "family",
    "fen"
  ]
}

Check whether a move is legal in the current position without applying it. Pass the move object in the same format as play_get_moves returns.

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    },
    "move": {
      "type": "object",
      "description": "Move object to validate (same format as play_get_moves output)"
    }
  },
  "required": [
    "state",
    "move"
  ]
}

Apply a sequence of moves to a game and return the final state. Stops at the first illegal move. Move objects must match play_get_moves format.

{
  "type": "object",
  "properties": {
    "state": {
      "type": "object",
      "description": "Game state object from play_create_game or play_apply_move"
    },
    "moves": {
      "type": "array",
      "items": {
        "type": "object"
      },
      "description": "Array of move objects in the format returned by play_get_moves"
    }
  },
  "required": [
    "state",
    "moves"
  ]
}

List all available game rulebooks with metadata (players, duration, complexity, mechanics). Filterable by type, complexity, and mechanics.

{
  "type": "object",
  "properties": {
    "category": {
      "type": "string",
      "description": "Filter by type (standalone, hub, classic, rpg, component, platform, mod, game)"
    },
    "complexity": {
      "type": "string",
      "enum": [
        "simple",
        "moderate",
        "complex"
      ],
      "description": "Filter by complexity level"
    },
    "mechanic": {
      "type": "string",
      "description": "Filter by mechanic (e.g. dice, capture, hex, oracle, narrative)"
    },
    "status": {
      "type": "string",
      "enum": [
        "live",
        "alpha",
        "playtest"
      ],
      "description": "Filter by status (default: all)"
    }
  }
}

Get full rulebook content for a specific game (markdown). For metadata only, use rules_get_game_meta instead.

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. chess, dnd-5e, catan)"
    }
  },
  "required": [
    "game"
  ]
}

Get structured metadata for a game: players, duration, complexity, mechanics, how_to_play, variant list, page list, related games. Lightweight alternative to fetching the full rulebook.

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. chess, backgammon, cairn)"
    }
  },
  "required": [
    "game"
  ]
}

Get a specific page/section from a game rulebook (e.g. character creation, combat rules, marketplace). Use rules_get_game_meta to see available pages.

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. cairn, dnd-5e)"
    },
    "section": {
      "type": "string",
      "description": "Section name (e.g. rules, classes, spells). Default: rules"
    },
    "page": {
      "type": "string",
      "description": "Page slug (e.g. character-creation, combat-and-difficulty)"
    }
  },
  "required": [
    "game",
    "page"
  ]
}

List all variants for a game with structured metadata (players, board, playable status, topology, engine config). Much richer than parsing the rulebook.

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug (e.g. chess, backgammon, draughts)"
    },
    "playable": {
      "type": "boolean",
      "description": "Filter to only engine-playable variants"
    },
    "topology": {
      "type": "string",
      "description": "Filter by board topology (grid, hex, track, graph, tableau)"
    }
  },
  "required": [
    "game"
  ]
}

Get board diagram SVG URL for a game variant. Returns the diagram path, topology, and rendering metadata.

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game family slug (e.g. chess, go, agon)"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug (default: standard)"
    }
  },
  "required": [
    "game"
  ]
}

Get rules for a specific game variant

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game slug"
    },
    "variant": {
      "type": "string",
      "description": "Variant slug"
    }
  },
  "required": [
    "game",
    "variant"
  ]
}

Full-text search across all published rulebooks. Returns section-typed results with deep-link anchors.

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search query"
    },
    "game": {
      "type": "string",
      "description": "Limit to specific game slug"
    },
    "sectionType": {
      "type": "string",
      "description": "Filter by section type (general, board, pieces, setup, movement, capture, winning, special, variants)"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    }
  },
  "required": [
    "query"
  ]
}

Get a random game suggestion from the library

{
  "type": "object",
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players available"
    },
    "maxDuration": {
      "type": "number",
      "description": "Maximum game duration in minutes"
    }
  }
}

Search the board gallery (334 rendered board layouts across 33 game families)

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term (e.g. \"8x8\", \"hex\", \"shogi\")"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    }
  }
}

Get details of a specific board layout by ID

{
  "type": "object",
  "properties": {
    "board": {
      "type": "string",
      "description": "Board ID or name"
    }
  },
  "required": [
    "board"
  ]
}

Search hex tile sets by name, game, or terrain type

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term (omit to list all)"
    }
  }
}

Get details of a specific tile set with all tile types

{
  "type": "object",
  "properties": {
    "set": {
      "type": "string",
      "description": "Tile set ID or name"
    }
  },
  "required": [
    "set"
  ]
}

Get statistics about available tile sets

{
  "type": "object",
  "properties": {}
}

Get statistics about the board gallery (total boards, families, topologies)

{
  "type": "object",
  "properties": {}
}

Search the piece set gallery by name, style, or game type

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term (e.g. \"staunton\", \"pixel\", \"shogi\")"
    },
    "family": {
      "type": "string",
      "description": "Filter by game family (chess, shogi, xiangqi, draughts, go, etc)"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    }
  },
  "required": [
    "query"
  ]
}

Get full details and piece list for a specific set

{
  "type": "object",
  "properties": {
    "set": {
      "type": "string",
      "description": "Set name or ID"
    }
  },
  "required": [
    "set"
  ]
}

Get statistics about the piece gallery (total sets, styles, authors, game families)

{
  "type": "object",
  "properties": {}
}

List all supported RPG systems with oracle tables and entity data availability

{
  "type": "object",
  "properties": {}
}

Generate a random character for an RPG system (D&D 5e, Pathfinder, Ironsworn, Cairn, Knave, etc)

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "RPG system (dnd-5e, pathfinder-1e, ironsworn, starforged, cairn, knave, maze-rats, dungeon-world)"
    },
    "level": {
      "type": "number",
      "description": "Character level (default: 1)"
    },
    "class": {
      "type": "string",
      "description": "Class preference (omit for random)"
    }
  },
  "required": [
    "system"
  ]
}

Roll on a random oracle table (Ironsworn, Starforged, Maze Rats, etc)

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "RPG system slug (ironsworn, starforged, maze-rats, cairn, knave, fate-core)"
    },
    "table": {
      "type": "string",
      "description": "Specific table name (omit for random)"
    }
  },
  "required": [
    "system"
  ]
}

List available oracle tables for a system

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "RPG system slug"
    }
  },
  "required": [
    "system"
  ]
}

Ask the oracle a yes/no question with likelihood modifier

{
  "type": "object",
  "properties": {
    "question": {
      "type": "string",
      "description": "Yes/no question"
    },
    "likelihood": {
      "type": "string",
      "enum": [
        "certain",
        "likely",
        "even",
        "unlikely",
        "impossible"
      ],
      "description": "How likely is yes? (default: even)"
    }
  },
  "required": [
    "question"
  ]
}

Generate a scene using oracle tables. With a recipe, rolls each table in the recipe, resolves cross-references, and composes a narrative sentence. Without, picks random tables.

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "RPG system slug (default: ironsworn)"
    },
    "recipe": {
      "type": "string",
      "description": "Recipe ID (from oracle_list_recipes) — rolls each table in the recipe"
    },
    "region": {
      "type": "string",
      "enum": [
        "terminus",
        "outlands",
        "expanse"
      ],
      "description": "Region for Starforged region-aware recipes"
    },
    "type": {
      "type": "string",
      "enum": [
        "location",
        "npc",
        "event",
        "combat"
      ],
      "description": "Scene type for random mode (default: event)"
    }
  }
}

Search RPG entities (spells, monsters, classes, items) across all systems

{
  "type": "object",
  "properties": {
    "query": {
      "type": "string",
      "description": "Search term"
    },
    "system": {
      "type": "string",
      "description": "Limit to system (dnd-5e, pathfinder-1e, etc)"
    },
    "game": {
      "type": "string",
      "description": "Alias for system"
    },
    "category": {
      "type": "string",
      "description": "Entity category (spell, monster, class, item)"
    },
    "limit": {
      "type": "number",
      "description": "Max results (default 10)"
    }
  },
  "required": [
    "query"
  ]
}

Get full details of a specific RPG entity by name

{
  "type": "object",
  "properties": {
    "name": {
      "type": "string",
      "description": "Entity name"
    },
    "system": {
      "type": "string",
      "description": "System slug"
    },
    "game": {
      "type": "string",
      "description": "Alias for system"
    },
    "category": {
      "type": "string",
      "description": "Category filter (spells, monsters, classes, etc)"
    }
  },
  "required": [
    "name"
  ]
}

Generate a random encounter for a system and difficulty level

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "System slug (default: dnd-5e)"
    },
    "difficulty": {
      "type": "string",
      "enum": [
        "easy",
        "medium",
        "hard",
        "deadly"
      ],
      "description": "Encounter difficulty"
    },
    "type": {
      "type": "string",
      "description": "Monster type filter (beast, undead, fiend, dragon, etc)"
    }
  }
}

Browse entities by category with pagination

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "System slug"
    },
    "game": {
      "type": "string",
      "description": "Alias for system"
    },
    "category": {
      "type": "string",
      "description": "Category (spell, monster, class, item, feat, etc)"
    },
    "page": {
      "type": "number",
      "description": "Page number (default 1)"
    },
    "pageSize": {
      "type": "number",
      "description": "Items per page (default 20)"
    }
  },
  "required": [
    "system",
    "category"
  ]
}

Generate random loot/treasure for a system and tier

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "description": "System slug (default: dnd-5e)"
    },
    "tier": {
      "type": "string",
      "enum": [
        "minor",
        "major",
        "legendary"
      ],
      "description": "Loot tier (default: minor)"
    },
    "count": {
      "type": "number",
      "description": "Number of items (default 3)"
    }
  }
}

List all predefined scene recipes — curated multi-table compositions that produce coherent narrative prompts

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Filter by game system (omit for all)"
    }
  }
}

Resolve oracle cross-references. Given a result like "Action + Theme", follows references and returns expanded results

{
  "type": "object",
  "properties": {
    "result": {
      "type": "string",
      "description": "Oracle result text to interpret"
    },
    "source_table": {
      "type": "string",
      "description": "Table ID the result came from"
    },
    "game": {
      "type": "string",
      "description": "Game system (default: starforged)"
    }
  },
  "required": [
    "result"
  ]
}

View the complete contents of an oracle table — all entries with roll ranges

{
  "type": "object",
  "properties": {
    "table": {
      "type": "string",
      "description": "Table ID to view"
    },
    "game": {
      "type": "string",
      "description": "Game system (default: starforged)"
    }
  },
  "required": [
    "table"
  ]
}

Generate a tabletop RPG encounter with CR-appropriate monsters, terrain, and loot (D&D 5e or Pathfinder 1e)

{
  "type": "object",
  "properties": {
    "system": {
      "type": "string",
      "enum": [
        "dnd-5e",
        "pathfinder-1e"
      ],
      "description": "Game system (default: dnd-5e)"
    },
    "party_level": {
      "type": "number",
      "description": "Average party level 1-20 (default: 5)"
    },
    "party_size": {
      "type": "number",
      "description": "Number of players 1-10 (default: 4)"
    },
    "difficulty": {
      "type": "string",
      "enum": [
        "easy",
        "medium",
        "hard",
        "deadly"
      ],
      "description": "Encounter difficulty (default: medium)"
    },
    "monster_type": {
      "type": "string",
      "description": "Filter by type (undead, dragon, beast, etc)"
    },
    "terrain": {
      "type": "string",
      "description": "Terrain type (omit for random)"
    }
  }
}

List entity categories for an RPG system (spells, monsters, classes, equipment, etc)

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game system slug (omit for all systems)"
    },
    "system": {
      "type": "string",
      "description": "Alias for game"
    }
  }
}

Get random entities from an RPG system for inspiration or encounter prep

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game system slug"
    },
    "system": {
      "type": "string",
      "description": "Alias for game"
    },
    "category": {
      "type": "string",
      "description": "Category to draw from (omit for any)"
    },
    "count": {
      "type": "number",
      "description": "Number of random picks 1-10 (default: 1)"
    }
  },
  "required": [
    "game"
  ]
}

Generate random faction assignments for Twilight Imperium 4th Edition

{
  "type": "object",
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players (3-8)"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter (e.g. [\"base\",\"pok\"]). Default: all"
    }
  },
  "required": [
    "players"
  ]
}

Milty-style TI4 draft with pick pools per player

{
  "type": "object",
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players (3-8, default: 6)"
    },
    "choices": {
      "type": "number",
      "description": "Factions per player to choose from (default: 3)"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter (e.g. [\"base\",\"pok\"]). Default: all"
    }
  }
}

List all TI4 factions with colors, flags, and expansion info

{
  "type": "object",
  "properties": {
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Filter by expansion (e.g. [\"base\",\"pok\"]). Default: all"
    }
  }
}

Draw random public objectives for TI4

{
  "type": "object",
  "properties": {
    "stage": {
      "type": "number",
      "enum": [
        1,
        2
      ],
      "description": "Stage 1 or 2 (default: both)"
    },
    "count": {
      "type": "number",
      "description": "Number to draw (default: 5)"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter"
    }
  }
}

Draw random agenda cards for TI4 political phase

{
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number to draw (default: 2)"
    },
    "type": {
      "type": "string",
      "enum": [
        "law",
        "directive"
      ],
      "description": "Filter by type"
    },
    "expansions": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Expansion filter"
    }
  }
}

Generate random territory/resource setup for a Nukes game

{
  "type": "object",
  "properties": {
    "players": {
      "type": "number",
      "description": "Number of players (2-6, default: 2)"
    }
  }
}

Resolve a Nukes combat encounter between units

{
  "type": "object",
  "properties": {
    "attacker": {
      "type": "string",
      "description": "Attacking unit type"
    },
    "defender": {
      "type": "string",
      "description": "Defending unit type"
    },
    "terrain": {
      "type": "string",
      "description": "Terrain type (plains, forest, mountain, urban)"
    }
  },
  "required": [
    "attacker",
    "defender"
  ]
}

Calculate settlement dice probability for Colony/Catan-style resource numbers

{
  "type": "object",
  "properties": {
    "numbers": {
      "type": "string",
      "description": "Settlement numbers, comma-separated (e.g. \"5,6,8,9\")"
    }
  },
  "required": [
    "numbers"
  ]
}

Create, shuffle, and optionally draw/deal from a card deck

{
  "type": "object",
  "properties": {
    "type": {
      "type": "string",
      "enum": [
        "standard-52",
        "bavarian-32",
        "hanafuda-48",
        "mahjong-136",
        "dominoes-28",
        "standard-dice"
      ],
      "description": "Deck type (default: standard-52)"
    },
    "draw": {
      "type": "number",
      "description": "Number of cards to draw"
    },
    "hands": {
      "type": "number",
      "description": "Deal into N hands"
    },
    "per_hand": {
      "type": "number",
      "description": "Cards per hand (default: 5)"
    }
  }
}

List all available deck types with metadata

{
  "type": "object",
  "properties": {}
}

Shuffle and deal a custom deck of arbitrary named cards

{
  "type": "object",
  "properties": {
    "cards": {
      "type": "array",
      "items": {
        "type": "object",
        "properties": {
          "name": {
            "type": "string"
          },
          "quantity": {
            "type": "number",
            "default": 1
          }
        },
        "required": [
          "name"
        ]
      },
      "description": "Cards in the deck (name + optional quantity)"
    },
    "hands": {
      "type": "number",
      "description": "Deal into N hands (default: 1 = draw pile only)"
    },
    "per_hand": {
      "type": "number",
      "description": "Cards per hand (default: 5)"
    },
    "draw": {
      "type": "number",
      "description": "Draw N cards from the top instead of dealing hands"
    }
  },
  "required": [
    "cards"
  ]
}

Track scores for players in any game

{
  "type": "object",
  "properties": {
    "players": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Player names"
    },
    "scores": {
      "type": "array",
      "items": {
        "type": "number"
      },
      "description": "Scores (default: all 0)"
    },
    "game": {
      "type": "string",
      "description": "Game name"
    }
  },
  "required": [
    "players"
  ]
}

Draw random characters from the Talisman 4e (revised) base set for a character lottery

{
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of characters to draw (2-6, default: 4)"
    }
  }
}

Draw a random encounter for a Talisman ring (outer, middle, inner, crown)

{
  "type": "object",
  "properties": {
    "ring": {
      "type": "string",
      "enum": [
        "outer",
        "middle",
        "inner",
        "crown"
      ],
      "description": "Ring to draw from (default: outer)"
    }
  }
}

Get the current Mod Jam status (active jam, deadline, submissions)

{
  "type": "object",
  "properties": {}
}

Get time remaining in the current Mod Jam

{
  "type": "object",
  "properties": {}
}

Get voting status for the current Mod Jam

{
  "type": "object",
  "properties": {}
}

Roll dice using standard notation (e.g. 2d6+3, 4d8, d20). Supports comma-separated pools and keep-high/low (4d6kh3).

{
  "type": "object",
  "properties": {
    "notation": {
      "type": "string",
      "description": "Dice notation (e.g. 2d6+3, 4d6kh3, 3d8,1d12+2)"
    },
    "expression": {
      "type": "string",
      "description": "Alias for notation"
    },
    "count": {
      "type": "number",
      "description": "Number of times to roll (default 1)"
    }
  }
}

Flip one or more coins, or pick from a list of choices

{
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of coins (default 1)"
    },
    "choices": {
      "type": "string",
      "description": "Comma-separated options to pick from (overrides coin flip)"
    }
  }
}

Randomly divide players into teams

{
  "type": "object",
  "properties": {
    "players": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Player names"
    },
    "members": {
      "type": "string",
      "description": "Comma-separated names (alternative to array)"
    },
    "count": {
      "type": "number",
      "description": "Number of teams (default 2)"
    },
    "teams": {
      "type": "number",
      "description": "Alias for count"
    }
  },
  "required": [
    "players"
  ]
}

Randomise turn order for a list of players

{
  "type": "object",
  "properties": {
    "players": {
      "type": "array",
      "items": {
        "type": "string"
      },
      "description": "Player names"
    }
  },
  "required": [
    "players"
  ]
}

Suggest time controls for a game based on player count and complexity

{
  "type": "object",
  "properties": {
    "game": {
      "type": "string",
      "description": "Game name"
    },
    "players": {
      "type": "number",
      "description": "Number of players"
    }
  },
  "required": [
    "game"
  ]
}

Generate a random game jam theme combining mechanics and themes

{
  "type": "object",
  "properties": {
    "count": {
      "type": "number",
      "description": "Number of themes to generate (default 3)"
    }
  }
}

Calculate probability of meeting a target with a dice expression. Supports keep-high/low (4d6kh3).

{
  "type": "object",
  "properties": {
    "expression": {
      "type": "string",
      "description": "Dice expression (e.g. 2d6, 4d6kh3)"
    },
    "target": {
      "type": "number",
      "description": "Target number to meet or exceed"
    },
    "comparison": {
      "type": "string",
      "enum": [
        ">=",
        ">",
        "<=",
        "<",
        "="
      ],
      "description": "Comparison (default >=)"
    }
  },
  "required": [
    "expression",
    "target"
  ]
}