Renetcode

https://docs.rs/renetcode/2.0.0
Admin
Renetcode is a secure, connection-based client/server protocol for games using UDP, implementing the...
Tokens:135,460
Snippets:1,112
Trust Score:9.1
Update:4 months ago
Show doc for...
Tokens:
Raw
### Client Connection and Packet Processing Example

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeClient.html?search=

This example demonstrates how to set up a NetcodeClient, handle user input, send messages to the server, and process incoming packets. It includes logic for managing connection state and handling network I/O.

```rust
170fn client(authentication: ClientAuthentication) {
171    let udp_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
172    udp_socket.set_nonblocking(true).unwrap();
173    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
174    let mut client = NetcodeClient::new(now, authentication).unwrap();
175    let stdin_channel = spawn_stdin_channel();
176    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];
177
178    let mut last_updated = Instant::now();
179    loop {
180        if let Some(err) = client.disconnect_reason() {
181            panic!("Client error: {:?}", err);
182        }
183
184        match stdin_channel.try_recv() {
185            Ok(text) => {
186                if client.is_connected() {
187                    let (addr, payload) = client.generate_payload_packet(text.as_bytes()).unwrap();
188                    udp_socket.send_to(payload, addr).unwrap();
189                } else {
190                    println!("Client is not yet connected");
191                }
192            }
193            Err(TryRecvError::Empty) => {}
194            Err(TryRecvError::Disconnected) => panic!("Stdin channel disconnected"),
195        }
196
197        loop {
198            match udp_socket.recv_from(&mut buffer) {
199                Ok((len, addr)) => {
200                    if addr != client.server_addr() {
201                        // Ignore packets that are not from the server
202                        continue;
203                    }
204                    // println!("Received decrypted message {:?} from server {}", &buffer[..len], addr);
205                    if let Some(payload) = client.process_packet(&mut buffer[..len]) {
206                        let text = String::from_utf8(payload.to_vec()).unwrap();
207                        println!("Received message from server: {}", text);
208                    }
209                }
210                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
211                Err(e) => panic!("Socket error: {}", e),
212            };
213        }
214
215        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
216            udp_socket.send_to(packet, addr).unwrap();
217        }
218        last_updated = Instant::now();
219        thread::sleep(Duration::from_millis(50));
220    }
221}
```

--------------------------------

### Create an Example Calling a Function

Source: https://docs.rs/renetcode/2.0.0/scrape-examples-help.html

This example demonstrates how to call a documented item from a crate's source code, which Rustdoc will then include in the documentation.

```rust
// examples/ex.rs
fn main() {
  a_crate::a_func();
}
```

--------------------------------

### Rust NetcodeServer Example

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeServer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates a basic server setup, including binding a UDP socket, processing incoming packets, and sending messages to all connected clients. This snippet shows the core loop of a NetcodeServer application.

```rust
fn server(addr: SocketAddr, private_key: [u8; NETCODE_KEY_BYTES]) {
    let current_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let config = ServerConfig {
        current_time,
        max_clients: 16,
        protocol_id: PROTOCOL_ID,
        public_addresses: vec![addr],
        authentication: ServerAuthentication::Secure { private_key },
    };
    let mut server: NetcodeServer = NetcodeServer::new(config);
    let udp_socket = UdpSocket::bind(addr).unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let mut received_messages = vec![];
    let mut last_updated = Instant::now();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];
    let mut usernames: HashMap<u64, String> = HashMap::new();
    loop {
        server.update(Instant::now() - last_updated);
        received_messages.clear();

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    // println!("Received decrypted message {:?} from {}.", &buffer[..len], addr);
                    let server_result = server.process_packet(addr, &mut buffer[..len]);
                    handle_server_result(server_result, &udp_socket, &mut received_messages, &mut usernames);
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
                Err(e) => panic!("Socket error: {}", e),
            };
        }

        for text in received_messages.iter() {
            for client_id in server.clients_id().iter() {
                let (addr, payload) = server.generate_payload_packet(*client_id, text.as_bytes()).unwrap();
                udp_socket.send_to(payload, addr).unwrap();
            }
        }

        for client_id in server.clients_id().into_iter() {
            let server_result = server.update_client(client_id);
            handle_server_result(server_result, &udp_socket, &mut received_messages, &mut usernames);
        }

        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}
```

--------------------------------

### Rust NetcodeClient Example

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeClient.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates a basic client implementation using NetcodeClient in Rust. It handles sending and receiving messages over UDP, managing client connections, and processing packets. Ensure you have the necessary dependencies and setup for NetcodeClient.

