lightyear 0.3.0

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

//! Defines the server bevy systems and run conditions
use bevy::prelude::{Events, Mut, Res, ResMut, Time, World};
use tracing::{debug, error, info, trace};

use crate::connection::events::{IterEntityDespawnEvent, IterEntitySpawnEvent};
use crate::netcode::ClientId;
use crate::protocol::message::MessageProtocol;
use crate::protocol::Protocol;
use crate::server::events::{ConnectEvent, DisconnectEvent, EntityDespawnEvent, EntitySpawnEvent};
use crate::server::resource::Server;
use crate::shared::replication::resources::ReplicationData;
use crate::shared::replication::ReplicationSend;

pub(crate) fn receive<P: Protocol>(world: &mut World) {
    trace!("Receive client packets");
    world.resource_scope(|world, mut server: Mut<Server<P>>| {
        let time = world.get_resource::<Time>().unwrap();

        // update client state, send keep-alives, receive packets from io
        server.update(time.delta()).unwrap();
        // buffer packets into message managers
        server.recv_packets(world.change_tick()).unwrap();

        // receive events
        server.receive(world);

        // Write the received events into bevy events
        if !server.events.is_empty() {
            // TODO: write these as systems? might be easier to also add the events to the app
            //  it might just be less efficient? + maybe tricky to
            // Input events
            // Update the input buffers with any InputMessage received:

            // ADD A FUNCTION THAT ITERATES THROUGH EACH CONNECTION AND RETURNS InputEvent for THE CURRENT TICK

            // Connection / Disconnection events
            if server.events.has_connections() {
                let mut connect_event_writer =
                    world.get_resource_mut::<Events<ConnectEvent>>().unwrap();
                for client_id in server.events.iter_connections() {
                    debug!("Client connected event: {}", client_id);
                    connect_event_writer.send(ConnectEvent::new(client_id));
                }
            }

            if server.events.has_disconnections() {
                let mut connect_event_writer =
                    world.get_resource_mut::<Events<DisconnectEvent>>().unwrap();
                for client_id in server.events.iter_disconnections() {
                    debug!("Client disconnected event: {}", client_id);
                    connect_event_writer.send(DisconnectEvent::new(client_id));
                }
            }

            // Message Events
            P::Message::push_message_events(world, &mut server.events);

            // EntitySpawn Events
            if server.events.has_entity_spawn() {
                let mut entity_spawn_event_writer = world
                    .get_resource_mut::<Events<EntitySpawnEvent>>()
                    .unwrap();
                for (entity, client_id) in server.events.into_iter_entity_spawn() {
                    entity_spawn_event_writer.send(EntitySpawnEvent::new(entity, client_id));
                }
            }
            // EntityDespawn Events
            if server.events.has_entity_despawn() {
                let mut entity_despawn_event_writer = world
                    .get_resource_mut::<Events<EntityDespawnEvent>>()
                    .unwrap();
                for (entity, client_id) in server.events.into_iter_entity_spawn() {
                    entity_despawn_event_writer.send(EntityDespawnEvent::new(entity, client_id));
                }
            }

            // TODO: add component replication events
        }
    });
}

// or do additional send stuff here
pub(crate) fn send<P: Protocol>(mut server: ResMut<Server<P>>) {
    trace!("Send packets to clients");
    // finalize any packets that are needed for replication
    server.buffer_replication_messages().unwrap_or_else(|e| {
        error!("Error preparing replicate send: {}", e);
    });
    // send buffered packets to io
    server.send_packets().unwrap();

    server.new_clients.clear();
}

pub(crate) fn clear_events<P: Protocol>(mut server: ResMut<Server<P>>) {
    server.clear_events();
}

pub(crate) fn is_ready_to_send<P: Protocol>(server: Res<Server<P>>) -> bool {
    server.is_ready_to_send()
}