Channel Support for Networking

Cargo.toml

@@ -11,7 +11,7 @@ napi = { version = "2.16.8", features = ["tokio_rt", "napi6", "serde-json"] }
 napi-derive = "2.16.9"
 lazy_static = "1"
 tokio = { version = "1", features = ["sync", "time"] }
-steamworks = { git = "https://github.com/Noxime/steamworks-rs/", rev = "fbb79635b06b4feea8261e5ca3e8ea3ef42facf9", features = ["serde"] }
+steamworks = { git = "https://github.com/Noxime/steamworks-rs/", rev = "5fc8ef13d52e82068f031535446d786cf0bd60a8", features = ["serde"] }
 serde = "1"
 serde_json = "1"
 

client.d.ts

@@ -184,8 +184,11 @@ export declare namespace networking {
     ReliableWithBuffering = 3
   }
   export function sendP2PPacket(steamId64: bigint, sendType: SendType, data: Buffer): boolean
+  export function sendP2PPacketOnChannel(steamId64: bigint, sendType: SendType, data: Buffer, channel: number): boolean
   export function isP2PPacketAvailable(): number
+  export function isP2PPacketAvailableOnChannel(channel: number): number
   export function readP2PPacket(size: number): P2PPacket
+  export function readP2PPacketFromChannel(size: number, channel: number): P2PPacket
   export function acceptP2PSession(steamId64: bigint): void
 }
 export declare namespace overlay {

src/api/networking.rs

@@ -41,9 +41,19 @@ pub mod networking {
         steam_id64: BigInt,
         send_type: SendType,
         data: Buffer,
+    ) -> Result<bool, Error> {
+        self::send_p2p_packet_on_channel(steam_id64, send_type, data, 0)
+    }
+
+    #[napi]
+    pub fn send_p2p_packet_on_channel(
+        steam_id64: BigInt,
+        send_type: SendType,
+        data: Buffer,
+        channel: i32,
     ) -> Result<bool, Error> {
         let client = crate::client::get_client();
-        let result = client.networking().send_p2p_packet(
+        let result = client.networking().send_p2p_packet_on_channel(
             SteamId::from_raw(steam_id64.get_u64().1),
             match send_type {
                 SendType::Unreliable => steamworks::SendType::Unreliable,
@@ -52,27 +62,38 @@ pub mod networking {
                 SendType::ReliableWithBuffering => steamworks::SendType::ReliableWithBuffering,
             },
             &data,
+            channel
         );
         Ok(result)
     }
 
     #[napi]
     pub fn is_p2p_packet_available() -> i32 {
+        self::is_p2p_packet_available_on_channel(0)
+    }
+
+    #[napi]
+    pub fn is_p2p_packet_available_on_channel(channel: i32) -> i32 {
         let client = crate::client::get_client();
         client
             .networking()
-            .is_p2p_packet_available()
+            .is_p2p_packet_available_on_channel(channel)
             .unwrap_or_default() as i32
     }
 
     #[napi]
     pub fn read_p2p_packet(size: i32) -> Result<P2PPacket, Error> {
+        self::read_p2p_packet_from_channel(size, 0)
+    }
+
+    #[napi]
+    pub fn read_p2p_packet_from_channel(size: i32, channel: i32) -> Result<P2PPacket, Error> {
         let client = crate::client::get_client();
         let mut buffer = vec![0; size as usize];
 
         client
             .networking()
-            .read_p2p_packet(&mut buffer)
+            .read_p2p_packet_from_channel(&mut buffer, channel)
             .map(|(steam_id, read_size)| P2PPacket {
                 data: buffer.into(),
                 size: read_size as i32,