```rust
fn client(authentication: ClientAuthentication) {
    let udp_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let mut client = NetcodeClient::new(now, authentication).unwrap();
    let stdin_channel = spawn_stdin_channel();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];

    let mut last_updated = Instant::now();
    loop {
        if let Some(err) = client.disconnect_reason() {
            panic!("Client error: {:?}", err);
        }

        match stdin_channel.try_recv() {
            Ok(text) => {
                if client.is_connected() {
                    let (addr, payload) = client.generate_payload_packet(text.as_bytes()).unwrap();
                    udp_socket.send_to(payload, addr).unwrap();
                } else {
                    println!("Client is not yet connected");
                }
            }
            Err(TryRecvError::Empty) => {}
            Err(TryRecvError::Disconnected) => panic!("Stdin channel disconnected"),
        }

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    if addr != client.server_addr() {
                        // Ignore packets that are not from the server
                        continue;
                    }
                    // println!("Received decrypted message {:?} from server {}", &buffer[..len], addr);
                    if let Some(payload) = client.process_packet(&mut buffer[..len]) {
                        let text = String::from_utf8(payload.to_vec()).unwrap();
                        println!("Received message from server: {}", text);
                    }
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
                Err(e) => panic!("Socket error: {}", e),
            };
        }

        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
            udp_socket.send_to(packet, addr).unwrap();
        }
        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}
```

--------------------------------

### NetcodeClient Connection and Packet Handling Example

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeClient.html?search=u32+-%3E+bool

This example demonstrates how to initialize a NetcodeClient, send messages, process received packets, and handle disconnections. It requires setting up a UDP socket and a stdin channel for user input.

```rust
fn client(authentication: ClientAuthentication) {
    let udp_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let mut client = NetcodeClient::new(now, authentication).unwrap();
    let stdin_channel = spawn_stdin_channel();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];

    let mut last_updated = Instant::now();
    loop {
        if let Some(err) = client.disconnect_reason() {
            panic!("Client error: {:?}", err);
        }

        match stdin_channel.try_recv() {
            Ok(text) => {
                if client.is_connected() {
                    let (addr, payload) = client.generate_payload_packet(text.as_bytes()).unwrap();
                    udp_socket.send_to(payload, addr).unwrap();
                } else {
                    println!("Client is not yet connected");
                }
            }
            Err(TryRecvError::Empty) => {} // Ignore empty
            Err(TryRecvError::Disconnected) => panic!("Stdin channel disconnected"),
        }

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    if addr != client.server_addr() {
                        // Ignore packets that are not from the server
                        continue;
                    }
                    // println!("Received decrypted message {:?} from server {}", &buffer[..len], addr);
                    if let Some(payload) = client.process_packet(&mut buffer[..len]) {
                        let text = String::from_utf8(payload.to_vec()).unwrap();
                        println!("Received message from server: {}", text);
                    }
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break, // Socket would block
                Err(e) => panic!("Socket error: {}", e),
            };
        }

        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
            udp_socket.send_to(packet, addr).unwrap();
        }
        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}
```

--------------------------------

### Client Example: Processing Server Packets

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeClient.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates how to set up a client, receive data from the server, and process it using `NetcodeClient::process_packet`. It handles UDP socket operations and non-blocking reads.

```rust
fn client(authentication: ClientAuthentication) {
    let udp_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let mut client = NetcodeClient::new(now, authentication).unwrap();
    let stdin_channel = spawn_stdin_channel();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];

    let mut last_updated = Instant::now();
    loop {
        if let Some(err) = client.disconnect_reason() {
            panic!("Client error: {:?}", err);
        }

        match stdin_channel.try_recv() {
            Ok(text) => {
                if client.is_connected() {
                    let (addr, payload) = client.generate_payload_packet(text.as_bytes()).unwrap();
                    udp_socket.send_to(payload, addr).unwrap();
                } else {
                    println!("Client is not yet connected");
                }
            }
            Err(TryRecvError::Empty) => {} // Ignore empty
            Err(TryRecvError::Disconnected) => panic!("Stdin channel disconnected"),
        }

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    if addr != client.server_addr() {
                        // Ignore packets that are not from the server
                        continue;
                    }
                    // println!("Received decrypted message {:?} from server {}", &buffer[..len], addr);
                    if let Some(payload) = client.process_packet(&mut buffer[..len]) {
                        let text = String::from_utf8(payload.to_vec()).unwrap();
                        println!("Received message from server: {}", text);
                    }
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break, // Non-blocking socket
                Err(e) => panic!("Socket error: {}", e),
            };
        }

        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
            udp_socket.send_to(packet, addr).unwrap();
        }
        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}
```

--------------------------------

### NetcodeClient Example: Echo Client

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeClient.html?search=

This example demonstrates a basic echo client using NetcodeClient. It binds a UDP socket, handles user input for sending messages, processes incoming packets from the server, and updates the client state. Ensure you have a running server to connect to.

