Struct Quest 

pub struct Quest {
    pub arbiter: Actor,
    pub kind: QuestKind,
    pub timeout: Option<Time>,
    outcome: QuestOutcome,
    res: QuestRes,
}

Fields

arbiter: Actor

The actor responsible for arbitrating over the quest.

Quests can only be resolved by their designated arbiter. The arbiter is defined when the quest is created, and the arbiter receives the quest deposit (see [Quests::resolve]).

In the future, this can be extended to include factions, multiple actors, or even some system in the world (such as a noticeboard system, so that players can assign one-another quests).

kind: QuestKind

A machine-intelligible description of the quest and its completion conditions.

We try to avoid being prescriptive about what form quests can take

timeout: Option<Time>

The time before which the quest should be completed to be considered successful.

outcome: QuestOutcome

res: QuestRes

The only aspect of the quest that mutates over time. Resolving quests is monotonic: once resolved, they cannot be unresolved (to avoid the deposit being paid back twice, for example).

Implementations

impl Quest

pub fn escort(escortee: Actor, escorter: Actor, to: SiteId) -> Self

Create a new escort quest that requires an escoter to travel with an escortee to a destination.

The escortee is considered to be the quest arbiter.

pub fn slay(arbiter: Actor, target: Actor, slayer: Actor) -> Self

Create a new slay quest that requires the slayer to kill a target.

pub fn with_deposit(self, item: ItemResource, amount: f32) -> Self

Deposit an item (usually for payment to whoever completes the quest) in the quest for safekeeping.

Deposits are paid out to the arbiter when a quest is resolved. The arbiter usually passes the deposit on to the character that completed the quest, but this is not the concern of the quest system.

pub fn with_timeout(self, time: Time) -> Self

Add a timeout to the quest, beyond which the quest is considered to be failed.

pub fn resolve( &self, requester: impl Into<Actor>, res: bool, ) -> Option<QuestOutcome>

Resolve a quest.

Quest resolution is monotonic and so can only be done once: all future attempts will fail. If this is the first attempt at resolving (i.e: the function returns Some(...)), the deposit will be returned.

Note that the result type of this function only indicates whether updating the resolution status of the quest was successful: Some(...) will still be returned if the quest was resolved by failure too.

The requester parameter is a sanity test: you should pass the actor that originated the request to resolve, and the function will ensure that this matches the quest’s designated arbiter.

pub fn resolution(&self) -> Option<bool>

pub fn get_related_actors(&self) -> HashSet<Actor>

fn for_related_actors(&self, f: impl FnMut(Actor))

Trait Implementations

impl Clone for Quest

fn clone(&self) -> Quest

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl<'de> Deserialize<'de> for Quest

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

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for Quest

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

where __S: Serializer,

Serialize this value into the given Serde serializer.