Struct naia_server::Server

pub struct Server<P: ProtocolType, E: Copy + Eq + Hash> { /* private fields */ }

A server that uses either UDP or WebRTC communication to send/receive messages to/from connected clients, and syncs registered entities to clients to whom they are in-scope

Implementations

impl<P: ProtocolType, E: Copy + Eq + Hash> Server<P, E>

pub fn new(server_config: ServerConfig, shared_config: SharedConfig<P>) -> Self

Create a new Server

pub fn listen(&mut self, server_addrs: ServerAddrs)

Listen at the given addresses

pub fn receive(&mut self) -> VecDeque<Result<Event<P, E>, NaiaServerError>>

Must be called regularly, maintains connection to and receives messages from all Clients

pub fn accept_connection(&mut self, user_key: &UserKey)

Accepts an incoming Client User, allowing them to establish a connection with the Server

pub fn reject_connection(&mut self, user_key: &UserKey)

Rejects an incoming Client User, terminating their attempt to establish a connection with the Server

pub fn send_message<R: ReplicateSafe<P>>(
    &mut self,
    user_key: &UserKey,
    message: &R,
    guaranteed_delivery: bool
)

Queues up an Message to be sent to the Client associated with a given UserKey

pub fn scope_checks(&self) -> Vec<(RoomKey, UserKey, E)>

Used to evaluate whether, given a User & Entity that are in the same Room, said Entity should be in scope for the given User.

While Rooms allow for a very simple scope to which an Entity can belong, this provides complete customization for advanced scopes.

Return a collection of Entity Scope Sets, being a unique combination of a related Room, User, and Entity, used to determine which Entities to replicate to which Users

pub fn send_all_updates<W: WorldRefType<P, E>>(&mut self, world: W)

Sends all update messages to all Clients. If you don’t call this method, the Server will never communicate with it’s connected Clients

pub fn spawn_entity<'s, W: WorldMutType<P, E>>(
    &'s mut self,
    world: W
) -> EntityMut<'s, P, E, W>

Creates a new Entity and returns an EntityMut which can be used for further operations on the Entity

pub fn spawn_entity_at<'s>(
    &'s mut self,
    entity: &E
) -> WorldlessEntityMut<'s, P, E>

Creates a new Entity with a specific id

pub fn entity<'s, W: WorldRefType<P, E>>(
    &'s self,
    world: W,
    entity: &E
) -> EntityRef<'s, P, E, W>

Retrieves an EntityRef that exposes read-only operations for the Entity. Panics if the Entity does not exist.

pub fn entity_mut<'s, 'w, W: WorldMutType<P, E>>(
    &'s mut self,
    world: W,
    entity: &E
) -> EntityMut<'s, P, E, W>

Retrieves an EntityMut that exposes read and write operations for the Entity. Panics if the Entity does not exist.

pub fn worldless_entity_mut<'s>(
    &'s mut self,
    entity: &E
) -> WorldlessEntityMut<'s, P, E>

Retrieves a WorldlessEntityMut that exposes read and write operations on the Entity, but with no references allowed to the World. This is a very niche use case. Panics if the Entity does not exist.

pub fn entities<W: WorldRefType<P, E>>(&self, world: W) -> Vec<E>

Gets a Vec of all Entities in the given World

pub fn user_exists(&self, user_key: &UserKey) -> bool

Returns whether or not a User exists for the given RoomKey

pub fn user(&self, user_key: &UserKey) -> UserRef<'_, P, E>

Retrieves an UserRef that exposes read-only operations for the User associated with the given UserKey. Panics if the user does not exist.

pub fn user_mut(&mut self, user_key: &UserKey) -> UserMut<'_, P, E>

Retrieves an UserMut that exposes read and write operations for the User associated with the given UserKey. Returns None if the user does not exist.

pub fn user_keys(&self) -> Vec<UserKey>

Return a list of all currently connected Users’ keys

pub fn users_count(&self) -> usize

Get the number of Users currently connected

pub fn user_scope(&mut self, user_key: &UserKey) -> UserScopeMut<'_, P, E>

Returns a UserScopeMut, which is used to include/exclude Entities for a given User

pub fn user_scope_has_entity(&self, user_key: &UserKey, entity: &E) -> bool

Returns whether a given User has a particular Entity in-scope currently

pub fn make_room(&mut self) -> RoomMut<'_, P, E>

Creates a new Room on the Server and returns a corresponding RoomMut, which can be used to add users/entities to the room or retrieve its key

pub fn room_exists(&self, room_key: &RoomKey) -> bool

Returns whether or not a Room exists for the given RoomKey

pub fn room(&self, room_key: &RoomKey) -> RoomRef<'_, P, E>

Retrieves an RoomMut that exposes read and write operations for the Room associated with the given RoomKey. Panics if the room does not exist.

pub fn room_mut(&mut self, room_key: &RoomKey) -> RoomMut<'_, P, E>

Retrieves an RoomMut that exposes read and write operations for the Room associated with the given RoomKey. Panics if the room does not exist.

pub fn room_keys(&self) -> Vec<RoomKey>

Return a list of all the Server’s Rooms’ keys

pub fn rooms_count(&self) -> usize

Get a count of how many Rooms currently exist

pub fn client_tick(&self, user_key: &UserKey) -> Option<u16>

Gets the last received tick from the Client

pub fn server_tick(&self) -> Option<u16>

Gets the current tick of the Server