Impl multiplayer game readiness staging (#691)

crates/core/src/events.rs

@@ -10,6 +10,9 @@ use bevy::{
 
 use crate::gamestate::GameState;
 
+/// This plugin accumulates events received during [`GameState::Prepared`],
+/// [`GameState::Loading`] and [`GameState::Waiting`] and re-sends them on
+/// enter of [`GameState::Playing`].
 pub struct ResendEventPlugin<T: Event> {
     _marker: PhantomData<T>,
 }
@@ -24,10 +27,14 @@ impl<T: Event> Default for ResendEventPlugin<T> {
 
 impl<T: Event> Plugin for ResendEventPlugin<T> {
     fn build(&self, app: &mut App) {
-        app.add_systems(OnEnter(GameState::Loading), setup::<T>)
+        app.add_systems(OnEnter(GameState::Prepared), setup::<T>)
             .add_systems(
                 Update,
-                enqueue_events::<T>.run_if(in_state(GameState::Loading)),
+                enqueue_events::<T>.run_if(
+                    in_state(GameState::Prepared)
+                        .or_else(in_state(GameState::Loading))
+                        .or_else(in_state(GameState::Waiting)),
+                ),
             )
             .add_systems(
                 OnEnter(GameState::Playing),

crates/core/src/gamestate.rs

@@ -9,7 +9,7 @@ impl Plugin for GameStateSetupPlugin {
     fn build(&self, app: &mut App) {
         app.add_plugins((
             GameStatePlugin,
-            ProgressPlugin::new(GameState::Loading).continue_to(GameState::Playing),
+            ProgressPlugin::new(GameState::Loading).continue_to(GameState::Waiting),
         ));
     }
 }
@@ -20,13 +20,21 @@ nested_state!(
     enter = setup,
     exit = cleanup,
     variants = {
+        // The game is ready for initialization. Waiting for other players to
+        // get to the state as well.
+        Prepared,
+        // The game is being initialized locally and possibly by other players
+        // as well.
         Loading,
+        // The game is locally initialized, waiting for other player to finish
+        // initialization as well.
+        Waiting,
         Playing,
     }
 );
 
 fn setup(mut next_state: ResMut<NextState<GameState>>) {
-    next_state.set(GameState::Loading);
+    next_state.set(GameState::Prepared);
 }
 
 fn cleanup(mut commands: Commands) {

crates/core/src/gconfig.rs

@@ -10,13 +10,15 @@ use crate::player::{Player, PlayerRange};
 #[derive(Resource)]
 pub struct GameConfig {
     map_path: PathBuf,
+    multiplayer: bool,
     locals: LocalPlayers,
 }
 
 impl GameConfig {
-    pub fn new<P: Into<PathBuf>>(map_path: P, locals: LocalPlayers) -> Self {
+    pub fn new<P: Into<PathBuf>>(map_path: P, multiplayer: bool, locals: LocalPlayers) -> Self {
         Self {
             map_path: map_path.into(),
+            multiplayer,
             locals,
         }
     }
@@ -25,6 +27,10 @@ impl GameConfig {
         self.map_path.as_path()
     }
 
+    pub fn multiplayer(&self) -> bool {
+        self.multiplayer
+    }
+
     pub fn locals(&self) -> &LocalPlayers {
         &self.locals
     }
@@ -95,6 +101,7 @@ mod tests {
     fn test_game_config() {
         let config = GameConfig::new(
             "/some/path",
+            false,
             LocalPlayers::from_max_player(Player::Player1, Player::Player4),
         );
         assert_eq!(config.map_path().to_string_lossy(), "/some/path");

crates/loader/Cargo.toml

@@ -13,12 +13,14 @@ categories.workspace = true
 
 [dependencies]
 # DE
+de_camera.workspace = true
+de_conf.workspace = true
 de_core.workspace = true
 de_map.workspace = true
-de_terrain.workspace = true
+de_messages.workspace = true
+de_multiplayer.workspace = true
 de_spawner.workspace = true
-de_camera.workspace = true
-de_conf.workspace = true
+de_terrain.workspace = true
 
 # Other
 bevy.workspace = true

crates/loader/src/lib.rs

@@ -1,12 +1,16 @@
 use bevy::{app::PluginGroupBuilder, prelude::PluginGroup};
 use map::MapLoaderPlugin;
+use readiness::ReadinessPlugin;
 
 mod map;
+mod readiness;
 
 pub struct LoaderPluginGroup;
 
 impl PluginGroup for LoaderPluginGroup {
     fn build(self) -> PluginGroupBuilder {
-        PluginGroupBuilder::start::<Self>().add(MapLoaderPlugin)
+        PluginGroupBuilder::start::<Self>()
+            .add(MapLoaderPlugin)
+            .add(ReadinessPlugin)
     }
 }

crates/loader/src/readiness.rs

@@ -0,0 +1,47 @@
+use bevy::prelude::*;
+use de_core::{gamestate::GameState, gconfig::GameConfig};
+use de_messages::Readiness;
+use de_multiplayer::{GameReadinessEvent, SetReadinessEvent};
+
+pub(crate) struct ReadinessPlugin;
+
+impl Plugin for ReadinessPlugin {
+    fn build(&self, app: &mut App) {
+        app.add_systems(
+            OnEnter(GameState::Prepared),
+            set_readiness(Readiness::Prepared),
+        )
+        .add_systems(
+            OnEnter(GameState::Waiting),
+            set_readiness(Readiness::Initialized),
+        )
+        .add_systems(
+            Update,
+            (
+                progress(Readiness::Prepared, GameState::Loading)
+                    .run_if(in_state(GameState::Prepared)),
+                progress(Readiness::Initialized, GameState::Playing)
+                    .run_if(in_state(GameState::Waiting)),
+            ),
+        );
+    }
+}
+
+fn set_readiness(readiness: Readiness) -> impl Fn(EventWriter<SetReadinessEvent>) {
+    move |mut events: EventWriter<SetReadinessEvent>| {
+        events.send(SetReadinessEvent::from(readiness));
+    }
+}
+
+fn progress(
+    readiness: Readiness,
+    target_state: GameState,
+) -> impl Fn(Res<GameConfig>, EventReader<GameReadinessEvent>, ResMut<NextState<GameState>>) {
+    move |conf: Res<GameConfig>,
+          mut events: EventReader<GameReadinessEvent>,
+          mut state: ResMut<NextState<GameState>>| {
+        if !conf.multiplayer() || events.iter().any(|e| **e == readiness) {
+            state.set(target_state);
+        }
+    }
+}

crates/menu/src/multiplayer/joined/state.rs

@@ -143,6 +143,7 @@ fn start(
 
     commands.insert_resource(GameConfig::new(
         map_path,
+        true,
         LocalPlayers::from_single(player.0),
     ));
     app_state.set(AppState::InGame);

crates/menu/src/singleplayer.rs

@@ -107,6 +107,7 @@ fn button_system(
                     Some(path) => {
                         commands.insert_resource(GameConfig::new(
                             path,
+                            false,
                             LocalPlayers::from_max_player(Player::Player1, Player::Player4),
                         ));
                         next_state.set(AppState::InGame);