Logic — the game flow designer

The Logic tab is the node graph of how the player moves through the game. Every screen the player sees, every transition between them, every trigger that fires a feature — drawn as nodes and edges on a zoomable canvas.

This is the "what happens when" view. Game design tells you the brief. Flow shows you the screens. Logic shows you how they connect.

When to use this tab

Most projects don't need much hand-tuning here, because Logic auto-populates from your feature toggles. Free Spins on → the trigger event, intro pop-up, in-round, outro pop-up and return arrow all appear. Toggle on Hold & Spin and a parallel branch joins the graph at the right level. The default wiring is correct for ~80% of slot designs.

You touch the Logic tab when you want to:

• Add a non-default transition (e.g. "Free Spins → directly into Bonus Pick at the end" instead of returning to Base).
• Document a specific trigger condition the math team needs.
• Show stakeholders how the game flows without dragging them through Flow screen by screen.
• Add a custom event or system node the catalogue doesn't have.

The canvas

The Logic canvas is a separate full-screen modal that opens inside the Logic workspace. Like Flow, it has pan and zoom; unlike Flow, the nodes are abstract rather than rendered art.

Controls:

• Wheel — zoom in / out (zooms toward the cursor).
• Drag empty canvas — pan.
• Alt + drag — pan from anywhere.
• Double-click empty canvas — add a new screen node at that position.
• F — fit the graph to the viewport.
• Delete / Backspace — delete the selected node or connection.

Node types

Three flavours of node:

Each node has a label (shown on the canvas), an optional notes field (free text — surfaced in the Logic spec export and the GDD), and a colour drawn from the feature it belongs to.

Edges

Connections between nodes have a direction. They represent flow — the player moves from the source to the target.

Edges can carry a condition expression evaluated against game state: field, operator, value, plus and / or / not composition. The expression set:

• >=, <=, >, <, ==, != — numeric and equality.
• and, or, not — boolean composition.

Conditions are documentation today — they describe to the build team under what circumstances the transition fires. The flow evaluator engine is wired up internally for future simulator use; until that ships, treat conditions as comments-with-shape.

Auto-populated structure

When you first open Logic on a fresh project, it lays itself out automatically based on your features:

START → LOAD / SPLASH → BASE GAME → SESSION END
                              │
                              ├─ (per feature)
                              │   FS TRIGGER → FS INTRO → FREE SPINS → FS OUTRO ┐
                              │   H&S TRIGGER → H&S INTRO → HOLD & SPIN → H&S OUTRO ┤
                              │   PICK TRIGGER → PICK INTRO → BONUS PICK → PICK OUTRO ┘
                              │
                              ├─ BIG WIN / MEGA WIN / EPIC WIN celebration pops
                              ├─ GAMBLE (if on)
                              └─ BUY BONUS (if on)

(The exact columns and rows depend on which features are toggled. The auto-populate is idempotent — it re-runs without destroying your hand-edits on subsequent feature toggles, but it doesn't delete nodes you've added.)

Editing nodes

Click a node to select it. The Properties panel on the right shows:

• Label — short name on the canvas.
• Type — Screen / Event / System (mostly fixed; you can switch if you change what the node represents).
• Notes — the longer description that shows in the Logic spec.
• Linked screen — for Screen nodes, the SDEFS key of the Flow screen this node represents. Clicking the link jumps to the Flow workspace with that screen selected.
• Linked feature — for Event nodes, the feature key (if any) that owns this trigger.

Editing edges

Click an edge to select it. The Properties panel shows:

• Label — short text shown on the edge (e.g. "if landed=true").
• Condition — the structured expression (see above).
• Notes — free text.

Multi-flow projects

A project can carry multiple flow graphs in parallel (e.g. a Main Game flow and a separate Tournament Mode flow). The tab bar across the top of the Logic canvas lets you switch between them.

Most projects ship with one flow. Add a second only if your game has a meaningfully different player journey to document — typically tournament/mission modes or sweepstakes variants.

Exporting Logic

Two relevant exports from the project Export page:

• Flow diagram (SVG) — the raw vector graph, embeddable in dashboards, build tools, wikis.
• Flow presentation (PDF) — multi-page deck: cover, full graph overview, one slide per screen, legend at the back. Good for stakeholder reviews.

The free Logic spec (`logic_md`) export is a Markdown document of the same content: win-evaluation rules, wild substitutions and trigger conditions, formatted for engineers to read alongside the math spec.

How Logic ties into the GDD

The GDD PDF (under Export) renders the Logic graph as a section. Auto-populated nodes get default copy; your custom notes on a node or edge override it. If you want a polished GDD, take 10 minutes in Logic to write a clear note on each trigger event — the GDD's prose pass turns those into proper paragraphs.

What Logic is not

• Not a runtime. Spinative doesn't play the game. The flow evaluator is wired up for future simulator work; today the graph is documentation that travels with the project.
• Not the math spec. RTP, hit frequency, paytable values, reel strips — those live in the Math spec export, generated from Features + Project settings. Logic is *qualitative* (which screens connect, under what condition); Math is *quantitative*.
• Not the canvas. Logic doesn't render art. To compose a screen, switch to Flow.

Tips for clean Logic graphs

• Write the notes as you go. A node labelled FS TRIGGER with notes "3+ Scatter symbols land on reels 1, 2, 3" is far more useful in the GDD than FS TRIGGER alone.
• Don't overcrowd one flow. If you've got more than ~20 nodes, consider splitting into multiple flows (Main Game / Bonus Detail / Endgame).
• Use system nodes for boundaries. START, GAME LOAD, SESSION END — having them visible at the top and bottom of the graph helps anyone reading it orient themselves.
• Colour follows feature. Don't fight the auto-colours; they match the feature colours in the Features tab, which makes the graph readable across tabs.