Loading Leap…

Documentation

Guides for the Leap alpha: design your game's meta and economy, build systems, playtest your design and deploy it to your game.

Getting Started

Create your first project and learn your way around Leap Studio: its tabs, the project tree, the Element Explorer and the Inspector.

Start here. This section introduces the Leap alpha, walks you through creating a project and shows you around Leap Studio. Then read Work Modes, which explains the two ways to work on a project: editing Main directly, or in workspaces merged into Main.

  • Introduction to Leap — What Leap is, the building blocks of a design, and how a design goes from Leap Studio to your game.
  • Creating a Project — Create your first Leap project, name it, and see what Leap sets up for you automatically.
  • Navigating Leap Studio — Find your way around Leap Studio: the tabs, the project tree, the Element Explorer and the Inspector.

Work Modes

Choose how a project is worked on: edit Main directly, or make changes in workspaces and merge them into Main.

Every project is worked on in one of two work modes, chosen per project. Edit Main directly to save every change straight to Main, or use workspaces to make changes in isolated copies of your design and merge them into Main when they are ready. This section covers both.

  • Editing Main Directly — Save every change straight to Main with no workspaces to manage, and see how versions, playtests and teammates’ merges work in this mode.
  • Working with Workspaces — Make changes in isolated workspaces, deploy one to try it in your game, resolve conflicts and merge your work into Main.

Resources

Create what players earn, spend and accumulate — currencies, energy, XP, wins — and set the limits and starting values that shape them.

Resources are everything a player earns, spends or accumulates: soft and hard currencies, energy, experience, and counters such as total wins. This section covers creating them, and the limits and starting values that shape how each one behaves.

  • Creating Resources — Create resources such as gold, gems and energy, and set their limits and starting values.

Constants

Define the fixed tuning values of your design — base damage, XP per level, daily limits — that it reads but never changes.

Constants are the fixed tuning values of your design: a base damage value, the XP needed per level, a daily limit. Conditions, value expressions and formulas read them, but nothing in your design can change them. This section covers creating and using them.

  • Creating Constants — Create constants for the fixed tuning values of your design, and read them in conditions, expressions and formulas.

Flags

Track yes/no facts about a player — tutorial finished, hard mode unlocked — with flags.

Flags are yes/no facts about a player: whether they finished the tutorial, unlocked hard mode or claimed a one-time offer. Every flag starts false. This section covers creating flags, setting them from operations, and checking them in conditions anywhere in your design.

  • Creating Flags — Create flags, set them to true or false from operations, and check them in conditions.

Achievements

Create achievements that unlock automatically when a condition becomes true, and decide what they grant.

Achievements are goals that unlock automatically as soon as their condition becomes true — first victory, a hundred wins, a full collection. Each one can grant rewards when it unlocks and carry the matching IDs for each platform store. This section covers creating and configuring them.

  • Creating Achievements — Create achievements, set their unlock condition, choose what they grant, and add platform IDs.

Entitlements

Define what a store purchase grants — starter packs, ad removal, premium content — and when it can be bought.

Entitlements describe what a player receives from a store purchase — a starter pack, ad removal, premium content — together with the product IDs on each store and the conditions under which it can be bought. This section covers creating and configuring them from the Element Explorer.

  • Creating Entitlements — Create entitlements, link them to store products, and choose what they grant when purchased.

Groups

Organise your design with groups and folders, and learn how groups shape the paths your game uses.

Groups give your design structure. A group is a namespace: your game addresses the elements inside it as group.element, and groups can contain other groups. Folders organise the project tree for your team without affecting your game. This section covers both, and the rules for which elements can use which.

  • Creating Groups — Create groups from the project tree, add elements to them, and see how they change runtime paths.
  • Organizing Your Project — Use folders and groups to organise the project tree, and learn the slug and reach rules they bring.

Custom Operations & Events

Define the actions of your design with custom operations, and the signals that move systems with events.

Custom operations and events are the verbs of your design. A custom operation checks its conditions and then applies its effects; an event is a named signal that moves systems from one state to the next. Marking either as callable by game clients is how your game triggers them.

  • Custom Operations — Create custom operations that check conditions and apply effects, and let your game call them directly.
  • Events — Create events — named signals that move systems forward — and fire them from operations or your game.

Concepts

The shared editors you meet in every inspector — conditions, values, formulas and effects — and Element Flow.

Some building blocks appear in almost every inspector in Leap Studio. The condition editor decides when something happens, the value editor and formulas decide how much, and the effects editor decides what changes. Learning them once pays off everywhere; Element Flow then shows how it all connects.

  • Conditions — Build conditions from resources, flags, achievements, formulas, expressions and system states, and combine them with All, Any and NOT.
  • Values and Expressions — Use fixed numbers, element values, formulas and random curves wherever Leap expects a value.
  • Formulas — Name a calculation once as a formula and reuse it in any value across your design.
  • Operations and Effects — Change resources, flags and achievements, fire events and run custom operations with effects.
  • Element Flow — See how your elements and systems connect — what produces, reads, runs and fires what.

Systems

Build state machines for quests, tutorials and any other player flow, with states, randomizers and exits.

A system is a state machine: a player is always in exactly one of its states, starting in the first, and moves on when an exit's conditions pass or an event it waits for is fired. Randomizers pick a weighted outcome and pass straight through. This section covers building systems on the canvas.

  • Creating Systems — Create a system from the project tree, set its properties, and understand the GameSetup system.
  • States and Randomizers — Add states where players stay and randomizers that draw a weighted outcome, and choose the start state.
  • Exits and Transitions — Connect states with exits taken automatically or when an event fires, and drive systems from your game.
  • Working on the Canvas — Arrange, search and save your systems on the canvas, and learn which changes save immediately.

Playtest

Play your design — Main or a workspace — as a brand-new player, one action at a time, and read what each action changed.

Playtest plays your design as a brand-new player, one action at a time, so you can check your systems, custom operations and events behave the way you intended. This section covers starting a playtest, choosing actions, and reading what each action changed.

  • Playtesting Your Design — Start a playtest on Main or on a workspace and take actions one at a time as a new player would.
  • Reading a Playtest — Read the player state, the run history and the changes each action made during a playtest.

Going Live

Tag versions of Main or of a workspace and deploy them, in the same step or later, to the environments your game connects to.

Once your design works, it is time to ship it. Saving on Main, or merging a workspace, updates Main; a version tags Main — or the workspace you create it in — at a moment in time; and deploying a version to an environment, in the same step or later, is what game clients connecting to that environment receive. This section covers versions, environments and deployments.

  • Versions and Deployments — Create a version of Main or of a workspace, deploy it to an environment in the same step or later, and manage your environments.

Analyse

See what players and playtests did in each environment: the actions they ran, the values those changed and the states they moved.

Every action your game runs is recorded in the environment it plays on. The Analyse tab shows them: totals, every event, and each player one action at a time.

  • Analysing Your Game — Read the actions players and playtests ran in an environment, filter them, and jump from any of them to its design.