issun-bevy 0.10.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

use bevy::{
    ecs::message::{MessageReader, MessageWriter},
    prelude::*,
};
use issun_core::mechanics::diplomacy::{DiplomacyConfig, DiplomacyInput};
use issun_core::mechanics::Mechanic;

use super::types::{
    BevyDiplomacyEmitter, DiplomacyConfigResource, DiplomaticStance, NegotiationRequested,
    NegotiationResult, Negotiator,
};

/// System: Handle negotiation requests using the generic Mechanic.
pub fn negotiation_system<M>(
    mut requests: MessageReader<NegotiationRequested>,
    config: Res<DiplomacyConfigResource>,
    initiator_query: Query<&Negotiator>,
    mut target_query: Query<&mut DiplomaticStance>,
    mut result_writer: MessageWriter<NegotiationResult>,
) where
    M: Mechanic<
            Config = DiplomacyConfig,
            State = issun_core::mechanics::diplomacy::DiplomacyState,
            Input = DiplomacyInput,
            Event = issun_core::mechanics::diplomacy::DiplomacyEvent,
        > + Send
        + Sync
        + 'static,
{
    for request in requests.read() {
        // Validate initiator
        let Ok(negotiator) = initiator_query.get(request.initiator) else {
            warn!(
                "NegotiationRequested: Initiator {:?} invalid",
                request.initiator
            );
            continue;
        };

        // Validate target
        let Ok(mut stance) = target_query.get_mut(request.target) else {
            warn!("NegotiationRequested: Target {:?} invalid", request.target);
            continue;
        };

        // 1. Convert Component to State
        let mut state = stance.to_state();

        // 2. Construct Input
        let input = DiplomacyInput {
            argument_strength: negotiator.persuasion,
            argument_type: request.argument_type,
            target_resistance: stance.resistance,
        };

        // 3. Create Emitter
        let mut emitter =
            BevyDiplomacyEmitter::new(request.initiator, request.target, &mut result_writer);

        // 4. Run Mechanic
        M::step(&config.config, &mut state, input, &mut emitter);

        // 5. Update Component
        stance.from_state(&state);
    }
}

/// System: Log negotiation results.
pub fn log_negotiation_events(mut events: MessageReader<NegotiationResult>) {
    for result in events.read() {
        info!(
            "Negotiation {:?} -> {:?}: {:?}",
            result.initiator, result.target, result.event
        );
    }
}