```rust
fn client(authentication: ClientAuthentication) {
    let udp_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let mut client = NetcodeClient::new(now, authentication).unwrap();
    let stdin_channel = spawn_stdin_channel();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];

    let mut last_updated = Instant::now();
    loop {
        if let Some(err) = client.disconnect_reason() {
            panic!("Client error: {:?}", err);
        }

        match stdin_channel.try_recv() {
            Ok(text) => {
                if client.is_connected() {
                    let (addr, payload) = client.generate_payload_packet(text.as_bytes()).unwrap();
                    udp_socket.send_to(payload, addr).unwrap();
                } else {
                    println!("Client is not yet connected");
                }
            }
            Err(TryRecvError::Empty) => {} // Ignore empty messages
            Err(TryRecvError::Disconnected) => panic!("Stdin channel disconnected"),
        }

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    if addr != client.server_addr() {
                        // Ignore packets that are not from the server
                        continue;
                    }
                    // println!("Received decrypted message {:?} from server {}", &buffer[..len], addr);
                    if let Some(payload) = client.process_packet(&mut buffer[..len]) {
                        let text = String::from_utf8(payload.to_vec()).unwrap();
                        println!("Received message from server: {}", text);
                    }
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break, // No more packets to read
                Err(e) => panic!("Socket error: {}", e),
            };
        }

        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
            udp_socket.send_to(packet, addr).unwrap();
        }
        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}
```

--------------------------------

### NetcodeClient Example: Echo Client

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeClient.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates a basic echo client using NetcodeClient for UDP communication. It handles sending messages from stdin, receiving and processing packets from the server, and updating the client state. Ensure you have a running server to test this client.

```rust
fn client(authentication: ClientAuthentication) {
    let udp_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let mut client = NetcodeClient::new(now, authentication).unwrap();
    let stdin_channel = spawn_stdin_channel();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];

    let mut last_updated = Instant::now();
    loop {
        if let Some(err) = client.disconnect_reason() {
            panic!("Client error: {:?}", err);
        }

        match stdin_channel.try_recv() {
            Ok(text) => {
                if client.is_connected() {
                    let (addr, payload) = client.generate_payload_packet(text.as_bytes()).unwrap();
                    udp_socket.send_to(payload, addr).unwrap();
                } else {
                    println!("Client is not yet connected");
                }
            }
            Err(TryRecvError::Empty) => {}
            Err(TryRecvError::Disconnected) => panic!("Stdin channel disconnected"),
        }

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    if addr != client.server_addr() {
                        // Ignore packets that are not from the server
                        continue;
                    }
                    // println!("Received decrypted message {:?} from server {}", &buffer[..len], addr);
                    if let Some(payload) = client.process_packet(&mut buffer[..len]) {
                        let text = String::from_utf8(payload.to_vec()).unwrap();
                        println!("Received message from server: {}", text);
                    }
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
                Err(e) => panic!("Socket error: {}", e),
            };
        }

        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
            udp_socket.send_to(packet, addr).unwrap();
        }
        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}

```

--------------------------------

### Initialize NetcodeServer

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeServer.html?search=std%3A%3Avec

Creates a new NetcodeServer instance with the provided configuration. This is the primary way to start a server.

```rust
let config = ServerConfig {
    current_time,
    max_clients: 16,
    protocol_id: PROTOCOL_ID,
    public_addresses: vec![addr],
    authentication: ServerAuthentication::Secure { private_key },
};
let mut server: NetcodeServer = NetcodeServer::new(config);
```

--------------------------------

### NetcodeClient Example Loop

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeClient.html?search=u32+-%3E+bool

This example demonstrates a typical client loop for NetcodeClient. It handles sending user input as encrypted packets and processing received packets from the server. Ensure the client is initialized with valid authentication and the UDP socket is properly bound and set to non-blocking.

```rust
fn client(authentication: ClientAuthentication) {
    let udp_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let mut client = NetcodeClient::new(now, authentication).unwrap();
    let stdin_channel = spawn_stdin_channel();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];

    let mut last_updated = Instant::now();
    loop {
        if let Some(err) = client.disconnect_reason() {
            panic!("Client error: {:?}", err);
        }

        match stdin_channel.try_recv() {
            Ok(text) => {
                if client.is_connected() {
                    let (addr, payload) = client.generate_payload_packet(text.as_bytes()).unwrap();
                    udp_socket.send_to(payload, addr).unwrap();
                } else {
                    println!("Client is not yet connected");
                }
            }
            Err(TryRecvError::Empty) => {} // Ignore empty messages
            Err(TryRecvError::Disconnected) => panic!("Stdin channel disconnected"),
        }

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    if addr != client.server_addr() {
                        // Ignore packets that are not from the server
                        continue;
                    }
                    // println!("Received decrypted message {:?}", &buffer[..len]);
                    if let Some(payload) = client.process_packet(&mut buffer[..len]) {
                        let text = String::from_utf8(payload.to_vec()).unwrap();
                        println!("Received message from server: {}", text);
                    }
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break, // No more data to read
                Err(e) => panic!("Socket error: {}", e),
            };
        }

        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
            udp_socket.send_to(packet, addr).unwrap();
        }
        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}
```

