Enum CompositionConfig 

pub enum CompositionConfig {
    Sequence {
        children: Vec<CompositionConfig>,
        name: Option<String>,
    },
    Selector {
        children: Vec<CompositionConfig>,
        name: Option<String>,
    },
    Parallel {
        children: Vec<CompositionConfig>,
        policy: ParallelPolicyConfig,
        name: Option<String>,
    },
    Watch {
        children: Vec<CompositionConfig>,
        policy: ParallelPolicyConfig,
        name: Option<String>,
    },
    Subsumption {
        layers: Vec<SubsumptionLayerConfig>,
        name: Option<String>,
    },
    Inverter {
        child: Box<CompositionConfig>,
        name: Option<String>,
    },
    ForceSuccess {
        child: Box<CompositionConfig>,
        name: Option<String>,
    },
    ForceFailure {
        child: Box<CompositionConfig>,
        name: Option<String>,
    },
    Repeat {
        child: Box<CompositionConfig>,
        count: Option<u32>,
        name: Option<String>,
    },
    Retry {
        child: Box<CompositionConfig>,
        max_attempts: u32,
        name: Option<String>,
    },
    Timeout {
        child: Box<CompositionConfig>,
        timeout_secs: f64,
        name: Option<String>,
    },
    Node {
        node: String,
        config_ref: Option<String>,
        config: Option<Value>,
        name: Option<String>,
    },
}

A node in a behavior tree: either a composite control-flow node or a leaf behavior node.

Variants

Sequence

Runs its children in order, stopping early if one fails.

Fields

children: Vec<CompositionConfig>

Child nodes to run in order.

name: Option<String>

Optional name for this node.

Selector

Runs its children in order, stopping early if one succeeds.

Fields

children: Vec<CompositionConfig>

Child nodes to try in order.

name: Option<String>

Optional name for this node.

Parallel

Runs all of its children concurrently.

Fields

children: Vec<CompositionConfig>

Child nodes to run concurrently.

policy: ParallelPolicyConfig

Policy determining when this node succeeds based on its children’s outcomes.

name: Option<String>

Optional name for this node.

Watch

Like Parallel, but every child is re-ticked every call regardless of its previous status - no “frozen once resolved” memory. Use this (not Parallel) for a condition that must be re-evaluated indefinitely, e.g. inside a Subsumption layer that needs to flip between claiming and ceding control many times over a session.

Fields

children: Vec<CompositionConfig>

Child nodes, all re-ticked every call.

policy: ParallelPolicyConfig

Policy determining when this node succeeds/fails based on its children’s outcomes.

name: Option<String>

Optional name for this node.

Subsumption

Priority-based preemption (subsumption architecture): tries each layer highest-priority first, the first one to return Running/Success “wins” and its status is returned for this tick (lower-priority layers aren’t ticked at all that cycle, so their own internal progress - e.g. a Sequence’s current child index - is naturally preserved rather than reset, which is what gives a preempted lower layer “resume where it left off” semantics for free). A layer returns Failure to cede control to the next layer down, within the same tick - this matters: if every layer fails, Subsumption itself returns Failure, which the top-level executor treats as “whole tree finished, reset everything” - so a layer meant to cede control temporarily (not finish the whole tree) must never be the sole reason the overall tick ends in Failure while a lower layer still has work to do; in practice this means: as long as there’s always at least one always-available fallback layer (e.g. the lowest-priority layer is something like wander/patrol that’s essentially never Failure), a higher layer ceding just causes an immediate same-tick fallthrough to that layer instead, and Subsumption returns that layer’s status (typically Running) - never reaching the “all layers failed” case at all.

Fields

layers: Vec<SubsumptionLayerConfig>

Priority layers, highest priority first (ties broken by declaration order).

name: Option<String>

Optional name for this node.

Inverter

Negates its child’s Success/Failure result; Running passes through unchanged.

Fields

child: Box<CompositionConfig>

The single child node to invert.

name: Option<String>

Optional name for this node.

ForceSuccess

Reports Success once its child resolves, regardless of the child’s actual result; Running passes through unchanged. Useful for an optional/best-effort step whose failure shouldn’t abort a surrounding Sequence.

Fields

child: Box<CompositionConfig>

The single child node to force-succeed.

name: Option<String>

Optional name for this node.

ForceFailure

Reports Failure once its child resolves, regardless of the child’s actual result; Running passes through unchanged. The mirror of ForceSuccess.

Fields

child: Box<CompositionConfig>

The single child node to force-fail.

name: Option<String>

Optional name for this node.

Repeat

Re-runs its child every time it succeeds, up to an optional fixed count; a Failure ends the loop immediately with Failure. Omit count to repeat indefinitely.

Fields

child: Box<CompositionConfig>

The single child node to repeat.

count: Option<u32>

Number of successful runs required before this node succeeds. Omit to repeat indefinitely (the node only ever stops via the child failing).

name: Option<String>

Optional name for this node.

Retry

Re-runs its child up to max_attempts times whenever it fails, succeeding as soon as one attempt succeeds; only fails once every attempt is exhausted.

Fields

child: Box<CompositionConfig>

The single child node to retry.

max_attempts: u32

Maximum number of attempts (must be at least 1).

name: Option<String>

Optional name for this node.

Timeout

Bounds how long its child may stay Running: fails immediately once timeout_secs have elapsed since this node started ticking the child (without resolving).

Fields

child: Box<CompositionConfig>

The single child node to bound.

timeout_secs: f64

Maximum time, in seconds, the child is allowed to stay Running.

name: Option<String>

Optional name for this node.

Node

A leaf node that runs a single behavior node implementation.

Fields

node: String

Name of the behavior node type to run.

config_ref: Option<String>

Key into the top-level configs map to use as this node’s configuration.

config: Option<Value>

Inline configuration for this node.

name: Option<String>

Optional name for this node.

Trait Implementations

impl Clone for CompositionConfig

fn clone(&self) -> CompositionConfig

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CompositionConfig

fn fmt(&self, f: &mut Formatter<'_>) -> Result<(), Error>

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for CompositionConfig

fn deserialize<__D>( __deserializer: __D, ) -> Result<CompositionConfig, <__D as Deserializer<'de>>::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl JsonSchema for CompositionConfig

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl Serialize for CompositionConfig

fn serialize<__S>( &self, __serializer: __S, ) -> Result<<__S as Serializer>::Ok, <__S as Serializer>::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.