Merge pull request #152 from ferrumc-rs/feature/see-other-players

Actual multiplayer (see others move around, crouch, and swing their arm)

Author: Sweattypalms

src/bin/src/main.rs

@@ -16,7 +16,7 @@ use ferrumc_world::World;
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
 use systems::definition;
-use tracing::{error, info};
+use tracing::{error, info, trace};
 
 pub(crate) mod errors;
 use crate::cli::{CLIArgs, Command, ImportArgs};
@@ -37,11 +37,11 @@ async fn main() {
         let mut hasher = std::collections::hash_map::DefaultHasher::new();
         std::any::TypeId::of::<ChunkReceiver>().hash(&mut hasher);
         let digest = hasher.finish();
-        println!("ChunkReceiver: {:X}", digest);
+        trace!("ChunkReceiver: {:X}", digest);
         let mut hasher = std::collections::hash_map::DefaultHasher::new();
         std::any::TypeId::of::<StreamWriter>().hash(&mut hasher);
         let digest = hasher.finish();
-        println!("StreamWriter: {:X}", digest);
+        trace!("StreamWriter: {:X}", digest);
     }
 
     match cli_args.command {

src/bin/src/packet_handlers/login_process.rs

@@ -5,6 +5,7 @@ use ferrumc_core::transform::grounded::OnGround;
 use ferrumc_core::transform::position::Position;
 use ferrumc_core::transform::rotation::Rotation;
 use ferrumc_ecs::components::storage::ComponentRefMut;
+use ferrumc_ecs::entities::Entity;
 use ferrumc_macros::event_handler;
 use ferrumc_net::connection::{ConnectionState, StreamWriter};
 use ferrumc_net::errors::NetError;
@@ -20,13 +21,19 @@ use ferrumc_net::packets::outgoing::keep_alive::OutgoingKeepAlivePacket;
 use ferrumc_net::packets::outgoing::login_disconnect::LoginDisconnectPacket;
 use ferrumc_net::packets::outgoing::login_play::LoginPlayPacket;
 use ferrumc_net::packets::outgoing::login_success::LoginSuccessPacket;
+use ferrumc_net::packets::outgoing::player_info_update::PlayerInfoUpdatePacket;
 use ferrumc_net::packets::outgoing::registry_data::get_registry_packets;
 use ferrumc_net::packets::outgoing::set_center_chunk::SetCenterChunk;
 use ferrumc_net::packets::outgoing::set_default_spawn_position::SetDefaultSpawnPositionPacket;
 use ferrumc_net::packets::outgoing::set_render_distance::SetRenderDistance;
+use ferrumc_net::packets::outgoing::spawn_entity::SpawnEntityPacket;
 use ferrumc_net::packets::outgoing::synchronize_player_position::SynchronizePlayerPositionPacket;
+use ferrumc_net::utils::broadcast::{broadcast, get_all_play_players, BroadcastOptions};
+use ferrumc_net::NetResult;
 use ferrumc_net_codec::encode::NetEncodeOpts;
 use ferrumc_state::GlobalState;
+use futures::StreamExt;
+use std::time::Instant;
 use tracing::{debug, trace};
 
 #[event_handler]
@@ -46,7 +53,7 @@ async fn handle_login_start(
             login_start_event.conn_id,
             PlayerIdentity::new(username.to_string(), uuid),
         )?
-        .add_component::<ChunkReceiver>(login_start_event.conn_id, ChunkReceiver::default())?;
+        /*.add_component::<ChunkReceiver>(login_start_event.conn_id, ChunkReceiver::default())?*/;
 
     //Send a Login Success Response to further the login sequence
     let mut writer = state
@@ -145,69 +152,73 @@ async fn handle_ack_finish_configuration(
     state: GlobalState,
 ) -> Result<AckFinishConfigurationEvent, NetError> {
     trace!("Handling Ack Finish Configuration event");
+    let entity_id = ack_finish_configuration_event.conn_id;
+    {
+        let mut conn_state = state.universe.get_mut::<ConnectionState>(entity_id)?;
+
+        *conn_state = ConnectionState::Play;
+
+        // add components to the entity after the connection state has been set to play.
+        // to avoid wasting resources on entities that are fetching stuff like server status etc.
+        state
+            .universe
+            .add_component::<Position>(entity_id, Position::default())?
+            .add_component::<Rotation>(entity_id, Rotation::default())?
+            .add_component::<OnGround>(entity_id, OnGround::default())?
+            .add_component::<ChunkReceiver>(entity_id, ChunkReceiver::default())?;
+
+        let mut writer = state.universe.get_mut::<StreamWriter>(entity_id)?;
+
+        writer // 21
+            .send_packet(&LoginPlayPacket::new(entity_id), &NetEncodeOpts::WithLength)
+            .await?;
+        writer // 29
+            .send_packet(
+                &SynchronizePlayerPositionPacket::default(), // The coordinates here should be used for the center chunk.
+                &NetEncodeOpts::WithLength,
+            )
+            .await?;
+        writer // 37
+            .send_packet(
+                &SetDefaultSpawnPositionPacket::default(), // Player specific, aka. home, bed, where it would respawn.
+                &NetEncodeOpts::WithLength,
+            )
+            .await?;
+        writer // 38
+            .send_packet(
+                &GameEventPacket::start_waiting_for_level_chunks(),
+                &NetEncodeOpts::WithLength,
+            )
+            .await?;
+        writer // 41
+            .send_packet(
+                &SetCenterChunk::new(0, 0), // TODO - Dependent on the player spawn position.
+                &NetEncodeOpts::WithLength,
+            )
+            .await?;
+        writer // other
+            .send_packet(
+                &SetRenderDistance::new(5), // TODO
+                &NetEncodeOpts::WithLength,
+            )
+            .await?;
+
+        send_keep_alive(entity_id, &state, &mut writer).await?;
+
+        let pos = state.universe.get_mut::<Position>(entity_id)?;
+        let mut chunk_recv = state.universe.get_mut::<ChunkReceiver>(entity_id)?;
+        chunk_recv.last_chunk = Some((pos.x as i32, pos.z as i32, String::from("overworld")));
+        chunk_recv.calculate_chunks().await;
+    }
 
-    let conn_id = ack_finish_configuration_event.conn_id;
-
-    let mut conn_state = state.universe.get_mut::<ConnectionState>(conn_id)?;
-
-    *conn_state = ConnectionState::Play;
-
-    // add components to the entity after the connection state has been set to play.
-    // to avoid wasting resources on entities that are fetching stuff like server status etc.
-    state
-        .universe
-        .add_component::<Position>(conn_id, Position::default())?
-        .add_component::<Rotation>(conn_id, Rotation::default())?
-        .add_component::<OnGround>(conn_id, OnGround::default())?;
-
-    let mut writer = state.universe.get_mut::<StreamWriter>(conn_id)?;
-
-    writer // 21
-        .send_packet(&LoginPlayPacket::new(conn_id), &NetEncodeOpts::WithLength)
-        .await?;
-    writer // 29
-        .send_packet(
-            &SynchronizePlayerPositionPacket::default(), // The coordinates here should be used for the center chunk.
-            &NetEncodeOpts::WithLength,
-        )
-        .await?;
-    writer // 37
-        .send_packet(
-            &SetDefaultSpawnPositionPacket::default(), // Player specific, aka. home, bed, where it would respawn.
-            &NetEncodeOpts::WithLength,
-        )
-        .await?;
-    writer // 38
-        .send_packet(
-            &GameEventPacket::start_waiting_for_level_chunks(),
-            &NetEncodeOpts::WithLength,
-        )
-        .await?;
-    writer // 41
-        .send_packet(
-            &SetCenterChunk::new(0, 0), // TODO - Dependent on the player spawn position.
-            &NetEncodeOpts::WithLength,
-        )
-        .await?;
-    writer // other
-        .send_packet(
-            &SetRenderDistance::new(5), // TODO
-            &NetEncodeOpts::WithLength,
-        )
-        .await?;
-
-    let pos = state.universe.get_mut::<Position>(conn_id)?;
-    let mut chunk_recv = state.universe.get_mut::<ChunkReceiver>(conn_id)?;
-    chunk_recv.last_chunk = Some((pos.x as i32, pos.z as i32, String::from("overworld")));
-    chunk_recv.calculate_chunks().await;
-
-    send_keep_alive(conn_id, state, &mut writer).await?;
+    player_info_update_packets(entity_id, &state).await?;
+    broadcast_spawn_entity_packet(entity_id, &state).await?;
 
     Ok(ack_finish_configuration_event)
 }
 async fn send_keep_alive(
     conn_id: usize,
-    state: GlobalState,
+    state: &GlobalState,
     writer: &mut ComponentRefMut<'_, StreamWriter>,
 ) -> Result<(), NetError> {
     let keep_alive_packet = OutgoingKeepAlivePacket::default();
@@ -226,3 +237,63 @@ async fn send_keep_alive(
 
     Ok(())
 }
+
+async fn player_info_update_packets(entity_id: Entity, state: &GlobalState) -> NetResult<()> {
+    // Broadcasts a player info update packet to all players.
+    {
+        let packet = PlayerInfoUpdatePacket::new_player_join_packet(entity_id, state);
+
+        let start = Instant::now();
+        broadcast(
+            &packet,
+            state,
+            BroadcastOptions::default().except([entity_id]),
+        )
+        .await?;
+        trace!(
+            "Broadcasting player info update took: {:?}",
+            start.elapsed()
+        );
+    }
+
+    // Tell the player about all the other players that are already connected.
+    {
+        let packet = PlayerInfoUpdatePacket::existing_player_info_packet(entity_id, state);
+
+        let start = Instant::now();
+        let mut writer = state.universe.get_mut::<StreamWriter>(entity_id)?;
+        writer
+            .send_packet(&packet, &NetEncodeOpts::WithLength)
+            .await?;
+        debug!("Sending player info update took: {:?}", start.elapsed());
+    }
+
+    Ok(())
+}
+
+async fn broadcast_spawn_entity_packet(entity_id: Entity, state: &GlobalState) -> NetResult<()> {
+    let packet = SpawnEntityPacket::player(entity_id, state)?;
+
+    let start = Instant::now();
+    broadcast(
+        &packet,
+        state,
+        BroadcastOptions::default().except([entity_id]),
+    )
+    .await?;
+    trace!("Broadcasting spawn entity took: {:?}", start.elapsed());
+
+    let writer = state.universe.get_mut::<StreamWriter>(entity_id)?;
+    futures::stream::iter(get_all_play_players(state))
+        .fold(writer, |mut writer, entity| async move {
+            if let Ok(packet) = SpawnEntityPacket::player(entity, state) {
+                let _ = writer
+                    .send_packet(&packet, &NetEncodeOpts::WithLength)
+                    .await;
+            }
+            writer
+        })
+        .await;
+
+    Ok(())
+}

src/bin/src/packet_handlers/mod.rs

@@ -1,5 +1,6 @@
 mod animations;
 mod handshake;
 mod login_process;
+mod player;
+mod player_leave;
 mod tick_handler;
-mod transform;

src/bin/src/packet_handlers/player/do_action.rs

@@ -0,0 +1,38 @@
+use ferrumc_macros::event_handler;
+use ferrumc_net::errors::NetError;
+use ferrumc_net::packets::incoming::player_command::{PlayerCommandAction, PlayerDoActionEvent};
+use ferrumc_net::packets::outgoing::entity_metadata::{EntityMetadata, EntityMetadataPacket};
+use ferrumc_net::utils::broadcast::broadcast;
+use ferrumc_state::GlobalState;
+use tracing::trace;
+
+#[event_handler]
+async fn handle_player_do_action(
+    event: PlayerDoActionEvent,
+    state: GlobalState,
+) -> Result<PlayerDoActionEvent, NetError> {
+    trace!("player just did: {:?}", event.action);
+
+    match event.action {
+        PlayerCommandAction::StartSneaking => {
+            let packet = EntityMetadataPacket::new(
+                event.entity_id,
+                [
+                    EntityMetadata::entity_sneaking_visual(),
+                    EntityMetadata::entity_sneaking_pressed(),
+                ],
+            );
+
+            broadcast(&packet, &state, Default::default()).await?;
+        }
+        PlayerCommandAction::StopSneaking => {
+            let packet =
+                EntityMetadataPacket::new(event.entity_id, [EntityMetadata::entity_standing()]);
+
+            broadcast(&packet, &state, Default::default()).await?;
+        }
+        _ => {}
+    }
+
+    Ok(event)
+}

src/bin/src/packet_handlers/player/mod.rs

@@ -0,0 +1,3 @@
+pub mod do_action;
+pub mod see_other_players;
+pub mod update_player_position;

src/bin/src/packet_handlers/player/see_other_players.rs

@@ -0,0 +1,36 @@
+use ferrumc_core::transform::grounded::OnGround;
+use ferrumc_core::transform::position::Position;
+use ferrumc_core::transform::rotation::Rotation;
+use ferrumc_macros::event_handler;
+use ferrumc_net::errors::NetError;
+use ferrumc_net::packets::outgoing::set_head_rotation::SetHeadRotationPacket;
+use ferrumc_net::packets::outgoing::teleport_entity::TeleportEntityPacket;
+use ferrumc_net::packets::packet_events::TransformEvent;
+use ferrumc_net::utils::broadcast::{broadcast, BroadcastOptions};
+use ferrumc_net::utils::ecs_helpers::EntityExt;
+use ferrumc_net_codec::net_types::angle::NetAngle;
+use ferrumc_state::GlobalState;
+
+#[event_handler(priority = "normal")]
+async fn handle_player_move(
+    event: TransformEvent,
+    state: GlobalState,
+) -> Result<TransformEvent, NetError> {
+    let entity = event.conn_id;
+
+    let pos = entity.get::<Position>(&state)?;
+    let rot = entity.get::<Rotation>(&state)?;
+    let grounded = entity.get::<OnGround>(&state)?;
+
+    let teleport_packet = TeleportEntityPacket::new(entity, &pos, &rot, grounded.0);
+    let head_rot_packet =
+        SetHeadRotationPacket::new(entity as i32, NetAngle::from_degrees(rot.yaw as f64));
+
+    let start = std::time::Instant::now();
+    broadcast(&teleport_packet, &state, BroadcastOptions::default().all()).await?;
+    broadcast(&head_rot_packet, &state, BroadcastOptions::default().all()).await?;
+
+    tracing::trace!("broadcasting entity move took {:?}", start.elapsed());
+
+    Ok(event)
+}

src/bin/src/packet_handlers/transform/update_player_position.rs src/bin/src/packet_handlers/player/update_player_position.rs

@@ -9,12 +9,13 @@ use ferrumc_net::utils::ecs_helpers::EntityExt;
 use ferrumc_state::GlobalState;
 use tracing::trace;
 
-#[event_handler]
+#[event_handler(priority = "fastest")]
 async fn handle_player_move(
     event: TransformEvent,
     state: GlobalState,
 ) -> Result<TransformEvent, NetError> {
     let conn_id = event.conn_id;
+
     if let Some(ref new_position) = event.position {
         trace!("Getting chunk_recv 1 for player move");
         {
@@ -43,6 +44,7 @@ async fn handle_player_move(
         trace!("Getting position 1 for player move");
         let mut position = conn_id.get_mut::<Position>(&state)?;
         trace!("Got position 1 for player move");
+
         *position = Position::new(new_position.x, new_position.y, new_position.z);
     }
 

src/bin/src/packet_handlers/player_leave.rs

@@ -0,0 +1,28 @@
+use ferrumc_macros::event_handler;
+use ferrumc_net::connection::PlayerDisconnectEvent;
+use ferrumc_net::errors::NetError;
+use ferrumc_net::packets::outgoing::remove_entities::RemoveEntitiesPacket;
+use ferrumc_net::utils::broadcast::{broadcast, BroadcastOptions};
+use ferrumc_state::GlobalState;
+use tracing::info;
+
+#[event_handler]
+async fn handle_player_disconnect(
+    event: PlayerDisconnectEvent,
+    state: GlobalState,
+) -> Result<PlayerDisconnectEvent, NetError> {
+    let entity_id = event.entity_id;
+
+    info!("Player disconnected: {:?}", entity_id);
+
+    let remove_entity_packet = RemoveEntitiesPacket::from_entities([entity_id]);
+
+    broadcast(
+        &remove_entity_packet,
+        &state,
+        BroadcastOptions::default().all(),
+    )
+    .await?;
+
+    Ok(event)
+}