--------------------------------

### NetcodeClient Example: Echo Client

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeClient.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

This example demonstrates a basic echo client using NetcodeClient. It binds a UDP socket, generates payload packets from stdin, sends them to the server, and processes incoming packets from the server. Use this for understanding client-side network communication flow.

```rust
fn client(authentication: ClientAuthentication) {
    let udp_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let mut client = NetcodeClient::new(now, authentication).unwrap();
    let stdin_channel = spawn_stdin_channel();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];

    let mut last_updated = Instant::now();
    loop {
        if let Some(err) = client.disconnect_reason() {
            panic!("Client error: {:?}", err);
        }

        match stdin_channel.try_recv() {
            Ok(text) => {
                if client.is_connected() {
                    let (addr, payload) = client.generate_payload_packet(text.as_bytes()).unwrap();
                    udp_socket.send_to(payload, addr).unwrap();
                } else {
                    println!("Client is not yet connected");
                }
            }
            Err(TryRecvError::Empty) => {} // Ignore empty messages
            Err(TryRecvError::Disconnected) => panic!("Stdin channel disconnected"),
        }

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    if addr != client.server_addr() {
                        // Ignore packets that are not from the server
                        continue;
                    }
                    // println!("Received decrypted message {:?}", &buffer[..len]);
                    if let Some(payload) = client.process_packet(&mut buffer[..len]) {
                        let text = String::from_utf8(payload.to_vec()).unwrap();
                        println!("Received message from server: {}", text);
                    }
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break, // No more packets to read
                Err(e) => panic!("Socket error: {}", e),
            };
        }

        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
            udp_socket.send_to(packet, addr).unwrap();
        }
        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}
```

--------------------------------

### Generate ConnectToken Example

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.ConnectToken.html?search=

Demonstrates how to generate a ConnectToken for client authentication. Ensure the private key and protocol ID match the server's configuration.

```rust
let connect_token = ConnectToken::generate(
    now,
    PROTOCOL_ID,
    300,
    client_id,
    15,
    vec![server_addr],
    Some(&username.to_netcode_user_data()),
    private_key,
)
.unwrap();
```

--------------------------------

### Example: Iterating and Updating Clients

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=std%3A%3Avec

Demonstrates how to iterate through all connected client IDs, update each client using `update_client`, and handle the `ServerResult` to send packets or perform other actions.

```rust
use renetcode::ServerResult;
let mut server = renetcode::NetcodeServer::__test(); // Assuming a test constructor exists

for client_id in server.clients_id().into_iter() {
    match server.update_client(client_id) {
        ServerResult::PacketToSend { payload, addr } => send_to(payload, addr),
        _ => { /* ... handle other results ... */ }
    }
}

fn send_to(p: &[u8], addr: std::net::SocketAddr) {
    // Placeholder for actual network sending logic
    println!("Sending packet to {:?}", addr);
}
```

--------------------------------

### Connect Token Serialization and Deserialization Example

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/token.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates generating a connect token, serializing it into a buffer, and then deserializing it back. It also shows how to decode and verify the private data of the token.

```rust
    #[test]
    fn connect_token_serialization() {
        let server_addresses: Vec<SocketAddr> = vec!["127.0.0.1:8080".parse().unwrap(), "127.0.0.2:3000".parse().unwrap()];
        let user_data = generate_random_bytes();
        let private_key = b"an example very very secret key."; // 32-bytes
        let protocol_id = 2;
        let expire_seconds = 3;
        let client_id = 4;
        let timeout_seconds = 5;
        let token = ConnectToken::generate(
            Duration::ZERO,
            protocol_id,
            expire_seconds,
            client_id,
            timeout_seconds,
            server_addresses,
            Some(&user_data),
            private_key,
        )
        .unwrap();

        let mut buffer: Vec<u8> = vec![];
        token.write(&mut buffer).unwrap();

        let result = ConnectToken::read(&mut buffer.as_slice()).unwrap();
        assert_eq!(token, result);

        let private = PrivateConnectToken::decode(
            &result.private_data,
            protocol_id,
            result.expire_timestamp,
            &result.xnonce,
            private_key,
        )
        .unwrap();
        assert_eq!(timeout_seconds, private.timeout_seconds);
        assert_eq!(client_id, private.client_id);
        assert_eq!(user_data, private.user_data);
        assert_eq!(token.server_addresses, private.server_addresses);
        assert_eq!(token.client_to_server_key, private.client_to_server_key);
        assert_eq!(token.server_to_client_key, private.server_to_client_key);
    }
```

