diff options
| -rw-r--r-- | examples/chat_protocol/lib.rs | 32 | ||||
| -rw-r--r-- | examples/chat_server/main.rs | 108 | ||||
| -rw-r--r-- | examples/terminal_chat_client/main.rs | 128 |
3 files changed, 268 insertions, 0 deletions
diff --git a/examples/chat_protocol/lib.rs b/examples/chat_protocol/lib.rs new file mode 100644 index 0000000..6a51e50 --- /dev/null +++ b/examples/chat_protocol/lib.rs @@ -0,0 +1,32 @@ +use std::collections::HashMap; + +use bevy_quinnet::ClientId; +use serde::{Deserialize, Serialize}; + +// Messages from clients +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum ClientMessage { + Join { name: String }, + Disconnect {}, + ChatMessage { message: String }, +} + +// Messages from the server +#[derive(Debug, Clone, Serialize, Deserialize)] +pub enum ServerMessage { + ClientConnected { + client_id: ClientId, + username: String, + }, + ClientDisconnected { + client_id: ClientId, + }, + ChatMessage { + client_id: ClientId, + message: String, + }, + InitClient { + client_id: ClientId, + usernames: HashMap<ClientId, String>, + }, +} diff --git a/examples/chat_server/main.rs b/examples/chat_server/main.rs new file mode 100644 index 0000000..bb3318e --- /dev/null +++ b/examples/chat_server/main.rs @@ -0,0 +1,108 @@ +use std::collections::HashMap; + +use bevy::{app::ScheduleRunnerPlugin, log::LogPlugin, prelude::*}; +use bevy_quinnet::{ + server::{QuinnetServerPlugin, Server, ServerConfigurationData}, + ClientId, +}; + +use chat_protocol::{ClientMessage, ServerMessage}; + +#[path = "../chat_protocol/lib.rs"] // Because we can't have a shared lib between Cargo examples +mod chat_protocol; + +#[derive(Debug, Clone, Default)] +struct Users { + names: HashMap<ClientId, String>, +} + +fn handle_client_messages(mut server: ResMut<Server>, mut users: ResMut<Users>) { + while let Ok(Some(message)) = server.receive_message::<ClientMessage>() { + let client_id = message.1; + match message.0 { + ClientMessage::Join { name } => { + if users.names.contains_key(&client_id) { + warn!( + "Received a Join from an already connected client: {}", + client_id + ) + } else { + info!("{} connected", name); + users.names.insert(client_id, name.clone()); + // Initialize this client with existing state + server + .send_message( + client_id, + ServerMessage::InitClient { + client_id: client_id, + usernames: users.names.clone(), + }, + ) + .unwrap(); + // Broadcast the connection event + server + .send_group_message( + users.names.keys().into_iter(), + ServerMessage::ClientConnected { + client_id: client_id, + username: name, + }, + ) + .unwrap(); + } + } + ClientMessage::Disconnect {} => { + if !users.names.contains_key(&client_id) { + warn!( + "Received a Disconnect from an unknown or disconnected client: {}", + client_id + ) + } else { + server.disconnect_client(client_id); + let username = users.names.remove(&client_id); + // Broadcast its deconnection + server + .send_group_message( + users.names.keys().into_iter(), + ServerMessage::ClientDisconnected { + client_id: client_id, + }, + ) + .unwrap(); + info!("{:?} disconnected", username); + } + } + ClientMessage::ChatMessage { message } => { + info!( + "Chat message | {:?}: {}", + users.names.get(&client_id), + message + ); + server + .send_group_message( + users.names.keys().into_iter(), + ServerMessage::ChatMessage { + client_id: client_id, + message: message, + }, + ) + .unwrap(); + } + } + } +} + +fn main() { + App::new() + .add_plugin(ScheduleRunnerPlugin::default()) + .add_plugin(LogPlugin::default()) + .add_plugin(QuinnetServerPlugin::default()) + .insert_resource(ServerConfigurationData::new( + "127.0.0.1".to_string(), + 5000, + "127.0.0.1".to_string(), + )) + .insert_resource(Users::default()) + .add_system(handle_client_messages) + .run(); +} diff --git a/examples/terminal_chat_client/main.rs b/examples/terminal_chat_client/main.rs new file mode 100644 index 0000000..cc4a610 --- /dev/null +++ b/examples/terminal_chat_client/main.rs @@ -0,0 +1,128 @@ +use std::{ + collections::HashMap, + thread::{self, sleep}, + time::{Duration, SystemTime}, +}; + +use bevy::{ + app::AppExit, + prelude::{info, warn, App, Commands, CoreStage, EventReader, EventWriter, Res, ResMut}, +}; +use bevy_quinnet::{ + client::{Client, ClientConfigurationData, QuinnetClientPlugin}, + ClientId, +}; +use chat_protocol::{ClientMessage, ServerMessage}; +use tokio::sync::mpsc; + +#[path = "../chat_protocol/lib.rs"] // Because we can't have a shared lib between Cargo examples +mod chat_protocol; + +#[derive(Debug, Clone, Default)] +struct Users { + self_id: ClientId, + names: HashMap<ClientId, String>, +} + +pub fn on_app_exit(app_exit_events: EventReader<AppExit>, client: Res<Client>) { + if !app_exit_events.is_empty() { + client.send_message(ClientMessage::Disconnect {}).unwrap(); + // TODO Clean: event to let the async client send his last messages. + sleep(Duration::from_secs_f32(0.1)); + } +} + +fn handle_server_messages(mut client: ResMut<Client>, mut users: ResMut<Users>) { + while let Ok(Some(message)) = client.receive_message::<ServerMessage>() { + match message { + ServerMessage::ClientConnected { + client_id, + username, + } => { + info!("{} joined", username); + users.names.insert(client_id, username); + } + ServerMessage::ClientDisconnected { client_id } => { + if let Some(username) = users.names.remove(&client_id) { + info!("{} left", username); + } else { + warn!("ClientDisconnected for an unknown client_id: {}", client_id) + } + } + ServerMessage::ChatMessage { client_id, message } => { + if let Some(username) = users.names.get(&client_id) { + info!("{}: {}", username, message); + } else { + warn!("Chat message from an unknown client_id: {}", client_id) + } + } + ServerMessage::InitClient { + client_id, + usernames, + } => { + users.self_id = client_id; + users.names = usernames; + } + } + } +} + +fn handle_terminal_messages( + client: ResMut<Client>, + mut terminal_messages: ResMut<mpsc::Receiver<String>>, + mut app_exit_events: EventWriter<AppExit>, +) { + while let Ok(message) = terminal_messages.try_recv() { + if message == "quit" { + app_exit_events.send(AppExit); + } else { + client + .send_message(ClientMessage::ChatMessage { message: message }) + .expect("Failed to send chat message"); + } + } +} + +fn start_terminal_listener(mut commands: Commands) { + let (from_terminal_sender, from_terminal_receiver) = mpsc::channel::<String>(100); + + thread::spawn(move || loop { + let mut buffer = String::new(); + std::io::stdin().read_line(&mut buffer).unwrap(); + from_terminal_sender + .try_send(buffer.trim_end().to_string()) + .unwrap(); + }); + + commands.insert_resource(from_terminal_receiver); +} + +fn start_connection(client: ResMut<Client>) { + client.connect().unwrap(); + + let random_name = format!("User_{:?}", SystemTime::now()); + // You can already send message(s) even before being connected, they will be buffered. Else, just wait for client.is_connected() + client + .send_message(ClientMessage::Join { name: random_name }) + .unwrap(); +} + +fn main() { + App::new() + .add_plugin(QuinnetClientPlugin::default()) + // Currently, bevy_quinnet takes its configuration as a resource + .insert_resource(ClientConfigurationData::new( + "127.0.0.1".to_string(), + 5000, + "127.0.0.1".to_string(), + 0, + )) + .insert_resource(Users::default()) + .add_startup_system(start_terminal_listener) + .add_startup_system(start_connection) + .add_system(handle_terminal_messages) + .add_system(handle_server_messages) + // CoreStage::PostUpdate so that AppExit events generated in the previous stage are available + .add_system_to_stage(CoreStage::PostUpdate, on_app_exit) + .run(); +} |