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
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144

use std::{collections::HashSet, net::SocketAddr, time::Instant};

#[cfg(feature = "tester")]
use laminar::LinkConditioner;
use laminar::{Config, Packet, Socket, SocketEvent};

#[test]
fn binding_to_any() {
    // bind to 10 different addresses
    let sock_without_config = (0..5).map(|_| Socket::bind_any());
    let sock_with_config = (0..5).map(|_| Socket::bind_any_with_config(Config::default()));

    let valid_socks: Vec<_> = sock_without_config
        .chain(sock_with_config)
        .filter_map(|sock| sock.ok())
        .collect();
    assert_eq!(valid_socks.len(), 10);

    let unique_addresses: HashSet<_> = valid_socks
        .into_iter()
        .map(|sock| sock.local_addr().unwrap())
        .collect();
    assert_eq!(unique_addresses.len(), 10);
}

#[test]
fn blocking_sender_and_receiver() {
    let cfg = Config::default();

    let mut client = Socket::bind_any_with_config(cfg.clone()).unwrap();
    let mut server = Socket::bind_any_with_config(Config {
        blocking_mode: true,
        ..cfg
    })
    .unwrap();

    let server_addr = server.local_addr().unwrap();

    let time = Instant::now();

    client
        .send(Packet::unreliable(server_addr, b"Hello world!".to_vec()))
        .unwrap();

    client.manual_poll(time);
    server.manual_poll(time);

    if let SocketEvent::Packet(packet) = server.recv().unwrap() {
        assert_eq![b"Hello world!", packet.payload()];
    } else {
        panic!["Did not receive a packet when it should"];
    }
}

#[test]
fn local_addr() {
    let port = 40000;
    let socket =
        Socket::bind(format!("127.0.0.1:{}", port).parse::<SocketAddr>().unwrap()).unwrap();
    assert_eq!(port, socket.local_addr().unwrap().port());
}

#[test]
#[cfg(feature = "tester")]
fn use_link_conditioner() {
    let mut client = Socket::bind_any().unwrap();
    let mut server = Socket::bind_any().unwrap();

    let server_addr = server.local_addr().unwrap();

    let link_conditioner = {
        let mut lc = LinkConditioner::new();
        lc.set_packet_loss(1.0);
        Some(lc)
    };

    client.set_link_conditioner(link_conditioner);
    client
        .send(Packet::unreliable(server_addr, b"Hello world!".to_vec()))
        .unwrap();

    let time = Instant::now();
    client.manual_poll(time);
    server.manual_poll(time);

    assert_eq!(server.recv().is_none(), true);
}

#[test]
#[cfg(feature = "tester")]
fn poll_in_thread() {
    use std::thread;
    let mut server = Socket::bind_any().unwrap();
    let mut client = Socket::bind_any().unwrap();
    let server_addr = server.local_addr().unwrap();

    // get sender and receiver from server, and start polling in separate thread
    let (sender, receiver) = (server.get_packet_sender(), server.get_event_receiver());
    let _thread = thread::spawn(move || server.start_polling());

    // server will responde to this
    client
        .send(Packet::reliable_unordered(server_addr, b"Hello!".to_vec()))
        .expect("This should send");
    // this will break the loop
    client
        .send(Packet::reliable_unordered(server_addr, b"Bye!".to_vec()))
        .expect("This should send");
    client.manual_poll(Instant::now());

    // listen for received server messages, and break when "Bye!" is received.
    loop {
        if let Ok(event) = receiver.recv() {
            if let SocketEvent::Packet(packet) = event {
                let msg = packet.payload();

                if msg == b"Bye!" {
                    break;
                }

                sender
                    .send(Packet::reliable_unordered(
                        packet.addr(),
                        b"Hi, there!".to_vec(),
                    ))
                    .expect("This should send");
            }
        }
    }
    // loop until we get response from server.
    loop {
        client.manual_poll(Instant::now());
        if let Some(packet) = client.recv() {
            assert_eq!(
                packet,
                SocketEvent::Packet(Packet::reliable_unordered(
                    server_addr,
                    b"Hi, there!".to_vec()
                ))
            );
            break;
        }
    }
}