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
102
103

use bevy::prelude::{Component, Events, World};

use crate::connection::events::{
    IterComponentInsertEvent, IterComponentRemoveEvent, IterComponentUpdateEvent, IterMessageEvent,
};
use crate::packet::message::Message;
use crate::protocol::component::IntoKind;
use crate::protocol::{EventContext, Protocol};
use crate::shared::events::{
    ComponentInsertEvent, ComponentRemoveEvent, ComponentUpdateEvent, MessageEvent,
};

// TODO: would it be easier to have this be a system?

// TODO: make server events a trait, so we can use the same function for client events and server events
//  maybe we have a wrapper around generic Events
pub fn push_message_events<
    M: Message,
    P: Protocol,
    E: IterMessageEvent<P, Ctx>,
    Ctx: EventContext,
>(
    world: &mut World,
    events: &mut E,
) where
    P::Message: TryInto<M, Error = ()>,
{
    if events.has_messages::<M>() {
        let mut message_event_writer = world
            .get_resource_mut::<Events<MessageEvent<M, Ctx>>>()
            .unwrap();
        for (message, ctx) in events.into_iter_messages::<M>() {
            let message_event = MessageEvent::new(message, ctx);
            message_event_writer.send(message_event);
        }
    }
}

pub fn push_component_insert_events<
    C: Component,
    P: Protocol,
    E: IterComponentInsertEvent<P, Ctx>,
    Ctx: EventContext,
>(
    world: &mut World,
    events: &mut E,
) where
    C: IntoKind<P::ComponentKinds>,
{
    if events.has_component_insert::<C>() {
        let mut event_writer = world
            .get_resource_mut::<Events<ComponentInsertEvent<C, Ctx>>>()
            .unwrap();
        for (entity, ctx) in events.into_iter_component_insert::<C>() {
            let event = ComponentInsertEvent::new(entity, ctx);
            event_writer.send(event);
        }
    }
}

pub fn push_component_remove_events<
    C: Component,
    P: Protocol,
    E: IterComponentRemoveEvent<P, Ctx>,
    Ctx: EventContext,
>(
    world: &mut World,
    events: &mut E,
) where
    C: IntoKind<P::ComponentKinds>,
{
    if events.has_component_remove::<C>() {
        let mut event_writer = world
            .get_resource_mut::<Events<ComponentRemoveEvent<C, Ctx>>>()
            .unwrap();
        for (entity, ctx) in events.into_iter_component_remove::<C>() {
            let event = ComponentRemoveEvent::new(entity, ctx);
            event_writer.send(event);
        }
    }
}

pub fn push_component_update_events<
    C: Component,
    P: Protocol,
    E: IterComponentUpdateEvent<P, Ctx>,
    Ctx: EventContext,
>(
    world: &mut World,
    events: &mut E,
) where
    C: IntoKind<P::ComponentKinds>,
{
    if events.has_component_update::<C>() {
        let mut event_writer = world
            .get_resource_mut::<Events<ComponentUpdateEvent<C, Ctx>>>()
            .unwrap();
        for (entity, ctx) in events.iter_component_update::<C>() {
            let event = ComponentUpdateEvent::new(entity, ctx);
            event_writer.send(event);
        }
    }
}