Add bare minimum single-user multiplayer functionality #30

rc_multiplayer/src/events/activate_sync.rs

@@ -2,8 +2,8 @@ pub struct RequestLoadingSync {
     msg_router: tokio::sync::mpsc::Sender<crate::matches::GameMessage>,
 }
 
-pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::dataless::Dataless<RequestLoadingSync> {
-    crate::handlers::dataless::Dataless::new(RequestLoadingSync::new(init_ctx))
+pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::Dataless<RequestLoadingSync> {
+    crate::handlers::Dataless::new(RequestLoadingSync::new(init_ctx))
 }
 
 impl RequestLoadingSync {
@@ -15,7 +15,7 @@ impl RequestLoadingSync {
 }
 
 #[async_trait::async_trait]
-impl crate::handlers::dataless::DatalessEventCodeHandler for RequestLoadingSync {
+impl crate::handlers::DatalessEventCodeHandler for RequestLoadingSync {
     const CODE: rlnl::event_code::NetworkEvent = rlnl::event_code::NetworkEvent::RequestSync;
 
     async fn handle(&self, _peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, user: &crate::UserData, _sender: &std::sync::Arc<literustlib_server::DataSender<crate::PacketData>>) {

rc_multiplayer/src/events/all_loading_progress.rs

@@ -2,8 +2,8 @@ pub struct RequestAllLoadingProgress {
     msg_router: tokio::sync::mpsc::Sender<crate::matches::GameMessage>,
 }
 
-pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::dataless::Dataless<RequestAllLoadingProgress> {
-    crate::handlers::dataless::Dataless::new(RequestAllLoadingProgress::new(init_ctx))
+pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::Dataless<RequestAllLoadingProgress> {
+    crate::handlers::Dataless::new(RequestAllLoadingProgress::new(init_ctx))
 }
 
 impl RequestAllLoadingProgress {
@@ -15,7 +15,7 @@ impl RequestAllLoadingProgress {
 }
 
 #[async_trait::async_trait]
-impl crate::handlers::dataless::DatalessEventCodeHandler for RequestAllLoadingProgress {
+impl crate::handlers::DatalessEventCodeHandler for RequestAllLoadingProgress {
     const CODE: rlnl::event_code::NetworkEvent = rlnl::event_code::NetworkEvent::RequestLoadingProgressAllUsers;
 
     async fn handle(&self, _peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, user: &crate::UserData, _sender: &std::sync::Arc<literustlib_server::DataSender<crate::PacketData>>) {

rc_multiplayer/src/events/loading_done.rs

@@ -0,0 +1,30 @@
+pub struct LoadComplete {
+    msg_router: tokio::sync::mpsc::Sender<crate::matches::GameMessage>,
+}
+
+pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::Dataless<LoadComplete> {
+    crate::handlers::Dataless::new(LoadComplete::new(init_ctx))
+}
+
+impl LoadComplete {
+    fn new(init_ctx: &crate::InitConfig) -> Self {
+        Self {
+            msg_router: init_ctx.matches_chann.clone(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::handlers::DatalessEventCodeHandler for LoadComplete {
+    const CODE: rlnl::event_code::NetworkEvent = rlnl::event_code::NetworkEvent::LoadingComplete;
+
+    async fn handle(&self, _peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, user: &crate::UserData, _sender: &std::sync::Arc<literustlib_server::DataSender<crate::PacketData>>) {
+        if let Some(user_info) = user.user().await {
+            super::log_channel_send_failure(self.msg_router.send(crate::matches::GameMessage::LoadComplete {
+                user_id: user_info.user_id(),
+            }).await);
+        } else {
+            log::error!("Failed to handle sync loading request for unknown user");
+        }
+    }
+}

rc_multiplayer/src/events/loading_progress.rs

@@ -2,8 +2,8 @@ pub struct GameLoadingProgress {
     msg_router: tokio::sync::mpsc::Sender<crate::matches::GameMessage>,
 }
 
-pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::simple_typed::SimpleRlnl<rlnl::events::loading::LoadingProgress, GameLoadingProgress> {
-    crate::handlers::simple_typed::SimpleRlnl::new(GameLoadingProgress::new(init_ctx))
+pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::SimpleRlnl<rlnl::events::loading::LoadingProgress, GameLoadingProgress> {
+    crate::handlers::SimpleRlnl::new(GameLoadingProgress::new(init_ctx))
 }
 
 impl GameLoadingProgress {
@@ -15,7 +15,7 @@ impl GameLoadingProgress {
 }
 
 #[async_trait::async_trait]
-impl crate::handlers::simple_typed::RlnlEventCodeHandler for GameLoadingProgress {
+impl crate::handlers::RlnlEventCodeHandler for GameLoadingProgress {
     type In = rlnl::events::loading::LoadingProgress;
     const CODE: rlnl::event_code::NetworkEvent = rlnl::event_code::NetworkEvent::BroadcastLoadingProgress;
 

rc_multiplayer/src/events/mod.rs

@@ -3,6 +3,8 @@ mod loading_progress;
 mod all_loading_progress;
 mod weapon_select;
 mod activate_sync;
+mod loading_done;
+//mod player_input;
 
 pub async fn handler(init_ctx: &crate::InitConfig) -> crate::handler::LnlEventHandler {
     crate::handler::LnlEventHandler::new(init_ctx.users.clone(), crate::vehicle_motion::handler(init_ctx))
@@ -11,6 +13,35 @@ pub async fn handler(init_ctx: &crate::InitConfig) -> crate::handler::LnlEventHa
         .add(all_loading_progress::handler(init_ctx))
         .add(weapon_select::handler(init_ctx))
         .add(activate_sync::handler(init_ctx))
+        .add(loading_done::handler(init_ctx))
+        //.add(player_input::handler(init_ctx))
+        .add(crate::handlers::Broadcaster::<
+            true,
+            {rlnl::event_code::NetworkEvent::OnPlayerInputChanged as i16},
+            {rlnl::event_code::NetworkEvent::OnServerReceivedInputChange as i16},
+            {literustlib::packet::Property::Unreliable as u8},
+            rlnl::events::ingame::MultiPlayerInputChanged,
+        >::handler(init_ctx))
+        .add(crate::handlers::DatalessBroadcaster::<
+            true,
+            {rlnl::event_code::NetworkEvent::AlignmentRectifierStarted as i16},
+            {rlnl::event_code::NetworkEvent::AlignmentRectifierStarted as i16},
+            {literustlib::packet::Property::Unreliable as u8},
+        >::handler(init_ctx))
+        .add(crate::handlers::Broadcaster::<
+            true,
+            {rlnl::event_code::NetworkEvent::FireWeaponEffect as i16},
+            {rlnl::event_code::NetworkEvent::FireWeaponEffect as i16},
+            {literustlib::packet::Property::Unreliable as u8},
+            rlnl::events::ingame::WeaponFireEffect,
+        >::handler(init_ctx))
+        .add(crate::handlers::Broadcaster::<
+            true,
+            {rlnl::event_code::NetworkEvent::FireMiss as i16},
+            {rlnl::event_code::NetworkEvent::FireMiss as i16},
+            {literustlib::packet::Property::Unreliable as u8},
+            rlnl::events::ingame::FireMiss,
+        >::handler(init_ctx))
 }
 
 #[inline]

rc_multiplayer/src/events/player_input.rs

@@ -0,0 +1,34 @@
+pub struct PlayerInput {
+    msg_router: tokio::sync::mpsc::Sender<crate::matches::GameMessage>,
+}
+
+pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::simple_typed::SimpleRlnl<rlnl::events::ingame::MultiPlayerInputChanged, PlayerInput> {
+    crate::handlers::simple_typed::SimpleRlnl::new(PlayerInput::new(init_ctx))
+}
+
+impl PlayerInput {
+    fn new(init_ctx: &crate::InitConfig) -> Self {
+        Self {
+            msg_router: init_ctx.matches_chann.clone(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::handlers::simple_typed::RlnlEventCodeHandler for PlayerInput {
+    type In = rlnl::events::ingame::MultiPlayerInputChanged;
+    const CODE: rlnl::event_code::NetworkEvent = rlnl::event_code::NetworkEvent::OnPlayerInputChanged;
+
+    async fn handle(&self, data: Self::In, _peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, user: &crate::UserData, _sender: &std::sync::Arc<literustlib_server::DataSender<crate::PacketData>>) {
+        if let Some(user_info) = user.user().await {
+            super::log_channel_send_failure(self.msg_router.send(crate::matches::GameMessage::BroadcastRlnl {
+                user_id: user_info.user_id(),
+                event: rlnl::event_code::NetworkEvent::OnServerReceivedInputChange,
+                property: literustlib::packet::Property::Unreliable,
+                data: Some(Box::new(data)),
+            }).await);
+        } else {
+            log::error!("Failed to rebroadcast OnPlayerInputChanged for user (no auth!)");
+        }
+    }
+}

rc_multiplayer/src/events/validate_game_guid.rs

@@ -2,8 +2,8 @@ pub struct AuthUserGame {
     matches: tokio::sync::mpsc::Sender<crate::matches::GameMessage>,
 }
 
-pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::simple_typed::SimpleRlnl<rlnl::events::loading::GameGuidInfo, AuthUserGame> {
-    crate::handlers::simple_typed::SimpleRlnl::new(AuthUserGame::new(init_ctx))
+pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::SimpleRlnl<rlnl::events::loading::GameGuidInfo, AuthUserGame> {
+    crate::handlers::SimpleRlnl::new(AuthUserGame::new(init_ctx))
 }
 
 impl AuthUserGame {
@@ -15,7 +15,7 @@ impl AuthUserGame {
 }
 
 #[async_trait::async_trait]
-impl crate::handlers::simple_typed::RlnlEventCodeHandler for AuthUserGame {
+impl crate::handlers::RlnlEventCodeHandler for AuthUserGame {
     type In = rlnl::events::loading::GameGuidInfo;
     const CODE: rlnl::event_code::NetworkEvent = rlnl::event_code::NetworkEvent::ValidateGameGuid;
 

rc_multiplayer/src/events/weapon_select.rs

@@ -2,8 +2,8 @@ pub struct WeaponSelect {
     msg_router: tokio::sync::mpsc::Sender<crate::matches::GameMessage>,
 }
 
-pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::simple_typed::SimpleRlnl<rlnl::events::ingame::SelectWeapon, WeaponSelect> {
-    crate::handlers::simple_typed::SimpleRlnl::new(WeaponSelect::new(init_ctx))
+pub(super) fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::SimpleRlnl<rlnl::events::ingame::SelectWeapon, WeaponSelect> {
+    crate::handlers::SimpleRlnl::new(WeaponSelect::new(init_ctx))
 }
 
 impl WeaponSelect {
@@ -15,7 +15,7 @@ impl WeaponSelect {
 }
 
 #[async_trait::async_trait]
-impl crate::handlers::simple_typed::RlnlEventCodeHandler for WeaponSelect {
+impl crate::handlers::RlnlEventCodeHandler for WeaponSelect {
     type In = rlnl::events::ingame::SelectWeapon;
     const CODE: rlnl::event_code::NetworkEvent = rlnl::event_code::NetworkEvent::WeaponSelect;