Struct weasel::client::Client

pub struct Client<R: BattleRules> { /* fields omitted */ }

A client event processor.

Clients can accept any kind of event from a remote server. Local events are sent to the server to which the client is connected.

One or more client sinks can be connected to a client. Events received from the server are propagated to these sinks.

Implementations

impl<R: BattleRules + 'static> Client<R>

pub fn builder(
    battle: Battle<R>,
    server_sink: Box<dyn ServerSink<R> + Send>
) -> ClientBuilder<R>

Returns a client builder.

pub fn authentication(&self) -> bool

Returns whether or not client events authentication is enabled.

pub fn player(&self) -> &Option<PlayerId>

Returns the player id associated to this client.

pub fn server_sink(&self) -> &(dyn ServerSink<R> + Send)

Returns a reference to the server sink to which all event prototypes initiated by this client are sent.

pub fn set_server_sink(&mut self, sink: Box<dyn ServerSink<R> + Send>)

Disconnects the current server sink and sets a new one.

pub fn client_sinks(&self) -> MultiClientSinkHandle<R>

Returns a handle to access the client sinks of this client.

pub fn client_sinks_mut(&mut self) -> MultiClientSinkHandleMut<R>

Returns a mutable handle to manage the client sinks of this client.

Trait Implementations

impl<R: BattleRules> BattleController<R> for Client<R>

fn battle(&self) -> &Battle<R>

Returns a reference to the battle.

fn event_callback(&self) -> &Option<EventCallback<R>>

Returns the current event callback set to the battle.

fn set_event_callback(&mut self, callback: Option<EventCallback<R>>)

Sets a new event callback for the battle. The current callback is discarded.

impl<R: BattleRules + 'static> EventProcessor<R> for Client<R>

type ProcessOutput = WeaselResult<(), R>

Return type for this processor's process().

fn process(&mut self, event: EventPrototype<R>) -> Self::ProcessOutput

Processes a local event prototype.

impl<R: BattleRules + 'static> EventReceiver<R> for Client<R>

fn receive(&mut self, event: VersionedEventWrapper<R>) -> WeaselResult<(), R>

Processes a verified event.