--------------------------------

### Get Server Public Addresses

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=std%3A%3Avec

Returns a clone of the server's public addresses.

```rust
pub fn addresses(&self) -> Vec<SocketAddr> {
        self.public_addresses.clone()
    }
```

--------------------------------

### Initialize NetcodeClient

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeClient.html

Creates a new NetcodeClient instance. This is typically done at the start of a client application. Ensure you provide the current time and valid client authentication details.

```rust
170fn client(authentication: ClientAuthentication) {
171    let udp_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
172    udp_socket.set_nonblocking(true).unwrap();
173    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
174    let mut client = NetcodeClient::new(now, authentication).unwrap();
175    let stdin_channel = spawn_stdin_channel();
176    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];
177
178    let mut last_updated = Instant::now();
179    loop {
180        if let Some(err) = client.disconnect_reason() {
181            panic!("Client error: {:?}", err);
182        }
183
184        match stdin_channel.try_recv() {
185            Ok(text) => {
186                if client.is_connected() {
187                    let (addr, payload) = client.generate_payload_packet(text.as_bytes()).unwrap();
188                    udp_socket.send_to(payload, addr).unwrap();
189                } else {
190                    println!("Client is not yet connected");
191                }
192            }
193            Err(TryRecvError::Empty) => {} 
194            Err(TryRecvError::Disconnected) => panic!("Stdin channel disconnected"),
195        }
196
197        loop {
198            match udp_socket.recv_from(&mut buffer) {
199                Ok((len, addr)) => {
200                    if addr != client.server_addr() {
201                        // Ignore packets that are not from the server
202                        continue;
203                    }
204                    // println!("Received decrypted message {:?} from server {}", &buffer[..len], addr);
205                    if let Some(payload) = client.process_packet(&mut buffer[..len]) {
206                        let text = String::from_utf8(payload.to_vec()).unwrap();
207                        println!("Received message from server: {}", text);
208                    }
209                }
210                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
211                Err(e) => panic!("Socket error: {}", e),
212            };
213        }
214
215        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
216            udp_socket.send_to(packet, addr).unwrap();
217        }
218        last_updated = Instant::now();
219        thread::sleep(Duration::from_millis(50));
220    }
221}
```

--------------------------------

### NetcodeServer::new

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeServer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Initializes a new NetcodeServer instance with the provided configuration. This is the entry point for setting up the server.

```APIDOC
## NetcodeServer::new

### Description
Initializes a new NetcodeServer instance with the provided configuration. This is the entry point for setting up the server.

### Method
`new`

### Signature
`pub fn new(config: ServerConfig) -> Self`

### Parameters
#### Path Parameters
- **config** (ServerConfig) - Required - The configuration object for the server, including timing, client limits, protocol ID, addresses, and authentication settings.
```

--------------------------------

### Update Client and Get Server Result

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Processes updates for a specific client and returns a `ServerResult` indicating the outcome, such as packets to send or connection status changes. Includes an example of how to iterate through clients and handle their results.

```APIDOC
## update_client

### Description
Updates the client, returns a ServerResult.

### Method
`update_client(client_id: u64)`

### Parameters
#### Path Parameters
- **client_id** (u64) - Required - The ID of the client to update.

### Returns
- `ServerResult`: An enum variant indicating the result of the update (e.g., `ServerResult::PacketToSend`, `ServerResult::None`).

### Example
```rust
# use renetcode::ServerResult;
# use std::time::Duration;
# fn send_to(p: &[u8], addr: std::net::SocketAddr) {}
# struct NetcodeServer { clients: Vec<Option<renetcode::Client>>, max_clients: usize, current_time: Duration, pending_clients: std::collections::HashMap<u64, renetcode::PendingClient>, protocol_id: u64, out: Vec<u8> } 
# impl NetcodeServer { 
#   pub fn __test() -> Self { unimplemented!() } 
#   pub fn clients_id(&self) -> Vec<u64> { vec![1, 2] } 
#   pub fn update_client(&mut self, client_id: u64) -> ServerResult { ServerResult::None } 
# }
# let mut server = NetcodeServer { clients: vec![Some(renetcode::Client{client_id: 1, state: renetcode::ConnectionState::Connected, user_data: [0u8; 32], last_packet_send_time: Duration::ZERO, sequence: 0, send_key: [0u8; 32], receive_key: [0u8; 32], client_id_from_server: 1}), Some(renetcode::Client{client_id: 2, state: renetcode::ConnectionState::Connected, user_data: [0u8; 32], last_packet_send_time: Duration::ZERO, sequence: 0, send_key: [0u8; 32], receive_key: [0u8; 32], client_id_from_server: 2})], max_clients: 10, current_time: Duration::ZERO, pending_clients: std::collections::HashMap::new(), protocol_id: 123, out: vec![0u8; 1024] };
for client_id in server.clients_id().into_iter() {
    match server.update_client(client_id) {
        ServerResult::PacketToSend { payload, addr } => send_to(payload, addr),
        _ => { /* ... */ }
    }
}
```
```

