Struct naia_shared::BaseConnection

pub struct BaseConnection<E: Copy + Eq + Hash + Send + Sync> {
    pub message_manager: MessageManager,
    pub host_world_manager: HostWorldManager<E>,
    pub remote_world_manager: RemoteWorldManager,
    pub local_world_manager: LocalWorldManager<E>,
    /* private fields */
}

Represents a connection to a remote host, and provides functionality to manage the connection and the communications to it

Fields

message_manager: MessageManager

host_world_manager: HostWorldManager<E>

remote_world_manager: RemoteWorldManager

local_world_manager: LocalWorldManager<E>

Implementations

impl<E: Copy + Eq + Hash + Send + Sync> BaseConnection<E>

pub fn new( address: &Option<SocketAddr>, host_type: HostType, connection_config: &ConnectionConfig, channel_kinds: &ChannelKinds, global_world_manager: &dyn GlobalWorldManagerType<E> ) -> Self

Create a new BaseConnection, given the appropriate underlying managers

pub fn mark_sent(&mut self)

Record that a message has been sent (to prevent needing to send a heartbeat)

pub fn should_send_heartbeat(&self) -> bool

Returns whether a heartbeat message should be sent

pub fn mark_heard(&mut self)

Record that a message has been received from a remote host (to prevent disconnecting from the remote host)

pub fn should_drop(&self) -> bool

Returns whether this connection should be dropped as a result of a timeout

pub fn process_incoming_header( &mut self, header: &StandardHeader, packet_notifiables: &mut [&mut dyn PacketNotifiable] )

Process an incoming packet, pulling out the packet index number to keep track of the current RTT, and sending the packet to the AckManager to handle packet notification events

pub fn write_outgoing_header( &mut self, packet_type: PacketType, writer: &mut BitWriter )

Given a packet payload, start tracking the packet via it’s index, attach the appropriate header, and return the packet’s resulting underlying bytes

pub fn next_packet_index(&self) -> PacketIndex

Get the next outgoing packet’s index

pub fn has_outgoing_messages(&self) -> bool

pub fn collect_outgoing_messages( &mut self, now: &Instant, rtt_millis: &f32, handle_converter: &dyn EntityHandleConverter<E>, message_kinds: &MessageKinds )

pub fn write_outgoing_packet<W: WorldRefType<E>>( &mut self, protocol: &Protocol, now: &Instant, writer: &mut BitWriter, packet_index: PacketIndex, world: &W, global_world_manager: &dyn GlobalWorldManagerType<E>, has_written: &mut bool, write_world_events: bool )

pub fn despawn_all_remote_entities<W: WorldMutType<E>>( &mut self, global_world_manager: &mut dyn GlobalWorldManagerType<E>, world: &mut W ) -> Vec<EntityEvent<E>>