naia-bevy-server 0.9.0

Library to faciliate naia_server & Bevy interop
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

use bevy::{
    app::Events,
    ecs::{
        entity::Entity,
        schedule::ShouldRun,
        system::{Res, ResMut},
        world::{Mut, World},
    },
};
use naia_server::{Event, ProtocolType, Server};

use super::{
    events::{AuthorizationEvent, CommandEvent, ConnectionEvent, DisconnectionEvent, MessageEvent},
    resource::ServerResource,
};

pub fn before_receive_events<P: ProtocolType>(world: &mut World) {
    world.resource_scope(|world, mut server: Mut<Server<P, Entity>>| {
        world.resource_scope(|world, mut server_resource: Mut<ServerResource>| {
            let event_results = server.receive();

            unsafe {
                let mut authorize_event_writer = world
                    .get_resource_unchecked_mut::<Events<AuthorizationEvent<P>>>()
                    .unwrap();
                let mut connect_event_writer = world
                    .get_resource_unchecked_mut::<Events<ConnectionEvent>>()
                    .unwrap();
                let mut disconnect_event_writer = world
                    .get_resource_unchecked_mut::<Events<DisconnectionEvent>>()
                    .unwrap();
                let mut message_event_writer = world
                    .get_resource_unchecked_mut::<Events<MessageEvent<P>>>()
                    .unwrap();
                let mut command_event_writer = world
                    .get_resource_unchecked_mut::<Events<CommandEvent<P>>>()
                    .unwrap();

                for event_result in event_results {
                    match event_result {
                        Ok(Event::Tick) => {
                            server_resource.ticker.set();
                            continue;
                        }
                        Ok(Event::Authorization(user_key, auth)) => {
                            authorize_event_writer.send(AuthorizationEvent(user_key, auth));
                        }
                        Ok(Event::Connection(user_key)) => {
                            connect_event_writer.send(ConnectionEvent(user_key));
                        }
                        Ok(Event::Disconnection(user_key, user)) => {
                            disconnect_event_writer.send(DisconnectionEvent(user_key, user));
                        }
                        Ok(Event::Message(user_key, message)) => {
                            message_event_writer.send(MessageEvent(user_key, message));
                        }
                        Ok(Event::Command(user_key, entity, command)) => {
                            command_event_writer.send(CommandEvent(user_key, entity, command));
                        }
                        Err(_) => {}
                    }
                }
            }
        });
    });
}

pub fn should_tick(resource: Res<ServerResource>) -> ShouldRun {
    if resource.ticker.is_set() {
        ShouldRun::Yes
    } else {
        ShouldRun::No
    }
}

pub fn finish_tick(mut resource: ResMut<ServerResource>) {
    resource.ticker.reset();
}

pub fn should_receive<P: ProtocolType>(server: Res<Server<P, Entity>>) -> ShouldRun {
    if server.is_listening() {
        ShouldRun::Yes
    } else {
        ShouldRun::No
    }
}