Struct weasel::server::Server

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

The server is the main object used to orchestrate a battle.

A server owns all data of the battle and it can also process events. Events are the only way in which a battle can be evolved; all battle data can be retrieved through immutable references.
Exactly one server is required in order to start a game.

One or more client sinks can be connected to a server, to receive verified events.

Implementations

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

pub fn builder(battle: Battle<R>) -> ServerBuilder<R>

Returns a server builder.

pub fn authentication(&self) -> bool

Returns true if the client events authentication is enforced.

pub fn rights(&self) -> RightsHandle<R>

Returns a handle to access the players' rights to control one or more teams.

pub fn rights_mut<'a>(
    &'a mut self
) -> RightsHandleMut<R, impl Iterator<Item = &'a TeamId<R>>>

Returns a mutable handle to manage the players' rights to control one or more teams.

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

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

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

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

Trait Implementations

impl<R: BattleRules> BattleController<R> for Server<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 Server<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 Server<R>

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

Processes a verified event.

impl<R: BattleRules + 'static> EventServer<R> for Server<R>

fn process_client(
    &mut self,
    event: ClientEventPrototype<R>
) -> WeaselResult<(), R>

Processes a client event prototype.