Create first event handler and framework for it

Cargo.lock

@@ -3335,6 +3335,7 @@ version = "0.3.0"
 dependencies = [
  "async-trait",
  "bytes",
+ "byteserde",
  "clap",
  "env_logger",
  "literustlib",

rc_multiplayer/Cargo.toml

@@ -15,6 +15,7 @@ clap.workspace = true
 oj_rc_core = { version = "*", path = "../rc_core" }
 async-trait.workspace = true
 bytes = "1.10"
+byteserde = "0.6.2"
 
 literustlib_server = { version = "0.1", path = "../../LiteRustLib/server" }
 literustlib = { version = "0.1", path = "../../LiteRustLib" }

rc_multiplayer/src/events/mod.rs

@@ -0,0 +1,6 @@
+mod validate_game_guid;
+
+pub async fn handler(init_ctx: &crate::InitConfig) -> crate::handler::LnlEventHandler {
+    crate::handler::LnlEventHandler::new()
+        .add(validate_game_guid::handler(init_ctx))
+}

rc_multiplayer/src/events/validate_game_guid.rs

@@ -0,0 +1,25 @@
+pub struct AuthUserGame {
+
+}
+
+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))
+}
+
+impl AuthUserGame {
+    fn new(_init_ctx: &crate::InitConfig) -> Self {
+        Self {
+
+        }
+    }
+}
+
+#[async_trait::async_trait]
+impl crate::handlers::simple_typed::RlnlEventCodeHandler for AuthUserGame {
+    type In = rlnl::events::loading::GameGuidInfo;
+    const CODE: rlnl::event_code::NetworkEvent = rlnl::event_code::NetworkEvent::ValidateGameGuid;
+
+    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>) {
+        log::debug!("Got {:?} event with data {:?}", Self::CODE, data);
+    }
+}

rc_multiplayer/src/handler.rs

@@ -1,15 +1,18 @@
 pub struct LnlEventHandler {
-    event_handlers: std::collections::HashMap<u16, Box<dyn super::EventCodeHandler>>,
+    event_handlers: std::collections::HashMap<i16, Box<dyn super::EventCodeHandler>>,
 }
 
 impl LnlEventHandler {
-    pub async fn new(init_ctx: &crate::InitConfig) -> Self {
-        let mut event_handlers = std::collections::HashMap::new();
-        // init event code handlers
+    pub fn new() -> Self {
         Self {
-            event_handlers
+            event_handlers: std::collections::HashMap::new(),
         }
     }
+
+    pub fn add<H: super::EventCode + super::EventCodeHandler + 'static>(mut self, handler: H) -> Self {
+        self.event_handlers.insert(H::CODE, Box::new(handler));
+        self
+    }
 }
 
 #[async_trait::async_trait]
