lightyear_messages 0.28.0

IO primitives for the lightyear networking library
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
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127

use crate::Message;
use crate::multi::MultiMessageSender;
use crate::prelude::{MessageReceiver, MessageSender};
use crate::registry::MessageRegistration;
use crate::send::Priority;
use crate::send_trigger::EventSender;
use crate::trigger::TriggerRegistration;
use bevy_ecs::entity::EntitySet;
use bevy_ecs::query::QueryFilter;
use bevy_ecs::{
    error::Result,
    event::Event,
    relationship::RelationshipTarget,
    system::{Res, SystemParam},
};
use lightyear_connection::client::PeerMetadata;
use lightyear_connection::client_of::ClientOf;
use lightyear_connection::direction::NetworkDirection;
use lightyear_connection::network_target::NetworkTarget;
use lightyear_link::prelude::Server;
use lightyear_transport::channel::Channel;

/// SystemParam to help send a message to the different [`ClientOf`] connected to a [`Server`].
///
/// Wrapper around a [`MultiMessageSender`] to allow sending messages to clients
/// by referring to them using their [`PeerId`](lightyear_core::prelude::PeerId)
/// instead of their Entity.
#[derive(SystemParam)]
pub struct ServerMultiMessageSender<'w, 's, F: QueryFilter + 'static = ()> {
    sender: MultiMessageSender<'w, 's, F>,
    metadata: Res<'w, PeerMetadata>,
}

impl<'w, 's, F: QueryFilter> ServerMultiMessageSender<'w, 's, F> {
    /// Send a message to the [`ClientOf`]s matching the [`NetworkTarget`] for the provided [`Server`]
    pub fn send<M: Message, C: Channel>(
        &mut self,
        message: &M,
        server: &Server,
        target: &NetworkTarget,
    ) -> Result {
        self.send_with_priority::<M, C>(message, server, target, 1.0)
    }

    /// Send a message to the [`ClientOf`]s matching the [`NetworkTarget`] for the provided [`Server`]
    ///
    /// Specifies a priority which is used if bandwidth limiting is used.
    pub fn send_with_priority<M: Message, C: Channel>(
        &mut self,
        message: &M,
        server: &Server,
        target: &NetworkTarget,
        priority: Priority,
    ) -> Result {
        // Resolve the NetworkTarget to concrete entities, then delegate to
        // MultiMessageSender which handles per-client entity mapping correctly.
        let mut targets = bevy_ecs::entity::EntityHashSet::default();
        target.apply_targets(
            server.collection().iter().copied(),
            &self.metadata.mapping,
            &mut |entity| {
                targets.insert(entity);
            },
        );
        self.sender
            .send_with_priority::<M, C>(message, &targets, priority)
    }

    /// Send a message to a set of  [`ClientOf`]s entities associated with the provided [`Server`]
    pub fn send_to_entities<M: Message, C: Channel>(
        &mut self,
        message: &M,
        target: impl EntitySet,
    ) -> Result {
        self.send_to_entities_with_priority::<M, C>(message, target, 1.0)
    }

    /// Send a message to a set of  [`ClientOf`]s entities associated with the provided [`Server`]
    ///
    /// Specifies a priority which is used if bandwidth limiting is used.
    pub fn send_to_entities_with_priority<M: Message, C: Channel>(
        &mut self,
        message: &M,
        target: impl EntitySet,
        priority: Priority,
    ) -> Result {
        self.sender
            .send_with_priority::<M, C>(message, target, priority)
    }
}

impl<M: Message> MessageRegistration<'_, M> {
    pub(crate) fn add_server_direction(&mut self, direction: NetworkDirection) {
        match direction {
            NetworkDirection::ClientToServer => {
                self.app
                    .register_required_components::<ClientOf, MessageReceiver<M>>();
            }
            NetworkDirection::ServerToClient => {
                self.app
                    .register_required_components::<ClientOf, MessageSender<M>>();
            }
            NetworkDirection::Bidirectional => {
                self.add_server_direction(NetworkDirection::ClientToServer);
                self.add_server_direction(NetworkDirection::ServerToClient);
            }
        }
    }
}

impl<M: Event> TriggerRegistration<'_, M> {
    pub(crate) fn add_server_direction(&mut self, direction: NetworkDirection) {
        match direction {
            NetworkDirection::ClientToServer => {
                // empty because we only have a Sender component, not a Receiver component
            }
            NetworkDirection::ServerToClient => {
                self.app
                    .register_required_components::<ClientOf, EventSender<M>>();
            }
            NetworkDirection::Bidirectional => {
                self.add_server_direction(NetworkDirection::ClientToServer);
                self.add_server_direction(NetworkDirection::ServerToClient);
            }
        }
    }
}