Most of the way toward the final camera setup

Two cameras only, one for 2d one for 3d -- none of this camera-per-state bs.

Still have a bug with switching while in the menu, but otherwise things
are working well.

src/credits.rs

@@ -72,19 +72,6 @@ fn parse_credits(bytes: &[u8]) -> Result<CreditsText, Utf8Error> {
 struct Credits;
 
 fn init_credits_ui(mut commands: Commands, server: Res<AssetServer>) {
-    commands.spawn((
-        Credits,
-        Camera2dBundle {
-            camera: Camera {
-                is_active: false,
-                ..default()
-            },
-            ..default()
-        },
-        UiCameraConfig { show_ui: true },
-        Name::new("Credits Camera"),
-    ));
-
     commands
         .spawn((
             Credits,

src/display2d.rs

@@ -35,12 +35,22 @@ impl Plugin for Display2dPlugin {
                     set_transform
                         .after(game::update_board)
                         .run_if(any_component_changed::<BoardIndex>),
-                    set_piece_sprite.run_if(any_component_changed::<Side>).after(game::set_side),
+                    set_piece_sprite
+                        .run_if(any_component_changed::<Side>)
+                        .after(game::set_side),
                     set_tile_sprite.run_if(any_component_added::<game::Tile>),
                 ),
             )
             .add_systems(OnEnter(DisplayState::Display2d), activate::<Display2d>)
-            .add_systems(OnExit(DisplayState::Display2d), deactivate::<Display2d>);
+            .add_systems(OnExit(DisplayState::Display2d), deactivate::<Display2d>)
+            .add_systems(
+                OnEnter(GameState::Play),
+                activate::<Display2d>.run_if(in_state(DisplayState::Display2d)),
+            )
+            .add_systems(
+                OnExit(GameState::Play),
+                deactivate::<Display2d>.run_if(in_state(DisplayState::Display2d)),
+            );
     }
 }
 
@@ -61,6 +71,7 @@ struct BackgroundImage;
 fn initialize_camera(mut commands: Commands) {
     commands.spawn((
         Display2d,
+        DisplayState::Display2d,
         Camera2dBundle {
             camera: Camera {
                 is_active: false,

src/display3d.rs

@@ -35,7 +35,9 @@ impl Plugin for Display3dPlugin {
                     set_board_model.run_if(any_component_added::<game::BoardComponent>),
                     set_tile_hitbox.run_if(any_component_added::<game::Tile>),
                     set_piece_position.run_if(any_component_changed::<BoardIndex>),
-                    set_piece_texture.run_if(any_component_changed::<Side>).after(game::set_side),
+                    set_piece_texture
+                        .run_if(any_component_changed::<Side>)
+                        .after(game::set_side),
                     select
                         .run_if(in_state(GameState::Play))
                         .run_if(in_state(DisplayState::Display3d))
@@ -58,7 +60,15 @@ impl Plugin for Display3dPlugin {
                     .run_if(in_state(DisplayState::Display3d)),
             )
             .add_systems(OnEnter(DisplayState::Display3d), activate::<Display3d>)
-            .add_systems(OnExit(DisplayState::Display3d), deactivate::<Display3d>);
+            .add_systems(OnExit(DisplayState::Display3d), deactivate::<Display3d>)
+            .add_systems(
+                OnEnter(GameState::Play),
+                activate::<Display3d>.run_if(in_state(DisplayState::Display3d)),
+            )
+            .add_systems(
+                OnExit(GameState::Play),
+                deactivate::<Display3d>.run_if(in_state(DisplayState::Display3d)),
+            );
     }
 }
 
@@ -173,6 +183,7 @@ fn hydrate_camera(
             info!("Initialize 3d camera");
             commands.entity(entity).insert((
                 Display3d,
+                DisplayState::Display3d,
                 Camera3dBundle {
                     camera: Camera {
                         is_active: false,

src/game.rs

@@ -17,7 +17,9 @@ impl Plugin for GamePlugin {
                     cancel_place.run_if(|buttons: Res<Input<MouseButton>>| -> bool {
                         buttons.just_pressed(MouseButton::Right)
                     }),
-                    select_sync.run_if(any_component_added::<Selected>).after(deselect_sync),
+                    select_sync
+                        .run_if(any_component_added::<Selected>)
+                        .after(deselect_sync),
                     deselect_sync.run_if(any_component_removed::<Selected>()),
                     move_piece.run_if(any_component_added::<Selected>),
                     capture_piece.run_if(any_component_added::<Captured>),
@@ -479,7 +481,10 @@ fn null_selections(
 ) {
     events.iter().for_each(|entity| {
         if selected_pieces.is_empty() {
-            info!("De-selecting piece that should not be selected {:?}", entity);
+            info!(
+                "De-selecting piece that should not be selected {:?}",
+                entity
+            );
             commands.entity(entity).remove::<Selected>();
             writer.send(audio::AudioEvent::PutDown);
         }

src/loading.rs

@@ -5,7 +5,6 @@ pub(crate) struct LoadingPlugin;
 impl Plugin for LoadingPlugin {
     fn build(&self, app: &mut App) {
         app.add_systems(Startup, initialize)
-            .add_systems(PostUpdate, deactivate_cameras.run_if(any_component_added::<Camera>))
             .add_systems(OnEnter(GameState::Loading), activate::<Loading>)
             .add_systems(OnExit(GameState::Loading), deactivate::<Loading>);
     }
@@ -15,19 +14,6 @@ impl Plugin for LoadingPlugin {
 struct Loading;
 
 fn initialize(mut commands: Commands) {
-    commands.spawn((
-        Loading,
-        Camera2dBundle {
-            camera: Camera {
-                is_active: false,
-                ..default()
-            },
-            ..default()
-        },
-        UiCameraConfig { show_ui: true },
-        Name::new("Loading Camera"),
-    ));
-
     commands
         .spawn((
             Loading,
@@ -62,11 +48,3 @@ fn initialize(mut commands: Commands) {
             },));
         });
 }
-
-fn deactivate_cameras(
-    mut events: Query<&mut Camera, (Added<Camera>, Without<Loading>)>
-) {
-    events.iter_mut().for_each(|mut camera| {
-        camera.is_active = false;
-    });
-}

src/main.rs

@@ -29,11 +29,22 @@ fn main() {
     let mut app = App::new();
     app.add_state::<GameState>();
     app.add_state::<DisplayState>();
-    app.add_systems(Update, state.run_if(resource_changed::<State<GameState>>()));
+    app.add_systems(
+        Update,
+        (
+            debug_state::<DisplayState>.run_if(resource_changed::<State<DisplayState>>()),
+            debug_state::<GameState>.run_if(resource_changed::<State<GameState>>()),
+        ),
+    );
     app.add_systems(Update, loading.run_if(in_state(GameState::Loading)));
     app.add_systems(
         Update,
+        (
             toggle_display_mode.run_if(on_event::<KeyboardInput>()),
+            // TODO: Run this other times too so we ensure a camera is always active
+            toggle_display_camera.run_if(state_changed::<DisplayState>()),
+            toggle_display_camera.run_if(state_changed::<GameState>()),
+        ),
     );
     app.add_plugins(
         DefaultPlugins
@@ -116,9 +127,8 @@ fn loading(
 /// System for printing the current state
 ///
 /// Only runs when state is modified.
-fn state(game_state: Res<State<GameState>>, display_state: Res<State<DisplayState>>) {
-    info!("Game State is {:?}", *game_state);
-    info!("Display State is {:?}", *display_state);
+fn debug_state<S: States>(state: Res<State<S>>) {
+    info!("State change {:?}", *state);
 }
 
 fn toggle_display_mode(
@@ -139,25 +149,26 @@ fn toggle_display_mode(
         })
 }
 
+fn toggle_display_camera(
+    state: Res<State<DisplayState>>,
+    mut cameras: Query<(&mut Camera, &DisplayState)>,
+) {
+    cameras.iter_mut().for_each(|(mut camera, display_state)| {
+        camera.is_active = display_state == state.get();
+    });
+}
+
 fn activate<Marker: Component>(
-    mut cameras: Query<&mut Camera, With<Marker>>,
     mut entities: Query<&mut Visibility, (With<Marker>, Without<game::Captured>)>,
 ) {
-    cameras.iter_mut().for_each(|mut camera| {
-        camera.is_active = true;
-    });
     entities.iter_mut().for_each(|mut visibility| {
         *visibility = Visibility::Visible;
     });
 }
 
 fn deactivate<Marker: Component>(
-    mut cameras: Query<&mut Camera, With<Marker>>,
     mut entities: Query<&mut Visibility, (With<Marker>, Without<game::Captured>)>,
 ) {
-    cameras.iter_mut().for_each(|mut camera| {
-        camera.is_active = false;
-    });
     entities.iter_mut().for_each(|mut visibility| {
         *visibility = Visibility::Hidden;
     });

src/menu.rs

@@ -33,18 +33,6 @@ struct Menu;
 struct Quit;
 
 fn init_menu_ui(mut commands: Commands) {
-    commands.spawn((
-        Menu,
-        Camera2dBundle {
-            camera: Camera {
-                is_active: false,
-                ..default()
-            },
-            ..default()
-        },
-        UiCameraConfig { show_ui: true },
-        Name::new("Menu Camera"),
-    ));
     commands
         .spawn((
             Menu,
@@ -67,7 +55,6 @@ fn init_menu_ui(mut commands: Commands) {
             parent
                 .spawn((
                     GameState::Play,
-                    DisplayState::Display3d,
                     ButtonBundle {
                         style: Style {
                             padding: UiRect::all(Val::Px(5.0)),
@@ -81,7 +68,6 @@ fn init_menu_ui(mut commands: Commands) {
                 .with_children(|parent| {
                     parent.spawn((
                         GameState::Play,
-                        DisplayState::Display3d,
                         TextBundle::from_section(
                             "Start",
                             TextStyle {
@@ -150,14 +136,12 @@ fn init_menu_ui(mut commands: Commands) {
 }
 
 fn handle_menu_button(
-    events: Query<(&Interaction, &GameState, &DisplayState), (With<Button>, Changed<Interaction>)>,
+    events: Query<(&Interaction, &GameState), (With<Button>, Changed<Interaction>)>,
     mut next_gs: ResMut<NextState<GameState>>,
-    mut next_ds: ResMut<NextState<DisplayState>>,
 ) {
-    events.iter().for_each(|(i, gs, ds)| match i {
+    events.iter().for_each(|(i, gs)| match i {
         Interaction::Pressed => {
             next_gs.set(gs.clone());
-            next_ds.set(ds.clone());
         }
         _ => (),
     });