Board Game Lab

Adds a playfield (a game table) to a project. With `scaffold`, also authors its complete setup in one step: seats with hands, a stock and a discard pile, an initial deal, per-seat cards laid on the table, and the rule plugins attached to every zone. Refuses a name an existing playfield already has, so nothing existing is changed (bgl_write_playfield_setup rewrites an existing playfield).

bgl_create_playfield

Deletes one thing by name: a whole project, a deck (with its templates and cards), a card template, a block of a template, a generation group (with its cards), a value of a keyword, a value from a template's spreadsheet column, an imported asset (moved to the project's deleted items), a playfield, a widget placed on a playfield, or a widget type of the project. Most deletions cannot be undone. Decks, templates and groups that a playfield's setup uses are refused.

bgl_delete

Ends the running playtest and returns the table to setup, or, with `restart: true`, discards the game in progress and deals a fresh one on the same table. The game in progress is lost either way.

bgl_end_playtest

Generates the cards of one card template from keyword values, replacing the cards previously generated for that template (cards matching the same values keep their identity). Either name the `keywords` to combine (all combinations; `inner_join_groups` pairs keywords 1:1 instead; `selected_values` limits the values used), or give a `formula` such as 'rank*(suit.color)'. With neither, regenerates from the current formula. `generate: false` only sets the formula. `regenerate_names` renames cards from their values.

bgl_generate_cards

Fetches the text at `url` (a web address, or a path inside the Board Game Lab app) and stores it as a project resource named `name`, replacing a resource of that name. Used to bring rules or reference documents into a project.

bgl_import_from_url

Imports images or symbols from the bundled asset library (bgl_browse_asset_library) into a project, each under the name the other tools then use for it (a block's image or symbol, a keyword's values). Importing a name an asset of the same kind already has reuses that asset; a name an asset of the other kind has (image or symbol) is pointed at the new file.

bgl_import_assets

Lists the signed-in user's Board Game Lab projects by name. Changes nothing.

bgl_list_projects

Plays one move in the running playtest through the rule engine, as a player at the table would: `move_card` moves a card between containers, `click` presses a button or zone on the table. The engine refuses moves the game's rules forbid. A move cannot be taken back.

bgl_make_move

Connects this conversation to the user's Board Game Lab tab, which the other tools act in. With an open Board Game Lab tab signed in to the same Board Game Lab account, it pairs that tab and returns 'Paired'. With none, it returns a link for the user that opens Board Game Lab, in the browser or the Board Game Lab app, already paired with this conversation once they are signed in. Pairing again replaces the previous pairing; no project data changes. `code` picks one tab when several are open: the short code shown in the tab's AI Agents badge.

bgl_pair

Reads what a project holds, part by part: its components (decks, playfields, dice), its text resources, its imported images and symbols, its game-logic plugins, its keywords (the named value lists cards are generated from) and the widget types its playfields can place. Changes no content; opens the project in the tab when another one is open.

bgl_get_project

Reads a card template: every block on it (name, type, position and size, side, bound keyword, style) and the keywords tagged for card generation; with `block`, also that image or symbol block's content scale. Changes no content; opens the template in the tab's card editor.

bgl_get_card_template

Reads a deck: its card templates, the generation formula of a template (how keyword values combine into cards, e.g. rank*suit), its generation groups (one per template, with row and card counts) and every generated card with its keyword values. Changes no content; opens the deck in the tab's deck composer and selects `template` there when given.

bgl_get_deck

Reads a playfield (the game table): its setup recipe (seats, zones, deck placement, deal, widgets, rules — as JSON) and the game-logic plugins that will actually load when it is played. Changes nothing.

bgl_get_playfield

Reads one of a project's documents: `rules` (the human-facing rules), `rule_book` (the sectioned rule book: game box, setup, turn order, legal actions, victory, scoring, glossary — as JSON), `implementation` (the technical plan mapping the rules onto decks, playfields and plugins) or a named text `resource`. Changes nothing; opens the project in the tab when another one is open.

bgl_read_document

