bhava 2.0.0

Emotion and personality engine — trait spectrums, mood vectors, archetypes, behavioral mapping
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84

use serde::{Deserialize, Serialize};

use super::types::{Emotion, MoodVector};

// --- Emotional Contagion ---

/// Parameters controlling how strongly an entity broadcasts and receives emotions.
#[derive(Debug, Clone, Serialize, Deserialize)]
pub struct ContagionParams {
    /// How strongly this entity broadcasts emotions (0.0–1.0).
    pub expressiveness: f32,
    /// How easily this entity catches emotions (0.0–1.0).
    pub susceptibility: f32,
}

impl Default for ContagionParams {
    fn default() -> Self {
        Self {
            expressiveness: 0.5,
            susceptibility: 0.5,
        }
    }
}

/// Derive contagion parameters from a personality profile.
#[cfg(feature = "traits")]
#[cfg_attr(feature = "tracing", tracing::instrument(skip_all))]
#[must_use]
pub fn contagion_from_personality(profile: &crate::traits::PersonalityProfile) -> ContagionParams {
    use crate::traits::TraitKind;
    let warmth = profile.get_trait(TraitKind::Warmth).normalized();
    let empathy = profile.get_trait(TraitKind::Empathy).normalized();
    let confidence = profile.get_trait(TraitKind::Confidence).normalized();
    let skepticism = profile.get_trait(TraitKind::Skepticism).normalized();

    ContagionParams {
        expressiveness: (warmth * 0.4 + confidence * 0.3 + 0.5).clamp(0.0, 1.0),
        susceptibility: (empathy * 0.5 - skepticism * 0.3 + 0.5).clamp(0.0, 1.0),
    }
}

/// Compute emotional contagion from a sender to a receiver.
///
/// Returns a mood delta to apply to the receiver's emotional state.
/// The delta is modulated by sender expressiveness, receiver susceptibility,
/// and the relationship affinity between them.
#[cfg_attr(feature = "tracing", tracing::instrument(skip_all))]
#[must_use]
pub fn compute_contagion(
    sender_mood: &MoodVector,
    sender_params: &ContagionParams,
    receiver_params: &ContagionParams,
    affinity: f32,
) -> MoodVector {
    let strength = sender_params.expressiveness * receiver_params.susceptibility * affinity.abs();
    let sign = if affinity >= 0.0 { 1.0 } else { -1.0 }; // rivals invert

    let mut delta = MoodVector::neutral();
    for &e in Emotion::ALL {
        let val = sender_mood.get(e) * strength * sign;
        delta.set(e, val);
    }
    delta
}

/// Compute the group emotional centroid (average mood of a group).
#[cfg_attr(feature = "tracing", tracing::instrument(skip_all))]
#[must_use]
pub fn group_mood(members: &[&MoodVector]) -> MoodVector {
    if members.is_empty() {
        return MoodVector::neutral();
    }
    let mut sum = MoodVector::neutral();
    for &m in members {
        for &e in Emotion::ALL {
            sum.set(e, sum.get(e) + m.get(e));
        }
    }
    let n = members.len() as f32;
    for &e in Emotion::ALL {
        sum.set(e, sum.get(e) / n);
    }
    sum
}