Rechannel: add DefaultChannel enum

This is a usability gain when using the default channel configuration.
lucaspoffo · Aug 9, 2022 · 58311b4 · 58311b4
1 parent d4625ac
commit 58311b4
Show file tree

Hide file tree

Showing 9 changed files with 87 additions and 99 deletions.
diff --git a/demo_bevy/src/bin/client.rs b/demo_bevy/src/bin/client.rs
@@ -67,7 +67,6 @@ fn main() {
     app.insert_resource(PlayerInput::default());
     app.insert_resource(MostRecentTick(None));
     app.insert_resource(new_renet_client());
-    app.insert_resource(RenetClientVisualizer::<200>::new(RenetVisualizerStyle::default()));
     app.insert_resource(NetworkMapping::default());
 
     app.add_system(player_input);
@@ -76,6 +75,8 @@ fn main() {
     app.add_system(client_send_input.with_run_criteria(run_if_client_connected));
     app.add_system(client_send_player_commands.with_run_criteria(run_if_client_connected));
     app.add_system(client_sync_players.with_run_criteria(run_if_client_connected));
+
+    app.insert_resource(RenetClientVisualizer::<200>::new(RenetVisualizerStyle::default()));
     app.add_system(update_visulizer_system);
 
     app.add_startup_system(setup_level);

diff --git a/demo_chat/chat/src/client.rs b/demo_chat/chat/src/client.rs
@@ -2,7 +2,7 @@ use bincode::Options;
 use eframe::egui;
 use log::error;
 use matcher::{LobbyListing, RequestConnection};
-use renet::{ClientAuthentication, ConnectToken, RenetClient, RenetConnectionConfig};
+use renet::{ClientAuthentication, ConnectToken, DefaultChannel, RenetClient, RenetConnectionConfig};
 use renet_visualizer::RenetClientVisualizer;
 
 use std::{
@@ -17,10 +17,10 @@ use std::{
     time::Duration,
 };
 
-use crate::{channels_config, server::ChatServer, Channels, Message};
 use crate::{
+    server::ChatServer,
     ui::{draw_chat, draw_loader, draw_main_screen},
-    ServerMessages,
+    Message, ServerMessages,
 };
 
 #[derive(Debug, Default)]
@@ -171,7 +171,7 @@ impl ChatApp {
                 } else {
                     visualizer.add_network_info(client.network_info());
 
-                    while let Some(message) = client.receive_message(Channels::Reliable.id()) {
+                    while let Some(message) = client.receive_message(DefaultChannel::Reliable) {
                         let message: ServerMessages = bincode::options().deserialize(&message).unwrap();
                         match message {
                             ServerMessages::ClientConnected { client_id, username } => {
@@ -242,11 +242,7 @@ impl ChatApp {
 fn create_renet_client_from_token(connect_token: ConnectToken) -> RenetClient {
     let client_addr = SocketAddr::from(([127, 0, 0, 1], 0));
     let socket = UdpSocket::bind(client_addr).unwrap();
-    let connection_config = RenetConnectionConfig {
-        send_channels_config: channels_config(),
-        receive_channels_config: channels_config(),
-        ..Default::default()
-    };
+    let connection_config = RenetConnectionConfig::default();
 
     let current_time = SystemTime::now().duration_since(SystemTime::UNIX_EPOCH).unwrap();
     let authentication = ClientAuthentication::Secure { connect_token };

diff --git a/demo_chat/chat/src/main.rs b/demo_chat/chat/src/main.rs
@@ -1,6 +1,5 @@
 use client::ChatApp;
 use eframe::{egui, App};
-use renet::{ChannelConfig, ReliableChannelConfig};
 use serde::{Deserialize, Serialize};
 
 use std::collections::HashMap;
@@ -29,28 +28,6 @@ enum ServerMessages {
     InitClient { usernames: HashMap<u64, String> },
 }
 
-#[derive(Debug)]
-pub enum Channels {
-    Reliable,
-}
-
-impl Channels {
-    pub fn id(&self) -> u8 {
-        match self {
-            Channels::Reliable => 0,
-        }
-    }
-}
-
-pub fn channels_config() -> Vec<ChannelConfig> {
-    let reliable_channel = ChannelConfig::Reliable(ReliableChannelConfig {
-        channel_id: Channels::Reliable.id(),
-        ..Default::default()
-    });
-
-    vec![reliable_channel]
-}
-
 impl Message {
     fn new(client_id: u64, text: String) -> Self {
         Self { client_id, text }

diff --git a/demo_chat/chat/src/server.rs b/demo_chat/chat/src/server.rs
@@ -7,10 +7,10 @@ use std::{
 };
 
 use matcher::{RegisterServer, ServerUpdate, Username, PROTOCOL_ID};
-use renet::{generate_random_bytes, RenetConnectionConfig, RenetServer, ServerAuthentication, ServerConfig, ServerEvent};
+use renet::{generate_random_bytes, DefaultChannel, RenetConnectionConfig, RenetServer, ServerAuthentication, ServerConfig, ServerEvent};
 use renet_visualizer::RenetServerVisualizer;
 
-use crate::{channels_config, lobby_status::update_lobby_status, Channels, ClientMessages, Message, ServerMessages};
+use crate::{lobby_status::update_lobby_status, ClientMessages, Message, ServerMessages};
 use bincode::Options;
 use log::info;
 
@@ -26,12 +26,7 @@ impl ChatServer {
     pub fn new(lobby_name: String, host_username: String, password: String) -> Self {
         let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
         let server_addr = socket.local_addr().unwrap();
-        let connection_config = RenetConnectionConfig {
-            send_channels_config: channels_config(),
-            receive_channels_config: channels_config(),
-            ..Default::default()
-        };
-
+        let connection_config = RenetConnectionConfig::default();
         let private_key = generate_random_bytes();
         let server_config = ServerConfig::new(64, PROTOCOL_ID, server_addr, ServerAuthentication::Secure { private_key });
 
@@ -83,26 +78,26 @@ impl ChatServer {
                     let message = bincode::options()
                         .serialize(&ServerMessages::ClientConnected { client_id, username })
                         .unwrap();
-                    self.server.broadcast_message(Channels::Reliable.id(), message);
+                    self.server.broadcast_message(DefaultChannel::Reliable, message);
                     let init_message = ServerMessages::InitClient {
                         usernames: self.usernames.clone(),
                     };
                     let init_message = bincode::options().serialize(&init_message).unwrap();
-                    self.server.send_message(client_id, Channels::Reliable.id(), init_message);
+                    self.server.send_message(client_id, DefaultChannel::Reliable, init_message);
                 }
                 ServerEvent::ClientDisconnected(client_id) => {
                     self.visualizer.remove_client(client_id);
                     self.usernames.remove(&client_id);
                     let message = bincode::options()
                         .serialize(&ServerMessages::ClientDisconnected { client_id })
                         .unwrap();
-                    self.server.broadcast_message(Channels::Reliable.id(), message);
+                    self.server.broadcast_message(DefaultChannel::Reliable, message);
                 }
             }
         }
 
         for client_id in self.server.clients_id().into_iter() {
-            while let Some(message) = self.server.receive_message(client_id, Channels::Reliable.id()) {
+            while let Some(message) = self.server.receive_message(client_id, DefaultChannel::Reliable) {
                 if let Ok(message) = bincode::options().deserialize::<ClientMessages>(&message) {
                     info!("Received message from client {}: {:?}", client_id, message);
                     match message {
@@ -125,6 +120,6 @@ impl ChatServer {
         let message = Message::new(client_id, text);
         self.messages.push(message.clone());
         let message = bincode::options().serialize(&ServerMessages::ClientMessage(message)).unwrap();
-        self.server.broadcast_message(Channels::Reliable.id(), message);
+        self.server.broadcast_message(DefaultChannel::Reliable, message);
     }
 }
diff --git a/demo_chat/chat/src/ui.rs b/demo_chat/chat/src/ui.rs
@@ -5,14 +5,14 @@ use eframe::{
 };
 use egui_extras::{Size, TableBuilder};
 use matcher::{LobbyListing, RequestConnection};
+use renet::DefaultChannel;
 
 use std::{collections::HashMap, sync::mpsc};
 
 use crate::{client::connect_token_request, ClientMessages};
 use crate::{
     client::{AppState, UiState},
     server::ChatServer,
-    Channels,
 };
 
 pub fn draw_lobby_list(ui: &mut Ui, lobby_list: Vec<LobbyListing>) -> Option<(u64, bool)> {
@@ -269,7 +269,7 @@ pub fn draw_chat(ui_state: &mut UiState, state: &mut AppState, usernames: HashMa
                 }
                 AppState::ClientChat { client, .. } => {
                     let message = bincode::options().serialize(&ClientMessages::Text(text)).unwrap();
-                    client.send_message(Channels::Reliable.id(), message);
+                    client.send_message(DefaultChannel::Reliable, message);
                 }
                 _ => unreachable!(),
             };

diff --git a/rechannel/src/channel/mod.rs b/rechannel/src/channel/mod.rs
@@ -28,6 +28,46 @@ pub enum ChannelConfig {
     Block(BlockChannelConfig),
 }
 
+pub(crate) trait SendChannel: std::fmt::Debug {
+    fn get_messages_to_send(&mut self, available_bytes: u64, sequence: u16, current_time: Duration) -> Option<ChannelPacketData>;
+    fn send_message(&mut self, payload: Bytes, current_time: Duration);
+    fn process_ack(&mut self, ack: u16);
+    fn can_send_message(&self) -> bool;
+    fn error(&self) -> Option<ChannelError>;
+}
+
+pub(crate) trait ReceiveChannel: std::fmt::Debug {
+    fn process_messages(&mut self, messages: Vec<Payload>);
+    fn receive_message(&mut self) -> Option<Payload>;
+    fn error(&self) -> Option<ChannelError>;
+}
+
+/// Default channels used when using the default configuration.
+/// Use this enum only when using the default channels configuration.
+pub enum DefaultChannel {
+    Reliable,
+    Unreliable,
+    Block,
+}
+
+impl From<ReliableChannelConfig> for ChannelConfig {
+    fn from(config: ReliableChannelConfig) -> Self {
+        Self::Reliable(config)
+    }
+}
+
+impl From<UnreliableChannelConfig> for ChannelConfig {
+    fn from(config: UnreliableChannelConfig) -> Self {
+        Self::Unreliable(config)
+    }
+}
+
+impl From<BlockChannelConfig> for ChannelConfig {
+    fn from(config: BlockChannelConfig) -> Self {
+        Self::Block(config)
+    }
+}
+
 impl ChannelConfig {
     pub(crate) fn new_channels(
         &self,
@@ -62,34 +102,22 @@ impl ChannelConfig {
     }
 }
 
-pub(crate) trait SendChannel: std::fmt::Debug {
-    fn get_messages_to_send(&mut self, available_bytes: u64, sequence: u16, current_time: Duration) -> Option<ChannelPacketData>;
-    fn send_message(&mut self, payload: Bytes, current_time: Duration);
-    fn process_ack(&mut self, ack: u16);
-    fn can_send_message(&self) -> bool;
-    fn error(&self) -> Option<ChannelError>;
-}
-
-pub(crate) trait ReceiveChannel: std::fmt::Debug {
-    fn process_messages(&mut self, messages: Vec<Payload>);
-    fn receive_message(&mut self) -> Option<Payload>;
-    fn error(&self) -> Option<ChannelError>;
-}
-
-impl From<ReliableChannelConfig> for ChannelConfig {
-    fn from(config: ReliableChannelConfig) -> Self {
-        Self::Reliable(config)
-    }
-}
-
-impl From<UnreliableChannelConfig> for ChannelConfig {
-    fn from(config: UnreliableChannelConfig) -> Self {
-        Self::Unreliable(config)
+impl From<DefaultChannel> for u8 {
+    fn from(channel: DefaultChannel) -> Self {
+        match channel {
+            DefaultChannel::Reliable => 0,
+            DefaultChannel::Unreliable => 1,
+            DefaultChannel::Block => 2,
+        }
     }
 }
 
-impl From<BlockChannelConfig> for ChannelConfig {
-    fn from(config: BlockChannelConfig) -> Self {
-        Self::Block(config)
+impl DefaultChannel {
+    pub fn config() -> Vec<ChannelConfig> {
+        vec![
+            ChannelConfig::Reliable(Default::default()),
+            ChannelConfig::Unreliable(Default::default()),
+            ChannelConfig::Block(Default::default()),
+        ]
     }
 }
diff --git a/rechannel/src/remote_connection.rs b/rechannel/src/remote_connection.rs
@@ -1,4 +1,4 @@
-use crate::channel::{ChannelConfig, ReceiveChannel, SendChannel};
+use crate::channel::{ChannelConfig, DefaultChannel, ReceiveChannel, SendChannel};
 use crate::error::{DisconnectionReason, RechannelError};
 use crate::packet::{Packet, Payload};
 
@@ -63,12 +63,6 @@ impl SentPacket {
 
 impl Default for ConnectionConfig {
     fn default() -> Self {
-        let channels = vec![
-            ChannelConfig::Reliable(Default::default()),
-            ChannelConfig::Unreliable(Default::default()),
-            ChannelConfig::Block(Default::default()),
-        ];
-
         Self {
             max_packet_size: 16 * 1024,
             sent_packets_buffer_size: 256,
@@ -77,8 +71,8 @@ impl Default for ConnectionConfig {
             packet_loss_smoothing_factor: 0.1,
             heartbeat_time: Duration::from_millis(100),
             fragment_config: FragmentConfig::default(),
-            send_channels_config: channels.clone(),
-            receive_channels_config: channels,
+            send_channels_config: DefaultChannel::config(),
+            receive_channels_config: DefaultChannel::config(),
         }
     }
 }

diff --git a/renet/examples/echo.rs b/renet/examples/echo.rs
@@ -1,17 +1,14 @@
-use renet::{
-    ClientAuthentication, RenetClient, RenetConnectionConfig, RenetServer, ServerAuthentication, ServerConfig, ServerEvent,
-    NETCODE_USER_DATA_BYTES,
-};
-use std::collections::HashMap;
-use std::thread;
-use std::time::Duration;
 use std::{
+    collections::HashMap,
     net::{SocketAddr, UdpSocket},
-    time::Instant,
-};
-use std::{
     sync::mpsc::{self, Receiver, TryRecvError},
-    time::SystemTime,
+    thread,
+    time::{Duration, Instant, SystemTime},
+};
+
+use renet::{
+    ClientAuthentication, DefaultChannel, RenetClient, RenetConnectionConfig, RenetServer, ServerAuthentication, ServerConfig, ServerEvent,
+    NETCODE_USER_DATA_BYTES,
 };
 
 // Helper struct to pass an username in the user data
@@ -95,7 +92,7 @@ fn server(addr: SocketAddr) {
         }
 
         for client_id in server.clients_id().into_iter() {
-            while let Some(message) = server.receive_message(client_id, 0) {
+            while let Some(message) = server.receive_message(client_id, DefaultChannel::Reliable) {
                 let text = String::from_utf8(message).unwrap();
                 let username = usernames.get(&client_id).unwrap();
                 println!("Client {} ({}) sent text: {}", username, client_id, text);
@@ -105,7 +102,7 @@ fn server(addr: SocketAddr) {
         }
 
         for text in received_messages.iter() {
-            server.broadcast_message(0, text.as_bytes().to_vec());
+            server.broadcast_message(DefaultChannel::Reliable, text.as_bytes().to_vec());
         }
 
         server.send_packets().unwrap();
@@ -134,12 +131,12 @@ fn client(server_addr: SocketAddr, username: Username) {
         last_updated = now;
         if client.is_connected() {
             match stdin_channel.try_recv() {
-                Ok(text) => client.send_message(0, text.as_bytes().to_vec()),
+                Ok(text) => client.send_message(DefaultChannel::Reliable, text.as_bytes().to_vec()),
                 Err(TryRecvError::Empty) => {}
                 Err(TryRecvError::Disconnected) => panic!("Channel disconnected"),
             }
 
-            while let Some(text) = client.receive_message(0) {
+            while let Some(text) = client.receive_message(DefaultChannel::Reliable) {
                 let text = String::from_utf8(text).unwrap();
                 println!("{}", text);
             }

diff --git a/renet/src/lib.rs b/renet/src/lib.rs
@@ -5,7 +5,7 @@ mod error;
 mod network_info;
 mod server;
 
-pub use rechannel::channel::{BlockChannelConfig, ChannelConfig, ReliableChannelConfig, UnreliableChannelConfig};
+pub use rechannel::channel::{BlockChannelConfig, ChannelConfig, DefaultChannel, ReliableChannelConfig, UnreliableChannelConfig};
 pub use rechannel::error::{ChannelError, DisconnectionReason, RechannelError};
 
 pub use renetcode::{generate_random_bytes, ConnectToken, NetcodeError};