Struct crystalorb::clocksync::ClockSyncer

pub struct ClockSyncer { /* fields omitted */ }

Client-side clock syncing logic. This is responsible for sending out clock synchronization request messages to the server, and handling the server’s responses. This also serves double duty for determining what client identifier has been allocated by the server to this client. For each server response, a sample of the time clock offset between the client and the server is calculated, and a rolling average (ignoring outliers) of these samples is used to update the effective clock offset that is used by the client once the effective clock offset deviates too far from the rolling average.

Implementations

impl ClockSyncer

pub fn new(config: Config) -> Self

Create a new ClockSyncer with the given configuration parameters. The ClockSyncer will start off in a “not ready” state until after multiple update calls. During the time when the ClockSyncer is not ready, some of the methods may return None as documented.

pub fn update<NetworkResourceType: NetworkResource>(
    &mut self,
    delta_seconds: f64,
    seconds_since_startup: f64,
    net: &mut NetworkResourceType
)

Perform the next update, where the ClockSyncer tries to gather more information about the client-server clock differences and makes adjustments when needed.

Panics

Panics when the ClockSyncer receives inconsistent client_id values from the server.

pub fn is_ready(&self) -> bool

Whether the ClockSyncer has enough information to make useful estimates.

It is guaranteed that once the ClockSyncer becomes “ready”, it stays “ready”.

TODO: Enforce this invariant.

pub fn sample_count(&self) -> usize

How many measurement samples the ClockSyncer has collected and currently stored. Previously collected samples that have since then been discarded are not counted. This merely counts the number of samples in the current moving window.

pub fn samples_needed(&self) -> usize

How many samples are needed to start making useful estimates.

pub fn client_id(&self) -> &Option<usize>

An identifier issued by the server for us to identify ourselves from other clients. Used, for example, for issuing our player’s commands to the server.

This is None if no server responses had been received yet.

pub fn server_seconds_offset(&self) -> &Option<f64>

The difference in seconds between client’s seconds_since_startup and server’s seconds_since_startup, where a positive value refers that an earlier client time value corresponds to the same instant as a later server time value. Since servers start earlier than clients, this value should in theory always be positive. The value stored here is the “effective” offset that is used by the client, and may be up to date with the latest measurements.

Before initialization, the value is None.

pub fn server_seconds_since_startup(
    &self,
    client_seconds_since_startup: f64
) -> Option<f64>

Convert local client seconds since startup into server seconds since startup using the latest estimated time difference between the client and the server, if available.

Trait Implementations

impl Debug for ClockSyncer

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

Formats the value using the given formatter.

impl<'a> From<&'a ClockSyncer> for SyncingClock<&'a ClockSyncer>

fn from(clocksyncer: &'a ClockSyncer) -> Self

Performs the conversion.

impl<'a> From<&'a mut ClockSyncer> for SyncingClock<&'a mut ClockSyncer>

fn from(clocksyncer: &'a mut ClockSyncer) -> Self

Performs the conversion.