lightyear 0.26.4

Server-client networking library for the Bevy game engine with modular architecture
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

use bevy_app::{PluginGroup, PluginGroupBuilder};

use crate::shared::SharedPlugins;
use core::time::Duration;

/// A plugin group containing all the client plugins.
///
/// The order in which the plugins are added matters!
/// You need to add:
/// - first add the `ClientPlugins`
/// - then build your protocol (usually in a `ProtocolPlugin`)
/// - then spawn your `Client` entity
pub struct ClientPlugins {
    /// The tick interval for the client. This is used to determine how often the client should tick.
    /// The default value is 1/60 seconds.
    pub tick_duration: Duration,
}

impl Default for ClientPlugins {
    fn default() -> Self {
        Self {
            tick_duration: Duration::from_secs_f32(1.0 / 60.0),
        }
    }
}

impl PluginGroup for ClientPlugins {
    #[allow(clippy::let_and_return)]
    fn build(self) -> PluginGroupBuilder {
        let builder = PluginGroupBuilder::start::<Self>();

        let builder = builder.add(lightyear_sync::client::ClientPlugin);

        let builder = builder.add(SharedPlugins {
            tick_duration: self.tick_duration,
        });

        // if the server feature is enabled (e.g. for host-server mode), then we don't need
        // the client to send checksum messages
        #[cfg(feature = "deterministic")]
        let builder = builder.add(lightyear_deterministic_replication::prelude::ChecksumSendPlugin);

        #[cfg(feature = "prediction")]
        let builder = builder.add(lightyear_prediction::plugin::PredictionPlugin);

        // IO
        #[cfg(feature = "webtransport")]
        let builder = builder.add(lightyear_webtransport::client::WebTransportClientPlugin);
        #[cfg(feature = "websocket")]
        let builder = builder.add(lightyear_websocket::client::WebSocketClientPlugin);
        #[cfg(feature = "steam")]
        let builder = builder.add(lightyear_steam::client::SteamClientPlugin);

        // CONNECTION
        #[cfg(feature = "netcode")]
        let builder = builder.add(lightyear_netcode::client_plugin::NetcodeClientPlugin);
        #[cfg(feature = "raw_connection")]
        let builder = builder.add(lightyear_raw_connection::client::RawConnectionPlugin);

        #[cfg(target_family = "wasm")]
        let builder = builder.add(lightyear_web::WebKeepalivePlugin {
            // The interval is in milliseconds. We can run app.update() infrequently when in the background
            wake_delay: 100.0,
        });

        builder
    }
}