cargo fmt

examples/text_image.rs

@@ -1,12 +1,14 @@
 use std::f32::consts::PI;
 
 use bevy::{
-    input::common_conditions::input_just_pressed, prelude::*, render::{
+    input::common_conditions::input_just_pressed,
+    prelude::*,
+    render::{
         camera::RenderTarget,
         render_resource::{
             Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
         },
-    }
+    },
 };
 
 fn main() {
@@ -15,8 +17,7 @@ fn main() {
         .add_systems(Startup, add_texture)
         .add_systems(
             Update,
-            rotate_mesh
+            rotate_mesh.run_if(input_just_pressed(KeyCode::Space)),
-                .run_if(input_just_pressed(KeyCode::Space)),
         )
         .run();
 }

src/camera.rs

@@ -5,8 +5,14 @@ pub(crate) struct CameraPlugin;
 
 impl Plugin for CameraPlugin {
     fn build(&self, app: &mut App) {
-		app.add_systems(Update, move_editor_fly_camera);
+        app.add_systems(
-		app.add_systems(Update, rotate_editor_fly_camera);
+            Update,
+            move_editor_fly_camera.run_if(any_with_component::<FlyCamera>),
+        );
+        app.add_systems(
+            Update,
+            rotate_editor_fly_camera.run_if(any_with_component::<FlyCamera>),
+        );
     }
 }
 
@@ -28,8 +34,9 @@ fn move_editor_fly_camera(
         KeyCode::KeyA,
         KeyCode::KeyD,
         KeyCode::KeyQ,
-		KeyCode::KeyE
+        KeyCode::KeyE,
-	])).then(|| {
+    ]))
+    .then(|| {
         // Iterate over all cameras
         cameras.iter_mut().for_each(|(c, mut t)| {
             // Determine which window this camera is attached to
@@ -90,9 +97,12 @@ fn rotate_editor_fly_camera(
             };
             let window = windows.get(target_window.unwrap()).unwrap();
             if mouse.pressed(MouseButton::Middle) {
-				cursor_events.read().filter_map(|CursorMoved { delta, window, .. }| {
+                cursor_events
+                    .read()
+                    .filter_map(|CursorMoved { delta, window, .. }| {
                         (*window == target_window.unwrap()).then_some(delta)
-				}).for_each(|delta| {
+                    })
+                    .for_each(|delta| {
                         if let Some(Vec2 { x, y }) = delta {
                             // Cribbing from bevy_flycam
                             // Link: https://github.com/sburris0/bevy_flycam/blob/baffe50e0961ad1491d467fa6ab5551f9f21db8f/src/lib.rs#L145-L151
@@ -101,7 +111,8 @@ fn rotate_editor_fly_camera(
                             let sensitivity = 0.00012;
                             pitch -= (sensitivity * y * window_scale).to_radians();
                             yaw -= (sensitivity * x * window_scale).to_radians();
-						t.rotation = Quat::from_axis_angle(Vec3::Y, yaw) * Quat::from_axis_angle(Vec3::X, pitch);
+                            t.rotation = Quat::from_axis_angle(Vec3::Y, yaw)
+                                * Quat::from_axis_angle(Vec3::X, pitch);
                         }
                     });
             } else {

src/editor.rs

@@ -7,10 +7,16 @@ impl Plugin for EditorPlugin {
     fn build(&self, app: &mut App) {
         app.init_state::<EditorState>();
         app.add_systems(Startup, init_editor);
-		app.add_systems(Update, toggle_editor.run_if(input_just_pressed(KeyCode::F3)));
+        app.add_systems(
+            Update,
+            toggle_editor.run_if(input_just_pressed(KeyCode::F3)),
+        );
         app.add_systems(OnEnter(EditorState::Open), open_editor);
         app.add_systems(OnExit(EditorState::Open), close_editor);
-		app.add_systems(Update, origin_directions.run_if(in_state(EditorState::Open)));
+        app.add_systems(
+            Update,
+            origin_directions.run_if(in_state(EditorState::Open)),
+        );
         app.add_systems(Update, world_plane.run_if(in_state(EditorState::Open)));
     }
 }
@@ -27,14 +33,13 @@ enum EditorState {
 struct Editor;
 
 /// Spawns all base editor entities including window, camera, and UI elements
-fn init_editor(
+fn init_editor(mut commands: Commands) {
-	mut commands: Commands
-) {
     // Spawn root editor entity hierarchy
-	commands.spawn(SpatialBundle { ..default() })
+    commands
+        .spawn(SpatialBundle { ..default() })
         .with_children(|parent| {
-
+            let editor_window = parent
-			let editor_window = parent.spawn((
+                .spawn((
                     Editor,
                     Window {
                         title: "Editor".into(),
@@ -42,10 +47,12 @@ fn init_editor(
                         visible: false,
                         ..default()
                     },
-			)).id();
+                ))
+                .id();
 
             // Spawn editor camera
-			let _editor_camera = parent.spawn((
+            let _editor_camera = parent
+                .spawn((
                     Editor,
                     FlyCamera,
                     Camera3dBundle {
@@ -53,24 +60,22 @@ fn init_editor(
                             target: RenderTarget::Window(WindowRef::Entity(editor_window)),
                             ..default()
                         },
-					transform: Transform::from_xyz(1.0, 1.0, 1.0).looking_at(Vec3::ZERO, Vec3::Y),
+                        transform: Transform::from_xyz(1.0, 1.0, 1.0)
+                            .looking_at(Vec3::ZERO, Vec3::Y),
                         ..default()
                     },
-			)).id();
+                ))
+                .id();
         });
 }
 
-fn open_editor(
+fn open_editor(mut ws: Query<&mut Window, With<Editor>>) {
-	mut ws: Query<&mut Window, With<Editor>>,
-) {
     ws.iter_mut().for_each(|mut w| {
         w.visible = true;
     });
 }
 
-fn close_editor(
+fn close_editor(mut ws: Query<&mut Window, With<Editor>>) {
-	mut ws: Query<&mut Window, With<Editor>>,
-) {
     ws.iter_mut().for_each(|mut w| {
         w.visible = false;
     });
@@ -93,17 +98,13 @@ fn toggle_editor(
     }
 }
 
-fn origin_directions(
+fn origin_directions(mut gizmos: Gizmos) {
-	mut gizmos: Gizmos
-) {
     gizmos.arrow(Vec3::ZERO, Vec3::X, Color::RED);
     gizmos.arrow(Vec3::ZERO, Vec3::Y, Color::GREEN);
     gizmos.arrow(Vec3::ZERO, Vec3::Z, Color::BLUE);
 }
 
-fn world_plane(
+fn world_plane(mut gizmos: Gizmos) {
-	mut gizmos: Gizmos
-) {
     (-10..=10).into_iter().for_each(|x| {
         (-10..=10).into_iter().for_each(|z| {
             {

src/game/dice.rs

@@ -141,8 +141,7 @@ fn move_die(
          }| {
             match state {
                 ButtonState::Pressed => {
-                    q.iter_mut().for_each(|mut t| {
+                    q.iter_mut().for_each(|mut t| match key_code {
-                        match key_code {
                         KeyCode::ArrowLeft => {
                             t.translation -= Vec3::X * time.delta_seconds() * 1000.0
                         }
@@ -156,7 +155,6 @@ fn move_die(
                             t.translation += Vec3::Y * time.delta_seconds() * 1000.0
                         }
                         _ => (),
-                        }
                     });
                 }
                 _ => (),

src/main.rs

@@ -29,13 +29,14 @@ use crate::prelude::*;
 
 fn main() {
     let mut app = App::new();
-    app.add_plugins(bevy::DefaultPlugins
+    app.add_plugins(
+        bevy::DefaultPlugins
             .set(low_latency_window_plugin())
             .set(WindowPlugin {
                 exit_condition: ExitCondition::OnPrimaryClosed,
                 close_when_requested: false,
                 ..default()
-        })
+            }),
     );
     app.add_plugins(bevy_mod_picking::DefaultPickingPlugins);
     app.add_plugins(menu::MenuPlugin);
@@ -43,8 +44,9 @@ fn main() {
     app.add_plugins(game::GamePlugin);
     app.add_plugins(editor::EditorPlugin);
     app.add_plugins(camera::CameraPlugin);
-    app.add_systems(Update, 
+    app.add_systems(
-        handle_window_close.run_if(on_event::<WindowCloseRequested>())
+        Update,
+        handle_window_close.run_if(on_event::<WindowCloseRequested>()),
     );
     app.run();
 }
@@ -75,10 +77,7 @@ fn handle_window_close(
         if primary.contains(*window) {
             commands.entity(*window).remove::<Window>();
         } else {
-            secondary
+            secondary.get_mut(*window).iter_mut().for_each(|w| {
-                .get_mut(*window)
-                .iter_mut()
-                .for_each(|w| {
                 w.visible = false;
             });
         }

src/prelude.rs

@@ -2,6 +2,7 @@ pub(crate) use std::fmt::Debug;
 
 /// Bevy imports
 pub(crate) use bevy::ecs::system::EntityCommand;
+pub(crate) use bevy::input::common_conditions::input_just_pressed;
 pub(crate) use bevy::input::keyboard::KeyboardInput;
 pub(crate) use bevy::input::ButtonState;
 pub(crate) use bevy::prelude::*;
@@ -9,14 +10,14 @@ pub(crate) use bevy::render::camera::RenderTarget;
 pub(crate) use bevy::render::render_resource::{
     Extent3d, TextureDescriptor, TextureDimension, TextureFormat, TextureUsages,
 };
+pub(crate) use bevy::window::ExitCondition;
 pub(crate) use bevy::window::WindowRef;
 pub(crate) use bevy::window::{PrimaryWindow, WindowCloseRequested};
-pub(crate) use bevy::window::ExitCondition;
-pub(crate) use bevy::input::common_conditions::input_just_pressed;
 
 /// Bevy Plugins
 pub(crate) use bevy_mod_picking::prelude::*;
 
+pub(crate) use crate::camera::FlyCamera;
 /// Intra-project imports
 pub(crate) use crate::ecs::schedule::common_conditions::*;
 pub(crate) use crate::game::GameChoice;
@@ -30,4 +31,3 @@ pub(crate) use crate::ui::style::UiStyle;
 pub(crate) use crate::ui::title::UiTitle;
 pub(crate) use crate::ui::EmitEvent;
 pub(crate) use crate::ui::SetState;
-pub(crate) use crate::camera::FlyCamera;