Where to go next

The rest of this documentation is not meant to be read in order. Each track answers one kind of question; pick the one you have.

Concepts — why it is shaped this way

Read these once. They are shared with the Unity plugin, because the shape is the same.

• The three files — what a sync produces, and which of it your writer changes without a compile.
• The two seams — which module holds what, and why the engine has no Unreal in it.
• Node meaning is resolved once — why there is no class per node type, and why there cannot be.
• Expressions — the gates and scripts, parsed at sync time and evaluated here.
• The payload, field by field — every type in runtime.json.

Playing — you are drawing a story

The integration, in the order you will hit it.

• Starting a session — the component, the subsystem, the verbs and the events.
• Reading a step — the whole read surface.
• Choices, and why one is locked.
• One handler per node type — where a node type’s own logic goes.
• Entity display — a name, a colour, a portrait.
• Implementing commands — how a story makes your game do something, and how it waits for you.

The generated assets and code — you are wondering where something came from

• What a sync writes as data — the assets and tags every sync writes without a compile.
• The typed C++ layer — what a schema change generates into your module, and the naming rules behind it.
• What a sync writes — every file, where it lands, what to commit.

Media — you are wondering where the pictures and the sound went

• Where synced media lands — the folder a sync imports into, the index it writes beside the assets, and what a rename does to a project that already shipped. This is where the files ARE; Loading media in Reference is how you turn a step’s reference into one at play time.

The plugin’s tools — something looks wrong while the game plays

• The Story Debugger — where the story playing in the editor is, its variables, what it played, and a jump to any node.

Authoring — you are telling a writer what reaches a build

• What a build needs from a project — codes, commands, option sets, the start, and the two kinds of blank.

Extending — you want your own code to run when a sync finishes

• Running your own code after a sync — the two editor-module delegates that fire when a sync and its generation end, for validation, custom imports or generation of your own.

Reference — you are looking something up

• The Unreal player — every verb, the policy, how a playthrough ends.
• Saving a playthrough.
• Loading media.
• Drawing a line of text — the presenter widget and the markup.
• Diagnostics — every code the runtime emits.
• The project’s UI strings.

The sample

TaleShard > Open Sample opens the plugin’s sample level in place: a TaleShard Story actor and a command handler that prints every command it receives, playing your own synced story on the plugin’s dialogue screen, with no C++. It is for looking at and playing, not for copying: your own level needs only a TaleShard Story actor.