Steps

Step types

Steps are organized into six categories. Each step performs a single action when the sequence executes.

Stacks

Steps that manipulate stacks and their tiles.

Draw from Stack

Draw tiles from a stack to a player's hand, a space, or directly onto the table. Configure the number of tiles to draw, the destination, and an optional face rule (face up, face down, or as-is).

Draw Position controls where in the stack tiles are drawn from:

• Top (default) draws from the top of the stack, the standard behavior for most card games
• Bottom draws from the bottom of the stack, useful for mechanics where players peek at or take the lowest tile
• Random draws from a random position in the stack, useful for bag-like draw mechanics without needing to shuffle first

Deal to Hands

Deal tiles from a stack evenly to all player hands, or to specific seats. Configure the number of tiles each player receives and an optional face rule.

Deal Stacks

Deal a stack of tiles to each targeted seat as one held stack, the way a draft hands out stacks.

This is not the same step as Deal to Hands, and the two labels are one word apart. Deal to Hands gives each player loose tiles that sit in their hand individually. Deal Stacks gives each player one stack that they hold as a single piece, keeps its contents private to its holder, and lets them draw out of it one tile at a time. A draft wants Deal Stacks. Dealing an opening hand of cards wants Deal to Hands.

Configuration:

• Stack - the source stack the tiles come out of
• Tiles Per Stack - how many tiles each dealt stack holds
• Deal To - All Seats, Acting Player, Left Player, Right Player, or Specific Seat
• Seat Index - the seat to deal to, shown only when Specific Seat is chosen
• Face - Face Down (default) or Face Up, applied to the dealt stack itself rather than to the source

Behavior:

• The deal is all or nothing. If the source cannot give every eligible seat a full stack, nothing is dealt at all and the step fails with the count it needed against the count remaining. No seat gets a short stack and no tiles are consumed. This is the first thing to check when a deal refuses: raise the source's contents or lower Tiles Per Stack.
• A seat nobody is sitting in is skipped, not an error, and consumes no tiles. The run says so in the Sequence Debugger.
• A seat whose hand is already at Max Hand Size is skipped the same way. A held stack counts as one occupant of the hand however many tiles are inside it, so this only bites at a genuinely full hand.
• Skipped seats are decided before any tile moves, so the all-or-nothing count is measured against the seats that can actually receive.
• The dealt stacks are saved to context, by default under the key dealtStacks, so a later step can act on exactly the stacks this step created. Save Result As renames that key.
• The whole deal is one action, so a single Undo takes back every stack it dealt.

Example: To open a booster draft round, set Stack to the draft supply, Tiles Per Stack to 15, Deal To to All Seats, and Face to Face Down. Every occupied seat receives its own face-down stack held in hand. Follow it with a Pass Stack step and the round runs without anyone pressing a button.

Deal to Tagged Spaces

Deal tiles from a stack to every space that has a specific tag. Configure the tag to match, the number of tiles per space, and an optional face rule.

Deal Stacks to Tagged Spaces

Deal one new held stack of tiles to every space carrying a given tag -- the third corner of the Deal triangle: Deal Stacks deals stacks to seats, Deal to Tagged Spaces deals loose tiles to tagged spaces, and this step deals stacks to tagged spaces.

Configuration:

• Stack - the source stack the tiles come out of
• Space Tag - the tag that selects which spaces receive a dealt stack
• Tiles Per Stack - how many tiles each dealt stack holds
• Face - Face Down (default) or Face Up, applied to the dealt stack itself rather than to the source

Behavior:

• The deal is all or nothing, the same refusal Deal Stacks uses for seats: if the source cannot give every space carrying the tag a full stack, nothing is dealt at all and the step fails with the count it needed against the count remaining.
• If the tag resolves to no spaces, the step fails rather than silently dealing nothing -- there is no such thing as a no-op tagged deal. A tag matching spaces where nobody is seated fails the same way, naming the tag.
• The source stack is drawn down by exactly what was dealt, and nothing is duplicated or left uncounted.
• The dealt stacks are saved to context under dealtStacks by default, the same key Deal Stacks uses. Save Result As renames it.
• The whole deal is one action, so a single Undo takes back every stack it dealt.

