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

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

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

struct Config;

impl ClientConfig for Config { type ClientPacket = ClientPacket; type ServerPacket = ServerPacket; type Protocol = TcpProtocol; type Serializer = BincodeSerializer; type LengthSerializer = LittleEndian; }

[derive(Serialize, Deserialize, Debug)]

enum ClientPacket { String(String), }

[derive(Serialize, Deserialize, Debug)]

enum ServerPacket { String(String), }

fn main() { App::new() .addplugins(MinimalPlugins) .addplugin(ClientPlugin::::connect("127.0.0.1:3000")) .addsystem(connectionestablishsystem) .addsystem(packetreceivesystem) .run() }

fn connectionestablishsystem(mut events: EventReader>) { for _event in events.iter() { println!("Connected!"); } }

fn packetreceivesystem(mut events: EventReader>) { for event in events.iter() { match &event.packet { ServerPacket::String(s) => println!("Got a message: {}", s), } event .connection .send(ClientPacket::String("Hello, Server!".to_string())).unwrap(); } } ```

Server Example

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

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

struct Config;

impl ServerConfig for Config { type ClientPacket = ClientPacket; type ServerPacket = ServerPacket; type Protocol = TcpProtocol; type Serializer = BincodeSerializer; type LengthSerializer = LittleEndian; }

[derive(Serialize, Deserialize, Debug)]

enum ClientPacket { String(String), }

[derive(Serialize, Deserialize, Debug)]

enum ServerPacket { String(String), }

fn main() { App::new() .addplugins(MinimalPlugins) .addplugin(ServerPlugin::::bind("127.0.0.1:3000").unwrap()) .addsystem(newconnectionsystem) .addsystem(packetreceivesystem) .run() }

fn newconnectionsystem(mut events: EventReader>) { for event in events.iter() { event .connection .send(ServerPacket::String("Hello, Client!".to_string())).unwrap(); } }

fn packetreceivesystem(mut events: EventReader>) { for event in events.iter() { 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 lobbyandbattle_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 | | main | 0.9 |