Skip to main content
Flow Core Documentation
Menu

Debug and Maintain Projects

Questions & Answers

Find concise answers to common Flow Core setup, graph, data, module, scripting, debugging, and update questions.

Audience
All developers
Time
As needed
Requires
None
Modules
Flow Core
On this page

Resolve questions here, then follow their guides. For a reproducible failure, start with Troubleshooting.

Browse by topic

Getting Started

Where should I start after installing Flow Core?

Complete Install & Verify, observe a Working Flow, then Build Your First Flow. Choose a larger architecture once you can explain the runtime owner, start point, and visible result. Keep the first exercise small before adding project-specific behavior.

Why are Character example scenes missing from the Asset Store package?

Character demo scenes and third-party assets are excluded for licensing and redistribution reasons. The Flow Character module is included. Play the Online Demo for the complete examples, including Zombie Walk; use appropriately licensed models and animations in your own project.

Do I need C# to use Flow Core?

No. Assemble built-in Triggers, nodes, Instructions, Conditions, and typed values without C#. Write code for custom operations, decisions, event sources, or external bridges. Start with Build Your First Flow, then use the Scripting guides when you need an extension.

Which logic model should I choose?

Use Flow for known event sequences, FSM for persistent modes, Behavior Tree for repeated priority decisions, Stack for temporary layers, and GOAP for plans derived from facts and costs. Choosing a Logic Model explains the selection and composition boundaries.

Which Flow Core modules do I need?

Choose Character for movement, Camera for Shots, Interaction for candidate routing, and Stats for calculated values and effects. Connect only the capabilities your project needs through Flow. See Gameplay Module Architecture before adopting additional systems or sharing mutable runtime state.

Graphs & Runtime

What is the difference between a Flow Graph and FlowCoreProcess?

A Flow Graph stores reusable authored behavior. FlowCoreProcess assigns it, builds instance state, binds Local Blackboards, and exposes Entries on one GameObject. Graph Assets & FlowCoreProcess explains this separation; changing the shared asset still changes the behavior used by its processes.

Can multiple GameObjects use the same Flow Graph without sharing runtime state?

Yes. Each FlowCoreProcess owns independent runtime state. Keep instance values in Local Blackboards or another explicit owner. The graph remains shared authored data, so editing it affects all consumers. See Graph Assets & FlowCoreProcess when diagnosing accidental state sharing.

Are Flow Core editor preferences shared with my team?

Personal preferences use EditorPrefs scoped to your project location. Project Shared settings synchronize build/runtime configuration through the settings asset; values authored in graphs remain shared. This includes personal Editor versus shared Player prewarm policy. See Personal & Project Settings.

Why did my preferences reset after moving the project?

Moving the project or opening another checkout creates a fresh preference scope. Missing fields initialize from the legacy asset or defaults; preferences at the original location remain separate. See Personal & Project Settings before intentionally resetting or reimporting your choices.

Why does my graph not start?

Confirm the intended FlowCoreProcess is enabled, references the correct graph, and binds its Blackboards. Check the Trigger or Entry, first connection, and rejecting Guards. Use Troubleshooting for symptoms and Debugging Running Graphs to trace the actual process and execution route.

Data & Lifetime

When should I use a Blackboard?

Use Blackboard for named, typed, inspectable values with explicit ownership. Choose Local for instance state, Scene for scene-wide sharing, and Global for application state. Scope, index, key, and type form the complete path. See Blackboard & Typed Values.

What is the difference between payload and TempPayload?

The starting event supplies read-only payload. TempPayload is writable scratch data within that chain and clears when the chain ends. Store longer-lived state in an explicitly owned Blackboard. See Triggers, Entries & Payloads when selecting an intentional data lifetime.

How should I share data without relying on accidental global state?

Choose the narrowest owner: Local for objects, Scene for shared scene facts, Global for application data. Modules retain the state they own and expose intentional handoffs. See Blackboard & Typed Values; global scope does not replace lifecycle or reset decisions.

Scripting & Persistence

How can C# or a third-party system interact with Flow Core?

Call the intended process Entry when C# owns timing. Translate external state through typed Blackboards or events while retaining one source of truth. Follow Running Graphs from C# and Integrating Third-Party Systems rather than mutating graph topology at runtime.

How do I create custom Instructions or Conditions?

Use an Instruction for work and a Condition for a typed decision without gameplay side effects. Keep runtime code and cloneable Data separate from Editor UI. Follow Custom Instructions and Custom Conditions; supported sources bind automatically after compilation in 6.0.

Do the reflection UI changes require running Generator again?

Reflection-only improvements need no rerun. Regenerate separately maintained Drawer implementations when templates or field contracts change; handwritten Drawers retain their UI. Flow Core 6.0 supplies supported bindings during compilation, without central-list maintenance. See Custom Instructions for the implementation-generation boundary.

How do I save and restore runtime state?

Use Flow Core’s supported save channel and persistence groups to choose included state. Restore against compatible graph and type identities; an asset reference alone is not a complete runtime snapshot. Follow Save & Restore Runtime State and verify the intended reset/restore boundary.

Help & Updates

Why does entering Play Mode take longer with domain reload?

Domain reload recreates managed state and invokes package initialization. Third-party callbacks and window repaint can dominate before gameplay frames run. Flow Core cannot frame-slice another package’s static initializer. Slow Play Mode Entry explains profiling and the project-specific Unity Visual Scripting case.

Where should I look when something is not working?

Start from an observable symptom in Troubleshooting. Trace the intended process and context with Debugging Running Graphs, or inspect configuration through Field Information & Flow Knowledge. Record expected versus actual behavior before changing shared graph assets or requesting help.

Where can I review changes, report an issue, or get help?

Read Release Notes for additions, compatibility changes, and upgrade steps. The documentation footer links to Tech Docs, Discord, bug reporting, and feature requests. Include version, reproduction steps, expected result, and actual behavior when reporting an issue that others need to reproduce.