Example: To seed a face-down resource stack onto every space tagged "market", set Stack to the resource supply, Space Tag to "market", Tiles Per Stack to 3, and Face to Face Down. Every seated space tagged "market" receives its own three-tile stack.

Shuffle Stack

Randomize the order of tiles in a stack. Select which stack to shuffle.

Shuffle Tagged in Place

Shuffle tiles across all spaces that share a given tag. The tiles stay in their spaces but their positions are randomized among those spaces.

Return to Stack

Return a tile back to a stack. The tile can come from the current context (set by a previous selection or prompt step) or be a specific tile chosen in the step configuration.

Sort Pieces

Sort tiles within a stack or hand alphabetically by name. The source must be a context entry containing either a stack (piece) or a hand (seat index) set by an upstream step.

Configuration:

• Source -- context entry containing the stack or hand to sort
• Sort By -- currently "Name" (alphabetical by tile name)
• Direction -- Ascending (A to Z) or Descending (Z to A)

Behavior for stacks: Reorders tiles by zIndex within the stack. In ascending order, tiles named earlier in the alphabet appear on top.

Behavior for hands: Repositions tiles within the player's hand lane so they appear in the chosen alphabetical order.

Tiles with no name sort before named tiles.

Example: Sort a hand alphabetically after drawing multiple cards so the player can find cards more easily.

Pieces

Steps that change the state or position of individual pieces.

Flip

Flip a tile to show its other side. Configure the flip mode: face up, face down, or toggle. The target tile can come from context or be a specific tile.

Rotate

Rotate a piece by a set angle. Configure the rotation mode: set to an absolute angle, match the rotation of the piece's current space, or rotate by a relative delta. The target piece can come from context or be a specific piece.

Set Markup Mode

Open or close markup mode on a piece for the player who runs the sequence. Markup mode is the inline editor for drawing on a tile, die, or sprite token. Configure the mode: turn on, turn off, or toggle. The target piece can come from context or be a specific piece. Markup mode is personal, so it only opens for the acting player, not for everyone at the table.

Move Piece

Move a piece to a space, a player's hand, or a position on the table. When moving to a space, you can target a specific space or a space matched by tag. The target piece can come from context or be a specific piece.

Move to Hand

Move a piece into a player's hand. Configure which player receives the piece: the player who triggered the sequence (actor) or a specific seat. The target piece can come from context or be a specific piece.

Move to Stack

Place a piece on top, bottom, or at a random position within a stack. The target piece can come from context or be a specific piece.

Move to Table

Move a piece to specific X/Y coordinates on the table surface. The target piece can come from context or be a specific piece.

Selection

Steps that select pieces for downstream steps to operate on.

Select Specific

Select specific pieces by their identity for use by later steps. Choose one or more pieces from the table and they become available in the context for subsequent steps.

Select by Filter

Select pieces that match filter criteria. Filters can match on piece type, name, required tags, blocked tags, color, token kind, where the piece is sitting, or which player's hand holds it. Matching pieces become available in the context for subsequent steps.

In Space picks the location source, and only one at a time:

• Any -- the piece can be anywhere.
• One space -- only pieces sitting in the one space you name.
• Spaces with tag -- every piece sitting in ANY space carrying that tag.

The tag form uses the same space tags as Move Piece, Deal to Tagged Spaces and Shuffle Tagged in Place, so "gather every card from the six source spaces" is one step instead of six: tag those spaces origin, select pieces in spaces tagged origin, then move the selection to the space tagged destination. Adding a seventh source space later is a tag on that space, not an edit to the sequence.

A tag that matches no space selects nothing. That is not an error -- unlike a tagged deal, an empty selection is a legitimate answer, and later steps simply act on nothing.

