Enum State

pub enum State<A, S> {
    WaitForPressedState(Button),
    WaitForReleasedState(Button),
    ActionState(A, Option<S>),
    FailState(Box<State<A, S>>),
    AlwaysSucceedState(Box<State<A, S>>),
    WaitState(f64, f64),
    WaitForeverState,
    IfState(Box<Behavior<A>>, Box<Behavior<A>>, Status, Box<State<A, S>>),
    SelectState(Vec<Behavior<A>>, usize, Box<State<A, S>>),
    SequenceState(Vec<Behavior<A>>, usize, Box<State<A, S>>),
    WhileState(Box<State<A, S>>, Vec<Behavior<A>>, usize, Box<State<A, S>>),
    WhenAllState(Vec<Option<State<A, S>>>),
    WhenAnyState(Vec<Option<State<A, S>>>),
    AfterState(usize, Vec<State<A, S>>),
}

Keeps track of a behavior.

Variants

WaitForPressedState(Button)

Returns Success when button is pressed.

WaitForReleasedState(Button)

Returns Success when button is released.

ActionState(A, Option<S>)

Executes an action.

FailState(Box<State<A, S>>)

Converts Success into Failure and vice versa.

AlwaysSucceedState(Box<State<A, S>>)

Ignores failures and always return Success.

WaitState(f64, f64)

Keeps track of waiting for a period of time before continuing.

f64: Total time in seconds to wait

f64: Time elapsed in seconds

WaitForeverState

Waits forever.

IfState(Box<Behavior<A>>, Box<Behavior<A>>, Status, Box<State<A, S>>)

Keeps track of an If behavior. If status is Running, then it evaluates the condition. If status is Success, then it evaluates the success behavior. If status is Failure, then it evaluates the failure behavior.

SelectState(Vec<Behavior<A>>, usize, Box<State<A, S>>)

Keeps track of a Select behavior.

SequenceState(Vec<Behavior<A>>, usize, Box<State<A, S>>)

Keeps track of an Sequence behavior.

WhileState(Box<State<A, S>>, Vec<Behavior<A>>, usize, Box<State<A, S>>)

Keeps track of a While behavior.

WhenAllState(Vec<Option<State<A, S>>>)

Keeps track of a WhenAll behavior.

WhenAnyState(Vec<Option<State<A, S>>>)

Keeps track of a WhenAny behavior.

AfterState(usize, Vec<State<A, S>>)

Keeps track of an After behavior.

Implementations

impl<A: Clone, S> State<A, S>

pub fn new(behavior: Behavior<A>) -> Self

Creates a state from a behavior.

pub fn event<E, F>(&mut self, e: &E, f: &mut F) -> (Status, f64)

where E: GenericEvent, F: FnMut(ActionArgs<'_, E, A, S>) -> (Status, f64),

Updates the cursor that tracks an event.

The action need to return status and remaining delta time. Returns status and the remaining delta time.

Passes event, delta time in seconds, action and state to closure. The closure should return a status and remaining delta time.

Trait Implementations

impl<A: Clone, S: Clone> Clone for State<A, S>

fn clone(&self) -> State<A, S>

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de, A, S> Deserialize<'de> for State<A, S>

where A: Deserialize<'de>, S: Deserialize<'de>,

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl<A: PartialEq, S: PartialEq> PartialEq for State<A, S>

fn eq(&self, other: &State<A, S>) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl<A, S> Serialize for State<A, S>

where A: Serialize, S: Serialize,

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl<A, S> StructuralPartialEq for State<A, S>