--------------------------------

### Run a Basic Echo Server

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeServer.html?search=std%3A%3Avec

An example demonstrating how to set up a UDP socket, bind it to an address, and run a continuous loop to process incoming packets and send responses using NetcodeServer. It handles packet reception, processing, and sending.

```rust
fn server(addr: SocketAddr, private_key: [u8; NETCODE_KEY_BYTES]) {
    let current_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let config = ServerConfig {
        current_time,
        max_clients: 16,
        protocol_id: PROTOCOL_ID,
        public_addresses: vec![addr],
        authentication: ServerAuthentication::Secure { private_key },
    };
    let mut server: NetcodeServer = NetcodeServer::new(config);
    let udp_socket = UdpSocket::bind(addr).unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let mut received_messages = vec![];
    let mut last_updated = Instant::now();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];
    let mut usernames: HashMap<u64, String> = HashMap::new();
    loop {
        server.update(Instant::now() - last_updated);
        received_messages.clear();

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    // println!("Received decrypted message {:?}
 from {}.
", &buffer[..len], addr);
                    let server_result = server.process_packet(addr, &mut buffer[..len]);
                    handle_server_result(server_result, &udp_socket, &mut received_messages, &mut usernames);
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
                Err(e) => panic!("Socket error: {}
", e),
            };
        }

        for text in received_messages.iter() {
            for client_id in server.clients_id().iter() {
                let (addr, payload) = server.generate_payload_packet(*client_id, text.as_bytes()).unwrap();
                udp_socket.send_to(payload, addr).unwrap();
            }
        }

        for client_id in server.clients_id().into_iter() {
            let server_result = server.update_client(client_id);
            handle_server_result(server_result, &udp_socket, &mut received_messages, &mut usernames);
        }

        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}
```

--------------------------------

### Update Client and Get Server Result

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=u32+-%3E+bool

Processes updates for a specific client and returns a `ServerResult`. This method is used to handle client-specific logic and potential packet transmissions. The example shows how to iterate through clients and process their results.

```APIDOC
## update_client

### Description
Updates the state for a given client and returns a `ServerResult` which may contain packets to send or other status information.

### Method
`update_client(&mut self, client_id: u64) -> ServerResult`

### Parameters
#### Path Parameters
- `client_id` (u64): The unique identifier of the client to update.

### Returns
- `ServerResult`: An enum variant indicating the outcome of the update, such as `ServerResult::PacketToSend` or `ServerResult::None`.

### Example
```rust
# use renetcode::ServerResult;
# use std::time::Duration;
# struct NetcodeServer { clients: Vec<Option<renetcode::Client>>, current_time: Duration, pending_clients: std::collections::HashMap<u64, renetcode::PendingClient>, max_clients: usize, protocol_id: u64, out: Vec<u8> };
# impl NetcodeServer {
#   pub fn __test() -> Self { NetcodeServer { clients: vec![Some(renetcode::Client{client_id: 1, state: renetcode::ConnectionState::Connected, user_data: [0u8; 1024], last_packet_send_time: Duration::ZERO, sequence: 0, send_key: [0u8; 4], receive_key: [0u8; 4] })], current_time: Duration::ZERO, pending_clients: std::collections::HashMap::new(), max_clients: 10, protocol_id: 1, out: vec![0u8; 1024] } }
#   pub fn clients_id(&self) -> Vec<u64> { self.clients.iter().filter_map(|slot| slot.as_ref().map(|client| client.client_id)) }
#   pub fn update_client(&mut self, client_id: u64) -> ServerResult { ServerResult::PacketToSend { payload: &mut self.out[..10], addr: "127.0.0.1:1234".parse().unwrap() } }
# }
# fn send_to(p: &[u8], addr: std::net::SocketAddr) {}
let mut server = NetcodeServer::__test();

for client_id in server.clients_id().into_iter() {
    match server.update_client(client_id) {
        ServerResult::PacketToSend { payload, addr } => send_to(payload, addr),
        _ => { /* Handle other results */ }
    }
}
```
```

--------------------------------

### Server Configuration and Initialization

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=std%3A%3Avec

Constructs a new Server instance with the provided configuration. It initializes client data structures, protocol information, and authentication settings based on the ServerConfig.

