Struct Context 

pub struct Context<'a> { /* private fields */ }

State and services available during one step call.

Implementations

impl<'a> Context<'a>

pub fn location(&self) -> (SequenceRef, usize)

Returns the sequence and step index.

pub fn note(&mut self, message: impl Into<String>)

Adds a location-tagged note to the runner event stream.

Examples found in repository

examples/dialog.rs (line 27)

fn main() {
    let mut library = Library::new();

    // Insert first so later steps can refer to the cycle.
    let hub = library.insert(Sequence::new("hub"));

    let accepted = library.insert(
        Sequence::new("accepted")
            .with_step(steps::run("Take the ring", |ctx| {
                match ctx.services_mut().get_mut::<World>() {
                    Some(world) => world.items.retain(|item| item != "gold ring"),
                    None => ctx.note("no World service; the ring stayed put"),
                }
            }))
            .with_step(say("Elder", "You have my thanks.")),
    );

    let refused = library.insert(
        Sequence::new("refused")
            .with_step(say("Elder", "Come back when you have."))
            .with_step(
                steps::run("Return to the hub", move |_ctx| Progress::Goto(Some(hub)))
                    .ends()
                    .delegating_to(hub),
            ),
    );

    let answered = Completion::new();
    let waiting_on = answered.clone();
    let hub_body = library.get_mut(hub).unwrap();
    hub_body.push(say("Elder", "Have you found my ring?"));
    hub_body.push(steps::run("Wait for the player", move |_ctx| {
        waiting_on.clone()
    }));
    hub_body.push(steps::run("Record the answer", |ctx| {
        let said_yes = ctx.services().get::<World>().is_some_and(|w| w.said_yes);
        ctx.set_flag("said_yes", said_yes);
    }));
    hub_body.push(steps::Branch {
        condition: Some(Box::new(conditions::Flag::is_set("said_yes"))),
        if_true: Some(accepted),
        if_false: Some(refused),
    });

    let mut services = TypeMap::new();
    services.insert(World {
        items: vec!["gold ring".to_owned(), "lantern".to_owned()],
        said_yes: false,
    });

    let mut runner = Runner::default();
    runner.start(hub, None).unwrap();

    loop {
        let poll = runner.advance(&mut library, &mut services);
        drain(&mut runner);

        match poll {
            Poll::Pending => {
                println!("> Yes");
                services.get_mut::<World>().unwrap().said_yes = true;
                answered.signal();
            }
            Poll::Ready(outcome) => {
                println!("--- {outcome:?} ---");
                break;
            }
        }
    }

    println!("inventory: {:?}", services.get::<World>().unwrap().items);
}

pub fn services(&self) -> &TypeMap

Returns the host service registry.

Examples found in repository

examples/dialog.rs (line 51)

fn main() {
    let mut library = Library::new();

    // Insert first so later steps can refer to the cycle.
    let hub = library.insert(Sequence::new("hub"));

    let accepted = library.insert(
        Sequence::new("accepted")
            .with_step(steps::run("Take the ring", |ctx| {
                match ctx.services_mut().get_mut::<World>() {
                    Some(world) => world.items.retain(|item| item != "gold ring"),
                    None => ctx.note("no World service; the ring stayed put"),
                }
            }))
            .with_step(say("Elder", "You have my thanks.")),
    );

    let refused = library.insert(
        Sequence::new("refused")
            .with_step(say("Elder", "Come back when you have."))
            .with_step(
                steps::run("Return to the hub", move |_ctx| Progress::Goto(Some(hub)))
                    .ends()
                    .delegating_to(hub),
            ),
    );

    let answered = Completion::new();
    let waiting_on = answered.clone();
    let hub_body = library.get_mut(hub).unwrap();
    hub_body.push(say("Elder", "Have you found my ring?"));
    hub_body.push(steps::run("Wait for the player", move |_ctx| {
        waiting_on.clone()
    }));
    hub_body.push(steps::run("Record the answer", |ctx| {
        let said_yes = ctx.services().get::<World>().is_some_and(|w| w.said_yes);
        ctx.set_flag("said_yes", said_yes);
    }));
    hub_body.push(steps::Branch {
        condition: Some(Box::new(conditions::Flag::is_set("said_yes"))),
        if_true: Some(accepted),
        if_false: Some(refused),
    });

    let mut services = TypeMap::new();
    services.insert(World {
        items: vec!["gold ring".to_owned(), "lantern".to_owned()],
        said_yes: false,
    });

    let mut runner = Runner::default();
    runner.start(hub, None).unwrap();

    loop {
        let poll = runner.advance(&mut library, &mut services);
        drain(&mut runner);

        match poll {
            Poll::Pending => {
                println!("> Yes");
                services.get_mut::<World>().unwrap().said_yes = true;
                answered.signal();
            }
            Poll::Ready(outcome) => {
                println!("--- {outcome:?} ---");
                break;
            }
        }
    }

    println!("inventory: {:?}", services.get::<World>().unwrap().items);
}

pub fn services_mut(&mut self) -> &mut TypeMap

Returns mutable access to the service registry.

Examples found in repository

examples/dialog.rs (line 25)

