bevy_rtc 0.3.1

A client-server library designed over WebRTC for Bevy
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

use super::router::{IncomingMessages, OutgoingMessages};
use crate::protocol::Protocol;
use bevy::{ecs::system::SystemParam, prelude::*};

#[derive(SystemParam, Debug)]
pub struct RtcClient<'w, M: Protocol> {
    // Option is none if it's send-only or read-only.
    pub(crate) incoming: Option<ResMut<'w, IncomingMessages<M>>>,
    pub(crate) outgoing: Option<ResMut<'w, OutgoingMessages<M>>>,
}

impl<'w, M: Protocol> RtcClient<'w, M> {
    /// Returns the capacity of incoming messages.
    pub fn capacity(&self) -> usize {
        self.incoming.as_ref().map(|v| v.bound).unwrap_or(0)
    }

    /// Returns the number of messages waiting in the buffer without draining them.
    pub fn len(&self) -> usize {
        self.incoming
            .as_ref()
            .map(|v| v.messages.len())
            .unwrap_or(0)
    }

    /// Returns the number of messages waiting in the buffer without draining them.
    pub fn is_empty(&self) -> bool {
        self.incoming
            .as_ref()
            .map(|v| v.messages.is_empty())
            .unwrap_or(true)
    }

    /// Clear all messages waiting in the buffer.
    pub fn clear(&mut self) {
        if let Some(ref mut incoming) = self.incoming {
            incoming.messages.clear()
        }
    }

    /// Consumes all messages in the buffer and iterate on them.
    pub fn read(&mut self) -> Vec<M> {
        if let Some(ref mut incoming) = self.incoming {
            incoming.messages.drain(..).collect()
        } else {
            panic!(
                "Attempting to read from `{}` is not allowed, it is registered write only.",
                M::reflect_name()
            );
        }
    }

    /// Send a payload to the host with reliability. The payload is created with
    /// lazy behavior, only when the send rate allows.
    pub fn reliable_to_host_with(&mut self, message_fn: impl Fn() -> M) {
        if let Some(ref mut outgoing) = self.outgoing {
            outgoing.reliable_to_host.push(message_fn());
        } else {
            panic!(
                "Attempting to write `{}` is not allowed, it is registered read only.",
                M::reflect_name()
            );
        }
    }

    /// Send a payload to the host with no expectation of delivery. The payload
    /// is created with lazy behavior, only when the send rate allows.
    pub fn unreliable_to_host_with(&mut self, message_fn: impl Fn() -> M) {
        if let Some(ref mut outgoing) = self.outgoing {
            outgoing.unreliable_to_host.push(message_fn());
        } else {
            panic!(
                "Attempting to write `{}` is not allowed, it is registered read only.",
                M::reflect_name()
            );
        }
    }

    /// Send a payload to the host with reliability.
    pub fn reliable_to_host(&mut self, message: M) {
        if let Some(ref mut outgoing) = self.outgoing {
            outgoing.reliable_to_host.push(message);
        } else {
            panic!(
                "Attempting to write `{}` is not allowed, it is registered read only.",
                M::reflect_name()
            );
        }
    }

    /// Send a payload to the host with no expectation of delivery.
    pub fn unreliable_to_host(&mut self, message: M) {
        if let Some(ref mut outgoing) = self.outgoing {
            outgoing.unreliable_to_host.push(message);
        } else {
            panic!(
                "Attempting to write `{}` is not allowed, it is registered read only.",
                M::reflect_name()
            );
        }
    }
}