Struct amethyst_network::NetPacket

pub struct NetPacket<T> { /* fields omitted */ }

Represents a packet which could have any serializable payload.

A packet could have reliability guarantees to specify how it should be delivered and processed.

Reliability Type	Packet Drop	Packet Duplication	Packet Order	Packet Fragmentation	Packet Delivery
Unreliable Unordered	Yes	Yes	No	No	No
Unreliable Sequenced	Yes	No	Sequenced	No	No
Reliable Unordered	No	No	No	Yes	Yes
Reliable Ordered	No	No	Ordered	Yes	Yes
Reliable Sequenced	No	No	Sequenced	Yes	Yes

You are able to send packets with any the above guarantees.

For more information please have a look at: https://amethyst.github.io/laminar/docs/reliability/reliability.html

Methods

impl<T> NetPacket<T>

pub fn unreliable(content: T) -> NetPacket<T>

Create a new unreliable packet with the given content.

Unreliable: Packets can be dropped, duplicated or arrive without order.

Details

Packet Drop	Packet Duplication	Packet Order	Packet Fragmentation	Packet Delivery
Yes	Yes	No	No	No

Basically just bare UDP. The packet may or may not be delivered.

pub fn unreliable_sequenced(content: T, stream_id: Option<u8>) -> NetPacket<T>

Create a new unreliable sequenced packet with the given content.

Unreliable Sequenced; Packets can be dropped, but could not be duplicated and arrive in sequence.

Details

Packet Drop	Packet Duplication	Packet Order	Packet Fragmentation	Packet Delivery
Yes	Yes	Sequenced	No	No

Basically just bare UDP, free to be dropped, but has some sequencing to it so that only the newest packets are kept.

pub fn reliable_unordered(content: T) -> NetPacket<T>

Create a new packet with the given content. Reliable; All packets will be sent and received, but without order.

Details

Packet Drop	Packet Duplication	Packet Order	Packet Fragmentation	Packet Delivery
No	No	No	Yes	Yes

Basically this is almost TCP without ordering of packets.

pub fn reliable_ordered(content: T, stream_id: Option<u8>) -> NetPacket<T>

Create a new packet with the given content and optional stream on which the ordering will be done.

Reliable; All packets will be sent and received, with order.

Details

Packet Drop	Packet Duplication	Packet Order	Packet Fragmentation	Packet Delivery
No	No	Ordered	Yes	Yes

Basically this is almost TCP-like with ordering of packets.

Remark

• When stream_id is specified as None the default stream will be used; if you are not sure what this is you can leave it at None.

pub fn reliable_sequenced(content: T, stream_id: Option<u8>) -> NetPacket<T>

Create a new packet with the given content and optional stream on which the sequencing will be done.

Reliable; All packets will be sent and received, but arranged in sequence. Which means that only the newest packets will be let through, older packets will be received but they won't get to the user.

Details

Packet Drop	Packet Duplication	Packet Order	Packet Fragmentation	Packet Delivery
Yes	No	Sequenced	Yes	Yes

Basically this is almost TCP-like but then sequencing instead of ordering.

Remark

• When stream_id is specified as None the default stream will be used; if you are not sure what this is you can leave it at None.

pub fn is_reliable(&self) -> bool

Returns if this event is reliable.

Each net event type is either reliable or unreliable. Reliable events always reach their destination, unreliable events may be lost.

pub fn is_unreliable(&self) -> bool

Returns if this event is unreliable.

Each net event type is either reliable or unreliable. Reliable events always reach their destination, unreliable events may be lost.

pub fn is_ordered(&self) -> bool

Returns whether this event is an ordered event.

pub fn is_sequenced(&self) -> bool

Returns whether this event is an sequenced event.

pub fn is_unordered(&self) -> bool

Return if this event is neither ordered or sequenced.

pub fn content(&self) -> &T

Returns a immutable reference to the content.

pub fn content_mut(&mut self) -> &mut T

Returns a immutable reference to the content.

Trait Implementations

impl<T: Clone> Clone for NetPacket<T>

fn clone(&self) -> NetPacket<T>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<T: PartialEq> PartialEq<NetPacket<T>> for NetPacket<T>

fn eq(&self, other: &NetPacket<T>) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &NetPacket<T>) -> bool

This method tests for !=.

impl<T: Debug> Debug for NetPacket<T>

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

Formats the value using the given formatter.

impl<T> Serialize for NetPacket<T> where
    T: Serialize, 

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

Serialize this value into the given Serde serializer.

impl<'de, T> Deserialize<'de> for NetPacket<T> where
    T: Deserialize<'de>, 

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error> where
    __D: Deserializer<'de>, 

Deserialize this value from the given Serde deserializer.