fn main() {
    let mut library = Library::new();

    // Insert first so later steps can refer to the cycle.
    let hub = library.insert(Sequence::new("hub"));

    let accepted = library.insert(
        Sequence::new("accepted")
            .with_step(steps::run("Take the ring", |ctx| {
                match ctx.services_mut().get_mut::<World>() {
                    Some(world) => world.items.retain(|item| item != "gold ring"),
                    None => ctx.note("no World service; the ring stayed put"),
                }
            }))
            .with_step(say("Elder", "You have my thanks.")),
    );

    let refused = library.insert(
        Sequence::new("refused")
            .with_step(say("Elder", "Come back when you have."))
            .with_step(
                steps::run("Return to the hub", move |_ctx| Progress::Goto(Some(hub)))
                    .ends()
                    .delegating_to(hub),
            ),
    );

    let answered = Completion::new();
    let waiting_on = answered.clone();
    let hub_body = library.get_mut(hub).unwrap();
    hub_body.push(say("Elder", "Have you found my ring?"));
    hub_body.push(steps::run("Wait for the player", move |_ctx| {
        waiting_on.clone()
    }));
    hub_body.push(steps::run("Record the answer", |ctx| {
        let said_yes = ctx.services().get::<World>().is_some_and(|w| w.said_yes);
        ctx.set_flag("said_yes", said_yes);
    }));
    hub_body.push(steps::Branch {
        condition: Some(Box::new(conditions::Flag::is_set("said_yes"))),
        if_true: Some(accepted),
        if_false: Some(refused),
    });

    let mut services = TypeMap::new();
    services.insert(World {
        items: vec!["gold ring".to_owned(), "lantern".to_owned()],
        said_yes: false,
    });

    let mut runner = Runner::default();
    runner.start(hub, None).unwrap();

    loop {
        let poll = runner.advance(&mut library, &mut services);
        drain(&mut runner);

        match poll {
            Poll::Pending => {
                println!("> Yes");
                services.get_mut::<World>().unwrap().said_yes = true;
                answered.signal();
            }
            Poll::Ready(outcome) => {
                println!("--- {outcome:?} ---");
                break;
            }
        }
    }

    println!("inventory: {:?}", services.get::<World>().unwrap().items);
}

pub fn service<T: Any>(&self) -> Option<&T>

Returns the host service of type T.

pub fn service_mut<T: Any>(&mut self) -> Option<&mut T>

Returns mutable access to the host service of type T.

pub fn instigator(&self) -> Option<&dyn Any>

Returns the opaque chain instigator.

pub fn instigator_as<T: Any>(&self) -> Option<&T>

Returns the instigator as type T.

pub fn flags(&self) -> &ChainFlags

Returns the chain flags.

pub fn flags_mut(&mut self) -> &mut ChainFlags

Returns mutable access to the chain flags.

pub fn flag(&self, name: &str) -> bool

Returns a chain flag.

pub fn set_flag(&mut self, name: impl Into<String>, value: bool)

Sets a chain flag.

Examples found in repository

examples/dialog.rs (line 52)

fn main() {
    let mut library = Library::new();

    // Insert first so later steps can refer to the cycle.
    let hub = library.insert(Sequence::new("hub"));

    let accepted = library.insert(
        Sequence::new("accepted")
            .with_step(steps::run("Take the ring", |ctx| {
                match ctx.services_mut().get_mut::<World>() {
                    Some(world) => world.items.retain(|item| item != "gold ring"),
                    None => ctx.note("no World service; the ring stayed put"),
                }
            }))
            .with_step(say("Elder", "You have my thanks.")),
    );

    let refused = library.insert(
        Sequence::new("refused")
            .with_step(say("Elder", "Come back when you have."))
            .with_step(
                steps::run("Return to the hub", move |_ctx| Progress::Goto(Some(hub)))
                    .ends()
                    .delegating_to(hub),
            ),
    );

    let answered = Completion::new();
    let waiting_on = answered.clone();
    let hub_body = library.get_mut(hub).unwrap();
    hub_body.push(say("Elder", "Have you found my ring?"));
    hub_body.push(steps::run("Wait for the player", move |_ctx| {
        waiting_on.clone()
    }));
    hub_body.push(steps::run("Record the answer", |ctx| {
        let said_yes = ctx.services().get::<World>().is_some_and(|w| w.said_yes);
        ctx.set_flag("said_yes", said_yes);
    }));
    hub_body.push(steps::Branch {
        condition: Some(Box::new(conditions::Flag::is_set("said_yes"))),
        if_true: Some(accepted),
        if_false: Some(refused),
    });

    let mut services = TypeMap::new();
    services.insert(World {
        items: vec!["gold ring".to_owned(), "lantern".to_owned()],
        said_yes: false,
    });

    let mut runner = Runner::default();
    runner.start(hub, None).unwrap();

    loop {
        let poll = runner.advance(&mut library, &mut services);
        drain(&mut runner);

        match poll {
            Poll::Pending => {
                println!("> Yes");
                services.get_mut::<World>().unwrap().said_yes = true;
                answered.signal();
            }
            Poll::Ready(outcome) => {
                println!("--- {outcome:?} ---");
                break;
            }
        }
    }

    println!("inventory: {:?}", services.get::<World>().unwrap().items);
}

pub fn eval(&self, condition: &dyn Condition) -> bool

Evaluates a condition with the chain context.

pub fn enact<'e>(&mut self, effects: impl IntoIterator<Item = &'e dyn Effect>)

Applies effects with the chain context.