Renet: add can_send_message and channel_available_memory

renet/src/channel/reliable.rs

@@ -83,6 +83,14 @@ impl SendChannelReliable {
         }
     }
 
+    pub fn available_memory(&self) -> usize {
+        self.max_memory_usage_bytes - self.memory_usage_bytes
+    }
+
+    pub fn can_send_message(&self, size_bytes: usize) -> bool {
+        size_bytes + self.memory_usage_bytes <= self.max_memory_usage_bytes
+    }
+
     pub fn get_packets_to_send(&mut self, packet_sequence: &mut u64, available_bytes: &mut u64, current_time: Duration) -> Vec<Packet> {
         if self.unacked_messages.is_empty() {
             return vec![];
@@ -272,10 +280,10 @@ impl ReceiveChannelReliable {
         match &mut self.reliable_order {
             ReliableOrder::Ordered => {
                 if let btree_map::Entry::Vacant(entry) = self.messages.entry(message_id) {
-                    self.memory_usage_bytes += message.len();
-                    if self.max_memory_usage_bytes < self.memory_usage_bytes {
+                    if self.memory_usage_bytes + message.len() > self.max_memory_usage_bytes {
                         return Err(ChannelError::ReliableChannelMaxMemoryReached);
                     }
+                    self.memory_usage_bytes += message.len();
 
                     entry.insert(message);
                 }
@@ -289,10 +297,10 @@ impl ReceiveChannelReliable {
                 }
 
                 if !received_messages.contains(&message_id) {
-                    self.memory_usage_bytes += message.len();
-                    if self.max_memory_usage_bytes < self.memory_usage_bytes {
+                    if self.memory_usage_bytes + message.len() > self.max_memory_usage_bytes {
                         return Err(ChannelError::ReliableChannelMaxMemoryReached);
                     }
+                    self.memory_usage_bytes += message.len();
 
                     received_messages.insert(message_id);
                     self.messages.insert(message_id, message);
@@ -310,10 +318,11 @@ impl ReceiveChannelReliable {
         }
 
         if !self.slices.contains_key(&slice.message_id) {
-            self.memory_usage_bytes += slice.num_slices * SLICE_SIZE;
-            if self.max_memory_usage_bytes < self.memory_usage_bytes {
+            let message_len = slice.num_slices * SLICE_SIZE;
+            if self.memory_usage_bytes + message_len > self.max_memory_usage_bytes {
                 return Err(ChannelError::ReliableChannelMaxMemoryReached);
             }
+            self.memory_usage_bytes += message_len;
         }
 
         let slice_constructor = self

renet/src/channel/unreliable.rs

@@ -41,6 +41,14 @@ impl SendChannelUnreliable {
         }
     }
 
+    pub fn can_send_message(&self, size_bytes: usize) -> bool {
+        size_bytes + self.memory_usage_bytes <= self.max_memory_usage_bytes
+    }
+
+    pub fn available_memory(&self) -> usize {
+        self.max_memory_usage_bytes - self.memory_usage_bytes
+    }
+
     pub fn get_packets_to_send(&mut self, packet_sequence: &mut u64, available_bytes: &mut u64) -> Vec<Packet> {
         let mut packets: Vec<Packet> = vec![];
         let mut small_messages: Vec<Bytes> = vec![];
@@ -109,7 +117,7 @@ impl SendChannelUnreliable {
     }
 
     pub fn send_message(&mut self, message: Bytes) {
-        if self.max_memory_usage_bytes < self.memory_usage_bytes + message.len() {
+        if self.memory_usage_bytes + message.len() > self.max_memory_usage_bytes {
             log::warn!(
                 "dropped unreliable message sent because channel {} is memory limited",
                 self.channel_id
@@ -135,7 +143,7 @@ impl ReceiveChannelUnreliable {
     }
 
     pub fn process_message(&mut self, message: Bytes) {
-        if self.max_memory_usage_bytes < self.memory_usage_bytes + message.len() {
+        if self.memory_usage_bytes + message.len() > self.max_memory_usage_bytes {
             log::warn!(
                 "dropped unreliable message received because channel {} is memory limited",
                 self.channel_id
@@ -150,7 +158,7 @@ impl ReceiveChannelUnreliable {
     pub fn process_slice(&mut self, slice: Slice, current_time: Duration) -> Result<(), ChannelError> {
         if !self.slices.contains_key(&slice.message_id) {
             let message_len = slice.num_slices * SLICE_SIZE;
-            if self.max_memory_usage_bytes < self.memory_usage_bytes + message_len {
+            if self.memory_usage_bytes + message_len > self.max_memory_usage_bytes {
                 log::warn!(
                     "dropped unreliable slice message received because channel {} is memory limited",
                     self.channel_id

renet/src/remote_connection.rs

@@ -251,6 +251,30 @@ impl RenetClient {
         self.disconnect_reason = Some(DisconnectReason::Transport);
     }
 
+    /// Returns the available memory in bytes for the given channel.
+    pub fn channel_available_memory<I: Into<u8>>(&self, channel_id: I) -> usize {
+        let channel_id = channel_id.into();
+        if let Some(reliable_channel) = self.send_reliable_channels.get(&channel_id) {
+            reliable_channel.available_memory()
+        } else if let Some(unreliable_channel) = self.send_unreliable_channels.get(&channel_id) {
+            unreliable_channel.available_memory()
+        } else {
+            panic!("Called 'channel_available_memory' with invalid channel {channel_id}");
+        }
+    }
+
+    /// Checks if the channel can send a message with the given size in bytes.
+    pub fn can_send_message<I: Into<u8>>(&self, channel_id: I, size_bytes: usize) -> bool {
+        let channel_id = channel_id.into();
+        if let Some(reliable_channel) = self.send_reliable_channels.get(&channel_id) {
+            reliable_channel.can_send_message(size_bytes)
+        } else if let Some(unreliable_channel) = self.send_unreliable_channels.get(&channel_id) {
+            unreliable_channel.can_send_message(size_bytes)
+        } else {
+            panic!("Called 'can_send_message' with invalid channel {channel_id}");
+        }
+    }
+
     /// Send a message to the server over a channel.
     pub fn send_message<I: Into<u8>, B: Into<Bytes>>(&mut self, channel_id: I, message: B) {
         if self.is_disconnected() {
@@ -265,7 +289,7 @@ impl RenetClient {
         } else if let Some(unreliable_channel) = self.send_unreliable_channels.get_mut(&channel_id) {
             unreliable_channel.send_message(message.into());
         } else {
-            panic!("Tried to send message to invalid channel {channel_id}");
+            panic!("Called 'send_message' with invalid channel {channel_id}");
         }
     }
 
@@ -281,7 +305,7 @@ impl RenetClient {
         } else if let Some(unreliable_channel) = self.receive_unreliable_channels.get_mut(&channel_id) {
             unreliable_channel.receive_message()
         } else {
-            panic!("Tried to receive message from invalid channel {channel_id}");
+            panic!("Called 'receive_message' with invalid channel {channel_id}");
         }
     }
 

renet/src/server.rs

@@ -172,6 +172,24 @@ impl RenetServer {
         }
     }
 
+    /// Returns the available memory in bytes of a channel for the given client.
+    /// Returns 0 if the client is not found.
+    pub fn channel_available_memory<I: Into<u8>>(&self, client_id: u64, channel_id: I) -> usize {
+        match self.connections.get(&client_id) {
+            Some(connection) => connection.channel_available_memory(channel_id),
+            None => 0,
+        }
+    }
+
+    /// Checks if can send a message with the given size in bytes over a channel for the given client.
+    /// Returns false if the client is not found.
+    pub fn can_send_message<I: Into<u8>>(&self, client_id: u64, channel_id: I, size_bytes: usize) -> bool {
+        match self.connections.get(&client_id) {
+            Some(connection) => connection.can_send_message(channel_id, size_bytes),
+            None => false,
+        }
+    }
+
     /// Send a message to a client over a channel.
     pub fn send_message<I: Into<u8>, B: Into<Bytes>>(&mut self, client_id: u64, channel_id: I, message: B) {
         match self.connections.get_mut(&client_id) {