laminar 0.5.0

A simple semi-reliable UDP protocol for multiplayer games
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66

#[cfg(feature = "tester")]
use std::net::SocketAddr;
#[cfg(feature = "tester")]
use std::{thread, time::Duration};

#[cfg(feature = "tester")]
use log::debug;

#[cfg(feature = "tester")]
use common::{client_addr, Client, Server, ServerEvent};
#[cfg(feature = "tester")]
use laminar::{DeliveryGuarantee, OrderingGuarantee, Packet};

#[cfg(feature = "tester")]
mod common;

#[test]
#[cfg(feature = "tester")]
fn send_receive_fragment_packets() {
    let listen_addr: SocketAddr = "127.0.0.1:12346".parse().unwrap();
    let client_addr = client_addr();

    let server = Server::new(listen_addr);

    let client = Client::new(Duration::from_millis(1), 5000);

    let assert_function = move |packet: Packet| {
        assert_eq!(packet.order_guarantee(), OrderingGuarantee::None);
        assert_eq!(packet.delivery_guarantee(), DeliveryGuarantee::Reliable);
        assert_eq!(packet.payload(), payload().as_slice());
    };

    let packet_factory = move || -> Packet { Packet::reliable_unordered(listen_addr, payload()) };

    let server_handle = server.start_receiving(assert_function);

    client
        .run_instance(packet_factory, client_addr)
        .wait_until_finished();

    // give the server time to process all packets.
    thread::sleep(Duration::from_millis(500));

    server_handle.shutdown();

    for event in server_handle.iter_events().collect::<Vec<ServerEvent>>() {
        match event {
            ServerEvent::Throughput(throughput) => {
                debug!("Throughput: {}", throughput);
            }
            ServerEvent::AverageThroughput(avg_throughput) => {
                debug!("Avg. Throughput: {}", avg_throughput);
            }
            ServerEvent::TotalSent(total) => {
                debug!("Total Packets Received {}", total);
            }
            _ => debug!("Not handled!"),
        }
    }

    server_handle.wait_until_finished();
}

pub fn payload() -> Vec<u8> {
    vec![0; 4000]
}