Crate bevy_slinet

bevy_slinet

A simple networking plugin for bevy.

Features

• You can choose TCP or UDP protocol. Adding your own protocols is as easy as implementing a few traits.
• Multiple clients/servers with different configs (specifies a protocol, packet types, serializer, etc.)
• De/serialization. You choose a serialization format, packet type (you probably want it to be enum), and receive events with deserialized packets.

Note: Everything in bevy_slinet is feature-gated. Make sure to enable features you need (client, server, protocol_tcp, protocol_udp, serializer_bincode).

Client example

use bevy::prelude::*;
use serde::{Deserialize, Serialize};

use bevy_slinet::client::{ClientPlugin, ConnectionEstablishEvent, PacketReceiveEvent};
use bevy_slinet::packet_length_serializer::LittleEndian;
use bevy_slinet::protocols::tcp::TcpProtocol;
use bevy_slinet::serializers::bincode::{BincodeSerializer, DefaultOptions};
use bevy_slinet::ClientConfig;

struct Config;

impl ClientConfig for Config {
    type ClientPacket = Packet;
    type ServerPacket = Packet;
    type Protocol = TcpProtocol;
    type SerializerError = bincode::Error;
    type LengthSerializer = LittleEndian<u32>;
    fn build_serializer(
    ) -> SerializerAdapter<Self::ClientPacket, Self::ServerPacket, Self::SerializerError> {
        SerializerAdapter::ReadOnly(Arc::new(
            BincodeSerializer::<DefaultOptions>::default(),
        ))
    }
}

#[derive(Serialize, Deserialize, Debug)]
enum ClientPacket {
    String(String),
}

#[derive(Serialize, Deserialize, Debug)]
enum ServerPacket {
    String(String),
}

fn main() {
    App::new()
        .add_plugins(MinimalPlugins)
        .add_plugins(ClientPlugin::<Config>::connect("127.0.0.1:3000"))
        .add_observer(connection_establish_system)
        .add_observer(packet_receive_system)
        .run()
}

fn connection_establish_system(event: Trigger<ConnectionEstablishEvent<Config>>) {
    println!("Connected!");
}

fn packet_receive_system(event: Trigger<PacketReceiveEvent<Config>>) {
    match &event.event().packet {
        ServerPacket::String(s) => println!("Got a message: {}", s),
    }
    event
        .event()
        .connection
        .send(ClientPacket::String("Hello, Server!".to_string()))
        .unwrap();
}

Server Example

use bevy::prelude::*;
use serde::{Deserialize, Serialize};

use bevy_slinet::packet_length_serializer::LittleEndian;
use bevy_slinet::protocols::tcp::TcpProtocol;
use bevy_slinet::serializers::bincode::{BincodeSerializer, DefaultOptions};
use bevy_slinet::server::{NewConnectionEvent, ServerPlugin, PacketReceiveEvent};
use bevy_slinet::ServerConfig;

struct Config;

impl ServerConfig for Config {
    type ClientPacket = Packet;
    type ServerPacket = Packet;
    type Protocol = TcpProtocol;
    type SerializerError = bincode::Error;
    type LengthSerializer = LittleEndian<u32>;
    fn build_serializer(
    ) -> SerializerAdapter<Self::ClientPacket, Self::ServerPacket, Self::SerializerError> {
        SerializerAdapter::ReadOnly(Arc::new(
            BincodeSerializer::<DefaultOptions>::default(),
        ))
    }
}

#[derive(Serialize, Deserialize, Debug)]
enum ClientPacket {
    String(String),
}

#[derive(Serialize, Deserialize, Debug)]
enum ServerPacket {
    String(String),
}

fn main() {
    App::new()
        .add_plugins(MinimalPlugins)
        .add_plugins(ServerPlugin::<Config>::bind("127.0.0.1:3000").unwrap())
        .add_observer(new_connection_system)
        .add_observer(packet_receive_system)
        .run()
}

fn new_connection_system(event: Trigger<NewConnectionEvent<Config>>) {
    event
        .event()
        .connection
        .send(ServerPacket::String("Hello, Client!".to_string()))
        .unwrap();
}

fn packet_receive_system(event: Trigger<PacketReceiveEvent<Config>>) {
    match &event.event().packet {
        ClientPacket::String(s) => println!("Got a message from a client: {}", s),
    }
    event
        .event()
        .connection
        .send(ServerPacket::String("Hello, Client!".to_string()))
        .unwrap();
}

Note: you should implement keep-alive and disconnection systems yourself, or look at lobby_and_battle_servers example

More examples

Here.

Compatibility table

Plugin Version	Bevy Version
0.1	0.6
0.2	0.6
0.3	0.7
0.4	0.8
0.5	0.9
0.6	0.10.1
0.7	0.11
0.8	0.12
0.9	0.13
0.10	0.13
0.11	0.14
0.12	0.14
0.13	0.15
main	0.15

Modules

client

Client part of the plugin. You can enable it by adding client feature.

connection

This module contains structs that are used connection handling.

packet_length_serializer

In bevy_slinet all packets are prefixed by their length.

protocol

Implement Protocol to create your own protocol implementation and use it in ServerConfig or ClientConfig.

protocols

Implemented protocols are tcp and udp.

serializer

Implement the ReadOnlySerializer or MutableSerializer trait for serialzer and build it in config refer BincodeSerializer to check how to do this.

serializers

Implemented serializers are: bincode

server

Server part of the plugin. You can enable it by adding server feature.

Enums

SystemSets

SystemSets in bevy are used for system ordering. See [System Order of Execution][cheatbook_order] on unofficial bevy cheatbook for details. For more details on what each SystemSet means, refer to client or server source code

Traits

ClientConfig

A client plugin config.

ServerConfig

A server plugin config.