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_systems(Update, (connection_establish_system, packet_receive_system))
        .run()
}

fn connection_establish_system(mut events: EventReader<ConnectionEstablishEvent<Config>>) {
    for _event in events.read() {
        println!("Connected!");
    }
}

fn packet_receive_system(mut events: EventReader<PacketReceiveEvent<Config>>) {
    for event in events.read() {
        match &event.packet {
            ServerPacket::String(s) => println!("Got a message: {}", s),
        }
        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_systems(Update, (new_connection_system, packet_receive_system))
        .run()
}

fn new_connection_system(mut events: EventReader<NewConnectionEvent<Config>>) {
    for event in events.read() {
        event
            .connection
            .send(ServerPacket::String("Hello, Client!".to_string())).unwrap();
    }
}

fn packet_receive_system(mut events: EventReader<PacketReceiveEvent<Config>>) {
    for event in events.read() {
        match &event.packet {
            ClientPacket::String(s) => println!("Got a message from a client: {}", s),
        }
        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
main	0.14

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.