renet

Renet uses unidirectional channels for communication. Channels are configured via ConnectionConfig.client_channels_config (for client-to-server) and ConnectionConfig.server_channels_config (for server-to-client).

Each channel is defined by a ChannelConfig which includes a unique channel_id, max_memory_usage_bytes, and a send_type that determines the delivery guarantee:

• SendType::ReliableOrdered: Guarantees both message delivery and the order of arrival. Requires a resend_time (Duration) to specify how long to wait before resending a lost message.
• SendType::ReliableUnordered: Guarantees message delivery but does not guarantee the order of arrival. Also requires a resend_time.
• SendType::Unreliable: No guarantee of delivery or order.

// No guarantee of message delivery or order
let send_type = SendType::Unreliable;

// guarantee of message delivery and order
let send_type = SendType::ReliableOrdered {
    // If a message is lost, it will be resent after this duration
    resend_time: Duration::from_millis(300)
};

// Guarantee of message delivery but not order
let send_type = SendType::ReliableUnordered {
    resend_time: Duration::from_millis(300)
};

let channel_config = ChannelConfig {
    // The id for the channel, must be unique within its own list,
    // but it can be repeated between the server and client lists.
    channel_id: 0,
    // Maximum number of bytes that the channel may hold without acknowledgement of messages before becoming full.
    max_memory_usage_bytes: 5 * 1024 * 1024, // 5 megabytes
    send_type
};

To monitor server-side metrics and individual connected client metrics, use RenetServerVisualizer.

1. Initialization: Create the visualizer with a capacity and style: RenetServerVisualizer::<200>::new(RenetVisualizerStyle::default()).
2. Client Management: Listen for ServerEvents. When a ServerEvent::ClientConnected(client_id, ...) occurs, call visualizer.add_client(client_id). When a ServerEvent::ClientDisconnected(client_id) occurs, call visualizer.remove_client(client_id).
3. Data Update: Call visualizer.update(&server) to collect metrics from all currently tracked clients.
4. Rendering: Call visualizer.show_window(egui_ctx) to draw the metrics window.

let mut visualizer = RenetServerVisualizer::<200>::new(RenetVisualizerStyle::default());
// ..

loop {
    // Update Renet Server
    server.update(delta).unwrap();

    // Add/Remove clients from the visualizer
    while let Some(event) = server.get_event() {
        match event {
            ServerEvent::ClientConnected(client_id, user_data) => {
                visualizer.add_client(client_id);
                // ...
            }
            ServerEvent::ClientDisconnected(client_id) => {
                visualizer.remove_client(client_id);
                // ...
            }
        }
    }

    // Add all clients metrics to the visualizer
    visualizer.update(&server);

    // Draws a new egui window with all clients metrics
    visualizer.show_window(egui_ctx);

    // ..
}

To run a client, initialize a RenetClient with a ConnectionConfig. You must set up a transport layer (e.g., NetcodeClientTransport) with authentication details (like ClientAuthentication::Unsecure or secure variants).

In your gameplay loop:

1. Call client.update(delta_time) to process internal state.
2. Call transport.update(delta_time, &mut client) to bridge the network and the client.
3. If client.is_connected() is true, use client.receive_message(channel) to read messages from the server.
4. Use client.send_message(channel, message) to send data to the server.
5. Call transport.send_packets(&mut client) to flush outgoing packets.

let mut client = RenetClient::new(ConnectionConfig::default());

// Setup transport layer using renet_netcode
const server_addr: SocketAddr = "127.0.0.1:5000".parse().unwrap();
let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
let current_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
let authentication = ClientAuthentication::Unsecure {
    server_addr,
    client_id: 0,
    user_data: None,
    protocol_id: 0,
};

let mut transport = NetcodeClientTransport::new(current_time, authentication, socket).unwrap();

// Your gameplay loop
loop {
    let delta_time = Duration::from_millis(16);
    // Receive new messages and update client
    client.update(delta_time);
    transport.update(delta_time, &mut client).unwrap();
    
    if client.is_connected() {
        // Receive message from server
        while let Some(message) = client.receive_message(DefaultChannel::ReliableOrdered) {
            // Handle received message
        }
        
        // Send message
        client.send_message(DefaultChannel::ReliableOrdered, "client text");
    }
 
    // Send packets to server using the transport layer
    transport.send_packets(&mut client)?;
    
    std::thread::sleep(delta_time);
}

To implement a server, you must add the RenetServerPlugin and a transport plugin (like NetcodeServerPlugin) to your Bevy App. You then need to initialize a RenetServer and a transport instance (e.g., NetcodeServerTransport), inserting both as resources.

Key steps:

1. Add RenetServerPlugin.
2. Insert RenetServer as a resource.
3. Add the transport plugin (e.g., NetcodeServerPlugin).
4. Initialize and insert the transport (e.g., NetcodeServerTransport) as a resource.
5. Use systems to interact with the server via ResMut<RenetServer> and MessageReader<ServerEvent> for connection events.

fn main() {
    let mut app = App::new();
    app.add_plugin(RenetServerPlugin);

    let server = RenetServer::new(ConnectionConfig::default());
    app.insert_resource(server);

    // Transport layer setup
    app.add_plugin(NetcodeServerPlugin);
    let server_addr = "127.0.0.1:5000".parse().unwrap();
    let socket = UdpSocket::bind(server_addr).unwrap();
    let server_config = ServerConfig {
        current_time: SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap(),
        max_clients: 64,
        protocol_id: 0,
        public_addresses: vec![server_addr],
        authentication: ServerAuthentication::Unsecure
    };
    let transport = NetcodeServerTransport::new(server_config, socket).unwrap();
    app.insert_resource(transport);

    app.add_system(send_message_system);
    app.add_system(receive_message_system);
    app.add_system(handle_events_system);
}