Merge pull request #7 from firefly-zero/net

Multiplayer

Author: orsinium

src/bindings.rs

@@ -1,24 +1 @@
-#[link(wasm_import_module = "fs")]
-extern {
-    pub(crate) fn get_rom_file_size(path_ptr: u32, path_len: u32) -> u32;
-    pub(crate) fn get_file_size(path_ptr: u32, path_len: u32) -> u32;
-    pub(crate) fn load_rom_file(path_ptr: u32, path_len: u32, buf_ptr: u32, buf_len: u32) -> u32;
-    pub(crate) fn load_file(path_ptr: u32, path_len: u32, buf_ptr: u32, buf_len: u32) -> u32;
-    pub(crate) fn dump_file(path_ptr: u32, path_len: u32, buf_ptr: u32, buf_len: u32) -> u32;
-    pub(crate) fn remove_file(path_ptr: u32, path_len: u32);
-}
 
-#[link(wasm_import_module = "input")]
-extern {
-    pub(crate) fn read_pad(player: u32) -> u32;
-    pub(crate) fn read_buttons(player: u32) -> u32;
-}
-
-#[link(wasm_import_module = "misc")]
-extern {
-    pub(crate) fn log_debug(ptr: u32, len: u32);
-    pub(crate) fn log_error(ptr: u32, len: u32);
-    pub(crate) fn set_seed(seed: u32);
-    pub(crate) fn get_random() -> u32;
-    pub(crate) fn quit();
-}

src/fs.rs