```rust
pub fn new(config: ServerConfig) -> Self {
        let mut clients = Vec::new();
        clients.resize_with(config.max_clients, || Client::default());

        let connect_key = match config.authentication {
            ServerAuthentication::Unsecure => [0u8; NETCODE_CONNECT_KEY_BYTES],
            ServerAuthentication::Secure { private_key } => private_key,
        };

        let secure = match config.authentication {
            ServerAuthentication::Unsecure => false,
            ServerAuthentication::Secure { .. } => true,
        };

        Self {
            clients,
            connect_token_entries: Box::new([None; NETCODE_MAX_CLIENTS * 2]),
            pending_clients: HashMap::new(),
            protocol_id: config.protocol_id,
            connect_key,
            max_clients: config.max_clients,
            challenge_sequence: 0,
            global_sequence: 0,
            challenge_key,
            public_addresses: config.public_addresses,
            current_time: config.current_time,
            secure,
            out: [0u8; NETCODE_MAX_PACKET_BYTES],
        }
    }
```

--------------------------------

### Server Initialization

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=

Initializes a new NetcodeServer instance with the provided configuration. It generates a challenge key and sets up the client connection storage. Panics if the configured max clients exceed the system limit.

```rust
pub fn new(config: ServerConfig) -> Self {
        if config.max_clients > NETCODE_MAX_CLIENTS {
            // TODO: do we really need to set a max?
            //       only using for token entries
            panic!("The max clients allowed is {}", NETCODE_MAX_CLIENTS);
        }
        let challenge_key = generate_random_bytes();
        let clients = vec![None; config.max_clients].into_boxed_slice();

        let connect_key = match config.authentication {
            ServerAuthentication::Unsecure => [0; NETCODE_KEY_BYTES],

```

--------------------------------

### Any::type_id Implementation

Source: https://docs.rs/renetcode/2.0.0/renetcode/enum.TokenGenerationError.html

Gets the TypeId of the implementing type.

```rust
fn type_id(&self) -> TypeId
```

--------------------------------

### Server Configuration

Source: https://docs.rs/renetcode/2.0.0/src/echo/echo.rs.html?search=std%3A%3Avec

Sets up the server configuration including current time, maximum clients, protocol ID, public addresses, and authentication method.

```rust
let current_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
let config = ServerConfig {
    current_time,
    max_clients: 16,
    protocol_id: PROTOCOL_ID,
    public_addresses: vec![addr],
    authentication: ServerAuthentication::Secure { private_key },
};
```

--------------------------------

### Server Initialization

Source: https://docs.rs/renetcode/2.0.0/src/echo/echo.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Configures and initializes the RenetCode server with essential parameters like protocol ID, maximum clients, and authentication details.

```rust
fn server(addr: SocketAddr, private_key: [u8; NETCODE_KEY_BYTES]) {
    let current_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let config = ServerConfig {
        current_time,
        max_clients: 16,
        protocol_id: PROTOCOL_ID,
        public_addresses: vec![addr],
        authentication: ServerAuthentication::Secure { private_key },
    };
}
```

--------------------------------

### NetcodeServer::current_time

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeServer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Gets the current time as maintained by the server.

```APIDOC
## NetcodeServer::current_time

### Description
Gets the current time as maintained by the server.

### Method
`current_time`

### Signature
`pub fn current_time(&self) -> Duration`

### Returns
- **Duration** - The current time duration.
```

--------------------------------

### Server Initialization

Source: https://docs.rs/renetcode/2.0.0/src/echo/echo.rs.html?search=

Configures and initializes the RenetCode server with essential parameters like protocol ID, public addresses, and authentication method.

```Rust
fn server(addr: SocketAddr, private_key: [u8; NETCODE_KEY_BYTES]) {
    let current_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let config = ServerConfig {
        current_time,
        max_clients: 16,
        protocol_id: PROTOCOL_ID,
        public_addresses: vec![addr],
        authentication: ServerAuthentication::Secure { private_key },
    };
    // ... rest of server implementation
```

--------------------------------

### Get Packet ID

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/packet.rs.html

Returns the byte identifier for the packet type.

```Rust
    pub fn id(&self) -> u8 {
        self.packet_type() as u8
    }
}
```

--------------------------------

### Get Maximum Clients

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the maximum number of clients that can be connected to the server.

```APIDOC
## max_clients

### Description
Returns the maximum number of clients that can be connected.

### Method
`max_clients()`

### Returns
- `usize`: The maximum number of clients allowed.
```

--------------------------------

### Get Maximum Clients

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the maximum number of clients that can be connected to the server.

```rust
    pub fn max_clients(&self) -> usize {
        self.max_clients
    }
```

--------------------------------

### NetcodeServer Initialization and Update Loop

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeServer.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to initialize a NetcodeServer and its main update loop for processing incoming UDP packets, generating outgoing packets, and managing client connections. Requires setting up a UDP socket and handling potential IO errors.

