Struct EncounterResult 

pub struct EncounterResult {
    pub participants: Vec<String>,
    pub practice: Option<String>,
    pub beats: Vec<Beat>,
    pub relationship_deltas: Vec<Effect>,
    pub knowledge_transfers: Vec<Effect>,
    pub emotional_events: Vec<Effect>,
    pub mood_shifts: Vec<Effect>,
    pub need_satisfactions: Vec<Effect>,
    pub value_shifts: Vec<Effect>,
    pub practice_exits: Vec<Effect>,
    pub escalation_requested: bool,
    pub escalation_requests: Vec<EscalationRequest>,
}

Aggregated output of a resolved encounter.

Each Effect variant has a corresponding aggregate bucket; consumers may either walk beats[*].effects for fully ordered context, or read the per-variant buckets when only one effect kind is needed.

Fields

participants: Vec<String>

Characters who participated.

practice: Option<String>

The practice that framed this encounter, if any.

beats: Vec<Beat>

Ordered sequence of beats that occurred.

relationship_deltas: Vec<Effect>

All Effect::RelationshipDelta effects from all beats.

knowledge_transfers: Vec<Effect>

All Effect::KnowledgeTransfer effects from all beats.

emotional_events: Vec<Effect>

All Effect::EmotionalEvent effects from all beats.

mood_shifts: Vec<Effect>

All Effect::MoodShift effects from all beats.

need_satisfactions: Vec<Effect>

All Effect::NeedSatisfaction effects from all beats.

value_shifts: Vec<Effect>

All Effect::ValueShift effects from all beats.

practice_exits: Vec<Effect>

All Effect::PracticeExit effects from all beats.

escalation_requested: bool

Whether any participant requested escalation.

escalation_requests: Vec<EscalationRequest>

Escalation requests emitted during the encounter.

Implementations

impl EncounterResult

pub fn new(participants: Vec<String>, practice: Option<String>) -> Self

Create a new, empty result for the given participants and optional practice.

pub fn push_beat(&mut self, beat: Beat)

Append a beat and categorize each effect into its corresponding bucket.

Every Effect variant is mirrored into a typed aggregate field; the beat’s full effects vec is also preserved on beats.

Trait Implementations

impl Clone for EncounterResult

fn clone(&self) -> EncounterResult

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for EncounterResult

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

Formats the value using the given formatter.

impl PartialEq for EncounterResult

fn eq(&self, other: &EncounterResult) -> 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 Serialize for EncounterResult

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for EncounterResult