Struct ConditionNode 

pub struct ConditionNode { /* private fields */ }

Single-child decorator that gates its child on a ConditionKind predicate: it evaluates the predicate FIRST and only ticks the child (forwarding the child’s status unchanged) while the predicate holds; when the predicate is false it reports Failure WITHOUT ticking the child at all.

Dropping several of these into a SelectOrNode gives capability- or state-gated branch selection out of a small, reusable building block: SelectOrNode already advances past any child that returns Failure, so a false condition naturally falls through to the next option without ever running its subtree. A smaller, more composable primitive than a bespoke branch-on-capability composite node, and it fits the existing decorator pattern (InverterNode/ForceSuccessNode/ForceFailureNode).

Implementations

impl ConditionNode

pub fn new(condition: ConditionKind, child: BoxedBehavior) -> Self

Create a new condition node gating child on condition.

Trait Implementations

impl BehaviorNode for ConditionNode

fn tick<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 Context, ) -> Pin<Box<dyn Future<Output = Result<NodeStatus>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Execute one tick of the behavior. Called repeatedly by the execution engine; should perform one unit of work, return quickly, and report progress via NodeStatus.

fn name(&self) -> &str

Get the name of this behavior node.

fn children_mut(&mut self) -> Vec<&mut dyn BehaviorNode>

Return mutable references to this node’s child behaviors, in the order they should receive lifecycle events. Leaf nodes should not override this; composite nodes override it to expose their children.

fn active_capability(&self) -> Option<&str>

The capability this node implies should be published on /behavior/status while it’s actively being ticked; None for nodes with no such gate (the default). Composite nodes override this to forward whichever child is currently active.

fn status_snapshot(&self) -> TreeStatusSnapshot

Snapshot of what this node (and, for composite nodes, its subtree) reported on its last tick(), for live behavior-tree visualization. The default implementation reports status: None (as if never ticked) and no children - correct for a brand-new node type that hasn’t been wired up for status tracking yet, but every node type should override this once it stores a last_status field: leaf nodes return their own last_status, composite nodes additionally recurse into children_mut’s non-mut counterpart (there’s no shared non-mut child accessor, so each composite overrides this to walk its own child collection directly - same pattern as children_mut).

fn reset_self(&mut self)

Reset this node’s own local state, ignoring children.

fn reset<'life0, 'async_trait>( &'life0 mut self, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait,

Reset the behavior to its initial state.

fn on_init<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 Context, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called when the behavior is first initialized.

fn on_terminate<'life0, 'life1, 'async_trait>( &'life0 mut self, ctx: &'life1 Context, ) -> Pin<Box<dyn Future<Output = Result<()>> + Send + 'async_trait>>

where Self: 'async_trait, 'life0: 'async_trait, 'life1: 'async_trait,

Called when the behavior is being terminated.

impl Debug for ConditionNode

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

Formats the value using the given formatter.