Struct BackgroundScheme 

pub struct BackgroundScheme {
    pub initiator: String,
    pub target: String,
    pub scheme_type: String,
    pub progress: f64,
    pub threshold: f64,
    pub phase: SchemePhase,
    pub advantages: Vec<String>,
}

State of an ongoing background scheme.

Created with BackgroundScheme::new, advanced over time via BackgroundScheme::advance, and converted to a final EncounterResult via BackgroundScheme::to_result once the phase reaches SchemePhase::Resolved.

Fields

initiator: String

The character running the scheme.

target: String

The character the scheme is directed against.

scheme_type: String

Identifier for the type of scheme (e.g. "assassination").

progress: f64

Accumulated progress toward the threshold.

threshold: f64

Progress value at which the scheme resolves.

phase: SchemePhase

Current phase of the scheme lifecycle.

advantages: Vec<String>

Labels describing situational advantages held by the initiator.

Implementations

impl BackgroundScheme

pub fn new( initiator: String, target: String, scheme_type: String, threshold: f64, ) -> Self

Create a new scheme in the SchemePhase::Preparation phase with zero progress.

pub fn advance(&mut self, delta: f64) -> bool

Advance progress. Returns true if scheme resolved this tick.

Calling advance on an already-resolved scheme is a no-op (returns false and does not change progress or phase). Phase transitions are one-way: Preparation → Execution → Resolved.

pub fn add_advantage(&mut self, label: String)

Record an advantage label for the initiator.

pub fn to_result( &self, success_effects: Vec<Effect>, failure_effects: Vec<Effect>, ) -> EncounterResult

Convert resolved scheme to an EncounterResult with one beat.

The resulting beat carries either the success or failure effects depending on whether the scheme reached SchemePhase::Resolved. The same escalation check used by crate::resolution::MultiBeat runs on the resolution beat — high-magnitude relationship deltas or emotion intensities populate result.escalation_requests, since the resolution beat of a scheme is often the most consequential moment in the encounter.

Trait Implementations

impl Clone for BackgroundScheme

fn clone(&self) -> BackgroundScheme

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for BackgroundScheme

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

Formats the value using the given formatter.

impl Serialize for BackgroundScheme

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

where __S: Serializer,

Serialize this value into the given Serde serializer.