Struct naia_hecs_client::Client

pub struct Client<E>where
    E: Copy + Eq + Hash + Send + Sync,{ /* private fields */ }

Client can send/receive messages to/from a server, and has a pool of in-scope entities/components that are synced with the server

Implementations

impl<E> Client<E>where E: Copy + Eq + Hash + Send + Sync,

pub fn new<P>(client_config: ClientConfig, protocol: P) -> Client<E>where P: Into<Protocol>,

Create a new Client

pub fn auth<M>(&mut self, auth: M)where M: Message,

Set the auth object to use when setting up a connection with the Server

pub fn connect<S>(&mut self, socket: S)where S: Into<Box<dyn Socket + 'static, Global>>,

Connect to the given server address

pub fn is_disconnected(&self) -> bool

Returns whether or not the client is disconnected

pub fn is_connecting(&self) -> bool

Returns whether or not a connection is being established with the Server

pub fn is_connected(&self) -> bool

Returns whether or not a connection has been established with the Server

pub fn disconnect(&mut self)

Disconnect from Server

pub fn socket_config(&self) -> &SocketConfig

Returns socket config

pub fn receive<W>(&mut self, world: W) -> Events<E>where W: WorldMutType<E>,

Must call this regularly (preferably at the beginning of every draw frame), in a loop until it returns None. Retrieves incoming update data from the server, and maintains the connection.

pub fn send_message<C, M>(&mut self, message: &M)where C: Channel, M: Message,

Queues up an Message to be sent to the Server

pub fn send_tick_buffer_message<C, M>(&mut self, tick: &u16, message: &M)where C: Channel, M: Message,

pub fn enable_replication(&mut self, entity: &E)

pub fn disable_replication(&mut self, entity: &E)

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

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

pub fn spawn_entity_at(&mut self, entity: &E)

Creates a new Entity with a specific id

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

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

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

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

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

Return a list of all Entities

pub fn entity_owner(&self, entity: &E) -> EntityOwner

pub fn server_address(&self) -> Result<SocketAddr, NaiaClientError>

Get the address currently associated with the Server

pub fn rtt(&self) -> f32

Gets the average Round Trip Time measured to the Server

pub fn jitter(&self) -> f32

Gets the average Jitter measured in connection to the Server

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

Gets the current tick of the Client

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

Gets the current tick of the Server

pub fn client_interpolation(&self) -> Option<f32>

Gets the interpolation tween amount for the current frame, for use by entities on the Client Tick (i.e. predicted)

pub fn server_interpolation(&self) -> Option<f32>

Gets the interpolation tween amount for the current frame, for use by entities on the Server Tick (i.e. authoritative)

pub fn outgoing_bandwidth(&mut self) -> f32

pub fn incoming_bandwidth(&mut self) -> f32

pub fn despawn_entity_worldless(&mut self, entity: &E)

pub fn insert_component_worldless( &mut self, entity: &E, component: &mut (dyn Replicate + 'static) )

pub fn remove_component_worldless( &mut self, entity: &E, component_kind: &ComponentKind )

Trait Implementations

impl<E> EntityAndGlobalEntityConverter<E> for Client<E>where E: Copy + Eq + Hash + Send + Sync,

fn global_entity_to_entity( &self, global_entity: &GlobalEntity ) -> Result<E, EntityDoesNotExistError>

fn entity_to_global_entity( &self, entity: &E ) -> Result<GlobalEntity, EntityDoesNotExistError>