Crate bevy_spicy_networking

A spicy simple networking plugin for Bevy

Using this plugin is meant to be straightforward. You have one server and multiple clients. You simply add either the ClientPlugin or the ServerPlugin to the respective bevy app, register which kind of messages can be received through listen_for_client_message or listen_for_server_message (provided respectively by AppNetworkClientMessage and AppNetworkServerMessage) and you can start receiving packets as events of NetworkData<T>.

Example Client

use bevy::prelude::*;
use bevy_spicy_networking::{ClientPlugin, NetworkData, NetworkMessage, ServerMessage, ClientNetworkEvent, AppNetworkServerMessage};
use serde::{Serialize, Deserialize};

#[derive(Serialize, Deserialize)]
struct WorldUpdate;

#[typetag::serde]
impl NetworkMessage for WorldUpdate {}

impl ServerMessage for WorldUpdate {
    const NAME: &'static str = "example:WorldUpdate";
}

fn main() {
     let mut app = App::build();
     app.add_plugin(ClientPlugin);
     // We are receiving this from the server, so we need to listen for it
     app.listen_for_server_message::<WorldUpdate>();
     app.add_system(handle_world_updates.system());
     app.add_system(handle_connection_events.system());
}

fn handle_world_updates(
    mut chunk_updates: EventReader<NetworkData<WorldUpdate>>,
) {
    for chunk in chunk_updates.iter() {
        info!("Got chunk update!");
    }
}

fn handle_connection_events(mut network_events: EventReader<ClientNetworkEvent>,) {
    for event in network_events.iter() {
        match event {
            &ClientNetworkEvent::Connected => info!("Connected to server!"),
            _ => (),
        }
    }
}

Example Server

use bevy::prelude::*;
use bevy_spicy_networking::{ServerPlugin, NetworkData, NetworkMessage, NetworkServer, ServerMessage, ClientMessage, ServerNetworkEvent, AppNetworkClientMessage};

use serde::{Serialize, Deserialize};
#[derive(Serialize, Deserialize)]
struct UserInput;

#[typetag::serde]
impl NetworkMessage for UserInput {}

impl ClientMessage for UserInput {
    const NAME: &'static str = "example:UserInput";
}

fn main() {
     let mut app = App::build();
     app.add_plugin(ServerPlugin);
     // We are receiving this from a client, so we need to listen for it!
     app.listen_for_client_message::<UserInput>();
     app.add_system(handle_world_updates.system());
     app.add_system(handle_connection_events.system());
}

fn handle_world_updates(
    net: Res<NetworkServer>,
    mut chunk_updates: EventReader<NetworkData<UserInput>>,
) {
    for chunk in chunk_updates.iter() {
        info!("Got chunk update!");
    }
}

#[derive(Serialize, Deserialize)]
struct PlayerUpdate;

#[typetag::serde]
impl NetworkMessage for PlayerUpdate {}

impl ClientMessage for PlayerUpdate {
    const NAME: &'static str = "example:PlayerUpdate";
}

impl PlayerUpdate {
    fn new() -> PlayerUpdate {
        Self
    }
}

fn handle_connection_events(
    net: Res<NetworkServer>,
    mut network_events: EventReader<ServerNetworkEvent>,
) {
    for event in network_events.iter() {
        match event {
            &ServerNetworkEvent::Connected(conn_id) => {
                net.send_message(conn_id, PlayerUpdate::new());
                info!("New client connected: {:?}", conn_id);
            }
            _ => (),
        }
    }
}

As you can see, they are both quite similar, and provide everything a basic networked game needs.

For a more

Caveats

Currently this library uses TCP under the hood. Meaning that it has all its drawbacks, where for example a very large update packet can ‘block’ the connection. This is currently not built for fast-paced games that are not meant to be played on LAN, but should suffice for slow-paced games where less-stringent latency delays might be acceptable.

Structs

ClientPlugin

The plugin to add to your bevy AppBuilder when you want to instantiate a client

ConnectionId

A ConnectionId denotes a single connection

NetworkClient

An instance of a NetworkClient is used to connect to a remote server using NetworkClient::connect

NetworkData

NetworkData is what is sent over the bevy event system

NetworkServer

An instance of a NetworkServer is used to listen for new client connections using NetworkServer::listen

NetworkSettings

Settings to configure the network, both client and server

ServerPlugin

The plugin to add to your bevy AppBuilder when you want to instantiate a server

Enums

ClientNetworkEvent

A network event originating from a NetworkClient

ServerNetworkEvent

A network event originating from a NetworkServer

Traits

AppNetworkClientMessage

A utility trait on AppBuilder to easily register ClientMessages

AppNetworkServerMessage

A utility trait on AppBuilder to easily register ServerMessages

ClientMessage

A marker trait to signal that this message should be sent to a client

NetworkMessage

Any type that should be sent over the wire has to implement NetworkMessage.

ServerMessage

A marker trait to signal that this message should be sent to a server