Name filters tiles by their name. A mode picker controls how the name is matched:

• Exact -- the tile name must match the filter text exactly
• Contains -- the tile name must contain the filter text anywhere
• Starts with -- the tile name must begin with the filter text
• Ends with -- the tile name must end with the filter text

Name matching is case-insensitive. The name filter composes with all other filter fields -- combining multiple filters narrows the results.

Count Selection

Count the number of pieces in a context entry and save the count as a number. Configure the Source Context Entry -- a context key produced by an upstream step that selected or drew pieces. The step reads that entry and writes its length as a number context entry.

This is useful when a downstream step needs a numeric value based on how many pieces were produced. For example, draw a variable number of tiles from a stack, then use Count Selection to get that count, then use Adjust Counter to add the count to a score counter.

If the source entry contains a single piece, the count is 1. If it contains multiple pieces, the count is the number of pieces in the list.

Utility

Steps that interact with counters, dice, spinners, timers, bags, and bowls.

Read Counter

Read a counter's current value and save it as a number context entry. Select which Counter to read. The result is stored in context so downstream steps can use it.

This is useful when you need a counter's value as input to another step. For example, read a score counter, then use its value in a Stop If condition to end the sequence when the score reaches a threshold. You can also pass the value to an Adjust Counter step -- select "Context Reference" as the value source and pick the context key produced by Read Counter.

Adjust Counter

Increment, decrement, or set a counter's value. Configure the counter, the mode (increment, decrement, or set), and the amount. The amount can be a fixed number or a reference to a context value (such as a number entered by a player in a Prompt Number step).

Roll Die

Roll a die to produce a random result. Select which die to roll. The result can be saved to context for use by later steps.

Set Die Face

Set a die to show a specific face value without rolling. Select the die and the face value to display.

Spin Spinner

Spin a spinner to produce a random result. Select which spinner to spin. The result can be saved to context for use by later steps.

Start Timer

Start a timer counting down from its configured duration.

Pause Timer

Pause a running timer, preserving its remaining time.

Stop Timer

Stop a timer completely.

Reset Timer

Reset a timer to its full initial duration.

Dispense from Bowl

Dispense pieces from a token bowl to a destination. Configure the bowl and the destination.

Destinations:

• Hand - Dispense to a player's hand. Set the quantity and choose the hand owner (the acting player or a specific seat).
• Table - Dispense directly onto the table surface. Set the quantity.
• Space - Dispense into a specific space. Set the quantity and select the target space.
• Tagged Spaces - Dispense tokens to every space matching a tag. Each matching space receives the configured quantity per space.

Tagged Spaces

When you select Tagged Spaces as the destination, two additional fields appear:

• Space Tag - The tag to match spaces against. Every space with this tag is a target.
• Per Space - How many tokens each matched space receives (default 1).

Behavior details:

• Spaces that do not accept the piece type are skipped.
• Spaces that are full (at capacity) are skipped.
• The bowl must have enough supply for all target spaces. If the bowl runs out, the step fails with an error.
• All dispensed pieces are available in context under the result key for use by later steps.

Example: To place 1 gold token on every space tagged "resource", set the destination to Tagged Spaces, enter "resource" as the space tag, and set per space to 1.

Draw from Bag

Draw a random piece from a bag. Configure the bag, an optional quantity, and the destination (hand, space, or table).

Flow

Steps that control the execution flow of the sequence itself.

Run Sequence

Run another sequence as a sub-routine. The called sequence executes completely before the current sequence continues. You can optionally map context values from the parent sequence into the child. If the child sequence is stopped (by a Stop If step), you can choose whether the parent also stops.

Sequences can nest up to 8 levels deep.

Stop If

Stop the current sequence if a condition is met. Configure a condition using the condition builder. If the condition evaluates to true, the sequence halts and no further steps execute.

Pass Stack

