issun-bevy 0.8.0

ISSUN plugins for Bevy ECS
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
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112

use bevy::prelude::*;
use issun_core::mechanics::diplomacy::{
    ArgumentType, DiplomacyConfig, DiplomacyEvent, DiplomacyState,
};

/// Resource wrapper for DiplomacyConfig
#[derive(Resource, Reflect, Default, Clone)]
#[reflect(Resource)]
pub struct DiplomacyConfigResource {
    #[reflect(ignore)]
    pub config: DiplomacyConfig,
}

impl DiplomacyConfigResource {
    pub fn new(config: DiplomacyConfig) -> Self {
        Self { config }
    }
}

/// Component for entities that can negotiate (Actors).
#[derive(Component, Reflect, Default)]
#[reflect(Component)]
pub struct Negotiator {
    /// Base persuasion power
    pub persuasion: f32,
}

/// Component for entities that can be negotiated with (Targets).
#[derive(Component, Reflect)]
#[reflect(Component)]
pub struct DiplomaticStance {
    /// Base resistance to persuasion
    pub resistance: f32,
    /// Current relationship score (-1.0 to 1.0)
    pub relationship: f32,
    /// Patience turns remaining
    pub patience: u32,
    /// Current agreement progress
    pub progress: f32,
}

impl Default for DiplomaticStance {
    fn default() -> Self {
        Self {
            resistance: 10.0,
            relationship: 0.0,
            patience: 5,
            progress: 0.0,
        }
    }
}

impl DiplomaticStance {
    pub fn to_state(&self) -> DiplomacyState {
        let mut state = DiplomacyState::new(self.relationship, self.patience);
        state.agreement_progress = self.progress;
        state
    }

    pub fn from_state(&mut self, state: &DiplomacyState) {
        self.progress = state.agreement_progress;
        self.patience = state.patience;
        // Relationship might change based on events, but state holds the snapshot used for calc
    }
}

/// Message: Request a negotiation attempt.
#[derive(bevy::ecs::message::Message, Debug, Clone)]
pub struct NegotiationRequested {
    pub initiator: Entity,
    pub target: Entity,
    pub argument_type: ArgumentType,
}

/// Message: Result of a negotiation step.
#[derive(bevy::ecs::message::Message, Debug, Clone, PartialEq)]
pub struct NegotiationResult {
    pub initiator: Entity,
    pub target: Entity,
    pub event: DiplomacyEvent,
}

/// Helper to emit Bevy messages from the core mechanic.
pub struct BevyDiplomacyEmitter<'a, 'b> {
    initiator: Entity,
    target: Entity,
    writer: &'a mut bevy::ecs::message::MessageWriter<'b, NegotiationResult>,
}

impl<'a, 'b> BevyDiplomacyEmitter<'a, 'b> {
    pub fn new(
        initiator: Entity,
        target: Entity,
        writer: &'a mut bevy::ecs::message::MessageWriter<'b, NegotiationResult>,
    ) -> Self {
        Self {
            initiator,
            target,
            writer,
        }
    }
}

impl<'a, 'b> issun_core::mechanics::EventEmitter<DiplomacyEvent> for BevyDiplomacyEmitter<'a, 'b> {
    fn emit(&mut self, event: DiplomacyEvent) {
        self.writer.write(NegotiationResult {
            initiator: self.initiator,
            target: self.target,
            event,
        });
    }
}