Struct RenetServer

pub struct RenetServer { /* private fields */ }

Implementations

impl RenetServer

pub fn new(connection_config: ConnectionConfig) -> Self

pub fn add_connection(&mut self, client_id: ClientId, socket_is_reliable: bool)

Adds a new connection to the server. If a connection already exits it does nothing.

The argument socket_is_reliable should be set if using something like WebSockets for the underlying connection. The client should also set that value in their RenetClient.

Note: This should only be called by the transport layer.

pub fn get_event(&mut self) -> Option<ServerEvent>

Returns a server event if available

Usage

while let Some(event) = server.get_event() {
    match event {
        ServerEvent::ClientConnected { client_id } => {
            println!("Client {client_id} connected.")
        }
        ServerEvent::ClientDisconnected { client_id, reason } => {
            println!("Client {client_id} disconnected: {reason}");
        }
    }
}

pub fn has_connections(&self) -> bool

Returns whether or not the server has connections

pub fn disconnect_reason(&self, client_id: ClientId) -> Option<DisconnectReason>

Returns the disconnection reason for the client if its disconnected

pub fn rtt(&self, client_id: ClientId) -> f64

Returns the round-time trip for the client or 0.0 if the client is not found

pub fn packet_loss(&self, client_id: ClientId) -> f64

Returns the packet loss for the client or 0.0 if the client is not found

pub fn bytes_sent_per_sec(&self, client_id: ClientId) -> f64

Returns the bytes sent per seconds for the client or 0.0 if the client is not found

pub fn bytes_received_per_sec(&self, client_id: ClientId) -> f64

Returns the bytes received per seconds for the client or 0.0 if the client is not found

pub fn network_info( &self, client_id: ClientId, ) -> Result<NetworkInfo, ClientNotFound>

Returns all network informations for the client

pub fn remove_connection(&mut self, client_id: ClientId)

Removes a connection from the server, emits an disconnect server event. It does nothing if the client does not exits.

Note: This should only be called by the transport layer.

pub fn disconnect(&mut self, client_id: ClientId)

Disconnects a client, it does nothing if the client does not exist.

pub fn disconnect_all(&mut self)

Disconnects all client.

pub fn broadcast_message<I: Into<u8>, B: Into<Bytes>>( &mut self, channel_id: I, message: B, )

Send a message to all clients over a channel.

pub fn broadcast_message_except<I: Into<u8>, B: Into<Bytes>>( &mut self, except_id: ClientId, channel_id: I, message: B, )

Send a message to all clients, except the specified one, over a channel.

pub fn channel_available_memory<I: Into<u8>>( &self, client_id: ClientId, channel_id: I, ) -> usize

Returns the available memory in bytes of a channel for the given client. Returns 0 if the client is not found.

pub fn can_send_message<I: Into<u8>>( &self, client_id: ClientId, channel_id: I, size_bytes: usize, ) -> bool

Checks if can send a message with the given size in bytes over a channel for the given client. Returns false if the client is not found.

pub fn send_message<I: Into<u8>, B: Into<Bytes>>( &mut self, client_id: ClientId, channel_id: I, message: B, )

Send a message to a client over a channel.

pub fn receive_message<I: Into<u8>>( &mut self, client_id: ClientId, channel_id: I, ) -> Option<Bytes>

Receive a message from a client over a channel.

pub fn clients_id_iter(&self) -> impl Iterator<Item = ClientId> + '_

Return ids for all connected clients (iterator)

pub fn clients_id(&self) -> Vec<ClientId>

Return ids for all connected clients

pub fn disconnections_id_iter(&self) -> impl Iterator<Item = ClientId> + '_

Return ids for all disconnected clients (iterator)

pub fn disconnections_id(&self) -> Vec<ClientId>

Return ids for all disconnected clients

pub fn connected_clients(&self) -> usize

Returns the current number of connected clients.

pub fn is_connected(&self, client_id: ClientId) -> bool

pub fn update(&mut self, duration: Duration)

Advances the server by the duration. Should be called every tick

pub fn get_packets_to_send( &mut self, client_id: ClientId, ) -> Result<Vec<Payload>, ClientNotFound>

Returns a list of packets to be sent to the client.

Note: This should only be called by the transport layer.

pub fn process_packet_from( &mut self, payload: &[u8], client_id: ClientId, ) -> Result<(), ClientNotFound>

Process a packet received from the client.

Note: This should only be called by the transport layer.

pub fn new_local_client(&mut self, client_id: ClientId) -> RenetClient

Creates a local RenetClient, use this for testing. Use Self::process_local_client to update the local connection.

pub fn disconnect_local_client( &mut self, client_id: ClientId, client: &mut RenetClient, )

Disconnects a local RenetClient that was created with Self::new_local_client.

pub fn process_local_client( &mut self, client_id: ClientId, client: &mut RenetClient, ) -> Result<(), ClientNotFound>

Given a local RenetClient, receive and send packets to/from it. Use this to update local client created from Self::new_local_client.

Trait Implementations

impl Debug for RenetServer

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Resource for RenetServer

where Self: Send + Sync + 'static,