Move a held stack from the hand holding it one seat to the left or right, one hop around the circular seating order. This is the drafting verb: it hands a stack across the table without disturbing anything else either player is holding.

Configuration:

• Which Stack - Seat, From Context, or Specific Stack
• From Seat - All Seats, Acting Player, Left Player, Right Player, or Specific Seat, shown only when Which Stack is Seat
• Seat Index - the seat to take the stack from, shown only when Specific Seat is chosen
• Context Key - the key holding the stack, shown only when Which Stack is From Context
• Stack - the stack to move, shown only when Which Stack is Specific Stack
• Direction - Left or Right, meaning the same two directions as the Pass Left and Pass Right actions. See which way is left.

Behavior:

• Only the held stack moves. Loose tiles in a hand stay with their owner, so picks a player has already taken out of a stack are never handed away.
• Every tile inside the stack travels with it, and the stack's contents stay private to whoever is holding it, before and after. The sender can no longer read it; the receiver can.
• All Seats moves every occupied seat's held stack at the same time, so nobody ever receives a stack they just sent.
• The direction is set on the step itself. Pass Left and Pass Right in the Action Dock are the manual equivalent, and each of those carries its direction in the press, so the step and the actions can never disagree about which way Left is.
• A seat with no other occupied seat to pass to, with no held stack, or with more than one held stack is skipped, and the run explains why in the Sequence Debugger. The step never guesses which stack you meant and never fails the run.
• Passing does not check the receiving hand's size limit, so a stack always has somewhere to land.
• Unoccupied seats are not part of the ring, so a stack hops over an empty seat to the next occupied one.

Example: For a booster draft, set Which Stack to Seat, From Seat to All Seats and Direction to Left. Each player draws their pick out of the stack they are holding, then one Pass Stack step sends every remaining stack one seat around the table at once. With seats 1, 2, and 4 occupied and seat 3 empty, that one step sends seat 1's stack to seat 2, seat 2's to seat 4, and seat 4's to seat 1. Run it again with Direction set to Right to turn the draft around for the next round. Note that only the held stack travels: the picks each player has already taken out stay in their own hand, which is what makes this a draft rather than a hand swap.

Player Visibility

Show, hide, or toggle the player space eyeball for one seat, the acting player, or all seats. This is the same visibility control each player has over their own player space, driven from a sequence so you can reveal or conceal areas at the right moment in play.

Configuration:

• Player Spaces - All Seats, Acting Player, or Specific Seat
• Seat Index - the seat to target, shown only when Specific Seat is chosen
• Visibility - Shown, Hidden, or Toggle

Behavior:

