Usernames

Cargo.toml

@@ -20,6 +20,7 @@ bevy_egui = { version = "0.38.1", features = ["immutable_ctx"]}
 bevy_diagnostic = "0.17.3"
 bevy-inspector-egui = {version = "0.35", features = ["bevy_render"]}
 bevy_renet = "3.0.0"
+bevy_mod_billboard = "0.7.0"
 renet_visualizer = {version="1.1.0", features=["bevy"]}
 egui_plot = "0.34.0"
 
@@ -41,6 +42,8 @@ clap = { version = "4.5.54", features = ["derive"] }
 renet_visualizer = {git = "https://github.com/cb341/renet.git" }
 bevy_renet = {git = "https://github.com/cb341/renet.git" }
 renet = {git = "https://github.com/cb341/renet.git" }
+bevy_mod_billboard = {git = "https://github.com/kisya-games/bevy_mod_billboard.git", branch="bevy-0.17"} # TODO: Remove once https://github.com/kulkalkul/bevy_mod_billboard/pull/36 is merged
+# bevy_mod_billboard = {git = "https://github.com/kulkalkul/bevy_mod_billboard.git"}
 
 [profile.dev.package."*"]
 opt-level = 3

src/client/chat/systems.rs

@@ -168,7 +168,7 @@ pub fn add_message_to_chat_container_system(
                 Node::default(),
                 Name::new("chat_entry"),
                 chat_components::ChatMessageElement,
-                Text::new(event.0.message.clone()),
+                Text::new(event.0.format_string()),
             ));
         });
     }
