Enum NetworkEvent 

pub enum NetworkEvent {
    ClientConnected(ClientId),
    ClientDisconnected(ClientId),
    UnreliableMessage {
        client_id: ClientId,
        data: Vec<u8>,
    },
    ReliableMessage {
        client_id: ClientId,
        data: Vec<u8>,
    },
    Ping {
        client_id: ClientId,
        tick: u64,
    },
    Pong {
        tick: u64,
    },
    Auth {
        session_token: String,
    },
    SessionClosed(ClientId),
    StreamReset(ClientId),
    Fragment {
        client_id: ClientId,
        fragment: FragmentedEvent,
    },
    StressTest {
        client_id: ClientId,
        count: u16,
        rotate: bool,
    },
    Spawn {
        client_id: ClientId,
        entity_type: u16,
        x: f32,
        y: f32,
        rot: f32,
    },
    ClearWorld {
        client_id: ClientId,
    },
    Disconnected(ClientId),
}

Events produced by GameTransport::poll_events().

Variants

ClientConnected(ClientId)

A new client has connected and been assigned a ClientId.

ClientDisconnected(ClientId)

A client has disconnected (graceful or timeout).

UnreliableMessage

Raw unreliable data received from a client.

Fields

client_id: ClientId

The client that sent the message.

data: Vec<u8>

The raw message bytes.

ReliableMessage

Raw reliable data received from a client.

Fields

client_id: ClientId

The client that sent the message.

data: Vec<u8>

The raw message bytes.

Ping

A heartbeat ping from a client.

Fields

client_id: ClientId

The client that sent the ping.

tick: u64

The client’s tick/timestamp when the ping was sent.

Pong

A heartbeat pong from the server.

Fields

tick: u64

The original tick/timestamp from the ping.

Auth

A session authentication request from the client.

Fields

session_token: String

The session token obtained from the Control Plane.

SessionClosed(ClientId)

A WebTransport session was closed by the remote or due to error.

StreamReset(ClientId)

A WebTransport stream was reset.

Fragment

A fragment of a larger message.

Fields

client_id: ClientId

The client that sent the fragment.

fragment: FragmentedEvent

The fragment data.

StressTest

A testing command to trigger a stress test (Phase 1/Playground only).

Fields

client_id: ClientId

The client that requested the stress test.

count: u16

Number of entities to spawn.

rotate: bool

Whether spawned entities should rotate.

Spawn

A testing command to spawn a specific entity (Phase 1/Playground only).

Fields

client_id: ClientId

The client that requested the spawn.

entity_type: u16

Which entity type to spawn.

x: f32

Position X

y: f32

Position Y

rot: f32

Initial rotation

ClearWorld

A command to clear all entities from the world (Phase 1/Playground only).

Fields

client_id: ClientId

The client that requested the clear.

Disconnected(ClientId)

A local event indicating the client transport has been disconnected.

Implementations

impl NetworkEvent

pub const fn is_wire(&self) -> bool

Returns true if this event is capable of being sent over the wire.

Trait Implementations

impl Clone for NetworkEvent

fn clone(&self) -> NetworkEvent

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for NetworkEvent

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for NetworkEvent

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for NetworkEvent

fn eq(&self, other: &NetworkEvent) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for NetworkEvent

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for NetworkEvent