Set current_time to absolute system time to prevent drift

demo_bevy/src/bin/client.rs

@@ -8,12 +8,11 @@ use bevy::{
 };
 use bevy_egui::{EguiContexts, EguiPlugin};
 use bevy_renet::{
-    client_connected,
     renet::{ClientId, RenetClient},
     RenetClientPlugin,
 };
 use demo_bevy::{
-    connection_config, setup_level, ClientChannel, NetworkedEntities, PlayerCommand, PlayerInput, ServerChannel, ServerMessages,
+    setup_level, ClientChannel, NetworkedEntities, PlayerCommand, PlayerInput, ServerChannel, ServerMessages,
 };
 use renet_visualizer::{RenetClientVisualizer, RenetVisualizerStyle};
 

renet_netcode/src/client.rs

@@ -84,7 +84,7 @@ impl NetcodeClientTransport {
     }
 
     /// Advances the transport by the duration, and receive packets from the network.
-    pub fn update(&mut self, duration: Duration, client: &mut RenetClient) -> Result<(), NetcodeTransportError> {
+    pub fn update(&mut self, _duration: Duration, client: &mut RenetClient) -> Result<(), NetcodeTransportError> {
         if let Some(reason) = self.netcode_client.disconnect_reason() {
             // Mark the client as disconnected if an error occured in the transport layer
             client.disconnect_due_to_transport();
@@ -124,7 +124,7 @@ impl NetcodeClientTransport {
             }
         }
 
-        if let Some((packet, addr)) = self.netcode_client.update(duration) {
+        if let Some((packet, addr)) = self.netcode_client.update() {
             self.socket.send_to(packet, addr)?;
         }
 

renetcode/examples/echo.rs

@@ -175,7 +175,6 @@ fn client(authentication: ClientAuthentication) {
     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);
@@ -212,10 +211,9 @@ fn client(authentication: ClientAuthentication) {
             };
         }
 
-        if let Some((packet, addr)) = client.update(Instant::now() - last_updated) {
+        if let Some((packet, addr)) = client.update() {
             udp_socket.send_to(packet, addr).unwrap();
         }
-        last_updated = Instant::now();
         thread::sleep(Duration::from_millis(50));
     }
 }

renetcode/src/client.rs

@@ -1,4 +1,4 @@
-use std::{error::Error, fmt, net::SocketAddr, time::Duration};
+use std::{error::Error, fmt, net::SocketAddr, time::{Duration, SystemTime}};
 
 use crate::{
     packet::Packet, replay_protection::ReplayProtection, token::ConnectToken, NetcodeError, NETCODE_CHALLENGE_TOKEN_BYTES,
@@ -270,8 +270,8 @@ impl NetcodeClient {
 
     /// Update the internal state of the client, receives the duration since last updated.
     /// Might return the serve address and a protocol packet to be sent to the server.
-    pub fn update(&mut self, duration: Duration) -> Option<(&mut [u8], SocketAddr)> {
-        if let Err(e) = self.update_internal_state(duration) {
+    pub fn update(&mut self) -> Option<(&mut [u8], SocketAddr)> {
+        if let Err(e) = self.update_internal_state() {
             log::error!("Failed to update client: {}", e);
             return None;
         }
@@ -280,8 +280,9 @@ impl NetcodeClient {
         self.generate_packet()
     }
 
-    fn update_internal_state(&mut self, duration: Duration) -> Result<(), NetcodeError> {
-        self.current_time += duration;
+    fn update_internal_state(&mut self) -> Result<(), NetcodeError> {
+        self.current_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
+
         let connection_timed_out = self.connect_token.timeout_seconds > 0
             && (self.last_packet_received_time + Duration::from_secs(self.connect_token.timeout_seconds as u64) < self.current_time);
 
@@ -405,7 +406,7 @@ mod tests {
         let client_key = connect_token.client_to_server_key;
         let authentication = ClientAuthentication::Secure { connect_token };
         let mut client = NetcodeClient::new(Duration::ZERO, authentication).unwrap();
-        let (packet_buffer, _) = client.update(Duration::ZERO).unwrap();
+        let (packet_buffer, _) = client.update().unwrap();
 
         let (r_sequence, packet) = Packet::decode(packet_buffer, protocol_id, None, None).unwrap();
         assert_eq!(0, r_sequence);
@@ -419,7 +420,7 @@ mod tests {
         client.process_packet(&mut buffer[..len]);
         assert_eq!(ClientState::SendingConnectionResponse, client.state);
 
-        let (packet_buffer, _) = client.update(Duration::ZERO).unwrap();
+        let (packet_buffer, _) = client.update().unwrap();
         let (_, packet) = Packet::decode(packet_buffer, protocol_id, Some(&client_key), None).unwrap();
         assert!(matches!(packet, Packet::Response { .. }));
 

renetcode/src/server.rs

@@ -762,7 +762,7 @@ mod tests {
         .unwrap();
         let client_auth = ClientAuthentication::Secure { connect_token };
         let mut client = NetcodeClient::new(Duration::ZERO, client_auth).unwrap();
-        let (client_packet, _) = client.update(Duration::ZERO).unwrap();
+        let (client_packet, _) = client.update().unwrap();
 
         let result = server.process_packet(client_addr, client_packet);
         assert!(matches!(result, ServerResult::PacketToSend { .. }));
@@ -772,7 +772,7 @@ mod tests {
         };
 
         assert!(!client.is_connected());
-        let (client_packet, _) = client.update(Duration::ZERO).unwrap();
+        let (client_packet, _) = client.update().unwrap();
         let result = server.process_packet(client_addr, client_packet);
 
         match result {