# Choices & Branching

Source: https://docs.skaz.io/guide/choices

> How choices connect blocks in Skaz: adding choices, drawing links, inserting blocks into a link and building branches that loop or merge.

Choices are how blocks connect to each other. Every block has zero or more
choices, and each choice points at the next block in the story.

## Adding a choice

Select a block, open its **Node** inspector, scroll to **Branching**, and
click **+ Add choice**. Give the choice a **label** and connect it to the
target block.

## How choices look to players

For [Text](/guide/blocks#text) and [User Input](/guide/blocks#user-input)
blocks, each choice becomes a button at the bottom of the screen:

- **One choice** — shown as a single, full-width "Continue"-style button.
- **Multiple choices** — shown as several buttons side by side, one per
  choice. This is real branching: the story takes a different path depending
  on which one the player clicks.
- **No choices** — the player has reached the end of the story (or an ending
  branch). They'll see a "You finished the story" screen with options to try
  again or go back home.

> A choice's **label** is exactly the text players see on the button — so write
> it the way you'd want a reader to see it ("Open the door", "Run away", ...).

## Instant blocks

[Set Variable Value](/guide/blocks#set-variable-value) and
[Change Variable Value](/guide/blocks#change-variable-value) blocks don't show
buttons to the player — they have a single choice that the engine follows
automatically, right after running. Use them as an invisible "next step" in
the middle of a longer chain of logic.

## Variable Router conditions

A [Variable Router](/guide/blocks#variable-router) block is the exception: its
branches aren't buttons the player clicks — they're **conditions**, checked
against the router's chosen variable.

Each branch has an **operator** and a **value**, which you pick right on the
block (a dropdown for the operator, plus a field for the value — or a
`true`/`false` toggle for `bool` variables). The router checks its branches
**in the order they're listed** and follows the first one whose condition
matches. Which operators are available depends on the variable's type.

### Number variables (`int` / `float`)

| Operator | Shows as | Matches when the variable is... |
|---|---|---|
| equals | `== 10` | equal to `10` |
| not equals | `!= 10` | anything except `10` |
| greater | `> 10` | greater than `10` |
| greater or equal | `>= 10` | `10` or more |
| less | `< 10` | less than `10` |
| less or equal | `<= 10` | `10` or less |

### String and bool variables

Only **equals** and **not equals** are available — the value is compared
exactly.

- For a `bool` variable, the value is a `true` / `false` toggle.
- For a `string` variable, type the exact text you're comparing against.

### Otherwise (catch-all)

Every branch also offers an **Otherwise** operator — it always matches, no
matter the variable's value. Use it as the **last** branch so the router
always has somewhere to go.

> If none of a router's branches match, the story can't advance. Give every
> Variable Router a final **Otherwise** branch (or another condition that's
> guaranteed to match) so it never gets stuck.

### Example

A `score` (`int`) variable feeding a Variable Router with three branches, in
this order:

1. `>= 50` → "Great ending" block
2. `>= 20` → "Okay ending" block
3. **Otherwise** → "Bad ending" block (catches everything else, including negatives)

If `score` is `35`, the router skips branch 1 (`35 >= 50` is false), matches
branch 2 (`35 >= 20` is true), and jumps straight to the "Okay ending" block —
the player never sees this happen.