Reads Board Game Lab's own documentation: the manual's `sections` under a path, one section to `read`, the `build_workflow` (how a game is built with these tools: the order, how to prove it plays, and when edits are saved), a project's `build_progress` (which build steps are done and which comes next), guidance for the tab's current `screen`, or the poker deck walkthroughs. Where the text names the app's internal actions, the result lists the tool that performs each. Changes nothing.

bgl_get_guide

Reads the running playtest: the `full` state (phase, turn, every container with its cards), the current `turn`, one player's `hand`, one `container`'s cards, the list of `containers`, the game `log`, or the `setup_diagnostics` of the opening deal. With `wait_for_player`, first waits (up to wait_ms) until it is that player's turn. Changes nothing.

bgl_get_game_state

Asks the running game's rule engine what is allowed: the `drop_targets` where a card may be moved from its container, or the `suggested_move` of the autoplay advisor for a player. Changes nothing.

bgl_get_legal_moves

Renames a project, an imported asset (its uses keep working), or a deck's generation group, replacing its current name. Nothing else changes.

bgl_rename

Sets one visual effect on a block of a card template, replacing that effect's current settings: a drop or inner shadow, an outer or inner glow, a contour stroke, a color, gradient or pattern overlay, or a bevel. Each effect reads the fields its description names; colors are hex (8 digits to set alpha).

bgl_set_block_effect

Changes a card template's physical size in millimeters (scaling its blocks proportionally unless `scale_blocks` is false) and the opacity of its background layer (0 hides the card body, for piece-like cards), replacing the current values. Each field is optional.

bgl_set_card_template

Changes the data cards are generated from, replacing what was there. `replace_values` changes one value of a project-wide keyword (e.g. rank: 2..10, J, Q, K). In a deck, a template's spreadsheet holds one column per keyword and one row per card: `columns` replaces a keyword's per-row values in row order, and `quantities` replaces how many copies of each row's card the deck holds. Card rows exist only once bgl_generate_cards has run on the template: on a template without rows yet, `columns` stores the values and no card appears until bgl_generate_cards runs. The result names the template's current row count. Each field is optional; they apply in this order. The previous values are not kept. bgl_add_keyword_values adds values; cards are regenerated with bgl_generate_cards.

bgl_set_deck_data

Opens something in the paired Board Game Lab tab for the user to look at: the games library (no arguments), a project, one of its decks, a card template of a deck, or a playfield. Changes only what the tab displays; no project content changes. The other tools open what they work on by themselves.

bgl_show

Plays complete games of the running playtest automatically (no rendering), every seat on an autoplay strategy, and summarizes each: seed, moves, outcome, whether it reached the end, and its last log lines (a game that never ends usually points at a plugin). The same seed replays the same game. The game in progress on the table is not changed. The summary is added to the project's run notes. A playtest started with bgl_start_playtest is required.

bgl_simulate_games

Starts playing a project's game on one of its playfields in the paired tab: the table is set up and dealt as its setup recipe says, and the result reports what the setup did. A playtest of that playfield already running is kept; otherwise a fresh game is dealt and a game in progress is not kept. No project content changes.

bgl_start_playtest

Changes how one block of a card template looks, replacing the current setting of each field given. Each field is optional and applies when given: text font, size, alignment and auto-fit; the number a number block shows; the image or symbol an image or symbol block shows and how it scales in the block; centering on the card; and a number block's pips (repeated symbols instead of digits).

bgl_style_card_block

Saves a game-logic plugin: C# source files implementing one of the rule engine's plugin interfaces (e.g. IContainerConstraint), which run in the browser when the game is played. Stored in the project's plugin library, or, with `playfield`, written onto that playfield. A plugin of the same name is replaced.

bgl_write_game_plugin

Replaces a playfield's whole setup recipe: either with `timeline` (the full recipe JSON, as bgl_get_playfield returns it), pinning `pin_plugins`, or with a fresh `scaffold` (seats, piles, deal, tableau, rule plugins). The previous recipe is overwritten.

bgl_write_playfield_setup

Replaces one of a project's documents with `content`: the human-facing `rules` (markdown or HTML), one `rule_book_section` (HTML), the `implementation` plan (markdown or HTML), or a named text `resource` (created when new). The previous text of that document or section is overwritten.

bgl_write_document