@@ -19,7 +22,7 @@ impl literustlib_server::EventHandler for LnlEventHandler {
 
     async fn on_receive(&self, data: Self::PacketData, _header: &literustlib::packet::Header, peer: &std::sync::Arc< literustlib_server::Connection<Self::PacketData>>, user: &Self::UserData, sender: &literustlib_server::DataSender<Self::PacketData>) {
         log::debug!("Got event {:?} (len: {}) from connection id {}", data.variant, data.data.len(), peer.id());
-        if let Some(handler) = self.event_handlers.get(&(data.variant as u16)) {
+        if let Some(handler) = self.event_handlers.get(&(data.variant as i16)) {
             handler.handle(&data.data, peer, user, sender).await;
         } else {
             #[cfg(debug_assertions)]
@@ -38,7 +41,7 @@ impl literustlib_server::EventHandler for LnlEventHandler {
         //let mut buf = Vec::new();
         //literustlib::packet::Packet::with_data(literustlib::packet::Property::Reliable, &[9, 0, 0, 0, 0, 0]).dump(&mut buf).unwrap_or_default();
         //socket.send_to(&buf, addr).await.unwrap_or_default();
-        Some(())
+        Some(crate::UserData::new())
     }
 
     async fn on_connect_done(&self, peer: &std::sync::Arc< literustlib_server::Connection<Self::PacketData>>, _user: &Self::UserData, sender: &literustlib_server::DataSender<Self::PacketData>) {
@@ -65,7 +68,6 @@ impl literustlib::packet::PacketData for EventData {
     fn parse(bytes: bytes::Bytes, _header: &literustlib::packet::Header) -> std::io::Result<Self> {
         if bytes.len() >= 6 {
             let data = bytes.slice(6..);
-            let slice: &[u8] = &bytes[0..6];
             let net_message_num = i16::from_le_bytes([bytes[0], bytes[1]]);
             let net_message_type = crate::data::MessageType::from_i16(net_message_num).ok_or_else(|| std::io::Error::new(std::io::ErrorKind::Unsupported, format!("Unsupported message type {}", net_message_num)))?;
             let event_code = i16::from_le_bytes([bytes[2], bytes[3]]);

rc_multiplayer/src/handlers/mod.rs

@@ -0,0 +1 @@
+pub mod simple_typed;

rc_multiplayer/src/handlers/simple_typed.rs

@@ -0,0 +1,37 @@
+pub struct SimpleRlnl<In: byteserde::des_slice::ByteDeserializeSlice<In>, H: RlnlEventCodeHandler<In=In>> {
+    //_in: std::marker::PhantomData<In>,
+    //_out: std::marker::PhantomData<Out>,
+    handler: H,
+}
+
+impl <In: byteserde::des_slice::ByteDeserializeSlice<In>, H: RlnlEventCodeHandler<In=In>> SimpleRlnl<In, H> {
+    pub fn new(inner: H) -> Self {
+        Self {
+            handler: inner,
+        }
+    }
+}
+
+#[async_trait::async_trait]
+pub trait RlnlEventCodeHandler: Sync + Send {
+    type In: byteserde::des_slice::ByteDeserializeSlice<Self::In>;
+    //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_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>) {
+        let mut des = byteserde::des_slice::ByteDeserializerSlice::new(&data);
+        let rlnl_data = In::byte_deserialize(&mut des).expect("Bad serialization");
+        self.handler.handle(rlnl_data, peer, user, sender).await;
+    }
+}
+
+impl <In: byteserde::des_slice::ByteDeserializeSlice<In>, H: RlnlEventCodeHandler<In=In>> crate::EventCode for SimpleRlnl<In, H> {
+    const CODE: i16 = H::CODE as i16;
+}
+
+

rc_multiplayer/src/main.rs

@@ -1,8 +1,11 @@
 mod cli;
 mod handler;
 mod traits;
-pub use traits::{EventCodeHandler, UserData, PacketData};
+pub use traits::{EventCodeHandler, UserData, PacketData, EventCode};
 mod data;
+mod events;
+mod handlers;
+mod user;
 
 pub struct InitConfig {
     pub config: oj_rc_core::persist::config::ConfigImpl,
@@ -27,7 +30,7 @@ async fn main() -> std::io::Result<()> {
     };
 
     let mtu = oj_rc_core::ConfigProvider::<()>::network_config(&init_ctx.config).max_packet_size;
-    let event_handler = handler::LnlEventHandler::new(&init_ctx).await;
+    let event_handler = events::handler(&init_ctx).await;
     let server = literustlib_server::Server::new(event_handler, (args.ip, args.port), mtu).await.expect("Bad server");
     server.listen().await
 }

rc_multiplayer/src/traits.rs

@@ -1,7 +1,11 @@
-pub type UserData = ();
+pub type UserData = crate::user::User;
 pub type PacketData = crate::handler::EventData;
 
 #[async_trait::async_trait]
 pub trait EventCodeHandler: Send + Sync {
     async fn handle(&self, data: &bytes::Bytes, peer: &std::sync::Arc<literustlib_server::Connection<PacketData>>, user: &UserData, sender: &literustlib_server::DataSender<PacketData>);
 }
+
+pub trait EventCode: EventCodeHandler {
+    const CODE: i16;
+}

rc_multiplayer/src/user.rs

@@ -0,0 +1,29 @@
+pub struct User {
+    state: tokio::sync::RwLock<UserState>,
+}
+
+impl User {
+    pub fn new() -> Self {
+        Self {
+            state: tokio::sync::RwLock::new(UserState::Connecting),
+        }
+    }
+
+    pub async fn authenticate(&self, info: rlnl::events::loading::GameGuidInfo) -> bool {
+        *self.state.write().await = UserState::Authenticated(UserInfo {
+            game: info.game_guid.0,
+            username: info.player_name.0,
+        });
+        true
+    }
+}
+
+enum UserState {
+    Connecting,
+    Authenticated(UserInfo),
+}
+
+pub struct UserInfo {
+    pub game: String,
+    pub username: String,
+}