Could not get the examples to work

[i4lina]

Hi, I've been attempting to set up a small server-client using renet for a Bevy game. I began by following this tutorial, and everything worked fine. However, when I tried upgrading the crates to the latest version, I encountered issues with the networking.

I didn't receive any errors from renet, but the client wouldn't connect to the server. To troubleshoot, I decided to run an example of the latest version of the renet crate to ensure everything was functioning correctly. I attempted to run the example provided in the crate's readme (with added function declarations and imports), but it didn't work. Now, I'm encountering the error Netcode(Disconnected(ConnectionRequestTimedOut)) after unwrapping the transport.send_packets(&mut client); at the end of the loop in the client code, while the server is running in another terminal window.

I verified that both the server ID and the protocol ID were consistent between the client and the server. Additionally, I tried running the client as an administrator to rule out any permission-related issues.

Any suggestions on what I should do? Thanks!

[lucaspoffo]

Can you post the code, that you copied from the README. Will be easier do see why its not working

[i4lina]

Client code:

use std::{
    net::{SocketAddr, UdpSocket},
    time::{Duration, SystemTime},
};

use renet::{
    transport::{ClientAuthentication, NetcodeClientTransport},
    ConnectionConfig, DefaultChannel, RenetClient,
};

fn main() {
    let mut client = RenetClient::new(ConnectionConfig::default());

    // Setup transport layer
    let server_addr: SocketAddr = "127.0.0.1:5000".parse().unwrap();
    let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
    let current_time = SystemTime::now()
        .duration_since(SystemTime::UNIX_EPOCH)
        .unwrap();
    let authentication = ClientAuthentication::Unsecure {
        server_addr,
        client_id: 0,
        user_data: None,
        protocol_id: 0,
    };

    let mut transport = NetcodeClientTransport::new(current_time, authentication, socket).unwrap();

    // Your gameplay loop
    loop {
        let delta_time = Duration::from_millis(16);
        // Receive new messages and update client
        client.update(delta_time);
        transport.update(delta_time, &mut client).unwrap();

        if client.is_connected() {
            // Receive message from server
            while let Some(message) = client.receive_message(DefaultChannel::ReliableOrdered) {
                // Handle received message
            }

            // Send message
            client.send_message(DefaultChannel::ReliableOrdered, "client text");
        }

        // Send packets to server using the transport layer
        transport.send_packets(&mut client).unwrap();
    }
}

Server code:

use std::{
    net::{IpAddr, Ipv4Addr, SocketAddr, UdpSocket},
    time::{Duration, SystemTime},
};

use renet::{
    transport::{NetcodeServerTransport, ServerAuthentication, ServerConfig},
    ClientId, ConnectionConfig, DefaultChannel, RenetServer, ServerEvent,
};

fn main() {
    let mut server = RenetServer::new(ConnectionConfig::default());

    // Setup transport layer
    const SERVER_ADDR: SocketAddr = SocketAddr::new(IpAddr::V4(Ipv4Addr::new(127, 0, 0, 1)), 5000);
    let socket: UdpSocket = UdpSocket::bind(SERVER_ADDR).unwrap();
    let server_config = ServerConfig {
        current_time: SystemTime::now()
            .duration_since(SystemTime::UNIX_EPOCH)
            .unwrap(),
        max_clients: 64,
        protocol_id: 0,
        public_addresses: vec![SERVER_ADDR],
        authentication: ServerAuthentication::Unsecure,
    };
    let mut transport = NetcodeServerTransport::new(server_config, socket).unwrap();

    // Your gameplay loop
    loop {
        let delta_time = Duration::from_millis(16);
        // Receive new messages and update clients
        server.update(delta_time);
        transport.update(delta_time, &mut server).unwrap();

        // Check for client connections/disconnections
        while let Some(event) = server.get_event() {
            match event {
                ServerEvent::ClientConnected { client_id } => {
                    println!("Client {client_id} connected");
                }
                ServerEvent::ClientDisconnected { client_id, reason } => {
                    println!("Client {client_id} disconnected: {reason}");
                }
            }
        }

        // Receive message from channel
        for client_id in server.clients_id() {
            // The enum DefaultChannel describe the channels used by the default configuration
            while let Some(message) =
                server.receive_message(client_id, DefaultChannel::ReliableOrdered)
            {
                // Handle received message
            }
        }

        // Send a text message for all clients
        server.broadcast_message(DefaultChannel::ReliableOrdered, "server message");

        let client_id = ClientId::from_raw(0);
        // Send a text message for all clients except for Client 0
        server.broadcast_message_except(
            client_id,
            DefaultChannel::ReliableOrdered,
            "server message",
        );

        // Send message to only one client
        server.send_message(client_id, DefaultChannel::ReliableOrdered, "server message");

        // Send packets to clients using the transport layer
        transport.send_packets(&mut server);
    }
}

What do you think? Tell me if you're able to run it

[lucaspoffo]

Hey,
Can you add a sleep at the end of the loop, just after the send_packets:

   transport.send_packets .....
   std::thread::sleep(delta_time);
} // end of loop

Try adding this to both client and server code

[i4lina]

Adding the delay seems to do the trick.

[lucaspoffo]

Great, I'll add it to the README then