Implement basic battle arena functionality #32

rc_multiplayer/src/handlers/gamemode_specific.rs

@@ -0,0 +1,42 @@
+#![allow(dead_code)]
+pub struct GamemodeSpecific<const EVENT: i16, const PROPERTY: u8, InOut: byteserde::des_slice::ByteDeserializeSlice<InOut> + crate::Broadcastable> {
+    msg_router: tokio::sync::mpsc::Sender<crate::matches::GameMessage>,
+    event: rlnl::event_code::NetworkEvent,
+    property: literustlib::packet::Property,
+    _in: std::marker::PhantomData<InOut>,
+}
+
+impl <const EVENT: i16, const PROPERTY: u8, InOut: byteserde::des_slice::ByteDeserializeSlice<InOut> + crate::Broadcastable> GamemodeSpecific<EVENT, PROPERTY, InOut> {
+    pub fn handler(init_ctx: &crate::InitConfig) -> crate::handlers::simple_typed::SimpleRlnl<InOut, Self> {
+        crate::handlers::simple_typed::SimpleRlnl::new(GamemodeSpecific::new(init_ctx))
+    }
+
+    fn new(init_ctx: &crate::InitConfig) -> Self {
+        Self {
+            msg_router: init_ctx.matches_chann.clone(),
+            event: crate::handler::i16_to_event_or_panic(EVENT),
+            property: literustlib::packet::Property::try_from(PROPERTY).expect("Invalid literustlib packet property"),
+            _in: std::marker::PhantomData::default(),
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl <const EVENT: i16, const PROPERTY: u8, InOut: byteserde::des_slice::ByteDeserializeSlice<InOut> + crate::Broadcastable> crate::handlers::simple_typed::RlnlEventCodeHandler for GamemodeSpecific<EVENT, PROPERTY, InOut> {
+    type In = InOut;
+    const CODE: rlnl::event_code::NetworkEvent = crate::handler::i16_to_event_or_panic(EVENT);
+
+    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 {
+            crate::events::log_channel_send_failure(self.msg_router.send(crate::matches::GameMessage::RebroadcastRlnl {
+                skip_user_id: user_info.user_id(),
+                event: self.event,
+                event_in: Self::CODE,
+                property: self.property,
+                data: Some(Box::new(data)),
+            }).await);
+        } else {
+            log::error!("Failed to send gamemode specifc event {:?} for user (no auth!)", self.event);
+        }
+    }
+}

rc_multiplayer/src/handlers/ingame_broadcast.rs

@@ -47,7 +47,7 @@ impl <const EXCLUDE_SENDER: bool, const CODE_IN: i16, const CODE_OUT: i16, const
             }
 
         } else {
-            log::error!("Failed to rebroadcast OnPlayerInputChanged for user (no auth!)");
+            log::error!("Failed to rebroadcast {:?}->{:?} for user (no auth!)", Self::CODE, self.code_out);
         }
     }
 }

rc_multiplayer/src/handlers/ingame_broadcast_dataless.rs

@@ -44,7 +44,7 @@ impl <const EXCLUDE_SENDER: bool, const CODE_IN: i16, const CODE_OUT: i16, const
             }
 
         } else {
-            log::error!("Failed to rebroadcast OnPlayerInputChanged for user (no auth!)");
+            log::error!("Failed to rebroadcast {:?}-?{:?} for user (no auth!)", Self::CODE, self.code_out);
         }
     }
 }

rc_multiplayer/src/handlers/mod.rs

@@ -11,6 +11,10 @@ mod ingame_broadcast_dataless;
 #[allow(unused_imports)]
 pub use ingame_broadcast_dataless::DatalessBroadcaster;
 
+mod gamemode_specific;
+#[allow(unused_imports)]
+pub use gamemode_specific::GamemodeSpecific;
+
 mod stub;
 #[allow(unused_imports)]
 pub use stub::Stub;

rc_multiplayer/src/handlers/simple_typed.rs

@@ -27,6 +27,7 @@ impl <In: byteserde::des_slice::ByteDeserializeSlice<In> + Send, H: RlnlEventCod
         let mut des = byteserde::des_slice::ByteDeserializerSlice::new(&data);
         match In::byte_deserialize(&mut des) {
             Ok(rlnl_data) => {
+                //log::info!("Received {:?} message", H::CODE);
                 self.handler.handle(rlnl_data, peer, user, sender).await;
             },
             Err(e) => {
@@ -54,6 +55,7 @@ impl <'a> RlnlSender<'a> {
 
     pub async fn send_data<D: byteserde::ser_heap::ByteSerializeHeap + ?Sized>(&self, data: &D, event: rlnl::event_code::NetworkEvent, property: literustlib::packet::Property, conn: &literustlib_server::Connection<crate::PacketData>) -> std::io::Result<usize> {
         let mut ser = byteserde::ser_heap::ByteSerializerHeap::default();
+        //log::info!("Sending dataful event {:?} {:?}", event, property);
         data.byte_serialize_heap(&mut ser).map_err(|e| std::io::Error::new(std::io::ErrorKind::Unsupported, e.message))?;
         let event_data = crate::handler::EventData::with_data(
             crate::data::MessageType::ServerMsg,
@@ -64,6 +66,7 @@ impl <'a> RlnlSender<'a> {
     }
 
     pub async fn send_empty(&self, event: rlnl::event_code::NetworkEvent, property: literustlib::packet::Property, conn: &literustlib_server::Connection<crate::PacketData>) -> std::io::Result<usize> {
+        //log::info!("Sending dataless event {:?} {:?}", event, property);
         let event_data = crate::handler::EventData::without_data(crate::data::MessageType::ServerMsg, event);
         self.sender.send_data(event_data, property, conn).await
     }