Arguments and results

Every parameter row answers one question: where does this value come from? Then the Result card decides what the answer means to the graph.

The problem

Racing Line’s pace call is SmoothPaceGap(int driver, float smoothed, float signed, float delta, int tick). Four of those come from graph variables that other nodes maintain. The fifth is another member’s return value, RacingTickCount(), which nothing should have to store in a variable just to pass along.

CpuRace.bqbehavior authors exactly that: four Blackboard sources and one Project source that reads the tick count from its own member and hands it straight over. No glue method, no scratch variable.

When to reach for each argument source

Source	Use it when	Offered
Constant	The value is fixed by the design, like the Platformer fall threshold -10	Always, for a type a constant can express
Blackboard	Another node produced the value	When a compatible variable exists
Project	The value is another member’s reading	Where projection is legal
Default	The declaration already has the right default	Only when the parameter has a real compile-time default, shown as optional = and the value

A CancellationToken parameter is supplied by the runtime rather than authored, so no source control appears for it. Observe it in your own code and cancellation becomes cooperative instead of decorative.

See it

Figure 1. Arguments above, Result below. Each argument row names the parameter and its type.

Figure 2. A Test result: operator, compared value, and the outcome for each side.

Figure 3. Dungeon Heist’s TryGetPendingSignal(out Stimulus). The out value is a row in Outputs; the bool return goes to the Comparison card that starts below it. An output and a result are two separate cards, because they are two separate values.

Figure 4. Racing Line’s Pacing.AdvanceCatchUpPressure, bound as written. Its by-value parameters sit in Arguments; ref float catchUpPressure gets its own Read-write parameters row, which reads catch_up_pressure and writes the new value back to it, marked Same variable. A method node shows the same two cards.

Figure 5. The same binding, further down the rail. It sits on a member condition and the method returns nothing, so Tested value names the ref parameter whose value after the call gets compared, here against 3.

Do it

1. Select the member node and read Arguments. A parameterless method says so instead of showing an empty card.

2. Set each row’s source. A Constant row uses the typed editor for that parameter; a Blackboard row lists the compatible variables; Project lists the legal member projections.

3. For a ref parameter, use the Read-write parameters card: choose the Read source, then the required Write to destination. A Blackboard read writes back to the same variable, marked Same variable; Use different destination points the write somewhere else. A Constant read has no variable to fall back on, so its Write to stays Required until you choose one. On a member condition bound to a void method, the Comparison card’s Tested value row names which ref parameter’s value after the call stands in for the void return. A method with one ref parameter fills it in when you pick the method; with several, the row stays Required until you choose.

4. For an out parameter, use the Outputs card and choose its required destination. There is no input source on an out row.

5. For a trailing params parameter, choose Individual values to author rows with Add value, or Collection to pass one array or list.

6. Set Result. Choose Test to compare the return, Always to report a fixed result, or Returned when the member returns the product’s own node result. Set Store independently when a later node needs the value.

You should see

The card reads as a sentence: this method, these inputs, this destination, this result. In Live the same rows show the values that actually went in and came out.

Change one thing

Take Dungeon Heist’s TryGetPendingSignal(out Stimulus signal) shape: a bool return and one output. Map When true to succeeded and When false to failed, and point the output at a variable. The branch now runs only when a signal existed, and the signal is on the blackboard for the node that stores it. Then set the return to Always succeeded and watch the branch continue with an empty signal, which is the bug that mapping was preventing.

How it decides

Argument rules

• A Default row omits the argument at the call, so the method uses its current compile-time default. If the declaration loses that default, the row says the default is unavailable instead of inventing one.
• A required parameter with no source is reported at validation. A params parameter may legally stay empty, which invokes with an empty array.
• params cannot use Default, and it is distinct from passing a collection variable as one value. The chosen form, the element type, the order, and the values are all part of what the graph file records.
• An index argument on an indexed property needs the exact type, with no conversion at all, unlike ordinary arguments which accept the conversion set.
• A Blackboard index is re-read on every evaluation.

Reading and writing around the call

• ref inputs are read immediately before the call.
• out and ref destinations commit as one batch, in declaration order, after a normal return and before result mapping or storage. Two ref rows aimed at one variable both read the value from before the call, and the last one declared wins.
• A ref member condition runs in four steps: read, call once, write back, then compare the value it just wrote.
• A call that throws commits no outputs and stores no return.
• For a deferred call, outputs are captured when the invocation hands back a usable coroutine or awaitable handle, before the waiting starts, and a later fault or give-up does not roll them back.
• On the entity path a static method may take ref parameters under the same rules. out, in, and params are refused there, and the refusal names the modifier.

Result rules

• Store is independent of the result. A method can store its return and use that same return to decide the node result.
• An out destination never doubles as the Store destination, because a return value and an output value are two different things.
• Always offers the seven results: succeeded, failed, running, interrupted, blocked, timeout, authority.
• A mapping where every possible outcome is running is refused.

Generic methods

• A generic method adds a Generic types card with one slot per type parameter. Arguments, Outputs, Binding, Comparison, and Result stay locked until every slot is closed.
• Candidates are public closed types from the loaded assemblies. Open generics and editor-only types are excluded, and a candidate that fails a constraint stays visible and unpickable so you can see why.
• Type arguments are never inferred from the target, the arguments, or the destination. The picker shows the constraint, such as where T : Component, and you choose.
• Closure happens at authoring time. The generated call is already closed, so nothing constructs a generic method while the game runs.

Indexed properties

An indexer appears in the picker with its full signature, and its Member name row reads this. Its index values occupy an Arguments card ahead of the binding controls, so a get, a set, a two-way binding, or a member condition can address one entry without a wrapper method. Index parameters declared in and a trailing params index are discovered and executable but have no authoring control in this release, so ordinary by-value index parameters are the ones to use today.

When it goes wrong

When it goes wrong

Symptom	Check	Fix
A row says the default is unavailable.	The declaration no longer has a compile-time default for that parameter.	Choose Constant, Blackboard, or Project, or restore the default in your code.
An out destination is empty after the call.	Confirm the call returned normally.	A throw commits no outputs. A normal false return still commits them.
A ref row says Write to is required.	The Read source is a Constant, or the destination was cleared.	Choose a writable blackboard variable of the parameter type. A Blackboard Read writes back to itself by default.
A void ref condition says Tested value is required.	The method has more than one ref parameter.	Pick the parameter whose value after the call the comparison should test.
Validation reports a required parameter with no value.	Read the Arguments card for a row with no source.	Give it a source, or bind an overload that does not need it.
The variable you want is not in the Blackboard list.	Compare the variable type with the parameter type.	Declare the type the parameter takes, since only accepted conversions are offered.
The Result card is locked.	A generic slot is still open.	Close every type parameter, then the value cards appear.
An indexer index is refused.	Index arguments need exact type identity.	Use a variable or constant of the exact index type.

Next

• Conversion: the exact type pairs an argument or result accepts.
• Waiting and cancellation: the deferred half of the Result card.
• Racing Line: the pace call this page uses, in its own game.