@@ -67,15 +67,14 @@ impl<'a> File<'a> {
 /// Functions for accessing files in the app ROM.
 pub mod rom {
     use super::*;
-    use crate::bindings as b;
 
     /// Determine the required size (in bytes) to store the given file.
     ///
     /// If the file does not exist, 0 is returned.
     #[must_use]
     pub fn get_size(name: &str) -> usize {
         let path_ptr = name.as_ptr();
-        let size = unsafe { b::get_rom_file_size(path_ptr as u32, name.len() as u32) };
+        let size = unsafe { bindings::get_rom_file_size(path_ptr as u32, name.len() as u32) };
         size as usize
     }
 
@@ -87,7 +86,7 @@ pub mod rom {
         let path_ptr = name.as_ptr();
         let buf_ptr = buf.as_mut_ptr();
         unsafe {
-            b::load_rom_file(
+            bindings::load_rom_file(
                 path_ptr as u32,
                 name.len() as u32,
                 buf_ptr as u32,
@@ -123,15 +122,14 @@ pub mod rom {
 /// The device owner may empty this dir if they wish to remove the app data.
 pub mod data {
     use super::*;
-    use crate::bindings as b;
 
     /// Get a file size in the data dir.
     ///
     /// If the file does not exist, 0 is returned.
     #[must_use]
     pub fn get_size(name: &str) -> usize {
         let path_ptr = name.as_ptr();
-        let size = unsafe { b::get_file_size(path_ptr as u32, name.len() as u32) };
+        let size = unsafe { bindings::get_file_size(path_ptr as u32, name.len() as u32) };
         size as usize
     }
 
@@ -143,7 +141,7 @@ pub mod data {
         let path_ptr = name.as_ptr();
         let buf_ptr = buf.as_mut_ptr();
         unsafe {
-            b::load_file(
+            bindings::load_file(
                 path_ptr as u32,
                 name.len() as u32,
                 buf_ptr as u32,
@@ -178,7 +176,7 @@ pub mod data {
         let path_ptr = name.as_ptr();
         let buf_ptr = buf.as_ptr();
         unsafe {
-            b::dump_file(
+            bindings::dump_file(
                 path_ptr as u32,
                 name.len() as u32,
                 buf_ptr as u32,
@@ -191,7 +189,7 @@ pub mod data {
     pub fn remove(name: &str) {
         let path_ptr = name.as_ptr();
         unsafe {
-            b::remove_file(path_ptr as u32, name.len() as u32);
+            bindings::remove_file(path_ptr as u32, name.len() as u32);
         }
     }
 }
@@ -256,3 +254,20 @@ pub struct SubImage<'a> {
     pub(crate) size: Size,
     pub(crate) raw: &'a [u8],
 }
+
+mod bindings {
+    #[link(wasm_import_module = "fs")]
+    extern {
+        pub(crate) fn get_rom_file_size(path_ptr: u32, path_len: u32) -> u32;
+        pub(crate) fn get_file_size(path_ptr: u32, path_len: u32) -> u32;
+        pub(crate) fn load_rom_file(
+            path_ptr: u32,
+            path_len: u32,
+            buf_ptr: u32,
+            buf_len: u32,
+        ) -> u32;
+        pub(crate) fn load_file(path_ptr: u32, path_len: u32, buf_ptr: u32, buf_len: u32) -> u32;
+        pub(crate) fn dump_file(path_ptr: u32, path_len: u32, buf_ptr: u32, buf_len: u32) -> u32;
+        pub(crate) fn remove_file(path_ptr: u32, path_len: u32);
+    }
+}

src/input.rs

@@ -1,6 +1,6 @@
 //! Read inputs: touch pad, buttons, accelerometer.
 
-use crate::{bindings as b, *};
+use crate::*;
 
 const DPAD_THRESHOLD: i32 = 100;
 
@@ -203,11 +203,10 @@ impl Buttons {
 }
 
 /// Get the current touch pad state.
-///
-/// In singleplayer game, the player ID doesn't matter.
 #[must_use]
-pub fn read_pad(player: Player) -> Option<Pad> {
-    let raw = unsafe { b::read_pad(player.into()) };
+pub fn read_pad(p: Peer) -> Option<Pad> {
+    let p = u32::from(p.0);
+    let raw = unsafe { bindings::read_pad(p) };
     if raw == 0xffff {
         None
     } else {
@@ -219,11 +218,10 @@ pub fn read_pad(player: Player) -> Option<Pad> {
 }
 
 /// Get the currently pressed buttons.
-///
-/// In singleplayer game, the player ID doesn't matter.
 #[must_use]
-pub fn read_buttons(player: Player) -> Buttons {
-    let raw = unsafe { b::read_buttons(player.into()) };
+pub fn read_buttons(p: Peer) -> Buttons {
+    let p = u32::from(p.0);
+    let raw = unsafe { bindings::read_buttons(p) };
     Buttons {
         a: has_bit_set(raw, 0),
         b: has_bit_set(raw, 1),
@@ -238,3 +236,11 @@ pub fn read_buttons(player: Player) -> Buttons {
 fn has_bit_set(val: u32, bit: usize) -> bool {
     (val >> bit) & 0b1 != 0
 }
+
+mod bindings {
+    #[link(wasm_import_module = "input")]
+    extern {
+        pub(crate) fn read_pad(peer: u32) -> u32;
+        pub(crate) fn read_buttons(peer: u32) -> u32;
+    }
+}

src/misc.rs

@@ -1,11 +1,9 @@
-use crate::bindings as b;
-
 /// Log a debug message.
 pub fn log_debug(t: &str) {
     let ptr = t.as_ptr() as u32;
     let len = t.len() as u32;
     unsafe {
-        b::log_debug(ptr, len);
+        bindings::log_debug(ptr, len);
     }
 }
 
@@ -14,24 +12,35 @@ pub fn log_error(t: &str) {
     let ptr = t.as_ptr() as u32;
     let len = t.len() as u32;
     unsafe {
-        b::log_error(ptr, len);
+        bindings::log_error(ptr, len);
     }
 }
 
 /// Set the random seed.
 pub fn set_seed(seed: u32) {
     unsafe {
-        b::set_seed(seed);
+        bindings::set_seed(seed);
     }
 }
 
 /// Get a random value.
 #[must_use]
 pub fn get_random() -> u32 {
-    unsafe { b::get_random() }
+    unsafe { bindings::get_random() }
 }
 
 /// Exit the app after the current update is finished.
 pub fn quit() {
-    unsafe { b::quit() }
+    unsafe { bindings::quit() }
+}
+
+mod bindings {
+    #[link(wasm_import_module = "misc")]
+    extern {
+        pub(crate) fn log_debug(ptr: u32, len: u32);
+        pub(crate) fn log_error(ptr: u32, len: u32);
+        pub(crate) fn set_seed(seed: u32);
+        pub(crate) fn get_random() -> u32;
+        pub(crate) fn quit();
+    }
 }

src/net.rs

@@ -1,55 +1,114 @@
-/// The player ID.
+// The peer ID.
 #[derive(Copy, Clone, Eq, PartialEq, Hash, Debug)]
-pub enum Player {
-    P0,
-    P1,
-    P2,
-    P3,
+pub struct Peer(pub(crate) u8);
+
+impl Peer {
+    pub const COMBINED: Self = Peer(0xFF);
 }
 
-impl Player {
-    /// Get all players.
-    #[inline]
+/// The list of peers online.
+///
+/// Includes all connected peers as well as the local device.
+///
+/// The order is deterministic between calls and between runs.
+#[derive(Copy, Clone, Eq, PartialEq, Debug)]
+pub struct Peers(pub(crate) u32);
+
+impl Peers {
+    /// Iterate over peers.
     #[must_use]
-    pub fn all() -> [Player; 4] {
-        use Player::{P0, P1, P2, P3};
-        [P0, P1, P2, P3]
+    pub fn iter(&self) -> PeersIter {
+        PeersIter {
+            peer: 0,
+            peers: self.0,
+        }
     }
 
-    /// Get all players except this one.
+    /// Check if the given peer is online.
     #[must_use]
-    pub fn others(&self) -> [Player; 3] {
-        use Player::{P0, P1, P2, P3};
-        match self {
-            P0 => [P1, P2, P3],
-            P1 => [P0, P2, P3],
-            P2 => [P0, P1, P3],
-            P3 => [P0, P1, P2],
-        }
+    pub fn contains(&self, p: &Peer) -> bool {
+        self.0 >> p.0 & 1 != 0
+    }
+
+    /// Get the number of peers online.
+    ///
+    /// Never zero. 1 for local single-player game. 2 or more for multiplayer.
+    #[must_use]
+    #[allow(clippy::len_without_is_empty)] // always non-empty
+    pub fn len(&self) -> usize {
+        self.0.count_ones() as usize
+    }
+
+    /// Convert the list of peers into a vector.
+    #[cfg(feature = "alloc")]
+    #[must_use]
+    pub fn as_vec(&self) -> alloc::vec::Vec<Peer> {
+        self.iter().collect()
     }
 }
 
-impl From<Player> for u32 {
-    fn from(value: Player) -> Self {
-        match value {
-            Player::P0 => 0,
-            Player::P1 => 1,
-            Player::P2 => 2,
-            Player::P3 => 3,
+impl IntoIterator for Peers {
+    type Item = Peer;
+    type IntoIter = PeersIter;
+
+    fn into_iter(self) -> Self::IntoIter {
+        PeersIter {
+            peer: 0,
+            peers: self.0,
         }
     }
 }
 
-impl TryFrom<usize> for Player {
-    type Error = ();
+pub struct PeersIter {
+    peer: u8,
+    peers: u32,
+}
+
+impl Iterator for PeersIter {
+    type Item = Peer;
 
-    fn try_from(value: usize) -> Result<Self, Self::Error> {
-        match value {
-            0 => Ok(Player::P0),
-            1 => Ok(Player::P1),
-            2 => Ok(Player::P2),
-            3 => Ok(Player::P3),
-            _ => Err(()),
+    fn next(&mut self) -> Option<Self::Item> {
+        while self.peers != 0 {
+            let peer = self.peer;
+            let peers = self.peers;
+            self.peer += 1;
+            self.peers >>= 1;
+            if peers & 1 != 0 {
+                return Some(Peer(peer));
+            }
         }
+        None
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        let size = self.peers.count_ones() as usize;
+        (size, Some(size))
+    }
+
+    fn count(self) -> usize {
+        self.peers.count_ones() as usize
+    }
+}
+
+/// Get the peer cirresponding to the local device.
+#[must_use]
+pub fn get_me() -> Peer {
+    let me = unsafe { bindings::get_me() };
+    Peer(me as u8)
+}
+
+/// Get the list of peers online.
+#[must_use]
+pub fn get_peers() -> Peers {
+    let peers = unsafe { bindings::get_peers() };
+    Peers(peers)
+}
+
+/// Internal bindings to the raw runtime functions.
+mod bindings {
+    #[link(wasm_import_module = "net")]
+    extern {
+        pub(crate) fn get_me() -> u32;
+        pub(crate) fn get_peers() -> u32;
     }
 }