Struct ggrs::P2PSession

pub struct P2PSession { /* fields omitted */ }

A P2PSession provides a UDP protocol to connect to remote clients in a peer-to-peer fashion.

Implementations

impl P2PSession

pub fn add_player(
    &mut self,
    player_type: PlayerType,
    player_handle: PlayerHandle
) -> Result<PlayerHandle, GGRSError>

Must be called for each player in the session (e.g. in a 3 player session, must be called 3 times) before starting the session. Returns the player handle used by GGRS to represent that player internally. The player handle will be the same you provided for players, but player_handle + 1000 for spectators. You will need the player handle to add input, change parameters or disconnect the player or spectator.

Errors

• Returns InvalidHandle when the provided player handle is too big for the number of players
• Returns InvalidRequest if a player with that handle has been added before
• Returns InvalidRequest if the session has already been started
• Returns InvalidRequest when adding more than one local player

pub fn start_session(&mut self) -> Result<(), GGRSError>

After you are done defining and adding all players, you should start the session. Then, the synchronization process will begin.

Errors

• Returns InvalidRequest if the session has already been started or if insufficient players have been registered.

pub fn disconnect_player(
    &mut self,
    player_handle: PlayerHandle
) -> Result<(), GGRSError>

Disconnects a remote player from a game.

Errors

• Returns InvalidRequest if you try to disconnect a player who has already been disconnected or if you try to disconnect a local player.

pub fn advance_frame(
    &mut self,
    local_player_handle: PlayerHandle,
    local_input: &[u8]
) -> Result<Vec<GGRSRequest>, GGRSError>

You should call this to notify GGRS that you are ready to advance your gamestate by a single frame. Returns an order-sensitive Vec<GGRSRequest>. You should fulfill all requests in the exact order they are provided. Failure to do so will cause panics later.

Errors

• Returns InvalidHandle if the provided player handle is higher than the number of players.
• Returns InvalidRequest if the provided player handle refers to a remote player.
• Returns NotSynchronized if the session is not yet ready to accept input. In this case, you either need to start the session or wait for synchronization between clients.

pub fn poll_remote_clients(&mut self)

Should be called periodically by your application to give GGRS a chance to do internal work. GGRS will receive UDP packets, distribute them to corresponding endpoints, handle all occurring events and send all outgoing UDP packets.

pub fn network_stats(
    &self,
    player_handle: PlayerHandle
) -> Result<NetworkStats, GGRSError>

Returns a NetworkStats struct that gives information about the quality of the network connection.

Errors

• Returns InvalidHandle if the provided player handle does not refer to an existing remote player.
• Returns NotSynchronized if the session is not connected to other clients yet.

pub fn set_frame_delay(
    &mut self,
    frame_delay: u32,
    player_handle: PlayerHandle
) -> Result<(), GGRSError>

Change the amount of frames GGRS will delay the inputs for a player. You should only set the frame delay for local players.

Errors

• Returns InvalidHandle if the provided player handle is invalid.
• Returns InvalidRequest if the provided player handle does not refer to a local player.

pub fn set_disconnect_timeout(&mut self, timeout: Duration)

Sets the disconnect timeout. The session will automatically disconnect from a remote peer if it has not received a packet in the timeout window.

pub fn set_disconnect_notify_delay(&mut self, notify_delay: Duration)

Sets the time before the first notification will be sent in case of a prolonged period of no received packages.

pub fn set_fps(&mut self, fps: u32) -> Result<(), GGRSError>

Sets the FPS this session is used with. This influences estimations for frame synchronization between sessions.

pub fn set_sparse_saving(
    &mut self,
    sparse_saving: bool
) -> Result<(), GGRSError>

Sets the sparse saving mode. With sparse saving turned on, only the minimum confirmed frame (for which all inputs from all players are confirmed correct) will be saved. This leads to much less save requests at the cost of potentially longer rollbacks and thus more advance frame requests. Recommended, if saving your gamestate takes much more time than advancing the game state.

pub fn local_player_handle(&self) -> Option<PlayerHandle>

Returns the handle of the local player, if the player is already added

pub const fn current_state(&self) -> SessionState

Returns the current SessionState of a session.

pub fn events(&mut self) -> Drain<'_, GGRSEvent>

Returns all events that happened since last queried for events. If the number of stored events exceeds MAX_EVENT_QUEUE_SIZE, the oldest events will be discarded.

pub const fn num_players(&self) -> u32

Returns the number of players this session was constructed with.

pub const fn input_size(&self) -> usize

Returns the input size this session was constructed with.

Trait Implementations

impl Debug for P2PSession

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

Formats the value using the given formatter.