```rust
fn server(addr: SocketAddr, private_key: [u8; NETCODE_KEY_BYTES]) {
    let current_time = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let config = ServerConfig {
        current_time,
        max_clients: 16,
        protocol_id: PROTOCOL_ID,
        public_addresses: vec![addr],
        authentication: ServerAuthentication::Secure { private_key },
    };
    let mut server: NetcodeServer = NetcodeServer::new(config);
    let udp_socket = UdpSocket::bind(addr).unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let mut received_messages = vec![];
    let mut last_updated = Instant::now();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];
    let mut usernames: HashMap<u64, String> = HashMap::new();
    loop {
        server.update(Instant::now() - last_updated);
        received_messages.clear();

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    // println!("Received decrypted message {:?}", &buffer[..len]);
                    let server_result = server.process_packet(addr, &mut buffer[..len]);
                    handle_server_result(server_result, &udp_socket, &mut received_messages, &mut usernames);
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
                Err(e) => panic!("Socket error: {}", e),
            };
        }

        for text in received_messages.iter() {
            for client_id in server.clients_id().iter() {
                let (addr, payload) = server.generate_payload_packet(*client_id, text.as_bytes()).unwrap();
                udp_socket.send_to(payload, addr).unwrap();
            }
        }

        for client_id in server.clients_id().into_iter() {
            let server_result = server.update_client(client_id);
            handle_server_result(server_result, &udp_socket, &mut received_messages, &mut usernames);
        }

        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}
```

--------------------------------

### Get Connected Client Count

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Returns the current number of clients that are connected to the server.

```APIDOC
## connected_clients

### Description
Returns current number of clients connected.

### Method
`connected_clients()`

### Returns
- `usize`: The number of currently connected clients.
```

--------------------------------

### Initializing a NetcodeClient

Source: https://docs.rs/renetcode/2.0.0/renetcode/struct.NetcodeClient.html?search=Option%3CT%3E%2C+%28T+-%3E+U%29+-%3E+Option%3CU%3E

Demonstrates how to create and initialize a NetcodeClient instance. This is typically done at the start of a client application to establish a secure connection. Ensure the UDP socket is set to non-blocking mode before creating the client.

```rust
170fn client(authentication: ClientAuthentication) {
    let udp_socket = UdpSocket::bind("127.0.0.1:0").unwrap();
    udp_socket.set_nonblocking(true).unwrap();
    let now = SystemTime::now().duration_since(UNIX_EPOCH).unwrap();
    let mut client = NetcodeClient::new(now, authentication).unwrap();
    let stdin_channel = spawn_stdin_channel();
    let mut buffer = [0u8; NETCODE_MAX_PACKET_BYTES];

    let mut last_updated = Instant::now();
    loop {
        if let Some(err) = client.disconnect_reason() {
            panic!("Client error: {:?}", err);
        }

        match stdin_channel.try_recv() {
            Ok(text) => {
                if client.is_connected() {
                    let (addr, payload) = client.generate_payload_packet(text.as_bytes()).unwrap();
                    udp_socket.send_to(payload, addr).unwrap();
                } else {
                    println!("Client is not yet connected");
                }
            }
            Err(TryRecvError::Empty) => {}
            Err(TryRecvError::Disconnected) => panic!("Stdin channel disconnected"),
        }

        loop {
            match udp_socket.recv_from(&mut buffer) {
                Ok((len, addr)) => {
                    if addr != client.server_addr() {
                        // Ignore packets that are not from the server
                        continue;
                    }
                    // println!("Received decrypted message {:?}", &buffer[..len], addr);
                    if let Some(payload) = client.process_packet(&mut buffer[..len]) {
                        let text = String::from_utf8(payload.to_vec()).unwrap();
                        println!("Received message from server: {}", text);
                    }
                }
                Err(ref e) if e.kind() == std::io::ErrorKind::WouldBlock => break,
                Err(e) => panic!("Socket error: {}", e),
            };
        }

        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
            udp_socket.send_to(packet, addr).unwrap();
        }
        last_updated = Instant::now();
        thread::sleep(Duration::from_millis(50));
    }
}

```

--------------------------------

### Get Maximum Clients

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=std%3A%3Avec

Returns the maximum number of clients that the server is configured to support.

```rust
pub fn max_clients(&self) -> usize {
        self.max_clients
    }
```

--------------------------------

### Get Maximum Clients

Source: https://docs.rs/renetcode/2.0.0/src/renetcode/server.rs.html?search=

Returns the maximum number of clients that can be connected to the server simultaneously.

```APIDOC
## max_clients

### Description
Returns the maximum number of clients that the server is configured to allow.

### Method
`max_clients(&self) -> usize`

### Parameters
None

### Response
- `usize`: The maximum number of clients allowed.
```
Tokens:
Raw