• Shown and Hidden set the visibility outright, so the result is the same no matter what a player did by hand beforehand.
• Toggle flips each targeted seat relative to its own current state, so seats already in different states stay mixed.
• Works on any configured seat (1 to the table's player count), whether or not a player is currently seated. Setting an unoccupied seat pre-stages it, and a player who later joins that seat starts in that state.
• Visibility belongs to the seat, so it persists when a player leaves and the next occupant inherits it.
• Seats beyond the table's player count are skipped, so the step never fails.
• A seat that has never had its visibility set starts out visible.

Example: At the start of a hidden-bidding round, use Player Visibility with All Seats set to Hidden to conceal every player space at once. After bids lock in, run it again with All Seats set to Shown to reveal them together.

Change Turn

Set or advance whose turn it is, as part of a sequence. Requires turn tracking to be on for the table -- see Turn Tracking for what turn order means, who may change it by hand, and what happens when a seat joins, leaves, or switches; this entry covers only the step's own configuration.

Configuration:

• Turn Action - Advance or Set
• Set Turn To - Acting Player, Left Player, Right Player, or Specific Seat, shown only when Turn Action is Set
• Seat Index - the seat to set the turn to, shown only when Specific Seat is chosen

Behavior:

• Advance moves the turn to the next occupied seat, following the table's Turn Direction setting. It does not accept a Seat Index -- pairing Advance with a seat target fails the step rather than guessing which one was meant.
• Set moves the turn straight to the named seat, overriding wherever it currently is.
• If turn tracking is off for the table, the step fails rather than silently doing nothing.
• A Turn Action other than exactly Advance or Set fails the step -- there is no silent fallback to Set.
• Setting the turn to a specific seat nobody is sitting in is flagged at authoring time (pick an occupied seat, or use Acting Player), the same warning the editor gives for any other seat-targeting step.

Example: To hand the turn to whoever just triggered a reaction, add a Change Turn step with Turn Action set to Set and Set Turn To set to Acting Player.

Prompts

Steps that pause the sequence and ask a player for input before continuing.

Prompt Confirm

Ask a player to confirm before the sequence continues. Configure a message to display. The sequence pauses until the player confirms or the timeout expires.

Prompt Number

Ask a player to enter a number. Configure a message, minimum and maximum values, and an optional default. The entered number is saved to context so later steps can reference it (for example, as the amount in an Adjust Counter step).

Prompt Choose

Ask a player to choose from a list of options. Configure a message and the available options. The chosen option is saved to context for use by later steps.

Select via Prompt

Ask a player to select one or more pieces from the table. Configure filter criteria to limit which pieces are selectable, minimum and maximum selection counts, and a message. The selected pieces become available in context for subsequent steps. The same filter fields available in Select by Filter are available here, including the name filter with its four match modes -- except the space-tag location, which only Select by Filter offers. A prompt scopes to one named space.

Wait for All Seats

Suspend the sequence until every occupied seat has responded, or until it times out. This is a barrier, not a targeted prompt: unlike the four steps above, it has no seat-targeting field -- it always waits on the whole ring, never on a subset or a single named seat.

It cannot run inside a reactive trigger or a called sub-sequence. Both refuse to save a sequence that holds this step, exactly the same refusal the four prompt steps above already get in those two places -- a barrier suspends the same way a prompt does, so it is subject to the same rule.

Configuration:

• Message - optional text shown in the prompt. Defaults to "Waiting for every seat to respond" if left blank or set to only whitespace.
• Timeout (ms) - how long to wait, in milliseconds, not seconds. Defaults to 120000 (2 minutes) if not set -- double the 60-second default the four prompt steps above use, and entered directly in milliseconds rather than the seconds field those steps show. This step does not share their timeout vocabulary; read the field label before setting it.
• On Timeout - Release and continue lets the wait end and the sequence proceed, or Stop the sequence halts it. No further steps run when stopped.

Behavior:

• Every occupied seat sees the prompt with a single Ready action -- there is nothing to confirm, enter, choose, or select, only to acknowledge.
• The sequence resumes exactly once, the instant the last outstanding seat responds.
• The wait set is the seats currently in the ring, re-evaluated on every ring change. A seat leaving is dropped from the wait immediately, and if that was the last seat still owed a response, the barrier releases right then rather than waiting for a timeout. A ring that empties out entirely also releases immediately, for the same reason: there is nobody left to wait on.
• A timeout is a defined release, governed by On Timeout above, not a stall.
• The Sequence Debugger and each waiting player's own prompt both show the barrier as waiting on named seats ("Waiting on Alice and Bob"), never as a generic stalled run -- the same identity each surface already uses elsewhere, not raw seat numbers.

Prompt timeouts

All four prompt steps above support timeout configuration:

• Timeout (optional) -- how long the player has to respond, in seconds. Defaults to 60 seconds if not set.
• Timeout Behavior -- what happens when time runs out:
  • Use Default -- the prompt resolves with a default value (confirm defaults to "yes", number defaults to its configured default, choose defaults to the first option, select defaults to no selection). The sequence continues.
  • Stop -- the sequence stops executing. No further steps run.

Wait for All Seats has its own Timeout (ms) and On Timeout fields, described above -- it is a barrier, not a targeted prompt, so its timeout is entered in milliseconds and its default is 2 minutes rather than 1.