Trait bevy_replicon::network_event::client_event::ClientEventAppExt

pub trait ClientEventAppExt {
    // Required methods
    fn add_client_event<T: Event + Serialize + DeserializeOwned>(
        &mut self,
        channel: impl Into<RepliconChannel>
    ) -> &mut Self;
    fn add_mapped_client_event<T: Event + Serialize + DeserializeOwned + MapEntities + Clone>(
        &mut self,
        channel: impl Into<RepliconChannel>
    ) -> &mut Self;
    fn add_client_event_with<T: Event, Marker1, Marker2>(
        &mut self,
        channel: impl Into<RepliconChannel>,
        send_system: impl IntoSystemConfigs<Marker1>,
        receive_system: impl IntoSystemConfigs<Marker2>
    ) -> &mut Self;
}

An extension trait for App for creating client events.

Required Methods

fn add_client_event<T: Event + Serialize + DeserializeOwned>( &mut self, channel: impl Into<RepliconChannel> ) -> &mut Self

Registers FromClient<T> event that will be emitted on server after sending T event on client.

For usage example see the corresponding section in the quick start guide.

fn add_mapped_client_event<T: Event + Serialize + DeserializeOwned + MapEntities + Clone>( &mut self, channel: impl Into<RepliconChannel> ) -> &mut Self

Same as Self::add_client_event, but additionally maps client entities to server inside the event before sending.

Always use it for events that contain entities. For usage example see the corresponding section in the quick start guide.

fn add_client_event_with<T: Event, Marker1, Marker2>( &mut self, channel: impl Into<RepliconChannel>, send_system: impl IntoSystemConfigs<Marker1>, receive_system: impl IntoSystemConfigs<Marker2> ) -> &mut Self

Same as Self::add_client_event, but uses specified sending and receiving systems.

It’s advised to not panic in the receiving system because it runs on the server.

Examples

Serialize an event with Box<dyn Reflect>:

use bevy::{prelude::*, reflect::serde::{ReflectSerializer, UntypedReflectDeserializer}};
use bevy_replicon::{network_event::client_event::ClientEventChannel, prelude::*};
use bincode::{DefaultOptions, Options};
use serde::de::DeserializeSeed;

let mut app = App::new();
app.add_plugins((MinimalPlugins, RepliconPlugins));
app.add_client_event_with::<ReflectEvent, _, _>(
    ChannelKind::Ordered,
    send_reflect,
    receive_reflect,
);

fn send_reflect(
    mut reflect_events: EventReader<ReflectEvent>,
    mut client: ResMut<RepliconClient>,
    channel: Res<ClientEventChannel<ReflectEvent>>,
    registry: Res<AppTypeRegistry>,
) {
    let registry = registry.read();
    for event in reflect_events.read() {
        let serializer = ReflectSerializer::new(&*event.0, &registry);
        let message = DefaultOptions::new()
            .serialize(&serializer)
            .expect("client event should be serializable");

        client.send(*channel, message);
    }
}

fn receive_reflect(
    mut reflect_events: EventWriter<FromClient<ReflectEvent>>,
    mut server: ResMut<RepliconServer>,
    channel: Res<ClientEventChannel<ReflectEvent>>,
    registry: Res<AppTypeRegistry>,
) {
    let registry = registry.read();
    for (client_id, message) in server.receive(*channel) {
        let mut deserializer = bincode::Deserializer::from_slice(&message, DefaultOptions::new());
        match UntypedReflectDeserializer::new(&registry).deserialize(&mut deserializer) {
            Ok(reflect) => {
                reflect_events.send(FromClient {
                    client_id,
                    event: ReflectEvent(reflect),
                });
            }
            Err(e) => {
                debug!("unable to deserialize event from {client_id:?}: {e}")
            }
        }
    }
}

#[derive(Event)]
struct ReflectEvent(Box<dyn Reflect>);

Object Safety

This trait is not object safe.

Implementations on Foreign Types

impl ClientEventAppExt for App

fn add_client_event<T: Event + Serialize + DeserializeOwned>( &mut self, channel: impl Into<RepliconChannel> ) -> &mut Self

fn add_mapped_client_event<T: Event + Serialize + DeserializeOwned + MapEntities + Clone>( &mut self, channel: impl Into<RepliconChannel> ) -> &mut Self

fn add_client_event_with<T: Event, Marker1, Marker2>( &mut self, channel: impl Into<RepliconChannel>, send_system: impl IntoSystemConfigs<Marker1>, receive_system: impl IntoSystemConfigs<Marker2> ) -> &mut Self

Implementors