Struct Behavior 

pub struct Behavior {
    pub asset_id: AssetId,
    pub on: BehaviorSource,
    pub scope: Vec<String>,
    pub locals: Vec<BehaviorLocal>,
    pub queries: Vec<BehaviorQuery>,
    pub body: Vec<BehaviorNode>,
    pub once: bool,
    pub delay: f32,
    pub cooldown: f32,
}

A unit of world logic: an event source, the entities it runs against, its state, the world it reads, and the nodes it runs.

A behavior with an empty scope runs once per firing, world-scoped. A behavior with a scope runs once per matching entity, each with its own copy of locals, and "self" resolves to that entity.

locals and queries are declared here and resolved to dense slots once, when the world starts, so nothing is looked up by name while it runs. A query naming an unknown component is a build error.

once limits a behavior to a single firing; cooldown enforces a minimum number of seconds between firings; delay postpones the nodes after the firing decision, which is made at fire time rather than after the delay. Timers, delays, and cooldowns freeze while a menu is open, like the rest of the world clock.

Fields

asset_id: AssetId

Asset identity; injected via inject_name. Not part of args.

on: BehaviorSource

The event that fires this behavior.

scope: Vec<String>

Component names selecting the entities this behavior runs against. An empty list runs it once, world-scoped, with no "self".

The names are matched against the components entities carry while the world runs, which are not always the ones a world declares: the build expands some types away, compiles others into the resource stream, and a load-time pass decomposes the rest. "Prop" is the common case and works, resolving to the marker decomposition leaves on every prop’s entity, model- and mesh-backed alike. A name with no runtime counterpart is a build error rather than a scope that silently matches nothing.

locals: Vec<BehaviorLocal>

Per-entity state. Each matching entity gets its own copy, reset to the declared value when the world starts. Locals are never persisted.

queries: Vec<BehaviorQuery>

World reads, resolved once per tick into a stable-ordered entity list.

body: Vec<BehaviorNode>

The nodes run, in order, each time the behavior fires.

once: bool

Fire at most once per run.

delay: f32

Seconds between the firing decision and the nodes running (0 runs them immediately).

cooldown: f32

Minimum seconds between firings (0 allows every firing).

Implementations

impl Behavior

pub fn plays_sound(&self) -> bool

Whether any node plays an audio clip, so the runtime knows this behavior needs the audio system and its clip payloads cached.

pub fn saves_state(&self) -> bool

Whether any node saves the world’s logic state, so the runtime knows to restore persisted state when the world starts.

pub fn is_scoped(&self) -> bool

Whether the behavior runs against individual entities rather than the world as a whole.

Trait Implementations

impl Authored for Behavior

const TYPE: &'static str = "Behavior"

The registered asset type, as it appears in a world line’s type.

impl Clone for Behavior

fn clone(&self) -> Behavior

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Component for Behavior

const NAME: &'static str = "Behavior"

The registry name a world authors this component under.

fn inject_name(&mut self, id: AssetId)

Called after construction to inject the asset’s identity from the blob def. Only meaningful for components that look themselves up by id at runtime. The default implementation does nothing.

fn from_baked(bytes: &[u8]) -> Result<Behavior, CnResult>

Reconstruct this component from a blob record, whose bytes are the serialized runtime component (cook already ran the asset -> component translation). The default rejects: runtime-only components are never stored in a blob, so only loadable types provide an implementation.

fn inject_locator(&mut self, _locator: PayloadLocator)

Called after construction to inject the payload locator from the blob def. Only meaningful for components with a compiled payload. The default implementation does nothing (correct for most components).

impl ComponentSlot for Behavior

const DISCRIMINANT: u8

The component type’s stable id, used as its ComponentId.

fn slot(s: &ComponentStorage) -> &Column<Behavior>

Borrow this type’s column out of the storage.

fn slot_mut(s: &mut ComponentStorage) -> &mut Column<Behavior>

Mutably borrow this type’s column out of the storage.

impl Debug for Behavior

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

Formats the value using the given formatter.

impl Default for Behavior

fn default() -> Behavior

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Behavior

where Behavior: Default,

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl RuntimeComponent for Behavior

impl Serialize for Behavior

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.