@@ -277,7 +277,7 @@ mod tests {
 
         event_writer.write(SingleChatSendEvent(ChatMessage {
             message: "Hello World".to_string(),
-            client_id: 0,
+            sender: ChatMessageSender::Server,
             message_id: 1,
             timestamp: 0,
         }));
@@ -292,7 +292,7 @@ mod tests {
         assert_eq!(message_count, 1);
         assert_eq!(
             messages.iter(app.world()).next().unwrap().0 .0,
-            "Hello World"
+            "[1970-01-01 00:00:00 UTC] SERVER: Hello World"
         );
     }
 

src/client/gui/systems.rs

@@ -25,6 +25,7 @@ pub fn handle_debug_state_transition_system(
 ) {
     if key_input.just_pressed(KeyCode::Tab) {
         match *current_state.get() {
+            GameState::WaitingForServer => {}
             GameState::Playing => next_state.set(GameState::Debugging),
             GameState::Chatting => next_state.set(GameState::Debugging),
             GameState::Debugging => next_state.set(GameState::Playing),

src/client/main.rs

@@ -13,6 +13,7 @@ mod states;
 mod terrain;
 
 use bevy_flair::FlairPlugin;
+use clap::Parser;
 use scene::setup_scene;
 
 #[cfg(feature = "wireframe")]
@@ -32,7 +33,17 @@ mod wireframe_config {
     }
 }
 
+#[derive(Debug, Parser)]
+#[command(version)]
+#[command(long_about = None)]
+struct Cli {
+    #[command(flatten)]
+    networking_args: networking_commands::NetworkingArgs,
+}
+
 fn main() {
+    let cli = Cli::parse();
+
     let window_plugin = WindowPlugin {
         primary_window: Some(Window {
             resolution: WindowResolution::new(1920, 1080).with_scale_factor_override(2.0),
@@ -47,6 +58,17 @@ fn main() {
         .set(ImagePlugin::default_nearest());
 
     let mut app = App::new();
+
+    match networking::NetworkingPlugin::from_args(cli.networking_args) {
+        Ok(plugin) => {
+            app.add_plugins(plugin);
+        }
+        Err(err) => {
+            eprintln!("Error: {}", err);
+            return;
+        }
+    }
+
     app.add_plugins((
         default_plugins,
         FlairPlugin,
@@ -56,15 +78,14 @@ fn main() {
         EntityCountDiagnosticsPlugin::default(),
         SystemInformationDiagnosticsPlugin,
         gui::GuiPlugin,
-        networking::NetworkingPlugin,
         terrain::TerrainPlugin,
         collider::ColliderPlugin,
         player::PlayerPlugin,
         remote_player::RemotePlayerPlugin,
         #[cfg(feature = "chat")]
         chat::ChatPlugin,
     ));
-    app.insert_state(GameState::Playing);
+    app.insert_state(GameState::WaitingForServer);
 
     #[cfg(feature = "wireframe")]
     app.insert_resource(wireframe_config::wireframe_config());

src/client/networking/commands.rs

@@ -0,0 +1,23 @@
+use clap::*;
+
+use crate::networking::DEFAULT_SERVER_ADDR;
+use crate::prelude::NetworkingPlugin;
+
+#[derive(Parser, Debug)]
+#[command(version, about, long_about = None)]
+pub struct NetworkingArgs {
+    #[arg(short, long)]
+    username: String,
+    #[arg(short, long)]
+    server_addr: Option<String>,
+}
+
+impl NetworkingPlugin {
+    pub fn from_args(args: NetworkingArgs) -> Result<Self, String> {
+        let server_addr = args
+            .server_addr
+            .unwrap_or_else(|| String::from(DEFAULT_SERVER_ADDR));
+
+        NetworkingPlugin::new(&server_addr, args.username)
+    }
+}

src/client/networking/mod.rs

@@ -1,28 +1,50 @@
+pub mod commands;
 pub mod systems;
 
 use crate::connection_config;
 use bevy_renet::{
-    netcode::{ClientAuthentication, NetcodeClientPlugin, NetcodeClientTransport},
+    netcode::{
+        ClientAuthentication, NetcodeClientPlugin, NetcodeClientTransport, NetcodeTransportError,
+    },
     RenetClientPlugin,
 };
 
 use crate::prelude::*;
 
-const SERVER_ADDR: &str = "127.0.0.1:5000";
+const DEFAULT_SERVER_ADDR: &str = "127.0.0.1:5000";
+
+pub struct NetworkingPlugin {
+    username: Username,
+    server_addr: SocketAddr,
+}
+
+impl NetworkingPlugin {
+    pub fn new(server_addr: &str, username: String) -> Result<NetworkingPlugin, String> {
+        let server_addr = server_addr.parse().map_err(|_| {
+            format!(
+                "Address '{}' is invalid, please specify address in format like {DEFAULT_SERVER_ADDR}",
+                server_addr
+            )
+        })?;
+
+        Ok(Self {
+            server_addr,
+            username: Username::new(&username)?,
+        })
+    }
+}
 
-pub struct NetworkingPlugin;
 impl Plugin for NetworkingPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins((RenetClientPlugin, NetcodeClientPlugin));
 
         let client = RenetClient::new(connection_config());
         app.insert_resource(client);
 
-        let client_id = rand::random::<u64>();
         let authentication = ClientAuthentication::Unsecure {
-            server_addr: SERVER_ADDR.parse().unwrap(),
-            client_id,
-            user_data: None,
+            server_addr: self.server_addr,
+            client_id: rand::random::<u64>(),
+            user_data: Some(self.username.to_netcode_user_data()),
             protocol_id: 0,
         };
         let socket = UdpSocket::bind("127.0.0.1:0").unwrap();
@@ -32,6 +54,21 @@ impl Plugin for NetworkingPlugin {
         let transport = NetcodeClientTransport::new(current_time, authentication, socket).unwrap();
         app.insert_resource(transport);
 
+        app.add_systems(Last, networking_systems::exit_on_last_window_closed_system);
         app.add_systems(Update, networking_systems::receive_message_system);
+
+        fn exit_on_transport_error(
+            mut renet_error: MessageReader<NetcodeTransportError>,
+            mut exit_events: MessageWriter<AppExit>,
+        ) {
+            if !renet_error.is_empty() {
+                exit_events.write(AppExit::error());
+            }
+            for error in renet_error.read() {
+                eprintln!("{}", error);
+            }
+        }
+
+        app.add_systems(Update, exit_on_transport_error);
     }
 }

src/client/networking/systems.rs

@@ -1,7 +1,20 @@
 use crate::prelude::*;
 
+pub fn exit_on_last_window_closed_system(
+    close_events: MessageReader<WindowCloseRequested>,
+    windows: Query<(), With<Window>>,
+    mut client: ResMut<RenetClient>,
+    mut exit: MessageWriter<AppExit>,
+) {
+    if !close_events.is_empty() && windows.iter().count() <= 1 {
+        client.disconnect();
+        exit.write(AppExit::Success);
+    }
+}
+
 #[allow(clippy::too_many_arguments)]
 pub fn receive_message_system(
+    mut commands: Commands,
     mut client: ResMut<RenetClient>,
     mut player_spawn_events: ResMut<Messages<remote_player_events::RemotePlayerSpawnedEvent>>,
     mut player_despawn_events: ResMut<Messages<remote_player_events::RemotePlayerDespawnedEvent>>,
@@ -15,20 +28,29 @@ pub fn receive_message_system(
         Messages<chat_events::SingleChatSendEvent>,
     >,
     mut spawn_area_loaded: ResMut<terrain_resources::SpawnAreaLoaded>,
+    mut exit_events: MessageWriter<AppExit>,
+    mut next_state: ResMut<NextState<GameState>>,
 ) {
     while let Some(message) = client.receive_message(DefaultChannel::ReliableOrdered) {
         match bincode::deserialize(&message) {
             Ok(message) => match message {
-                NetworkingMessage::PlayerJoin(event) => {
+                NetworkingMessage::PlayerReject(reject_reason) => {
+                    eprintln!("Server connection rejected: {reject_reason}");
+                    exit_events.write(AppExit::error());
+                }
+                NetworkingMessage::PlayerAccept(player_state) => {
+                    commands.insert_resource(player_resources::LocalPlayerSpawnState(player_state));
+                    next_state.set(GameState::Playing);
+                }
+                NetworkingMessage::PlayerJoin(username) => {
                     player_spawn_events.write(remote_player_events::RemotePlayerSpawnedEvent {
-                        client_id: event,
+                        username,
                         position: Vec3::ZERO,
                     });
                 }
-                NetworkingMessage::PlayerLeave(event) => {
-                    player_despawn_events.write(remote_player_events::RemotePlayerDespawnedEvent {
-                        client_id: event,
-                    });
+                NetworkingMessage::PlayerLeave(username) => {
+                    player_despawn_events
+                        .write(remote_player_events::RemotePlayerDespawnedEvent { username });
                 }
                 NetworkingMessage::BlockUpdate { position, block } => {
                     debug!("Client received block update message: {:?}", position);

src/client/player/resources.rs

@@ -48,3 +48,6 @@ impl LastPlayerPosition {
         Self(Vec3::ZERO)
     }
 }
+
+#[derive(Resource)]
+pub struct LocalPlayerSpawnState(pub PlayerState);

src/client/player/systems/controller.rs

@@ -1,14 +1,5 @@
 use crate::prelude::*;
 
-#[cfg(feature = "skip_terrain")]
-const SPAWN_POINT: Vec3 = Vec3::new(0.0, 1.0, 0.0);
-
-#[cfg(all(not(feature = "skip_terrain"), not(feature = "lock_player")))]
-const SPAWN_POINT: Vec3 = Vec3::new(0.0, 43.0, 0.0); // TODO: determine terrain height at 0,0
-
-#[cfg(all(not(feature = "skip_terrain"), feature = "lock_player"))]
-const SPAWN_POINT: Vec3 = Vec3::new(128.0, 96.0, -128.0);
-
 pub fn setup_player_camera(mut commands: Commands) {
     commands.spawn((
         Name::new("Player cam?"),
@@ -38,8 +29,9 @@ pub fn setup_controller_on_area_ready_system(
     mut commands: Commands,
     mut player_spawned: ResMut<player_resources::PlayerSpawned>,
     mut render_player: Query<&mut RenderPlayer>,
+    spawn_state: Res<player_resources::LocalPlayerSpawnState>,
 ) {
-    info!("Setting up controller");
+    info!("Setting up controller at {:?}", spawn_state.0.position);
 
     let logical_entity = commands
         .spawn((
@@ -62,14 +54,17 @@ pub fn setup_controller_on_area_ready_system(
             LockedAxes::ROTATION_LOCKED,
             AdditionalMassProperties::Mass(1.0),
             GravityScale(0.0),
-            Ccd { enabled: true }, // Prevent clipping when going fast
-            Transform::from_translation(SPAWN_POINT),
+            Ccd { enabled: true },
+            Transform::from_translation(spawn_state.0.position),
             LogicalPlayer,
             #[cfg(not(feature = "lock_player"))]
-            FpsControllerInput {
-                pitch: -TAU / 20.0,
-                yaw: TAU * 5.0 / 12.0,
-                ..default()
+            {
+                let (yaw, pitch, _roll) = spawn_state.0.rotation.to_euler(EulerRot::YXZ);
+                FpsControllerInput {
+                    pitch,
+                    yaw,
+                    ..default()
+                }
             },
             #[cfg(feature = "lock_player")]
             FpsControllerInput {

src/client/prelude.rs

@@ -44,6 +44,7 @@ pub use crate::collider::components as collider_components;
 pub use crate::collider::events as collider_events;
 pub use crate::collider::systems as collider_systems;
 
+pub use crate::networking::commands as networking_commands;
 pub use crate::networking::systems as networking_systems;
 pub use crate::networking::NetworkingPlugin;
 

src/client/remote_player/components.rs

@@ -2,7 +2,7 @@ use crate::prelude::*;
 
 #[derive(Component)]
 pub struct RemotePlayer {
-    pub client_id: ClientId,
+    pub username: Username,
 }
 
 #[derive(Default, Reflect, GizmoConfigGroup)]

src/client/remote_player/events.rs

@@ -2,16 +2,16 @@ use crate::prelude::*;
 
 #[derive(Message)]
 pub struct RemotePlayerSpawnedEvent {
-    pub client_id: ClientId,
+    pub username: Username,
     pub position: Vec3,
 }
 
 #[derive(Message)]
 pub struct RemotePlayerDespawnedEvent {
-    pub client_id: ClientId,
+    pub username: Username,
 }
 
 #[derive(Message)]
 pub struct RemotePlayerSyncEvent {
-    pub players: HashMap<ClientId, PlayerState>,
+    pub players: HashMap<Username, PlayerState>,
 }