Get part way through loading (to sync) #30

rc_multiplayer/src/handlers/dataless.rs

@@ -0,0 +1,29 @@
+pub struct Dataless<H: DatalessEventCodeHandler> {
+    handler: H,
+}
+
+impl <H: DatalessEventCodeHandler> Dataless<H> {
+    pub fn new(inner: H) -> Self {
+        Self {
+            handler: inner,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+pub trait DatalessEventCodeHandler: Sync + Send {
+    const CODE: rlnl::event_code::NetworkEvent;
+
+    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>>);
+}
+
+#[async_trait::async_trait]
+impl <H: DatalessEventCodeHandler> crate::EventCodeHandler for Dataless<H> {
+    async fn handle(&self, _data: &bytes::Bytes, peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, user: &crate::UserData, sender: &std::sync::Arc<literustlib_server::DataSender<crate::PacketData>>) {
+        self.handler.handle(peer, user, sender).await;
+    }
+}
+
+impl <H: DatalessEventCodeHandler> crate::EventCode for Dataless<H> {
+    const CODE: i16 = H::CODE as i16;
+}

rc_multiplayer/src/handlers/mod.rs

@@ -1 +1,2 @@
 pub mod simple_typed;
+pub mod dataless;

rc_multiplayer/src/handlers/simple_typed.rs

@@ -18,14 +18,14 @@ pub trait RlnlEventCodeHandler: Sync + Send {
     //type Out: byteserde::ser_heap::ByteSerializeHeap;
     const CODE: rlnl::event_code::NetworkEvent;
 
-    async fn handle(&self, data: Self::In, peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, user: &crate::UserData, sender: &literustlib_server::DataSender<crate::PacketData>);
+    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>>);
 }
 
 #[async_trait::async_trait]
 impl <In: byteserde::des_slice::ByteDeserializeSlice<In>, H: RlnlEventCodeHandler<In=In>> crate::EventCodeHandler for SimpleRlnl<In, H> {
-    async fn handle(&self, data: &bytes::Bytes, peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, user: &crate::UserData, sender: &literustlib_server::DataSender<crate::PacketData>) {
+    async fn handle(&self, data: &bytes::Bytes, peer: &std::sync::Arc<literustlib_server::Connection<crate::PacketData>>, user: &crate::UserData, sender: &std::sync::Arc<literustlib_server::DataSender<crate::PacketData>>) {
         let mut des = byteserde::des_slice::ByteDeserializerSlice::new(&data);
-        let rlnl_data = In::byte_deserialize(&mut des).expect("Bad serialization");
+        let rlnl_data = In::byte_deserialize(&mut des).expect("Bad deserialization");
         self.handler.handle(rlnl_data, peer, user, sender).await;
     }
 }
@@ -34,4 +34,33 @@ impl <In: byteserde::des_slice::ByteDeserializeSlice<In>, H: RlnlEventCodeHandle
     const CODE: i16 = H::CODE as i16;
 }
 
+pub struct RlnlSender<'a> {
+    sender: &'a literustlib_server::DataSender<crate::PacketData>,
+}
+
+impl <'a> RlnlSender<'a> {
+    #[inline]
+    pub fn new(inner: &'a literustlib_server::DataSender<crate::PacketData>) -> Self {
+        Self {
+            sender: inner,
+        }
+    }
+
+    pub async fn send_data<D: byteserde::ser_heap::ByteSerializeHeap>(&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();
+        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,
+            event,
+            bytes::Bytes::copy_from_slice(ser.as_slice()),
+        );
+        self.sender.send_data(event_data, property, conn).await
+    }
+
+    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> {
+        let event_data = crate::handler::EventData::without_data(crate::data::MessageType::ServerMsg, event);
+        self.sender.send_data(event_data, property, conn).await
+    }
+}
+