feat(spectator): 観戦者が任意のタイミングで途中参加できるようにする

junowen-lib/src/connection.rs

@@ -2,4 +2,7 @@ mod data_channel;
 mod peer_connection;
 pub mod signaling;
 
-pub use self::{data_channel::DataChannel, peer_connection::PeerConnection};
+pub use self::{
+    data_channel::DataChannel,
+    peer_connection::{BATTLE_PROTOCOL, PeerConnection, SPECTATOR_PROTOCOL},
+};

junowen-lib/src/connection/peer_connection.rs

@@ -77,7 +77,12 @@ impl Drop for PeerConnection {
     }
 }
 
-const PROTOCOL: &str = "JUNOWEN/1.1";
+/// 対戦用の接続のプロトコル。互換性のない変更をしたら上げる
+pub const BATTLE_PROTOCOL: &str = "JUNOWEN/1.1";
+/// 観戦用の接続のプロトコル。互換性のない変更をしたら上げる
+///
+/// 1.2: 試合開始時の状態を送り、いつ接続しても次の試合から観戦できるようにした
+pub const SPECTATOR_PROTOCOL: &str = "JUNOWEN/1.2";
 
 impl PeerConnection {
     pub async fn new(timeout: Duration, ice_server_urls: Vec<String>) -> Result<Self> {
@@ -130,13 +135,14 @@ impl PeerConnection {
         self.rtc.as_ref().unwrap()
     }
 
-    pub async fn start_as_offerer(&mut self) -> Result<CompressedSdp> {
+    /// `protocol` はデータチャネルのプロトコル
+    pub async fn start_as_offerer(&mut self, protocol: &'static str) -> Result<CompressedSdp> {
         let rtc_data_channel = self
             .rtc()
             .create_data_channel(
                 "data",
                 Some(RTCDataChannelInit {
-                    protocol: Some(PROTOCOL.to_owned()),
+                    protocol: Some(protocol.to_owned()),
                     ..Default::default()
                 }),
             )
@@ -197,11 +203,15 @@ impl PeerConnection {
         Ok(())
     }
 
-    pub async fn wait_for_open_data_channel(&mut self) -> Result<DataChannel> {
+    /// 相手のプロトコルが `protocol` と一致しない場合は接続を拒否する
+    pub async fn wait_for_open_data_channel(
+        &mut self,
+        protocol: &'static str,
+    ) -> Result<DataChannel> {
         let data_channel_task = async {
             let mut data_channel = self.data_channel_rx.take().unwrap().await.unwrap();
             data_channel.wait_for_open_data_channel().await;
-            if data_channel.protocol() != PROTOCOL {
+            if data_channel.protocol() != protocol {
                 bail!("unexpected protocol: {}", data_channel.protocol());
             }
             Ok(data_channel)

junowen-lib/src/connection/signaling/socket.rs

@@ -10,7 +10,7 @@ use async_trait::async_trait;
 
 use crate::connection::data_channel::DataChannel;
 
-use super::super::peer_connection::PeerConnection;
+use super::super::peer_connection::{BATTLE_PROTOCOL, PeerConnection};
 
 use super::CompressedSdp;
 
@@ -36,10 +36,15 @@ pub trait SignalingSocket {
         vec![DEFAULT_STUN_SERVER_URL.to_owned()]
     }
 
+    /// データチャネルのプロトコル。観戦用の接続では `SPECTATOR_PROTOCOL` を返す
+    fn protocol(&self) -> &'static str {
+        BATTLE_PROTOCOL
+    }
+
     async fn receive_signaling(&mut self) -> Result<(PeerConnection, DataChannel, bool)> {
         let mut conn = PeerConnection::new(Self::timeout(), self.ice_server_urls()).await?;
         let offer_desc = conn
-            .start_as_offerer()
+            .start_as_offerer(self.protocol())
             .await
             .context("Failed to start as host")?;
         let answer_desc = self.offer(offer_desc).await?;
@@ -60,7 +65,7 @@ pub trait SignalingSocket {
                 (conn, false)
             }
         };
-        let data_channel = conn.wait_for_open_data_channel().await?;
+        let data_channel = conn.wait_for_open_data_channel(self.protocol()).await?;
         Ok((conn, data_channel, host))
     }
 }

junowen-lib/src/connection/signaling/socket/channel_socket.rs

@@ -13,18 +13,21 @@ pub struct ChannelSocket {
     offer_sender: Option<oneshot::Sender<CompressedSdp>>,
     answer_sender: Option<oneshot::Sender<CompressedSdp>>,
     message_receiver: Option<oneshot::Receiver<SignalingServerMessage>>,
+    protocol: &'static str,
 }
 
 impl ChannelSocket {
     pub fn new(
         offer_sender: oneshot::Sender<CompressedSdp>,
         answer_sender: oneshot::Sender<CompressedSdp>,
         message_receiver: oneshot::Receiver<SignalingServerMessage>,
+        protocol: &'static str,
     ) -> Self {
         Self {
             offer_sender: Some(offer_sender),
             answer_sender: Some(answer_sender),
             message_receiver: Some(message_receiver),
+            protocol,
         }
     }
 }
@@ -35,6 +38,10 @@ impl SignalingSocket for ChannelSocket {
         Duration::from_secs(20 * 60)
     }
 
+    fn protocol(&self) -> &'static str {
+        self.protocol
+    }
+
     async fn offer(&mut self, desc: CompressedSdp) -> Result<OfferResponse> {
         self.offer_sender.take().unwrap().send(desc).unwrap();
         Ok(match self.message_receiver.take().unwrap().await? {

junowen-lib/src/th19/structs/app.rs

@@ -53,7 +53,7 @@ pub struct CharacterCursor {
     _unknown1: [u8; 0xd0],
 }
 
-#[derive(CopyGetters, Debug, MutGetters, Setters)]
+#[derive(CopyGetters, Debug, Getters, MutGetters, Setters)]
 #[repr(C)]
 pub struct Menu {
     #[getset(get_copy = "pub", get_mut = "pub", set = "pub")]

junowen-lib/src/th19/structs/selection.rs

@@ -3,16 +3,16 @@ use std::mem::transmute;
 use anyhow::{Result, bail};
 use getset::{Getters, MutGetters};
 
-/// length=c0
+/// length=c8
 #[repr(C)]
 pub struct Player {
     _unknown1: [u8; 0x0c],
     /// NOT available on player select screen
     pub character: u32,
-    _unknown2: [u8; 0x80],
-    /// Available on player select screen
+    _unknown2: [u8; 0x84],
+    /// Available on player select screen (+94h)
     pub card: u32,
-    _unknown3: [u8; 0x34],
+    _unknown3: [u8; 0x30],
 }
 
 #[derive(Clone, Copy, PartialEq)]

junowen/src/custom_direct_3d/custom_direct_3d_device_9.rs

@@ -138,6 +138,9 @@ where
         hdestwindowoverride: HWND,
         pdirtyregion: *const RGNDATA,
     ) -> windows::core::Result<()> {
+        if self.delegate.should_skip_present() {
+            return Ok(());
+        }
         self.delegate.on_before_present(&self.instance);
         unsafe {
             self.instance

junowen/src/custom_direct_3d/direct_3d_device_event_listener.rs

@@ -1,5 +1,7 @@
 use windows::Win32::Graphics::Direct3D9::IDirect3DDevice9;
 
 pub trait Direct3DDeviceEventListener {
+    /// 表示を間引く場合は `true` を返す
+    fn should_skip_present(&self) -> bool;
     fn on_before_present(&self, device: &IDirect3DDevice9);
 }

junowen/src/helper.rs

@@ -9,3 +9,8 @@ pub fn pushed_f1(input_devices: &InputDevices) -> bool {
     let raw_keys = input_devices.keyboard_input().raw_keys();
     raw_keys[0x70] & 0x80 != 0
 }
+
+pub fn pushed_escape(input_devices: &InputDevices) -> bool {
+    let raw_keys = input_devices.keyboard_input().raw_keys();
+    raw_keys[0x1b] & 0x80 != 0
+}

junowen/src/junowen.rs

@@ -90,6 +90,10 @@ impl Th19EventListener for Junowen {
 }
 
 impl Direct3DDeviceEventListener for &Junowen {
+    fn should_skip_present(&self) -> bool {
+        self.state.should_skip_present()
+    }
+
     fn on_before_present(&self, device: &IDirect3DDevice9) {
         if !self.title_menu_modifier.selected_junowen() {
             return;

junowen/src/lib.rs

@@ -3,6 +3,7 @@ mod file;
 mod helper;
 mod junowen;
 mod lobby;
+mod present_skipper;
 mod session;
 mod signaling;
 mod state;

junowen/src/lobby/pure_p2p_guest.rs

@@ -3,8 +3,9 @@ use std::ffi::c_void;
 use clipboard_win::set_clipboard_string;
 use junowen_lib::{
     Th19,
-    connection::signaling::{
-        SignalingCodeType, socket::async_read_write_socket::SignalingServerMessage,
+    connection::{
+        BATTLE_PROTOCOL,
+        signaling::{SignalingCodeType, socket::async_read_write_socket::SignalingServerMessage},
     },
     structs::input_devices::InputValue,
 };
@@ -45,7 +46,11 @@ impl PureP2pGuest {
                     0,
                 ),
             ),
-            signaling: Signaling::new(session_tx, |conn, dc| BattleSession::new(conn, dc, false)),
+            signaling: Signaling::new(
+                session_tx,
+                |conn, dc| BattleSession::new(conn, dc, false),
+                BATTLE_PROTOCOL,
+            ),
             session_rx: Some(session_rx),
             offer: None,
             answer_generated: false,

junowen/src/lobby/pure_p2p_offerer.rs

@@ -35,6 +35,7 @@ pub struct PureP2pOfferer<T> {
     offer_type: SignalingCodeType,
     answer_type: SignalingCodeType,
     create_session: fn(PeerConnection, DataChannel) -> T,
+    protocol: &'static str,
     messages: Messages,
     common_menu: CommonMenu,
     signaling: Signaling,
@@ -52,6 +53,7 @@ where
         offer_type: SignalingCodeType,
         answer_type: SignalingCodeType,
         create_session: fn(PeerConnection, DataChannel) -> T,
+        protocol: &'static str,
         label: &'static str,
         messages: Messages,
     ) -> Self {
@@ -60,9 +62,10 @@ where
             offer_type,
             answer_type,
             create_session,
+            protocol,
             messages,
             common_menu: make_menu(label),
-            signaling: Signaling::new(session_tx, create_session),
+            signaling: Signaling::new(session_tx, create_session, protocol),
             session_rx: Some(session_rx),
             answer: None,
             copy_state: 0,
@@ -185,6 +188,7 @@ where
             self.offer_type,
             self.answer_type,
             self.create_session,
+            self.protocol,
             self.common_menu.root_title(),
             self.messages,
         );

junowen/src/lobby/pure_p2p_offerer/role.rs

@@ -1,4 +1,4 @@
-use junowen_lib::connection::signaling::SignalingCodeType;
+use junowen_lib::connection::{BATTLE_PROTOCOL, SPECTATOR_PROTOCOL, signaling::SignalingCodeType};
 
 use crate::session::{battle::BattleSession, spectator::SpectatorSession};
 
@@ -17,6 +17,7 @@ pub fn pure_p2p_host() -> PureP2pOfferer<BattleSession> {
         SignalingCodeType::BattleOffer,
         SignalingCodeType::BattleAnswer,
         |pc, dc| BattleSession::new(pc, dc, true),
+        BATTLE_PROTOCOL,
         "Connect as a Host",
         Messages {
             share: "pure_p2p.host_share",
@@ -31,6 +32,7 @@ pub fn pure_p2p_spectator() -> PureP2pOfferer<SpectatorSession> {
         SignalingCodeType::SpectatorOffer,
         SignalingCodeType::SpectatorAnswer,
         SpectatorSession::new,
+        SPECTATOR_PROTOCOL,
         "Connect as a Spectator",
         Messages {
             share: "pure_p2p.spectator_share",

junowen/src/present_skipper.rs

@@ -0,0 +1,42 @@
+//! 観戦者がホストに追いつくまでの早送り中は、画面の表示 (`Present`) を間引く
+//!
+//! 試合中は、ゲームの no wait 設定を有効にしても処理が速くならない。
+//! 表示のたびに垂直同期を待つため、1 秒あたり 60 フレームに抑えられていると考えられる。
+//! そこで表示を間引き、この待ちを減らす。
+
+use std::sync::atomic::{AtomicU32, Ordering};
+
+/// 早送りを要求されてから、表示を間引き続けるフレーム数。
+/// 要求が途絶えたら (セッションが終了した場合など) すぐに通常の表示に戻す
+const SKIP_FRAMES_PER_REQUEST: u32 = 2;
+/// 間引いている間も、このフレーム数ごとに1回は表示する
+const PRESENT_INTERVAL: u32 = 8;
+
+#[derive(Default)]
+pub struct PresentSkipper {
+    remaining_frames: AtomicU32,
+    counter: AtomicU32,
+}
+
+impl PresentSkipper {
+    /// 早送り中は毎フレーム呼ぶ
+    pub fn request_skip(&self) {
+        self.remaining_frames
+            .store(SKIP_FRAMES_PER_REQUEST, Ordering::Relaxed);
+    }
+
+    /// 表示を間引く場合は `true` を返す
+    pub fn should_skip_present(&self) -> bool {
+        let requested = self
+            .remaining_frames
+            .fetch_update(Ordering::Relaxed, Ordering::Relaxed, |x| x.checked_sub(1))
+            .is_ok();
+        if !requested {
+            return false;
+        }
+        !self
+            .counter
+            .fetch_add(1, Ordering::Relaxed)
+            .is_multiple_of(PRESENT_INTERVAL)
+    }
+}

junowen/src/session/session_message.rs

@@ -6,7 +6,7 @@ pub struct MatchInitial {
     pub game_settings: GameSettings,
 }
 
-#[derive(Debug, Deserialize, Serialize)]
+#[derive(Clone, Debug, Deserialize, Serialize)]
 pub struct RoundInitial {
     pub seed1: u32,
     pub seed2: u32,