BitQuirky.Behavior.Entities

Public behavior trees and state machines: runtime symbols in BitQuirky.Behavior.Entities.

Mixed: see page detailsGenerated 2026-09-23

Source snapshot ad0983d00d77.

On this page

Assembly: BitQuirky.Behavior.Runtime

BehaviorArtifactSurfaceException

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorArtifactSurfaceException

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorArtifactSurfaceValidator.cs:22-36

Inherits: InvalidOperationException

Refusal raised when a graph is assigned to an agent surface that cannot carry one of its declared values.

Responsibilities:

Carry every uncarried variable’s complete verdict, so the caller reports them all at once rather than one at a time.

Does NOT:

Fall back to the GameObject path, convert a value, omit a slot, or attach anything.

Members

Diagnostics

public System.Collections.Generic.IReadOnlyList<BitQuirky.Behavior.Member.BehaviorArtifactCompatibilityDiagnostic> Diagnostics { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorArtifactSurfaceValidator.cs:35

Gets every uncarried variable’s complete verdict, in author order.

BehaviorArtifactSurfaceException(IReadOnlyList<BehaviorArtifactCompatibilityDiagnostic> diagnostics)

public BehaviorArtifactSurfaceException(System.Collections.Generic.IReadOnlyList<BitQuirky.Behavior.Member.BehaviorArtifactCompatibilityDiagnostic> diagnostics)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorArtifactSurfaceValidator.cs:25-32

Creates one refusal carrying the complete verdict list.

BehaviorArtifactSurfaceValidator

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorArtifactSurfaceValidator

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorArtifactSurfaceValidator.cs:52-244

The shared storage verdict both agent surfaces reach before any attachment side effect.

Responsibilities:

Decide, from the baked declared-value tables alone, whether a graph can run on the target agent surface, and report every uncarried variable at once with the graph, the variable, its complete declared type identity, the dictionary half where one applies, the source line, the target path, the reason, and the recoveries.

Does NOT:

Resolve a type, call a binder, create a component, buffer, query or entity, tick a graph, substitute a value, or block authoring. The verdict is about the graph, not about one running entity.

Members

DescribeRefusal(IReadOnlyList<BehaviorArtifactCompatibilityDiagnostic> diagnostics)

public static string DescribeRefusal(System.Collections.Generic.IReadOnlyList<BitQuirky.Behavior.Member.BehaviorArtifactCompatibilityDiagnostic> diagnostics)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorArtifactSurfaceValidator.cs:136-153

Renders the complete refusal of one graph as one actionable message.

IsCompatible(BakedBehaviorArtifact artifact, BehaviorAgentSurface surface)

public static bool IsCompatible(BitQuirky.Behavior.Baked.BakedBehaviorArtifact artifact, BitQuirky.Behavior.Member.BehaviorAgentSurface surface)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorArtifactSurfaceValidator.cs:113-133

Returns whether the artifact can run on the target surface without producing the complete diagnostic list.

Validate(BakedBehaviorArtifact artifact, string graphIdentity, BehaviorAgentSurface surface)

public static System.Collections.Generic.IReadOnlyList<BitQuirky.Behavior.Member.BehaviorArtifactCompatibilityDiagnostic> Validate(BitQuirky.Behavior.Baked.BakedBehaviorArtifact artifact, string graphIdentity, BitQuirky.Behavior.Member.BehaviorAgentSurface surface)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorArtifactSurfaceValidator.cs:60-107

Returns every reason the artifact cannot run on the target surface, in author order. An empty result means the graph is compatible.

BehaviorBlackboardFieldHandle<T>

Category: Entity integration

readonly struct BitQuirky.Behavior.Entities.BehaviorBlackboardFieldHandle<T> where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:124-213

A resolved, type-safe blackboard field location.

Responsibilities:

Read and write one validated unmanaged field from an agent buffer without game-side byte-offset arithmetic.

Does NOT:

Resolve field names during a tick or own blackboard storage.

Members

IsValid

public bool IsValid { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:147

False for a default-constructed handle, which no read or write will accept.

Read(DynamicBuffer<BehaviorRuntimeBlackboardByte> blackboard)

public T Read(Unity.Entities.DynamicBuffer<BitQuirky.Behavior.Execution.BehaviorRuntimeBlackboardByte> blackboard)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:188-212

Reads the field’s current value from one agent’s blackboard buffer. Throws InvalidOperationExceptionwhen the handle is invalid or the buffer is smaller than the graph’s blackboard.

Write(DynamicBuffer<BehaviorRuntimeBlackboardByte> blackboard, T value)

public void Write(Unity.Entities.DynamicBuffer<BitQuirky.Behavior.Execution.BehaviorRuntimeBlackboardByte> blackboard, T value)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:155-181

Writesvalueinto the field on one agent’s blackboard buffer and records the write in the journal, so the editor’s Live view and the next tick see it as an external change. ThrowsInvalidOperationExceptionwhen the handle is invalid or the buffer is smaller than the graph’s blackboard.

BehaviorEntityBlackboardSchema

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityBlackboardSchema

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:225-310

Resolves required blackboard fields once while a graph is composed.

Responsibilities:

Validate a field’s stable name, baked type, and storage size.
Return a Burst-safe typed handle for per-agent binding jobs.

Does NOT:

Read or mutate live entity buffers.

Members

Require<T>(string fieldName)

public BitQuirky.Behavior.Entities.BehaviorBlackboardFieldHandle<T> Require<T>(string fieldName) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:241-275

Resolves one blackboard field by its authored name into a typed handle, checking that the baked slot’s type code and width matchT. Call it once while composing the graph, then reuse the handle every tick. Throws InvalidOperationExceptionwhen the graph has no such field or its type does not match, andArgumentExceptionfor a blank name.

BehaviorEntityBufferAccessor

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityBufferAccessor

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityBufferAccessor.cs:28-105

The one exact existing dynamic-buffer entry a baked entity target addresses.

Responsibilities:

Turn one baked entry selector into the exact entry index the evaluation now running will read or write: a non-negative constant index checked against the entries that actually exist, or a compatibility selection already recorded by generated source.
Name the exact live reading when no such entry exists, and carry the number of entries the buffer actually held, so an author reads what the buffer looked like rather than a bare failure.

Does NOT:

Add, remove, reorder, resize, or clear an entry; substitute a neighbouring entry; fall back to the first or last entry; bake a byte offset into the element; or perform the identity comparison itself. Current generated accessors perform that typed comparison at invocation time so an earlier synchronous graph operation cannot make it stale.

Members

NoEntry

public const int NoEntry = -1

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityBufferAccessor.cs:33

The entry index a component target and an unmatched search both carry.

TryResolveIdentityOperand(in BakedMemberEntityTarget target, NativeArray<BakedMemberConstant> constants, NativeArray<BakedBlackboardSlot> blackboardLayout, NativeArray<byte> blackboard, NativeArray<byte> identityScratch, out NativeArray<byte> operand, out int width)

public static bool TryResolveIdentityOperand(in BitQuirky.Behavior.Baked.BakedMemberEntityTarget target, Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberConstant> constants, Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedBlackboardSlot> blackboardLayout, Unity.Collections.NativeArray<byte> blackboard, Unity.Collections.NativeArray<byte> identityScratch, out Unity.Collections.NativeArray<byte> operand, out int width)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityBufferAccessor.cs:48-102

Resolves the exact current operand bytes of an identity-addressed entry selector. A constant is copied into the caller-owned storage and a blackboard value is addressed in the running agent’s own bytes, so every caller compares the value as it stands at this exact moment rather than a snapshot taken earlier.

Parameters

target: The baked entity target row carrying the selector.
constants: The canonical baked constant table.
blackboardLayout: The agent blackboard layout table.
blackboard: The running agent’s own blackboard bytes.
identityScratch: Caller-owned storage for a constant operand.
operand: The complete resolved operand bytes, or an empty array.
width: The exact fixed byte width of the identity value.

BehaviorEntityEcsAccessKind

Category: Entity integration

enum BitQuirky.Behavior.Entities.BehaviorEntityEcsAccessKind

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:25-32

Underlying type: byte

Whether one declared ECS access row reads its type or also writes it.

Responsibilities:

Carry the exact strength one folded access row grants, so read-write can dominate a duplicate read-only row deterministically.

Does NOT:

Describe which accessor asked for the access, or fence anything itself.

Members

ReadOnly

ReadOnly = 0

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:28

Every accessor touching the type only reads it.

ReadWrite

ReadWrite = 1

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:31

At least one accessor touching the type writes it.

BehaviorEntityEcsAccessRow

Category: Entity integration

readonly struct BitQuirky.Behavior.Entities.BehaviorEntityEcsAccessRow

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:64-109

Implements: IEquatable<BehaviorEntityEcsAccessRow>

One row of the exact ECS access table a generated binding set declares.

Responsibilities:

Name one component or buffer type by its stable type hash, its container shape, and the folded access strength every accessor of the binding set requires of it, so the generated schedule entry point can fence exactly that access and no more.

Does NOT:

Hold a native container, a type handle, or a resolved entity. It is plain unmanaged data so a Burst job may carry it without a managed reference.

Members

Access

public BitQuirky.Behavior.Entities.BehaviorEntityEcsAccessKind Access { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:85

Gets the folded access strength required of the type.

ContainerKind

public BitQuirky.Behavior.Entities.BehaviorEntityEcsContainerKind ContainerKind { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:82

Gets whether the row addresses a component or a buffer element.

IsReadWrite

public bool IsReadWrite { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:88

Gets whether the row requires write access.

StableTypeHash

public ulong StableTypeHash { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:79

Gets the Entities stable type hash of the accessed type.

BehaviorEntityEcsAccessRow(ulong stableTypeHash, BehaviorEntityEcsContainerKind containerKind, BehaviorEntityEcsAccessKind access)

public BehaviorEntityEcsAccessRow(ulong stableTypeHash, BitQuirky.Behavior.Entities.BehaviorEntityEcsContainerKind containerKind, BitQuirky.Behavior.Entities.BehaviorEntityEcsAccessKind access)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:68-76

Creates one exact declared access row.

Equals(BehaviorEntityEcsAccessRow other)

public bool Equals(BitQuirky.Behavior.Entities.BehaviorEntityEcsAccessRow other)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:91-96

Equals(object obj)

public override bool Equals(object obj)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:99-102

GetHashCode()

public override int GetHashCode()

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:105-108

BehaviorEntityEcsContainerKind

Category: Entity integration

enum BitQuirky.Behavior.Entities.BehaviorEntityEcsContainerKind

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:43-50

Underlying type: byte

Whether one declared ECS access row addresses a component or a dynamic buffer.

Responsibilities:

Distinguish the two container shapes the generated carrier declares typed handles for.

Does NOT:

Select an entry, or imply a buffer length may change.

Members

BufferElement

BufferElement = 1

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:49

An IBufferElementData addressed one exact existing entry at a time.

Component

Component = 0

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:46

An IComponentData read or written whole.

BehaviorEntityEventObservation

Category: Entity integration

enum BitQuirky.Behavior.Entities.BehaviorEntityEventObservation

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:24-34

Underlying type: byte

What one selected graph tick actually saw when it read an entity Event Condition’s source.

Responsibilities:

Distinguish a matched source, an observed non-match, and a source the tick could not observe at all, because the three drive different occurrence-state transitions: only an observed non-match re-arms a consumed source, and an unobservable source changes no match state. A separately observed selector-identity change still invalidates an old latch.

Does NOT:

Carry an occurrence itself, or stand in for a node result.

Members

Matched

Matched = 2

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:33

The authored polarity held, or exactly one entry carried the identity.

NotMatched

NotMatched = 1

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:30

The authored polarity was false or the selected entry was absent.

Unobserved

Unobserved = 0

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:27

The source could not be observed this tick; no match-state transition occurs.

BehaviorEntityEventObserver

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityEventObserver

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:63-354

The one-shot observed-occurrence latch of the entity Event Condition, over the bake-sized per-agent occurrence state.

Responsibilities:

Apply both authored enableable transitions, becoming enabled and becoming disabled, as rising-edge observations of the authored polarity.
Apply retained buffer observation by non-negative constant index and by the complete exact identity value, never a hash: an identity-field source retains the full selected identity bytes so a selector that resolves to a different exact identity is a different observed occurrence.
Latch one pending occurrence per rising edge, consume it exactly once, stay disarmed while the same occurrence remains continuously matched, and re-arm only after a tick observes the authored polarity false or the selected entry absent.
End a wait without a substitute consume: a consume attempt with no latched occurrence changes nothing and reports nothing, which is what interruption, reset, target loss, agent disable, graph replacement, and disposal leave behind.

Does NOT:

Mutate the game’s event buffer or enableable state to record a consumption, queue more than one occurrence, infer an occurrence from an unobserved edge, decide the node’s authored result, or erase occurrence state on interruption or reset.

Members

DisarmedOffset

public const int DisarmedOffset = 2

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:74

State byte holding the consumed-while-retained disarm latch.

LiveFailureOffset

public const int LiveFailureOffset = 4

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:80

State byte holding an ordinary live failure for the current observation.

PayloadValidOffset

public const int PayloadValidOffset = 3

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:77

State byte holding whether the identity payload bytes are meaningful.

PendingOffset

public const int PendingOffset = 0

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:68

State byte holding the pending observed, unconsumed occurrence latch.

PreviousMatchOffset

public const int PreviousMatchOffset = 1

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:71

State byte holding whether the previous observation matched.

HasLiveFailure(NativeArray<byte> state)

public static bool HasLiveFailure(Unity.Collections.NativeArray<byte> state)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:350-351

Gets whether the current source observation is an ordinary live failure.

IsDisarmed(NativeArray<byte> state)

public static bool IsDisarmed(Unity.Collections.NativeArray<byte> state)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:342-343

Gets whether the source is disarmed after a consumed, retained occurrence.

IsPending(NativeArray<byte> state)

public static bool IsPending(Unity.Collections.NativeArray<byte> state)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:314-317

Gets whether one observed occurrence is latched and unconsumed.

Observe(NativeArray<byte> state, BehaviorEntityEventObservation observation)

public static void Observe(Unity.Collections.NativeArray<byte> state, BitQuirky.Behavior.Entities.BehaviorEntityEventObservation observation)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:241-266

Applies one observed match state to the latch. A rising edge latches one pending occurrence; an observed non-match re-arms; an unobservable source changes nothing, so two occurrences the graph never saw end between remain one occurrence.

ObserveConstantIndex(NativeArray<byte> state, bool sourceObserved, int entryCount, int constantIndex)

public static void ObserveConstantIndex(Unity.Collections.NativeArray<byte> state, bool sourceObserved, int entryCount, int constantIndex)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:119-135

Applies one retained-entry observation addressed by the authored non-negative constant index. The entry existing is the retained occurrence; the index observed absent is the observed non-match that re-arms a consumed source.

Parameters

state: The node’s per-agent occurrence-state range.
sourceObserved: Whether the retained buffer was reachable.
entryCount: The number of entries the buffer held this tick.
constantIndex: The authored non-negative entry index.

ObserveEnableable(NativeArray<byte> state, bool sourceObserved, bool enabled, BakedMemberEntityPolarity polarity)

public static void ObserveEnableable(Unity.Collections.NativeArray<byte> state, bool sourceObserved, bool enabled, BitQuirky.Behavior.Baked.BakedMemberEntityPolarity polarity)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:91-108

Applies one enableable observation. The occurrence is the authored transition itself: a source observed at the authored polarity after a tick that observed the opposite polarity is one rising edge, at either polarity.

Parameters

state: The node’s per-agent occurrence-state range.
sourceObserved: Whether the enableable component was reachable.
enabled: The component’s observed enablement.
polarity: The authored enablement that counts as the event.

ObserveIdentity(NativeArray<byte> state, NativeArray<byte> operand, BehaviorEntityEventObservation observation)

public static void ObserveIdentity(Unity.Collections.NativeArray<byte> state, Unity.Collections.NativeArray<byte> operand, BitQuirky.Behavior.Entities.BehaviorEntityEventObservation observation)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:150-188

Applies one identity-addressed retained-entry observation. The complete fixed-size operand value is retained in the state’s payload bytes, so a selector that now resolves a different exact identity resets the latch, even when the source itself is currently unobserved or ambiguous: the newly selected identity is a different observed occurrence, and any occurrence latched for the previous identity no longer names what the node waits for.

Parameters

state: The node’s per-agent occurrence-state range.
stateByteSize: The bake-sized byte length of that range.
operand: The complete current identity operand bytes.
operandWidth: The exact fixed byte width of the identity value.
observation: The match this tick’s typed entry search produced.

ObserveIdentity<T>(NativeArray<byte> state, T operand, BehaviorEntityEventObservation observation)

public static void ObserveIdentity<T>(Unity.Collections.NativeArray<byte> state, T operand, BitQuirky.Behavior.Entities.BehaviorEntityEventObservation observation) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:193-234

Applies one typed identity observation through a bounds-checked native state buffer.

PreviousMatch(NativeArray<byte> state)

public static bool PreviousMatch(Unity.Collections.NativeArray<byte> state)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:346-347

Gets whether the previous observation matched the authored source.

ReadIdentity<T>(NativeArray<byte> state)

public static T ReadIdentity<T>(Unity.Collections.NativeArray<byte> state) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:320-339

Reads the complete typed identity retained in a native state buffer.

TryConsume(NativeArray<byte> state)

public static bool TryConsume(Unity.Collections.NativeArray<byte> state)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityEventObserver.cs:275-284

Consumes the one latched occurrence when one is pending. The consumption is recorded only here: the game’s event buffer and enableable state are untouched, and the source stays disarmed while the same occurrence remains continuously matched. Without a pending occurrence nothing is consumed and nothing substitutes for one, which is the complete wait-ending contract every lifecycle path relies on.

BehaviorEntityGraphHandle

Category: Entity integration

readonly struct BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:52-112

Implements: IEquatable<BehaviorEntityGraphHandle>

Identifies one graph registered with aBehaviorEntityRuntime.

Responsibilities:

Carry the supplied World’s sequence, runtime owner, and runtime-local graph id.

Does NOT:

Own the graph, query, or runtime resources.

Members

GraphId

public int GraphId { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:79

Id of the graph within its runtime. Runtime-local, not a global id: the same value in another World means another graph.

IsValid

public bool IsValid { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:87

False for a default-constructed handle; graph ids start at one, so zero never names a registered graph.

WorldSequenceNumber

public ulong WorldSequenceNumber { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:73

Sequence number of the World the graph was registered in, so a handle from a disposed or different World is rejected rather than misread.

Equals(BehaviorEntityGraphHandle other)

public bool Equals(BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle other)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:93-96

Two handles are equal when they name the same graph id, in the same World, owned by the same runtime entity.

Equals(object obj)

public override bool Equals(object obj)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:102-103

Equal only to anotherBehaviorEntityGraphHandlenaming the same graph in the same World.

GetHashCode()

public override int GetHashCode()

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:106-111

Hash over all three identity parts, so equal handles hash alike.

BehaviorEntityMemberAccessorIdentity

Category: Entity integration

readonly struct BitQuirky.Behavior.Entities.BehaviorEntityMemberAccessorIdentity

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:685-711

The authored diagnostic coordinates of one generated accessor.

Responsibilities:

Carry the node, binding, target label, and exact authored member identity in accessor-id order, so initialization failures retain the same coordinates as bake failures.

Does NOT:

Resolve a member, allocate during evaluation, or participate in the Burst call path.

Members

AuthoredMemberIdentity

public string AuthoredMemberIdentity { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:710

Gets the exact authored member identity.

BindingId

public string BindingId { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:704

Gets the stable binding identity.

NodeId

public string NodeId { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:701

Gets the owning node identity.

TargetLabel

public string TargetLabel { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:707

Gets the authored target label.

BehaviorEntityMemberAccessorIdentity(string nodeId, string bindingId, string targetLabel, string authoredMemberIdentity)

public BehaviorEntityMemberAccessorIdentity(string nodeId, string bindingId, string targetLabel, string authoredMemberIdentity)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:688-698

Creates one generated accessor’s authored diagnostic identity.

BehaviorEntityMemberBindingSet

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityMemberBindingSet

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:725-818

The generated, explicitly supplied entity member binding set of one registered graph.

Responsibilities:

Hold the exact declared ECS access table, accessor identities, and binding-set fingerprint consumed by the generated concrete carrier.

Does NOT:

Discover an accessor, register itself anywhere, hold a singleton, or fall back to a managed delegate path when Burst is unavailable. The consuming assembly supplies this set explicitly at graph registration.

Members

AccessRowCount

public int AccessRowCount { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:747

Gets the number of declared ECS access rows.

AccessorCount

public int AccessorCount { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:744

Gets the number of compiled accessors in accessor-id order.

Fingerprint

public ulong Fingerprint { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:741

Gets the deterministic binding-set fingerprint the graph must match.

BehaviorEntityMemberBindingSet(ulong fingerprint, BehaviorEntityEcsAccessRow[] access, BehaviorEntityMemberAccessorIdentity[] identities)

public BehaviorEntityMemberBindingSet(ulong fingerprint, BitQuirky.Behavior.Entities.BehaviorEntityEcsAccessRow[] access, BitQuirky.Behavior.Entities.BehaviorEntityMemberAccessorIdentity[] identities)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:730-738

Creates one explicitly supplied binding set.

AccessRow(int row)

public BitQuirky.Behavior.Entities.BehaviorEntityEcsAccessRow AccessRow(int row)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:750

Gets the declared ECS access row at the exact row index.

TryInitialize(string graphIdentity, out BehaviorMemberBindingDiagnostic diagnostic)

public bool TryInitialize(string graphIdentity, out BitQuirky.Behavior.Member.BehaviorMemberBindingDiagnostic diagnostic)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:757-761

Validates that the set is callable before the first evaluation. Burst is required, so an unavailable compiler is one structured failure rather than a managed fallback, and every accessor id must carry a compiled entry.

TryValidateBurst(string graphIdentity, BehaviorEntityMemberAccessorIdentity[] identities, out BehaviorMemberBindingDiagnostic diagnostic)

public static bool TryValidateBurst(string graphIdentity, BitQuirky.Behavior.Entities.BehaviorEntityMemberAccessorIdentity[] identities, out BitQuirky.Behavior.Member.BehaviorMemberBindingDiagnostic diagnostic)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:768-790

Validates the required Burst compiler before a generated scheduler constructs its typed carrier. The first accessor identity supplies complete structured coordinates for the set-wide failure.

BehaviorEntityMemberExecutionTables

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:29-54

The baked tables one graph’s entity member execution reads, gathered once at registration.

Responsibilities:

Carry the argument, constant, comparison, synchronization, blackboard-layout, and compiled accessor views a member operation needs, plus the exact byte stride the unmanaged argument and result frames use, so an evaluation looks nothing up and allocates nothing.

Does NOT:

Own or dispose any container, resolve a target, decide an outcome, or hold a managed reference. It is a plain view the batched tick hands to the executor.

Members

ArgumentCapacity

public int ArgumentCapacity

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:50

The greatest number of argument slots any one operation materializes.

Arguments

public Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberArgument> Arguments

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:32

The baked argument rows every operation addresses by its own range.

BlackboardByteSize

public int BlackboardByteSize

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:53

The logical payload length before any private entity journal tail.

BlackboardLayout

public Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedBlackboardSlot> BlackboardLayout

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:44

The agent blackboard layout every surfaced slot is addressed through.

Comparisons

public Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberComparison> Comparisons

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:38

The baked comparison rows a Member Condition reads its right operand from.

Constants

public Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberConstant> Constants

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:35

The canonical baked constants an argument or comparison operand names.

Synchronizations

public Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberSynchronizationRecord> Synchronizations

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:41

The baked synchronization rows a field or property operation reads.

ValueStride

public int ValueStride

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:47

The exact byte stride of one argument slot and of the result buffer.

BehaviorEntityMemberExecutor

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutor

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:86-1278

The one execution of a resolved entity member operation inside the batched tick.

Responsibilities:

Materialize the exact unmanaged argument frame each operation family is invoked with, call the operation’s generated typed accessor through constrained generic dispatch exactly once, and store the produced value into the operation’s surfaced blackboard slot when the family produces one.
Evaluate the authored result map: an operation carrying a comparison row applies the authored comparison to the produced value and reports the result its selected outcome names, and every other operation reports its one fixed authored completion result. Both shapes reach all seven node results, an outcome reporting running makes the node invoke its member again on the next tick, and storage happens before selection so a stored value implies nothing about which result was chosen.
Convert one materialized argument through the exact conversion the bake recorded, at the argument’s own value kind, without boxing and without consulting a runtime type table.
Evaluate one activated Event Condition against its per-agent occurrence latch: consume the one pending occurrence and report the authored result once, or keep the node running with nothing consumed, stored, or substituted while the wait continues or is ended by any lifecycle path.

Does NOT:

Resolve a target, address a buffer entry, supply a default value, discover a member, allocate, or hold a managed reference. Target resolution belongs to BehaviorEntityMemberTargetResolver.

Members

MinimumValueStride

public const int MinimumValueStride = 16

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:95

The smallest argument and result stride the frame uses. Every value kind the entity path carries fits in sixteen bytes, so a graph whose widest blackboard slot is narrower still invokes an accessor whose produced value is wider than that slot.

CommitRefArguments(in BehaviorEntityMemberExecutionTables tables, in BakedMemberOperation operation, NativeArray<byte> blackboard, NativeArray<byte> arguments)

public static void CommitRefArguments(in BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables tables, in BitQuirky.Behavior.Baked.BakedMemberOperation operation, Unity.Collections.NativeArray<byte> blackboard, Unity.Collections.NativeArray<byte> arguments)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:449-480

Commits every ref parameter’s post-call bytes from the materialized argument frame into its own Write to destination blackboard slot, reusing the exact copy-and-journal primitiveStoreResultalready uses. Called only once the accessor’s invocation has already succeeded (see theSucceededgate in Execute), so an unresolved invocation commits no ref write, exactly as an unresolved invocation stores no ordinary result.

ComputeValueStride(int widestBlackboardSlotSize)

public static int ComputeValueStride(int widestBlackboardSlotSize)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:523-528

Computes the exact stride one argument slot and the result buffer occupy. Every entity value kind fits withinMinimumValueStride, and a wider blackboard slot widens the frame to hold it.

Execute<TAccessor>(ref TAccessor accessor, in ArchetypeChunk chunk, in BehaviorEntityMemberExecutionTables tables, in BakedMemberOperation operation, in BehaviorEntityMemberInvocationContext context, int targetRow, NativeArray<byte> blackboard, int chunkIndex, int entityIndex, int entryIndex, uint activationGeneration, NativeArray<byte> arguments, NativeArray<byte> result)

public static BitQuirky.Behavior.Execution.BehaviorResultCode Execute<TAccessor>(ref TAccessor accessor, in Unity.Entities.ArchetypeChunk chunk, in BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables tables, in BitQuirky.Behavior.Baked.BakedMemberOperation operation, in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocationContext context, int targetRow, Unity.Collections.NativeArray<byte> blackboard, int chunkIndex, int entityIndex, int entryIndex, uint activationGeneration, Unity.Collections.NativeArray<byte> arguments, Unity.Collections.NativeArray<byte> result) where TAccessor : unmanaged, BitQuirky.Behavior.Entities.IBehaviorEntityMemberAccessor

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:184-222

Compatibility overload for generated sources that resolved their entry before calling the executor. Reimport moves identity selection into the accessor invocation.

Execute<TAccessor>(ref TAccessor accessor, in ArchetypeChunk chunk, in BehaviorEntityMemberExecutionTables tables, in BakedMemberOperation operation, in BehaviorEntityMemberInvocationContext context, int targetRow, NativeArray<byte> blackboard, int chunkIndex, int entityIndex, int entryIndex, NativeArray<byte> entryIdentity, int entryIdentitySize, uint activationGeneration, NativeArray<byte> arguments, NativeArray<byte> result, out bool invocationSucceeded, out BehaviorMemberBindingDiagnosticReason failureReason, out int observedCount, out int targetEntityIndex, out int targetEntityVersion, out bool hasTargetEntity)

public static BitQuirky.Behavior.Execution.BehaviorResultCode Execute<TAccessor>(ref TAccessor accessor, in Unity.Entities.ArchetypeChunk chunk, in BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables tables, in BitQuirky.Behavior.Baked.BakedMemberOperation operation, in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocationContext context, int targetRow, Unity.Collections.NativeArray<byte> blackboard, int chunkIndex, int entityIndex, int entryIndex, Unity.Collections.NativeArray<byte> entryIdentity, int entryIdentitySize, uint activationGeneration, Unity.Collections.NativeArray<byte> arguments, Unity.Collections.NativeArray<byte> result, out bool invocationSucceeded, out BitQuirky.Behavior.Member.BehaviorMemberBindingDiagnosticReason failureReason, out int observedCount, out int targetEntityIndex, out int targetEntityVersion, out bool hasTargetEntity) where TAccessor : unmanaged, BitQuirky.Behavior.Entities.IBehaviorEntityMemberAccessor

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:119-178

Runs one already-resolved member operation and returns the result the tree observes.

Parameters

tables: The graph’s baked execution tables.
operation: The baked operation row the activated node named.
context: The per-entity native views the generated carrier resolved.
target: The accessor’s exact target row, or null when it has none.
blackboard: The running agent’s own blackboard bytes.
chunkIndex: The unfiltered chunk index of the running entity.
entityIndex: The index of the running entity inside its chunk.
entryIndex: The already-resolved buffer entry index, or -1.
entryIdentity: The current authored identity operand, or null.
entryIdentitySize: The complete operand width in bytes.
activationGeneration: The activation generation of the request.
arguments: Caller-owned argument scratch of the frame’s exact size.
result: Caller-owned result scratch of the frame’s exact stride.
invocationSucceeded: Whether invocation-time target checks resolved exactly.
targetEntityIndex: The exact addressed entity index, when available.
targetEntityVersion: The exact addressed entity version, when available.
hasTargetEntity: Whether an exact target entity identity was available.

ExecuteEventCondition(in BakedMemberOperation operation, in BakedMemberEntityEvent bakedEvent, NativeArray<byte> occurrence)

public static BitQuirky.Behavior.Execution.BehaviorResultCode ExecuteEventCondition(in BitQuirky.Behavior.Baked.BakedMemberOperation operation, in BitQuirky.Behavior.Baked.BakedMemberEntityEvent bakedEvent, Unity.Collections.NativeArray<byte> occurrence)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:541-565

Runs one activated entity Event Condition evaluation over its per-agent occurrence state. Consuming the one latched occurrence reports the node’s authored result once for the activation; without a latched occurrence the node stays running, consumes nothing by fallback, and writes no result or value anywhere, which is exactly what interruption, reset, target loss, agent disable, graph replacement, and disposal leave behind when they end the wait: nothing at all.

Parameters

operation: The baked Event Condition operation row.
bakedEvent: The operation’s baked entity event row.
occurrence: The agent’s preallocated occurrence-state bytes.

Invoke<TAccessor>(ref TAccessor accessor, in ArchetypeChunk chunk, in BehaviorEntityMemberExecutionTables tables, in BakedMemberOperation operation, in BehaviorEntityMemberInvocationContext context, int targetRow, int chunkIndex, int entityIndex, int entryIndex, uint activationGeneration, NativeArray<byte> arguments, NativeArray<byte> result)

public static void Invoke<TAccessor>(ref TAccessor accessor, in Unity.Entities.ArchetypeChunk chunk, in BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables tables, in BitQuirky.Behavior.Baked.BakedMemberOperation operation, in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocationContext context, int targetRow, int chunkIndex, int entityIndex, int entryIndex, uint activationGeneration, Unity.Collections.NativeArray<byte> arguments, Unity.Collections.NativeArray<byte> result) where TAccessor : unmanaged, BitQuirky.Behavior.Entities.IBehaviorEntityMemberAccessor

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:368-403

Compatibility overload for accessors whose exact entry was resolved before invocation.

Invoke<TAccessor>(ref TAccessor accessor, in ArchetypeChunk chunk, in BehaviorEntityMemberExecutionTables tables, in BakedMemberOperation operation, in BehaviorEntityMemberInvocationContext context, int targetRow, int chunkIndex, int entityIndex, int entryIndex, NativeArray<byte> entryIdentity, int entryIdentitySize, uint activationGeneration, NativeArray<byte> arguments, NativeArray<byte> result, out BehaviorMemberBindingDiagnosticReason failureReason, out int observedCount, out int targetEntityIndex, out int targetEntityVersion, out bool hasTargetEntity)

public static bool Invoke<TAccessor>(ref TAccessor accessor, in Unity.Entities.ArchetypeChunk chunk, in BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables tables, in BitQuirky.Behavior.Baked.BakedMemberOperation operation, in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocationContext context, int targetRow, int chunkIndex, int entityIndex, int entryIndex, Unity.Collections.NativeArray<byte> entryIdentity, int entryIdentitySize, uint activationGeneration, Unity.Collections.NativeArray<byte> arguments, Unity.Collections.NativeArray<byte> result, out BitQuirky.Behavior.Member.BehaviorMemberBindingDiagnosticReason failureReason, out int observedCount, out int targetEntityIndex, out int targetEntityVersion, out bool hasTargetEntity) where TAccessor : unmanaged, BitQuirky.Behavior.Entities.IBehaviorEntityMemberAccessor

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:308-363

Calls one compiled accessor with an unmanaged invocation frame. The frame is built on the stack, carries no managed reference, and allocates nothing.

MaterializeArguments(in BehaviorEntityMemberExecutionTables tables, in BakedMemberOperation operation, NativeArray<byte> blackboard, NativeArray<byte> arguments)

public static int MaterializeArguments(in BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables tables, in BitQuirky.Behavior.Baked.BakedMemberOperation operation, Unity.Collections.NativeArray<byte> blackboard, Unity.Collections.NativeArray<byte> arguments)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:229-302

Materializes the operation’s complete argument frame and returns the number of argument slots it filled. Each slot occupies one exact stride, which is what a generated accessor reads its ordinal from.

SelectAuthoredResult(in BehaviorEntityMemberExecutionTables tables, in BakedMemberOperation operation, NativeArray<byte> blackboard, NativeArray<byte> result, NativeArray<byte> comparisonScratch)

public static BitQuirky.Behavior.Execution.BehaviorResultCode SelectAuthoredResult(in BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables tables, in BitQuirky.Behavior.Baked.BakedMemberOperation operation, Unity.Collections.NativeArray<byte> blackboard, Unity.Collections.NativeArray<byte> result, Unity.Collections.NativeArray<byte> comparisonScratch)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:575-593

Reports the authored result of one completed invocation. An operation carrying a comparison row is a tested outcome: the produced value is compared against the authored right operand and the matching outcome’s result is reported. Every other operation reports its one fixed authored completion result. The selection only reads the produced value, so a value stored before it implies nothing about which of the seven results was chosen.

StoreResult(in BehaviorEntityMemberExecutionTables tables, in BakedMemberOperation operation, NativeArray<byte> blackboard, NativeArray<byte> result)

public static void StoreResult(in BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables tables, in BitQuirky.Behavior.Baked.BakedMemberOperation operation, Unity.Collections.NativeArray<byte> blackboard, Unity.Collections.NativeArray<byte> result)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberExecutor.cs:411-439

Stores the produced value into the operation’s surfaced blackboard slot when the family produces one. A write to the member consumes the surfaced value rather than replacing it, a void call produces nothing, and a condition’s comparison input feeds the authored result map rather than a stored value.

BehaviorEntityMemberFrame

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityMemberFrame

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:361-669

The mechanical read and write surface every generated entity accessor calls.

Responsibilities:

Reach one declared access row’s component, buffer entry, or enableable state, and move exact unmanaged argument and result values, with no boxing, no allocation, and no managed dispatch, so a generated accessor body contains nothing but the customer’s own member access.

Does NOT:

Compare values, select an outcome, supply a default, map a node status, resolve a target, or change a buffer’s length. Every one of those belongs to the shared kernel, and a generated body that needed one would be a generation defect.

Members

BufferEntryRO<T>(in BehaviorEntityMemberInvocation invocation, int row)

public static ref readonly T BufferEntryRO<T>(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int row) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:391-397

Reads the already-resolved exact buffer entry of the row for reading.

BufferEntryRW<T>(in BehaviorEntityMemberInvocation invocation, int row)

public static ref T BufferEntryRW<T>(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int row) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:383-388

Reads the already-resolved exact buffer entry of the row for writing.

ComponentRO<T>(in BehaviorEntityMemberInvocation invocation, int row)

public static ref readonly T ComponentRO<T>(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int row) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:374-380

Reads one addressed component of the declared access row for reading.

ComponentRW<T>(in BehaviorEntityMemberInvocation invocation, int row)

public static ref T ComponentRW<T>(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int row) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:366-371

Reads one addressed component of the declared access row for writing.

EntryIdentityEquals<T>(in BehaviorEntityMemberInvocation invocation, T candidate)

public static bool EntryIdentityEquals<T>(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, T candidate) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:558-570

Compares one typed candidate with the complete authored identity bytes.

Fail(ref BehaviorEntityMemberInvocation invocation)

public static void Fail(ref BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:594-597

Marks an accessor invocation as an ordinary unresolved live reading.

HasEntryIdentity(in BehaviorEntityMemberInvocation invocation)

public static bool HasEntryIdentity(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:552-555

Gets whether the invocation carries an identity operand.

IsEnabled(in BehaviorEntityMemberInvocation invocation, int row)

public static bool IsEnabled(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int row)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:400-403

Reads the resolved enableable state of the declared access row.

IsEnabled(NativeArray<BehaviorEntityMemberRowView> rows, int row)

public static bool IsEnabled(Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView> rows, int row)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:628-634

Reads enablement from one row without exposing its native address.

IsResolved(in BehaviorEntityMemberInvocation invocation, int row)

public static bool IsResolved(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int row)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:546-549

Gets whether the exact authored component or buffer entry resolved.

Length(in BehaviorEntityMemberInvocation invocation, int row)

public static int Length(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int row)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:540-543

Gets the current number of elements the declared access row holds.

Read<T>(in BehaviorEntityMemberInvocation invocation, int ordinal)

public static T Read<T>(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int ordinal) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:447-459

Reads the exact unmanaged argument value at the ordinal.

ReadEntryIdentity<T>(in BehaviorEntityMemberInvocation invocation)

public static T ReadEntryIdentity<T>(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:573-584

Reads the exact typed identity operand carried by the safe native slice.

ReadFloat3(in BehaviorEntityMemberInvocation invocation, int ordinal)

public static Unity.Mathematics.float3 ReadFloat3(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int ordinal)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:462-471

Reads one twelve-byte vector from its padded argument slot.

SelectedEntry(in BehaviorEntityMemberInvocation invocation, int row)

public static int SelectedEntry(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int row)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:441-444

Gets the exact buffer entry the carrier’s typed identity match selected, or -1 when no entry carried the authored identity.

SetEnabled(in BehaviorEntityMemberInvocation invocation, int row, bool value)

public static void SetEnabled(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int row, bool value)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:411-435

Writes the enableable state of the declared access row and every row that addresses the same component storage, so later accessors in the same kernel tick observe the write. The generated carrier applies the exact recorded target after the kernel returns, because only it holds the typed handle that can change the component’s enable bit.

SetEnabled(NativeArray<BehaviorEntityMemberRowView> rows, int targetRow, int entityIndex, bool value)

public static void SetEnabled(Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView> rows, int targetRow, int entityIndex, bool value)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:603-625

Writes enablement through a native row table without requiring pointer syntax in the calling assembly.

SetEntryIndex(ref BehaviorEntityMemberInvocation invocation, int entryIndex)

public static void SetEntryIndex(ref BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int entryIndex)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:587-591

Updates the entry currently addressed by an identity-searching accessor.

Write<T>(in BehaviorEntityMemberInvocation invocation, T value)

public static void Write<T>(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, T value) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:517-526

Writes the exact unmanaged produced value of the invocation.

WriteArgument<T>(in BehaviorEntityMemberInvocation invocation, int ordinal, T value)

public static void WriteArgument<T>(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int ordinal, T value) where T : unmanaged

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:481-494

Writes the exact unmanaged value of a ref parameter back into its own argument slot, at the sameordinal * invocation.ArgumentStride offset Read reads from. The generated call stages this write after the customer’s method returns normally, soBehaviorEntityMemberExecutor can commit it into the ref slot’s own Write to destination blackboard field once the invocation is known to have succeeded.

WriteArgumentFloat3(in BehaviorEntityMemberInvocation invocation, int ordinal, float3 value)

public static void WriteArgumentFloat3(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, int ordinal, Unity.Mathematics.float3 value)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:505-514

Writes one twelve-byte vector ref parameter’s post-call value back into its own argument slot, at the sameordinal * invocation.ArgumentStrideoffset ReadFloat3reads from, using the exact twelve-byte width rather than the full argument stride. A padded kind’s byte width does not evenly divide the wider stride, so the full-stride reinterpretWriteArgumentuses for every other kind is unsafe here; the twelve-byte sub-array size keeps the reinterpret exact, mirroringWriteFloat3’s own padded-result treatment.

WriteFloat3(in BehaviorEntityMemberInvocation invocation, float3 value)

public static void WriteFloat3(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, Unity.Mathematics.float3 value)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:529-537

Writes one twelve-byte vector into the start of its padded result slot.

BehaviorEntityMemberInvocation

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:238-328

The unmanaged call frame passed to one generated entity member accessor.

Responsibilities:

Carry the resolved invocation context, the accessor and provider target identity, the addressed chunk, entity, and buffer entry indices, the argument and result buffers, and the activation generation, with no managed reference and no per-tick allocation.

Does NOT:

Decide an outcome, map a status, resolve a target, or own its buffers. The shared package kernel owns every decision; this frame is only the mechanical call surface.

Members

AccessorId

public int AccessorId

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:252

The baked accessor id being invoked.

ActivationGeneration

public int ActivationGeneration

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:327

The activation generation the invocation belongs to.

ArgumentStride

public int ArgumentStride

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:321

The per-argument byte stride of the argument buffer.

Arguments

public Unity.Collections.NativeArray<byte> Arguments

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:318

The materialized argument bytes of the current invocation.

ChangeDetected

public byte ChangeDetected

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:306

Whether the target storage changed after the completed update boundary.

ChunkIndex

public int ChunkIndex

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:258

The index of the chunk the addressed entity belongs to.

Context

public BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocationContext Context

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:242

The resolved per-evaluation native views.

Enabled

public byte Enabled

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:294

The current enabled state for an enableable source.

EntityIndex

public int EntityIndex

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:261

The index of the addressed entity inside its chunk.

EntryIdentity

public Unity.Collections.NativeArray<byte> EntryIdentity

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:270

The exact authored identity operand bytes for an identity-addressed buffer accessor, or null for every other accessor.

EntryIdentitySize

public int EntryIdentitySize

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:273

The complete byte width of EntryIdentity.

EntryIndex

public int EntryIndex

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:264

The already-resolved exact buffer entry index, or -1 when unused.

FailureReason

public BitQuirky.Behavior.Member.BehaviorMemberBindingDiagnosticReason FailureReason

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:315

The exact unresolved reason supplied by generated typed resolution.

Length

public int Length

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:297

The current target buffer length, or zero for component access.

ObservedCount

public int ObservedCount

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:312

The observed target cardinality, including Singleton zero or many.

ProviderTargetIndex

public int ProviderTargetIndex

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:255

The baked provider target index of the operation.

ResolveOnly

public byte ResolveOnly

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:309

When set, the accessor resolves metadata and returns before member execution.

Resolved

public byte Resolved

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:282

Whether the authored component or buffer resolved for this invocation.

Result

public Unity.Collections.NativeArray<byte> Result

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:324

The result bytes the accessor writes its produced value into.

Succeeded

public byte Succeeded

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:279

Set to zero by an accessor when its invocation-time identity search resolves zero or multiple entries. The shared kernel then reports the ordinary live failure.

TargetEntityIndex

public int TargetEntityIndex

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:300

The exact resolved target entity index, or zero when none resolved.

TargetEntitySet

public byte TargetEntitySet

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:291

Whether one exact target entity identity was materialized, even when it no longer exists or no longer carries the authored component.

TargetEntityVersion

public int TargetEntityVersion

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:303

The exact resolved target entity version, or zero when none resolved.

TargetExists

public byte TargetExists

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:285

Whether the exact target entity exists, even if its component is absent.

TargetRow

public int TargetRow

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:249

The exact target view resolved for this accessor. The generated row argument remains part of the public frame API for source compatibility and keeps two authored targets that share one folded ECS access row from aliasing each other.

BehaviorEntityMemberInvocationContext

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocationContext

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:214-224

The unmanaged per-evaluation context a generated accessor reads its native views from.

Responsibilities:

Present the resolved row views of the current chunk and entity in declared access-row order, so a generated accessor addresses its own row by the constant index the manifest assigned it.

Does NOT:

Resolve a target, allocate, hold a managed reference, or outlive the scheduled job that filled it.

Members

RowCount

public int RowCount

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:223

The total number of folded and accessor-specific rows.

Rows

public Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView> Rows

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:220

The folded dependency rows followed by one exact target row per accessor.

BehaviorEntityMemberKernel

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorEntityMemberKernel

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:78-232

The single shared package kernel a generated typed carrier delegates its chunk to.

Responsibilities:

Carry the batched tick payload every registered graph shares, accept the per-entity native views the generated carrier resolved from its own visible typed fields, record which declared access rows resolved, and run the one shared evaluation.

Does NOT:

Discover a member or a target, hold a native container the carrier did not declare, or contain a second evaluator. A generated carrier supplies views and nothing else; every decision belongs to the shared evaluation this kernel runs.

Members

BlackboardHandleAccessorCount

public int BlackboardHandleAccessorCount

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:95

The number of accessor slots in each entity’s snapshot block.

BlackboardHandleSnapshots

public Unity.Collections.NativeArray<Unity.Entities.Entity> BlackboardHandleSnapshots

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:92

One safe entity value per chunk-capacity slot and accessor, captured before the shared behavior core can overwrite a blackboard entry that a Handle target reads this tick.

RequiredChangeVersion

public uint RequiredChangeVersion

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:101

The ECS change-version boundary recorded after the previous completed graph update. Generated typed accessors compare against it before obtaining mutable container data.

RowResolution

public Unity.Collections.NativeArray<byte> RowResolution

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:86

One byte per declared access row, set to 1 once a scheduled chunk resolved that row’s native view. Chunks write only through the bounds-checked container supplied here.

BlackboardHandle(int unfilteredChunkIndex, int entityIndex, int accessorId)

public Unity.Entities.Entity BlackboardHandle(int unfilteredChunkIndex, int entityIndex, int accessorId)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:205-222

Reads the exact entity one agent’s surfaced blackboard entry currently carries for the accessor id a Handle target reaches through. The entry is read on every evaluation. The raw Entity index and version are interpreted only in the graph’s World, so a value absent there leaves the row unresolved and reports its own live reading.

Blackboards(in ArchetypeChunk chunk)

public Unity.Entities.BufferAccessor<BitQuirky.Behavior.Execution.BehaviorRuntimeBlackboardByte> Blackboards(in Unity.Entities.ArchetypeChunk chunk)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:179-182

Gets the agent blackboard buffers of one chunk. A generated carrier resolving a Handle whose fixed base is a surfaced blackboard entry reads the entity from here, through the buffer handle the shared kernel already declares, so no second handle to the same type is introduced and job reflection still sees exactly one declared access.

Entities(in ArchetypeChunk chunk)

public Unity.Collections.NativeArray<Unity.Entities.Entity> Entities(in Unity.Entities.ArchetypeChunk chunk)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:188-191

Gets the exact agent entities of one chunk so an enableable row retains target identity even when its component is a zero-sized tag with no payload address.

EntityAt(in ArchetypeChunk chunk, int entityIndex)

public Unity.Entities.Entity EntityAt(in Unity.Entities.ArchetypeChunk chunk, int entityIndex)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:194-197

Gets one exact agent entity from the current chunk.

Execute<TAccessor>(ref TAccessor accessor, in ArchetypeChunk chunk, int unfilteredChunkIndex, bool useEnabledMask, in v128 chunkEnabledMask)

public void Execute<TAccessor>(ref TAccessor accessor, in Unity.Entities.ArchetypeChunk chunk, int unfilteredChunkIndex, bool useEnabledMask, in Unity.Burst.Intrinsics.v128 chunkEnabledMask) where TAccessor : unmanaged, BitQuirky.Behavior.Entities.IBehaviorEntityMemberAccessor

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:116-130

Runs the shared evaluation for one chunk after the generated carrier resolved every declared access row intorows, a table of chunk.Countblocks ofrowCountviews in declared row order.

ForStage(BehaviorEntityMemberStage stage)

public BitQuirky.Behavior.Entities.BehaviorEntityMemberKernel ForStage(BitQuirky.Behavior.Entities.BehaviorEntityMemberStage stage)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:104-109

Gets a copy of this kernel configured for one lifecycle stage.

SnapshotBlackboardHandles(in ArchetypeChunk chunk, int unfilteredChunkIndex)

public void SnapshotBlackboardHandles(in Unity.Entities.ArchetypeChunk chunk, int unfilteredChunkIndex)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:133-171

Captures every blackboard-based Handle source for one scheduled chunk.

BehaviorEntityMemberLookupSystem

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityMemberLookupSystem

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:281-308

Inherits: SystemBase

World-owned typed lookup factory used only by explicitly composed member schedulers. It updates no state of its own and is never discovered through a default World.

Members

BufferLookup<T>(bool isReadOnly)

public Unity.Entities.BufferLookup<T> BufferLookup<T>(bool isReadOnly) where T : unmanaged, Unity.Entities.IBufferElementData

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:292-296

Gets one current buffer lookup at the declared access strength.

ComponentLookup<T>(bool isReadOnly)

public Unity.Entities.ComponentLookup<T> ComponentLookup<T>(bool isReadOnly) where T : unmanaged, Unity.Entities.IComponentData

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:285-289

Gets one current component lookup at the declared access strength.

EntityStorageInfo()

public Unity.Entities.EntityStorageInfoLookup EntityStorageInfo()

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:299-302

Gets the current exact-entity existence lookup.

OnUpdate()

protected override void OnUpdate()

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:305-307

BehaviorEntityMemberPreparedStage

Category: Entity integration

readonly struct BitQuirky.Behavior.Entities.BehaviorEntityMemberPreparedStage

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:259-275

One prepared carrier stage and its current row scratch.

Members

Kernel

public BitQuirky.Behavior.Entities.BehaviorEntityMemberKernel Kernel { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:271

Gets the stage-configured shared kernel.

RowViews

public Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView> RowViews { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:274

Gets the cleared row scratch for the current chunk topology.

BehaviorEntityMemberPreparedStage(BehaviorEntityMemberKernel kernel, NativeArray<BehaviorEntityMemberRowView> rowViews)

public BehaviorEntityMemberPreparedStage(BitQuirky.Behavior.Entities.BehaviorEntityMemberKernel kernel, Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView> rowViews)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:262-268

Creates one prepared carrier stage.

BehaviorEntityMemberResult

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityMemberResult

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:78-107

The one conversion from a baked authored outcome to the shared core’s result code.

Responsibilities:

Map each of the seven authored node results onto its exact executable code, in one place, so both object models report the same closed set and neither backend invents an eighth.

Does NOT:

Decide which outcome applies, or widen an unknown outcome into anything but a failure.

Members

ToResultCode(BakedMemberConditionResult result)

public static BitQuirky.Behavior.Execution.BehaviorResultCode ToResultCode(BitQuirky.Behavior.Baked.BakedMemberConditionResult result)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:83-104

Maps one baked authored outcome to its exact shared-core result code.

BehaviorEntityMemberRowView

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:126-200

Legacy safe metadata retained for compatibility with previously generated schedulers.

Responsibilities:

Carry resolved cardinality, selection, enablement, and change metadata without exposing an address. Current generated accessors use typed native containers directly.

Does NOT:

Own memory, resize a buffer, expose an address, or register job access. The carrier’s own visible typed fields are what Unity’s job reflection registers.

Members

ChangeDetected

public byte ChangeDetected

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:199

Whether this storage changed after the completed graph-update boundary supplied to the carrier. Change-version notifications read this bit directly, so a missing exact version never degrades into polling.

ChangeVersion

public uint ChangeVersion

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:192

The chunk change version of the storage this row addresses when the carrier resolved it through a chunk handle, or zero when the row has no change-version source at all. An authored change-version notification samples this; nothing else reads it.

Enabled

public byte Enabled

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:136

The resolved enableable state of the addressed entity, or zero.

EnabledWritten

public byte EnabledWritten

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:152

Whether an accessor wrote the enabled state of the exact storage this row addresses. The bit is what the generated carrier’s write-back looks for, so a graph that only reads enablement never touches the component’s enable bit at all.

Length

public int Length

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:133

The number of elements the resolved storage currently holds.

ObservedCount

public int ObservedCount

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:161

The number of entities the world actually held for this row’s authored type. An agent-relative row is always exactly one; a Singleton row carries the count that was counted, so an evaluation whose cardinality was wrong can state it. The count is recorded whether or not the row resolved, because zero and many are precisely the readings that need it.

Resolved

public byte Resolved

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:139

Whether the row resolved at all this evaluation.

SelectedEntry

public int SelectedEntry

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:168

The exact buffer entry older generated source selected, or -1 when it selected none. Current generated accessors refresh identity selection at invocation time, while a constant-index address is resolved from the baked index againstLength.

StableTypeHash

public ulong StableTypeHash

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:185

The stable type hash of the component storage this row addresses. Enabled-state rows use it with the target entity identity when a zero-sized component has no payload pointer of its own.

Stride

public int Stride

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:130

The per-element byte stride of the resolved storage.

TargetEntityIndex

public int TargetEntityIndex

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:175

The index of the exact entity an exact-entity lookup resolved this row for, or zero. An enabled write on such a row is applied back through the same lookup, so the target is carried here rather than recomputed from the hop a second time.

TargetEntityVersion

public int TargetEntityVersion

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:178

The version of the exact entity an exact-entity lookup resolved.

TargetExists

public byte TargetExists

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:145

Whether the exact target entity existed this evaluation. A Handle can reach a live entity that lacks the authored component, which is distinct from an invalid handle.

BehaviorEntityMemberScheduleContext

Category: Entity integration

readonly struct BitQuirky.Behavior.Entities.BehaviorEntityMemberScheduleContext

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:320-438

Everything a generated typed schedule entry point is handed for one graph update.

Responsibilities:

Supply the exact entity manager, the registered graph’s agent query, the shared kernel to delegate to, and the incoming job handle that must complete before any graph access.

Does NOT:

Discover a World, a default query, or a registered graph. Composition supplies all four.

Members

Agents

public Unity.Entities.EntityQuery Agents { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:391

Gets the registered graph’s agent query.

Dependency

public Unity.Jobs.JobHandle Dependency { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:397

Gets the incoming handle that completes before any declared access.

EntityManager

public Unity.Entities.EntityManager EntityManager { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:388

Gets the exact entity manager of the graph’s own World.

FrameNumber

public int FrameNumber { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:435

Gets the selected frame number supplied to command dispatch.

HasStageDriver

public bool HasStageDriver { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:406

Gets whether this runtime supplied the complete staged lifecycle.

Kernel

public BitQuirky.Behavior.Entities.BehaviorEntityMemberKernel Kernel { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:394

Gets the shared kernel the generated carrier delegates its chunk to.

LookupSystem

public BitQuirky.Behavior.Entities.BehaviorEntityMemberLookupSystem LookupSystem { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:403

Gets the explicit World-owned factory for exact-entity typed lookups.

ResolutionRowCount

public int ResolutionRowCount { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:432

Gets the current graph’s total resolved row count.

RowViews

public Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView> RowViews { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:400

Gets graph-owned scratch storage partitioned by unfiltered chunk index.

BehaviorEntityMemberScheduleContext(EntityManager entityManager, EntityQuery agents, BehaviorEntityMemberKernel kernel, JobHandle dependency)

public BehaviorEntityMemberScheduleContext(Unity.Entities.EntityManager entityManager, Unity.Entities.EntityQuery agents, BitQuirky.Behavior.Entities.BehaviorEntityMemberKernel kernel, Unity.Jobs.JobHandle dependency)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:323-330

Creates one graph update’s schedule context.

BehaviorEntityMemberScheduleContext(EntityManager entityManager, EntityQuery agents, BehaviorEntityMemberKernel kernel, JobHandle dependency, NativeArray<BehaviorEntityMemberRowView> rowViews)

public BehaviorEntityMemberScheduleContext(Unity.Entities.EntityManager entityManager, Unity.Entities.EntityQuery agents, BitQuirky.Behavior.Entities.BehaviorEntityMemberKernel kernel, Unity.Jobs.JobHandle dependency, Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView> rowViews)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:333-341

Creates one graph update’s schedule context with owned row scratch.

BehaviorEntityMemberScheduleContext(EntityManager entityManager, EntityQuery agents, BehaviorEntityMemberKernel kernel, JobHandle dependency, NativeArray<BehaviorEntityMemberRowView> rowViews, BehaviorEntityMemberLookupSystem lookupSystem)

public BehaviorEntityMemberScheduleContext(Unity.Entities.EntityManager entityManager, Unity.Entities.EntityQuery agents, BitQuirky.Behavior.Entities.BehaviorEntityMemberKernel kernel, Unity.Jobs.JobHandle dependency, Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView> rowViews, BitQuirky.Behavior.Entities.BehaviorEntityMemberLookupSystem lookupSystem)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:344-362

Creates one graph update’s complete generated scheduling context.

BehaviorEntityMemberScheduleContext(EntityManager entityManager, EntityQuery agents, BehaviorEntityMemberKernel kernel, JobHandle dependency, NativeArray<BehaviorEntityMemberRowView> rowViews, BehaviorEntityMemberLookupSystem lookupSystem, IBehaviorEntityMemberStageDriver stageDriver, int resolutionRowCount, int frameNumber)

public BehaviorEntityMemberScheduleContext(Unity.Entities.EntityManager entityManager, Unity.Entities.EntityQuery agents, BitQuirky.Behavior.Entities.BehaviorEntityMemberKernel kernel, Unity.Jobs.JobHandle dependency, Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView> rowViews, BitQuirky.Behavior.Entities.BehaviorEntityMemberLookupSystem lookupSystem, BitQuirky.Behavior.Entities.IBehaviorEntityMemberStageDriver stageDriver, int resolutionRowCount, int frameNumber)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:365-385

Creates one staged generated scheduling context.

DispatchCommands()

public void DispatchCommands()

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:426-429

Dispatches commands after the completed core stage.

PrepareStage(BehaviorEntityMemberStage stage)

public BitQuirky.Behavior.Entities.BehaviorEntityMemberPreparedStage PrepareStage(BitQuirky.Behavior.Entities.BehaviorEntityMemberStage stage)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:409-415

Prepares current scratch and a kernel copy for one carrier stage.

ScheduleInput(JobHandle dependency)

public Unity.Jobs.JobHandle ScheduleInput(Unity.Jobs.JobHandle dependency)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:418-423

Schedules the explicitly composed input binder.

BehaviorEntityMemberScheduler

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityMemberScheduler

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:483-638

The shared scheduling seam a generated typed entry point runs its graph update through.

Responsibilities:

Complete the incoming handle before any declared access, observe Singleton cardinality without choosing a candidate, validate that a supplied binding set and its generated entry point agree before the first tick, and complete a scheduled graph job before the runtime’s tick boundary returns.

Does NOT:

Fence a row itself. Fencing is typed, and only the generated entry point knows the exact types, so the seam owns the ordering and the consumer owns the types.

Members

CompleteIncoming(in BehaviorEntityMemberScheduleContext context)

public static void CompleteIncoming(in BitQuirky.Behavior.Entities.BehaviorEntityMemberScheduleContext context)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:491-494

Completes the incoming handle. Every generated entry point calls this first, so no declared access, singleton count, or handle refresh can observe in-flight work.

ResolveSingleton(EntityQuery query, EntityTypeHandle entityType, NativeArray<Entity> match)

public static BitQuirky.Behavior.Entities.BehaviorEntityMemberSingletonReading ResolveSingleton(Unity.Entities.EntityQuery query, Unity.Entities.EntityTypeHandle entityType, Unity.Collections.NativeArray<Unity.Entities.Entity> match)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:500-524

Observes one Singleton-mode target’s cardinality from its own query. Zero or many is reported with the count that was actually seen; neither picks a candidate.

Schedule(IBehaviorEntityMemberScheduler scheduler, in BehaviorEntityMemberScheduleContext context)

public static Unity.Jobs.JobHandle Schedule(BitQuirky.Behavior.Entities.IBehaviorEntityMemberScheduler scheduler, in BitQuirky.Behavior.Entities.BehaviorEntityMemberScheduleContext context)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:530-539

Runs one graph update through the supplied generated entry point and returns the graph job. The runtime completes that job before its tick boundary returns.

ValidateComposition(string graphIdentity, BehaviorEntityMemberBindingSet bindingSet, IBehaviorEntityMemberScheduler scheduler)

public static void ValidateComposition(string graphIdentity, BitQuirky.Behavior.Entities.BehaviorEntityMemberBindingSet bindingSet, BitQuirky.Behavior.Entities.IBehaviorEntityMemberScheduler scheduler)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:599-609

Compatibility overload for composition roots compiled before binding-set fingerprints were validated explicitly. Runtime registration always calls the fingerprint-aware overload.

ValidateComposition(string graphIdentity, ulong bindingSetFingerprint, BehaviorEntityMemberBindingSet bindingSet, IBehaviorEntityMemberScheduler scheduler)

public static void ValidateComposition(string graphIdentity, ulong bindingSetFingerprint, BitQuirky.Behavior.Entities.BehaviorEntityMemberBindingSet bindingSet, BitQuirky.Behavior.Entities.IBehaviorEntityMemberScheduler scheduler)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:546-592

Validates that an explicitly supplied binding set and its generated entry point belong to the same generation before the first tick. A mismatch is a composition failure, not a live reading: nothing about it changes while the graph runs.

BehaviorEntityMemberSingletonReading

Category: Entity integration

readonly struct BitQuirky.Behavior.Entities.BehaviorEntityMemberSingletonReading

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:29-46

One Singleton-mode target’s observed cardinality for the current graph update.

Responsibilities:

Carry the exact entity when the world holds precisely one match, and the observed count whenever it does not, so the affected evaluation can state the count it actually saw.

Does NOT:

Pick a candidate, order candidates, fall back to the first match, or turn a wrong count into a registration failure. Entities are created and destroyed while the graph runs, so cardinality is an ordinary live reading.

Members

Entity

public Unity.Entities.Entity Entity { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:39

Gets the exact resolved entity, or Null.

IsResolved

public bool IsResolved { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:45

Gets whether the world held precisely one match this update.

ObservedCount

public int ObservedCount { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:42

Gets the number of entities the world held for the authored type.

BehaviorEntityMemberSingletonReading(Entity entity, int observedCount)

public BehaviorEntityMemberSingletonReading(Unity.Entities.Entity entity, int observedCount)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:32-36

Creates one observed Singleton reading.

BehaviorEntityMemberStage

Category: Entity integration

enum BitQuirky.Behavior.Entities.BehaviorEntityMemberStage

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:53-63

Underlying type: byte

The exact lifecycle stage one generated carrier pass executes.

Members

Push

Push = 2

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:62

Pushes changed blackboard slots after command dispatch.

Sample

Sample = 1

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:59

Drains notifications and polls getters before input binding.

Tick

Tick = 0

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:56

Runs the shared behavior core and immediate member operations.

BehaviorEntityMemberSyncState

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorEntityMemberSyncState

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:27-65

Implements: IBufferElementData

One agent’s preallocated member synchronization state: a header element followed by one element per baked member blackboard binding.

Responsibilities:

Carry each binding’s last synchronized value baseline, last observed notification source, and last accepted change’s sequence and origin, plus the agent’s monotonic last-writer sequence counter in element zero, as plain unmanaged per-agent data.

Does NOT:

Decide anything.BehaviorEntityMemberSynchronizationowns every decision; this buffer is only the durable per-agent bookkeeping between selected ticks.

Members

Initialized

public byte Initialized

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:49

Whether the baseline has been captured since attachment or reset.

LastObservedVersion

public uint LastObservedVersion

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:37

The notification source value observed on the last selected tick.

LastOrigin

public byte LastOrigin

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:46

The BehaviorBlackboardWriteOrigin of the last change.

LastSelectorBits

public long LastSelectorBits

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:61

The low eight bytes of the previous blackboard-backed entry selector.

LastSelectorUpperBits

public long LastSelectorUpperBits

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:64

Bytes eight through fifteen of the previous entry selector.

LastSequence

public uint LastSequence

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:43

The sequence of the last accepted change of this binding; on the header element, the agent’s monotonic last-writer sequence counter.

LastSyncedBits

public long LastSyncedBits

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:31

The low eight bytes of the last synchronized value.

LastSyncedUpperBits

public long LastSyncedUpperBits

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:34

Bytes eight through fifteen of the last synchronized value.

LastTargetEntityIndex

public int LastTargetEntityIndex

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:55

The entity index resolved for the previous successful sample.

LastTargetEntityVersion

public int LastTargetEntityVersion

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:58

The entity version resolved for the previous successful sample.

Reserved0

public ushort Reserved0

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:52

Reserved word kept zero for additive binary evolution.

BehaviorEntityMemberSynchronization

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityMemberSynchronization

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:124-802

The per-agent member blackboard synchronization the batched entity tick runs around the shared evaluation: notification draining and getter polling before the tick, and blackboard-to-member pushes after it.

Responsibilities:

Drain each authored change-version or enableable notification into the agent’s blackboard when its source fired, poll every non-notification member-to-blackboard binding’s compiled accessor exactly once per selected tick, and push each changed member-bound slot through the generated setter in binding order after the tick, all throughBehaviorBlackboardSynchronizationArbiterso both object models apply the same portable last-writer rules.
Record every accepted change with a monotonic per-agent sequence and its origin, and keep the value baseline that suppresses push-notify and push-poll echoes.

Does NOT:

Discover a member or a target, publish a live reading, allocate, log, or decide a node outcome. An unresolved target simply skips its binding this tick and is retried on the next one; the node evaluations own the diagnostic surface.

Members

PushAfterTick<TAccessor>(ref TAccessor accessor, in ArchetypeChunk chunk, in BehaviorEntityMemberExecutionTables tables, NativeArray<BakedMemberBlackboardBinding> bindings, NativeArray<BakedMemberOperation> operations, NativeArray<BakedMemberEntityTarget> entityTargets, in BehaviorEntityMemberInvocationContext context, int accessRowCount, NativeArray<byte> blackboard, NativeArray<BehaviorEntityMemberSyncState> states, int chunkIndex, int entityIndex, NativeArray<byte> arguments, NativeArray<byte> result, NativeArray<byte> identityScratch)

public static void PushAfterTick<TAccessor>(ref TAccessor accessor, in Unity.Entities.ArchetypeChunk chunk, in BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables tables, Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberBlackboardBinding> bindings, Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberOperation> operations, Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberEntityTarget> entityTargets, in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocationContext context, int accessRowCount, Unity.Collections.NativeArray<byte> blackboard, Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberSyncState> states, int chunkIndex, int entityIndex, Unity.Collections.NativeArray<byte> arguments, Unity.Collections.NativeArray<byte> result, Unity.Collections.NativeArray<byte> identityScratch) where TAccessor : unmanaged, BitQuirky.Behavior.Entities.IBehaviorEntityMemberAccessor

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:359-460

Runs the post-tick blackboard-to-member pass for one agent: every member-bound slot the core or the game wrote since its last synchronized baseline pushes once through the generated setter, in recorded writer-sequence order, with legacy unrecorded writes following in binding order and a reentrancy baseline that suppresses echoes.

SampleBeforeTick<TAccessor>(ref TAccessor accessor, in ArchetypeChunk chunk, in BehaviorEntityMemberExecutionTables tables, NativeArray<BakedMemberBlackboardBinding> bindings, NativeArray<BakedMemberOperation> operations, NativeArray<BakedMemberEntityTarget> entityTargets, in BehaviorEntityMemberInvocationContext context, int accessRowCount, NativeArray<byte> blackboard, NativeArray<BehaviorEntityMemberSyncState> states, int chunkIndex, int entityIndex, NativeArray<byte> arguments, NativeArray<byte> result, NativeArray<byte> identityScratch)

public static void SampleBeforeTick<TAccessor>(ref TAccessor accessor, in Unity.Entities.ArchetypeChunk chunk, in BitQuirky.Behavior.Entities.BehaviorEntityMemberExecutionTables tables, Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberBlackboardBinding> bindings, Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberOperation> operations, Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberEntityTarget> entityTargets, in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocationContext context, int accessRowCount, Unity.Collections.NativeArray<byte> blackboard, Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberSyncState> states, int chunkIndex, int entityIndex, Unity.Collections.NativeArray<byte> arguments, Unity.Collections.NativeArray<byte> result, Unity.Collections.NativeArray<byte> identityScratch) where TAccessor : unmanaged, BitQuirky.Behavior.Entities.IBehaviorEntityMemberAccessor

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:134-351

Runs the pre-tick member-to-blackboard passes for one agent: authored notifications drain when their source fired, and every polled binding invokes its compiled getter exactly once. A push-only binding snapshots its baseline here so an authored default is never pushed as if the core had just written it.

BehaviorEntityMemberSynchronizationReading

Category: Entity integration

readonly struct BitQuirky.Behavior.Entities.BehaviorEntityMemberSynchronizationReading

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:79-98

The last accepted synchronization change of one member blackboard binding on one agent.

Responsibilities:

Report the portable last-writer sequence, the origin of the winning write, and whether any change has been accepted at all, so a test or diagnostic surface can state which writer won without reading private bookkeeping.

Does NOT:

Expose the value baseline or notification internals; the blackboard itself carries the synchronized value.

Members

HasSynchronized

public bool HasSynchronized { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:97

Gets whether any change has been accepted for the binding.

Origin

public BitQuirky.Behavior.Blackboard.BehaviorBlackboardWriteOrigin Origin { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:94

Gets the origin of the last accepted change.

Sequence

public uint Sequence { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:91

Gets the monotonic per-agent sequence of the last accepted change.

BehaviorEntityMemberSynchronizationReading(uint sequence, BehaviorBlackboardWriteOrigin origin, bool hasSynchronized)

public BehaviorEntityMemberSynchronizationReading(uint sequence, BitQuirky.Behavior.Blackboard.BehaviorBlackboardWriteOrigin origin, bool hasSynchronized)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberSynchronization.cs:82-88

Creates one reported reading.

BehaviorEntityMemberTargetResolution

Category: Entity integration

readonly struct BitQuirky.Behavior.Entities.BehaviorEntityMemberTargetResolution

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:24-62

What one evaluation observed when it went looking for its authored entity target.

Responsibilities:

State whether the exact authored component or buffer was reachable on this evaluation, and when it was not, carry the named reason and the cardinality that was actually observed, so the affected node can report a live reading instead of a bare failure.

Does NOT:

Choose a substitute target, remember a previous evaluation’s answer, or decide the node result. Resolution is retried from scratch every evaluation, so a world change that restores the target restores the binding with nothing stored and nothing re-authored.

Members

IsResolved

public bool IsResolved { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:49

Gets whether the exact authored target was reachable this evaluation.

ObservedCount

public int ObservedCount { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:61

Gets the number of entities the world actually held for the authored type. Every mode but Singleton addresses exactly one entity by construction and reports one.

Reason

public BitQuirky.Behavior.Member.BehaviorMemberBindingDiagnosticReason Reason { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:55

Gets the exact reason an unresolved evaluation could not act. A resolved reading carriesUnknown.

Resolved(int observedCount)

public static BitQuirky.Behavior.Entities.BehaviorEntityMemberTargetResolution Resolved(int observedCount)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:27-31

Creates one resolved reading.

Unresolved(BehaviorMemberBindingDiagnosticReason reason, int observedCount)

public static BitQuirky.Behavior.Entities.BehaviorEntityMemberTargetResolution Unresolved(BitQuirky.Behavior.Member.BehaviorMemberBindingDiagnosticReason reason, int observedCount)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:34-38

Creates one unresolved reading carrying its own named reason.

BehaviorEntityMemberTargetResolver

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityMemberTargetResolver

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:129-200

Per-evaluation resolution of the four backend-local entity target modes.

Responsibilities:

Read the already-resolved native views the generated carrier produced from its own visible typed fields, and report for one evaluation whether the exact authored component or buffer was reachable, naming Self, Handle, and Singleton failures by their own reasons and carrying the cardinality a Singleton actually observed.
Resolve Static without an entity at all, because a static call site has no instance.

Does NOT:

Scan the world, substitute a same-type entity, revive a cached entity index, pick a Singleton candidate, supply a default value, change a buffer’s length, or latch a resolution across evaluations. Every one of those is exactly what this backend refuses, and the row views this reads were resolved once per chunk by the carrier’s typed fields.

Members

Resolve(in BehaviorEntityMemberInvocationContext context, in BakedMemberEntityTarget target, int resolutionRow)

public static BitQuirky.Behavior.Entities.BehaviorEntityMemberTargetResolution Resolve(in BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocationContext context, in BitQuirky.Behavior.Baked.BakedMemberEntityTarget target, int resolutionRow)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:142-174

Resolves one operation’s authored entity target for the evaluation now running.

Parameters

context: The per-entity native views the carrier already resolved.
target: The baked entity target row of the operation.
resolutionRow: The accessor-specific resolution row, or -1 when the mode addresses no entity storage at all. Dependency rows remain folded by component type, but target identity does not.

UnresolvedReason(BakedMemberTargetMode mode, bool targetExists)

public static BitQuirky.Behavior.Member.BehaviorMemberBindingDiagnosticReason UnresolvedReason(BitQuirky.Behavior.Baked.BakedMemberTargetMode mode, bool targetExists = false)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberTargetResolver.cs:182-197

Gets the exact live-reading reason one target mode reports when its row did not resolve. The three modes fail for three different reasons and are never merged: a missing component, an unusable handle, and a wrong Singleton count are separate facts with separate recoveries.

BehaviorEntityOccurrenceSampler

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityOccurrenceSampler

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityOccurrenceState.cs:57-402

The per-agent event source sampler the batched entity tick runs before the shared evaluation on every selected graph tick.

Responsibilities:

Read every baked entity event source once per selected tick, whether or not its owning node is running, so an occurrence is never missed because the branch was elsewhere, and update each node’s bake-sized occurrence-state range through BehaviorEntityEventObserver.
Resolve an identity-addressed retained entry through the operation’s own compiled typed accessor at sampling time, so the comparison is the customer’s exact field type and the current authored operand, and publish the ambiguous-identity live reading when more than one entry carries the authored identity.
State the preallocated byte size one agent’s occurrence buffer requires, so attachment reserves everything once and the steady-state tick allocates nothing.

Does NOT:

Consume an occurrence, decide a node result, mutate the game’s event buffer or enableable state, or transition anything when a source cannot be observed this tick.

Members

RequiredByteSize(NativeArray<BakedMemberEntityEvent> events)

public static int RequiredByteSize(Unity.Collections.NativeArray<BitQuirky.Behavior.Baked.BakedMemberEntityEvent> events)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityOccurrenceState.cs:65-81

Computes the total per-agent occurrence byte size the baked event rows reserve: the end of the furthest bake-sized range, or zero when the graph observes nothing.

BehaviorEntityOccurrenceState

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorEntityOccurrenceState

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityOccurrenceState.cs:26-31

Implements: IBufferElementData

One byte of an agent’s preallocated entity event occurrence state. Every Event Condition owns one bake-sized, aligned range of this buffer, reserved at attachment.

Responsibilities:

Carry each Event Condition’s observed-occurrence latch, previous observed match state, consumed-while-retained disarm latch, and, for an identity-field selector, the complete fixed-size selected identity value in its native byte representation.

Does NOT:

Decide anything.BehaviorEntityEventObserverowns every transition, and BehaviorEntityOccurrenceSamplerdrives sampling on every selected tick.

Members

Value

public byte Value

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityOccurrenceState.cs:30

The raw state byte.

BehaviorEntityRandomSeed

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorEntityRandomSeed

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:34-41

Implements: IComponentData

Explicit deterministic seed supplied by an entity that runs probability nodes.

Responsibilities:

Provide a non-zero per-instance seed before the package attaches the graph runtime.

Does NOT:

Derive run seeds or own consumer gameplay randomness.

Members

Value

public uint Value

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:40

Non-zero seed for this entity’s probability nodes. Set it before the graph runtime attaches; zero is not a usable seed.

BehaviorEntityRuntime

Category: Entity integration

class BitQuirky.Behavior.Entities.BehaviorEntityRuntime

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:1318-3502

Implements: IDisposable

Explicitly constructed pure-entity behavior host for one supplied World.

Responsibilities:

Own graph artifacts, agent attachment, blackboard initialization, queues, command routing, batched per-graph scheduling, stable debugger identities, and disposal.

Does NOT:

Discover a default World, parse source at runtime, or contain game-specific facts.

Members

BehaviorEntityRuntime(World world)

public BehaviorEntityRuntime(Unity.Entities.World world)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:1336-1358

Creates the runtime inside an existing createdworld, allocating its owner entity and registry system.

Exceptions

ArgumentNullException: world is null.
ArgumentException: world is not created.

CompleteCommand(BehaviorEntityGraphHandle graph, in ExternalServiceCommand command, ExternalServiceOutcome outcome, int outcomeDetailId, int frameNumber)

public void CompleteCommand(BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle graph, in BitQuirky.Behavior.ExternalService.ExternalServiceCommand command, BitQuirky.Behavior.ExternalService.ExternalServiceOutcome outcome, int outcomeDetailId, int frameNumber)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:1988-2009

Reports the outcome of one command a graph emitted, so the waiting node resumes on the next tick.frameNumberstamps the completion record, and outcomeDetailIdcarries the adapter’s typed reason. Throws InvalidOperationExceptionfor a fire-and-forget command, which has no pending completion to satisfy.

Dispose()

public void Dispose()

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:2016-2110

Cancels outstanding work on every registered graph, releases the agent components, queries, and native artifact memory this runtime allocated, and leaves the World’s own entities intact. Safe to call more than once; every other member throws once disposed.

GetAgentQuery(BehaviorEntityGraphHandle graph)

public Unity.Entities.EntityQuery GetAgentQuery(BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle graph)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:1763-1766

The query of agents currently driven by this graph. Owned by the runtime: use it to read agent data, and do not dispose it.

GetMemberReadings(BehaviorEntityGraphHandle graph)

public BitQuirky.Behavior.Member.BehaviorEntityMemberReadingStore GetMemberReadings(BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle graph)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:2306-2316

Gets the structured live-reading surface of one registered graph: the occurrences whose entity target did not resolve, each carrying graph, node, target, member, and reason, with repeats counted rather than repeated.

ReadMemberSynchronization(BehaviorEntityGraphHandle graph, Entity agent, int bindingIndex)

public BitQuirky.Behavior.Entities.BehaviorEntityMemberSynchronizationReading ReadMemberSynchronization(BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle graph, Unity.Entities.Entity agent, int bindingIndex)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:2334-2360

Reads the last accepted synchronization change of one member blackboard binding on one attached agent: the portable monotonic last-writer sequence and the origin of the winning write. An agent with no member bindings, or a binding that has accepted no change yet, reports a default reading rather than inventing one.

RegisterGraph(BehaviorSourceAsset source, EntityQuery candidates, BehaviorEntityMemberBindingSet memberBindings, IBehaviorEntityMemberScheduler memberScheduler)

public BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle RegisterGraph(BitQuirky.Behavior.Authoring.BehaviorSourceAsset source, Unity.Entities.EntityQuery candidates, BitQuirky.Behavior.Entities.BehaviorEntityMemberBindingSet memberBindings, BitQuirky.Behavior.Entities.IBehaviorEntityMemberScheduler memberScheduler)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:1543-1556

Registers an entity-member graph that reads and writes its complete gameplay surface through the consuming assembly’s generated binding set. No host input binder or external-service command handler participates in this graph.

RegisterGraph(BehaviorSourceAsset source, EntityQuery candidates, IBehaviorEntityInputBinder inputBinder, IReadOnlyList<IBehaviorEntityCommandHandler> commandHandlers)

public BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle RegisterGraph(BitQuirky.Behavior.Authoring.BehaviorSourceAsset source, Unity.Entities.EntityQuery candidates, BitQuirky.Behavior.Entities.IBehaviorEntityInputBinder inputBinder, System.Collections.Generic.IReadOnlyList<BitQuirky.Behavior.Entities.IBehaviorEntityCommandHandler> commandHandlers)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:1523-1536

Registers a graph whose agents are the entities matched by candidates, binding host input through inputBinderand routing emitted external-service commands to commandHandlers. Returns the handle every later call identifies this graph by. Generated member bindings do not participate in this overload.

RegisterGraph(BehaviorSourceAsset source, EntityQuery candidates, IBehaviorEntityInputBinder inputBinder, IReadOnlyList<IBehaviorEntityCommandHandler> commandHandlers, BehaviorEntityMemberBindingSet memberBindings, IBehaviorEntityMemberScheduler memberScheduler)

public BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle RegisterGraph(BitQuirky.Behavior.Authoring.BehaviorSourceAsset source, Unity.Entities.EntityQuery candidates, BitQuirky.Behavior.Entities.IBehaviorEntityInputBinder inputBinder, System.Collections.Generic.IReadOnlyList<BitQuirky.Behavior.Entities.IBehaviorEntityCommandHandler> commandHandlers, BitQuirky.Behavior.Entities.BehaviorEntityMemberBindingSet memberBindings, BitQuirky.Behavior.Entities.IBehaviorEntityMemberScheduler memberScheduler)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:1564-1580

Registers one graph together with the consuming assembly’s explicitly supplied entity member binding set and its generated typed schedule entry point. Both are supplied or neither is: a set without an entry point could never fence its own declared access, and an entry point without a set has no accessor to call. Nothing is discovered.

ResetGraph(BehaviorEntityGraphHandle graph, int frameNumber)

public void ResetGraph(BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle graph, int frameNumber)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:1849-1979

Cancel every outstanding command and restore all agents in one registered graph. Probability graphs read each entity’s explicitBehaviorEntityRandomSeed.

TickAll(int frameNumber, float deltaSeconds, JobHandle dependency)

public void TickAll(int frameNumber, float deltaSeconds, Unity.Jobs.JobHandle dependency = default(Unity.Jobs.JobHandle))

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:1808-1843

Ticks every registered graph once forframeNumber, advancing each by deltaSecondsseconds. Agents are attached first, then every graph ticks, then readings and commands drain, so graphs in one frame observe a consistent set of agents. Completesdependencybefore touching entity data and returns only once the frame’s work has finished.

TickGraph(BehaviorEntityGraphHandle graph, int frameNumber, float deltaSeconds, JobHandle dependency)

public void TickGraph(BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle graph, int frameNumber, float deltaSeconds, Unity.Jobs.JobHandle dependency = default(Unity.Jobs.JobHandle))

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:1775-1799

Ticks one registered graph forframeNumber, advancing it by deltaSecondsseconds: newly matching agents are attached, the input binder runs, the tick is scheduled, and member readings and emitted commands drain. Completesdependencybefore touching entity data and returns only once the tick has finished, so component data is safe to read afterwards.

WasAccessRowResolved(BehaviorEntityGraphHandle graph, int row)

public bool WasAccessRowResolved(BitQuirky.Behavior.Entities.BehaviorEntityGraphHandle graph, int row)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:2367-2394

Gets whether a scheduled chunk resolved the declared ECS access row at the exact index during the most recent graph update. An absent authored component or buffer leaves its row unresolved rather than substituting anything.

BehaviorRuntimeActionState

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorRuntimeActionState

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:70-74

Implements: IBufferElementData

Entity buffer element retaining one direct state action’s persistent progress.

Responsibilities:

Store oneBehaviorActionRuntimeStateper baked node.

Does NOT:

Schedule actions or own the baked action-list table.

Members

Value

public BitQuirky.Behavior.Execution.BehaviorActionRuntimeState Value

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:73

The raw per-node action state.

BehaviorRuntimeNodeExecutionStatus

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorRuntimeNodeExecutionStatus

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:20-27

Implements: IBufferElementData

Entity buffer element retaining one baked node’s latest collapsed execution status.

Responsibilities:

Store oneBehaviorNodeExecutionStatusper baked node.
Preserve the runtime’s zero-valued resting initialization.

Does NOT:

Own graph identity or event history.

Members

Value

public BitQuirky.Behavior.Diagnostics.BehaviorNodeExecutionStatus Value

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:26

Latest collapsed status of the baked node at this buffer index; zero while the node has not run.

BehaviorRuntimeReferenceState

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorRuntimeReferenceState

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:91-95

Implements: IBufferElementData

One retained live-outcome row for a baked state-machine reference.

Members

Value

public BitQuirky.Behavior.Execution.BehaviorReferenceRuntimeState Value

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:94

The retained live outcome of one referenced state machine.

BehaviorRuntimeRepeatState

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorRuntimeRepeatState

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:55-59

Implements: IBufferElementData

Entity buffer element retaining one baked Repeat decorator’s independent progress.

Responsibilities:

Store oneBehaviorRepeatRuntimeStateper baked node.
Keep nested Repeat decorators isolated while they are simultaneously active.

Does NOT:

Select the policy or decide whether a completed child restarts.

Members

Value

public BitQuirky.Behavior.Execution.BehaviorRepeatRuntimeState Value

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:58

The raw per-node Repeat state.

BehaviorRuntimeSuspendedActionState

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorRuntimeSuspendedActionState

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:84-88

Implements: IBufferElementData

One action row preserved for a suspended activation.

Members

Value

public BitQuirky.Behavior.Execution.BehaviorActionRuntimeState Value

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:87

The action row as it stood when the activation was suspended.

BehaviorRuntimeSuspensionFrame

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorRuntimeSuspensionFrame

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:77-81

Implements: IBufferElementData

One preallocated native Push suspension frame.

Members

Value

public BitQuirky.Behavior.Execution.BehaviorStateSuspensionFrame Value

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:80

The suspension frame held by this slot.

BehaviorRuntimeTimeLimitState

Category: Entity integration

struct BitQuirky.Behavior.Entities.BehaviorRuntimeTimeLimitState

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:39-43

Implements: IBufferElementData

Entity buffer element retaining one baked Time Limit decorator’s persistent clock.

Responsibilities:

Store oneBehaviorTimeLimitRuntimeStateper baked node so nested limits and limits spanning several child nodes retain independent elapsed time.

Does NOT:

Decide expiration or alter the game’s components.

Members

Value

public BitQuirky.Behavior.Execution.BehaviorTimeLimitRuntimeState Value

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorRuntimeNodeExecutionStatus.cs:42

The raw per-node Time Limit state.

IBehaviorEntityCommandHandler

Category: Entity integration

interface BitQuirky.Behavior.Entities.IBehaviorEntityCommandHandler

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:347-357

Handles commands after the package resolves their live entities.

Responsibilities:

Declare every stable service token the handler implements.
Apply a resolved command and report its service outcome.

Does NOT:

Build entity-id lookup tables or manipulate completion storage.

Members

ServiceTokens

System.Collections.Generic.IReadOnlyList<string> ServiceTokens { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:350

Gets every stable service token this handler accepts commands for.

Handle(Entity entity, in ExternalServiceCommand command)

BitQuirky.Behavior.ExternalService.ExternalServiceOutcome Handle(Unity.Entities.Entity entity, in BitQuirky.Behavior.ExternalService.ExternalServiceCommand command)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:356

Applies one command whose target entity the package has already resolved, and reports the resulting service outcome.

IBehaviorEntityInputBinder

Category: Entity integration

interface BitQuirky.Behavior.Entities.IBehaviorEntityInputBinder

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:322-335

Writes game facts after package agent initialization and before the graph tick.

Responsibilities:

Resolve required fields once inBind.
Schedule Burst-compatible fact writes for the supplied graph query.

Does NOT:

Attach agents, tick graphs, or handle emitted commands.

Members

Bind(BehaviorEntityBlackboardSchema schema)

void Bind(BitQuirky.Behavior.Entities.BehaviorEntityBlackboardSchema schema)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:328

Resolves every field this binder writes against the graph’s baked schema. Called once, before the firstSchedule.

Schedule(EntityQuery agents, JobHandle dependency)

Unity.Jobs.JobHandle Schedule(Unity.Entities.EntityQuery agents, Unity.Jobs.JobHandle dependency)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:334

Schedules this binder’s fact writes for the supplied agent query and returns the handle the graph tick depends on.

IBehaviorEntityMemberAccessor

Category: Entity integration

interface BitQuirky.Behavior.Entities.IBehaviorEntityMemberAccessor

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:334-341

Generated unmanaged accessor dispatch implemented by each concrete typed carrier. A constrained generic kernel call lets Burst specialize the direct switch without boxing.

Members

Invoke(ref BehaviorEntityMemberInvocation invocation, in ArchetypeChunk chunk, int entityIndex)

void Invoke(ref BitQuirky.Behavior.Entities.BehaviorEntityMemberInvocation invocation, in Unity.Entities.ArchetypeChunk chunk, int entityIndex)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberBinding.cs:337-340

Invokes the exact generated accessor selected by the invocation id.

IBehaviorEntityMemberScheduler

Category: Entity integration

interface BitQuirky.Behavior.Entities.IBehaviorEntityMemberScheduler

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:452-459

The generated typed schedule entry point of one consumer binding set.

Responsibilities:

Complete the incoming handle, fence every declared ECS access row with its matching typed operation, resolve Singleton cardinality, refresh the carrier’s visible typed fields, schedule the carrier against the agent query, and return its handle.

Does NOT:

Register itself anywhere, hold mutable global state, or execute a graph. The consuming assembly supplies its implementation explicitly at graph registration.

Members

Fingerprint

ulong Fingerprint { get; }

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:455

Gets the binding-set fingerprint this entry point was generated for.

Schedule(in BehaviorEntityMemberScheduleContext context)

Unity.Jobs.JobHandle Schedule(in BitQuirky.Behavior.Entities.BehaviorEntityMemberScheduleContext context)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:458

Prepares and schedules the typed carrier for one graph update.

IBehaviorEntityMemberStageDriver

Category: Entity integration

interface BitQuirky.Behavior.Entities.IBehaviorEntityMemberStageDriver

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:242-256

Runtime-owned services a generated scheduler uses to preserve the complete selected-tick order while remaining the one graph-level generated entry call.

Members

DispatchCommands(int frameNumber)

void DispatchCommands(int frameNumber)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:255

Dispatches commands emitted by the completed core stage.

PrepareRowViews(EntityQuery agents, int resolutionRowCount)

Unity.Collections.NativeArray<BitQuirky.Behavior.Entities.BehaviorEntityMemberRowView> PrepareRowViews(Unity.Entities.EntityQuery agents, int resolutionRowCount)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:248-249

Returns compatibility row scratch for a previously generated scheduler. Current typed carriers resolve their own native containers and receive an empty array.

ScheduleInput(EntityQuery agents, JobHandle dependency)

Unity.Jobs.JobHandle ScheduleInput(Unity.Entities.EntityQuery agents, Unity.Jobs.JobHandle dependency)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:252

Schedules the graph’s explicitly composed input binder.

IBehaviorEntityMemberStagedScheduler

Category: Entity integration

interface BitQuirky.Behavior.Entities.IBehaviorEntityMemberStagedScheduler

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityMemberScheduler.cs:466-468

Implements: IBehaviorEntityMemberScheduler

Marks a generated scheduler that implements the Sample, Tick, and Push protocol. Older single-pass schedulers remain source compatible but are rejected for synchronized graphs so registration fails closed instead of silently omitting lifecycle stages.

IInterruptibleBehaviorEntityCommandHandler

Category: Entity integration

interface BitQuirky.Behavior.Entities.IInterruptibleBehaviorEntityCommandHandler

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:368-372

Additive entity-side capability for targeted synchronous service interruption.

Responsibilities:

Stop the identified entity service request before new requests are handled.

Does NOT:

Publish a terminal completion or imply GameObject stepped lifecycle support.

Members

Interrupt(Entity entity, in ExternalServiceInterruption interruption)

void Interrupt(Unity.Entities.Entity entity, in BitQuirky.Behavior.ExternalService.ExternalServiceInterruption interruption)

Source declaration: Packages/io.bitquirky.behavior/Runtime/Entities/BehaviorEntityRuntime.cs:371

Stops the exactly identified entity request synchronously.

Source fingerprint: sha256:ad0983d00d773d882bc61865e18d8c5559e009d181e5891575cd7f262515b23e