Struct veloren_rtsim::ai::Then

pub struct Then<A0, A1, R0> {
    a0: A0,
    a0_finished: bool,
    a1: A1,
    phantom: PhantomData<R0>,
}

See Action::then.

Fields

a0: A0

a0_finished: bool

a1: A1

phantom: PhantomData<R0>

Trait Implementations

impl<S: State, A0: Action<S, R0>, A1: Action<S, R1>, R0: Send + Sync + 'static, R1: Send + Sync + 'static> Action<S, R1> for Then<A0, A1, R0>

fn is_same(&self, other: &Self) -> bool

Returns true if the action should be considered the ‘same’ (i.e: achieving the same objective) as another. In general, the AI system will try to avoid switching (and therefore restarting) tasks when the new task is the ‘same’ as the old one.

fn dyn_is_same(&self, other: &dyn Action<S, R1>) -> bool

Like Action::is_same, but allows for dynamic dispatch.

fn backtrace(&self, bt: &mut Vec<String>)

Generate a backtrace for the action. The action should recursively push all of the tasks it is currently performing.

fn reset(&mut self)

Reset the action to its initial state such that it can be repeated.

fn tick(&mut self, ctx: &mut NpcCtx<'_>, state: &mut S) -> ControlFlow<R1>

Perform the action for the current tick.

fn dyn_is_same_sized(&self, other: &dyn Action<S, R>) -> bool

where Self: Sized,

Like Action::is_same, but allows for dynamic dispatch.

fn then<A1: Action<S, R1>, R1>(self, other: A1) -> Then<Self, A1, R>

where Self: Sized,

Create an action that chains together two sub-actions, one after the other.

fn repeat(self) -> Repeat<Self, R>

where Self: Sized,

Create an action that repeats a sub-action indefinitely.

fn stop_if<P: Predicate + Clone>(self, p: P) -> StopIf<Self, P>

where Self: Sized,

Stop the sub-action suddenly if a condition is reached.

fn interrupt_with<A1: Action<S, R1>, R1, F: Fn(&mut NpcCtx<'_>, &mut S) -> Option<A1> + Send + Sync + 'static>( self, f: F, ) -> InterruptWith<Self, F, A1, R1>

where Self: Sized,

Pause an action to possibly perform another action.

fn map<F: Fn(R, &mut S) -> R1, R1>(self, f: F) -> Map<Self, F, R>

where Self: Sized,

Map the completion value of this action to something else.

fn boxed(self) -> Box<dyn Action<S, R>>

where Self: Sized,

Box the action. Often used to perform type erasure, such as when you want to return one of many actions (each with different types) from the same function.

fn with_state<S0>(self, s: S) -> WithState<Self, S, S0>

where Self: Sized, S: Clone,

Set the state for child actions.

fn map_state<S0, F>(self, f: F) -> MapState<Self, F, S, S0>

where F: Fn(&mut S0) -> &mut S, Self: Sized,

Map the current state for child actions, this map expects the return value to have the same lifetime as the input state.

fn debug<F, T>(self, mk_info: F) -> Debug<Self, F, T>

where Self: Sized,

Add debugging information to the action that will be visible when using the /npc_info command.

fn l<Rhs>(self) -> Either<Self, Rhs>

where Self: Sized,

fn r<Lhs>(self) -> Either<Lhs, Self>

where Self: Sized,

impl<A0: Clone, A1: Clone, R0: Clone> Clone for Then<A0, A1, R0>

fn clone(&self) -> Then<A0, A1, R0>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<A0: Copy, A1: Copy, R0: Copy> Copy for Then<A0, A1, R0>