bevy_slinet 0.9.0

A simple networking plugin 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
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130

use crate::client;
use crate::client::{ClientConnection, ClientPlugin, ConnectionEstablishEvent};
use crate::packet_length_serializer::LittleEndian;
use crate::protocols::tcp::TcpProtocol;
use crate::serializers::bincode::BincodeSerializer;
use crate::server::{NewConnectionEvent, ServerConnections, ServerPlugin};
use crate::{server, ClientConfig, ServerConfig};
use bevy::app::App;
use bevy::ecs::event::Events;
use bevy::prelude::{EventReader, Update};
use bincode::DefaultOptions;
use serde::{Deserialize, Serialize};
use std::time::Duration;

#[derive(Serialize, Deserialize, Debug, Clone, Copy, PartialEq)]
struct Packet(u64);

struct TcpConfig;

impl ServerConfig for TcpConfig {
    type ClientPacket = Packet;
    type ServerPacket = Packet;
    type Protocol = TcpProtocol;
    type Serializer = BincodeSerializer<DefaultOptions>;
    type LengthSerializer = LittleEndian<u32>;
}

impl ClientConfig for TcpConfig {
    type ClientPacket = Packet;
    type ServerPacket = Packet;
    type Protocol = TcpProtocol;
    type Serializer = BincodeSerializer<DefaultOptions>;
    type LengthSerializer = LittleEndian<u32>;
}

#[test]
fn tcp_connection() {
    let mut app_server = App::new();
    app_server.add_plugins(ServerPlugin::<TcpConfig>::bind("127.0.0.1:3000"));

    let mut app_client = App::new();
    app_client.add_plugins(ClientPlugin::<TcpConfig>::connect("127.0.0.1:3000"));

    app_server.update(); // bind
    app_client.update(); // connect
    std::thread::sleep(Duration::from_secs(1));
    app_client.update(); // add connection resource
    app_server.update(); // handle connection

    assert!(
        app_client
            .world
            .get_resource::<ClientConnection<TcpConfig>>()
            .is_some(),
        "No ClientConnection resource found"
    );
    assert_eq!(
        app_server
            .world
            .get_resource::<ServerConnections<TcpConfig>>()
            .unwrap()
            .len(),
        1,
    )
}

#[test]
fn tcp_packets() {
    let client_to_server_packet = Packet(42);
    let server_to_client_packet = Packet(24);

    let mut app_server = App::new();
    app_server.add_plugins(ServerPlugin::<TcpConfig>::bind("127.0.0.1:3001"));
    app_server.add_systems(
        Update,
        move |mut events: EventReader<NewConnectionEvent<TcpConfig>>| {
            for event in events.read() {
                event
                    .connection
                    .send(server_to_client_packet)
                    .expect("Couldn't send server packet");
            }
        },
    );

    let mut app_client = App::new();
    app_client.add_plugins(ClientPlugin::<TcpConfig>::connect("127.0.0.1:3001"));
    app_client.add_systems(
        Update,
        move |mut events: EventReader<ConnectionEstablishEvent<TcpConfig>>| {
            for event in events.read() {
                event
                    .connection
                    .send(client_to_server_packet)
                    .expect("Couldn't send client packet");
            }
        },
    );

    app_server.update(); // bind
    app_client.update(); // connect
    std::thread::sleep(Duration::from_secs(1));
    app_client.update(); // add connection resource
    app_server.update(); // handle connection
    std::thread::sleep(Duration::from_secs(1));
    app_client.update(); // handle packet
    app_server.update(); // handle packet

    let server_events = app_server
        .world
        .resource::<Events<server::PacketReceiveEvent<TcpConfig>>>();
    let mut server_reader = server_events.get_reader();
    let mut server_events_iter = server_reader.read(server_events);
    assert_eq!(
        server_events_iter.next().map(|event| event.packet),
        Some(client_to_server_packet),
        "Serverside PacketReceiveEvent was not fired"
    );

    let client_events = app_client
        .world
        .resource::<Events<client::PacketReceiveEvent<TcpConfig>>>();
    let mut client_reader = client_events.get_reader();
    let mut client_events_iter = client_reader.read(client_events);
    assert_eq!(
        client_events_iter.next().map(|event| event.packet),
        Some(server_to_client_packet),
        "Serverside PacketReceiveEvent was not fired"
    );
}