diff --git a/examples/text_image.rs b/examples/text_image.rs
index 398c8fd..0dd8eb1 100644
--- a/examples/text_image.rs
+++ b/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
-                .run_if(input_just_pressed(KeyCode::Space)),
+            rotate_mesh.run_if(input_just_pressed(KeyCode::Space)),
         )
         .run();
 }
diff --git a/src/camera.rs b/src/camera.rs
index 0f50cc5..5777825 100644
--- a/src/camera.rs
+++ b/src/camera.rs
@@ -5,9 +5,15 @@ 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(Update, rotate_editor_fly_camera);
-	}
+        app.add_systems(
+            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>),
+        );
+    }
 }
 
 #[derive(Component)]
@@ -16,97 +22,102 @@ pub(crate) struct FlyCamera;
 /// Fly camera system for moving around like a drone
 /// TODO: Only if key is pressed!
 fn move_editor_fly_camera(
-	mut cameras: Query<(&Camera, &mut Transform), With<FlyCamera>>,
-	windows: Query<&Window>,
-	primary_window: Query<Entity, With<PrimaryWindow>>,
-	keys: Res<ButtonInput<KeyCode>>,
-	time: Res<Time>,
+    mut cameras: Query<(&Camera, &mut Transform), With<FlyCamera>>,
+    windows: Query<&Window>,
+    primary_window: Query<Entity, With<PrimaryWindow>>,
+    keys: Res<ButtonInput<KeyCode>>,
+    time: Res<Time>,
 ) {
-	(keys.any_pressed([
-		KeyCode::KeyW,
-		KeyCode::KeyS,
-		KeyCode::KeyA,
-		KeyCode::KeyD,
-		KeyCode::KeyQ,
-		KeyCode::KeyE
-	])).then(|| {
-		// Iterate over all cameras
-		cameras.iter_mut().for_each(|(c, mut t)| {
-			// Determine which window this camera is attached to
-			let target_window = match c.target {
-				RenderTarget::Window(wr) => match wr {
-					WindowRef::Entity(e) => Some(e),
-					WindowRef::Primary => Some(primary_window.get_single().unwrap()),
-				},
-				_ => None,
-			};
-			let window = windows.get(target_window.unwrap()).unwrap();
+    (keys.any_pressed([
+        KeyCode::KeyW,
+        KeyCode::KeyS,
+        KeyCode::KeyA,
+        KeyCode::KeyD,
+        KeyCode::KeyQ,
+        KeyCode::KeyE,
+    ]))
+    .then(|| {
+        // Iterate over all cameras
+        cameras.iter_mut().for_each(|(c, mut t)| {
+            // Determine which window this camera is attached to
+            let target_window = match c.target {
+                RenderTarget::Window(wr) => match wr {
+                    WindowRef::Entity(e) => Some(e),
+                    WindowRef::Primary => Some(primary_window.get_single().unwrap()),
+                },
+                _ => None,
+            };
+            let window = windows.get(target_window.unwrap()).unwrap();
 
-			// If the target window is focused
-			window.focused.then(|| {
-				let move_speed = 4.0;
-				let mut delta = Vec3::ZERO;
-				if keys.pressed(KeyCode::KeyW) {
-					delta += t.forward() * move_speed * time.delta_seconds()
-				}
-				if keys.pressed(KeyCode::KeyS) {
-					delta += t.back() * move_speed * time.delta_seconds()
-				}
-				if keys.pressed(KeyCode::KeyA) {
-					delta += t.left() * move_speed * time.delta_seconds()
-				}
-				if keys.pressed(KeyCode::KeyD) {
-					delta += t.right() * move_speed * time.delta_seconds()
-				}
-				if keys.pressed(KeyCode::KeyE) {
-					delta += Vec3::Y * move_speed * time.delta_seconds()
-				}
-				if keys.pressed(KeyCode::KeyQ) {
-					delta += Vec3::NEG_Y * move_speed * time.delta_seconds()
-				}
-				t.translation += delta;
-			});
-		});
-	});
+            // If the target window is focused
+            window.focused.then(|| {
+                let move_speed = 4.0;
+                let mut delta = Vec3::ZERO;
+                if keys.pressed(KeyCode::KeyW) {
+                    delta += t.forward() * move_speed * time.delta_seconds()
+                }
+                if keys.pressed(KeyCode::KeyS) {
+                    delta += t.back() * move_speed * time.delta_seconds()
+                }
+                if keys.pressed(KeyCode::KeyA) {
+                    delta += t.left() * move_speed * time.delta_seconds()
+                }
+                if keys.pressed(KeyCode::KeyD) {
+                    delta += t.right() * move_speed * time.delta_seconds()
+                }
+                if keys.pressed(KeyCode::KeyE) {
+                    delta += Vec3::Y * move_speed * time.delta_seconds()
+                }
+                if keys.pressed(KeyCode::KeyQ) {
+                    delta += Vec3::NEG_Y * move_speed * time.delta_seconds()
+                }
+                t.translation += delta;
+            });
+        });
+    });
 }
 
 fn rotate_editor_fly_camera(
-	mut cameras: Query<(&Camera, &mut Transform), With<FlyCamera>>,
-	windows: Query<&Window>,
-	primary_window: Query<Entity, With<PrimaryWindow>>,
-	mouse: Res<ButtonInput<MouseButton>>,
-	mut cursor_events: EventReader<CursorMoved>,
+    mut cameras: Query<(&Camera, &mut Transform), With<FlyCamera>>,
+    windows: Query<&Window>,
+    primary_window: Query<Entity, With<PrimaryWindow>>,
+    mouse: Res<ButtonInput<MouseButton>>,
+    mut cursor_events: EventReader<CursorMoved>,
 ) {
-	(cursor_events.len() > 0).then(|| {
-		// Iterate over all cameras
-		cameras.iter_mut().for_each(|(c, mut t)| {
-			// Determine which window this camera is attached to
-			let target_window = match c.target {
-				RenderTarget::Window(wr) => match wr {
-					WindowRef::Entity(e) => Some(e),
-					WindowRef::Primary => Some(primary_window.get_single().unwrap()),
-				},
-				_ => None,
-			};
-			let window = windows.get(target_window.unwrap()).unwrap();
-			if mouse.pressed(MouseButton::Middle) {
-				cursor_events.read().filter_map(|CursorMoved { delta, window, .. }| {
-					(*window == target_window.unwrap()).then_some(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
-						let (mut yaw, mut pitch, _) = t.rotation.to_euler(EulerRot::YXZ);
-						let window_scale = window.height().min(window.width());
-						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);
-					}
-				});
-			} else {
-				cursor_events.clear();
-			}
-		});
-	});
-}
\ No newline at end of file
+    (cursor_events.len() > 0).then(|| {
+        // Iterate over all cameras
+        cameras.iter_mut().for_each(|(c, mut t)| {
+            // Determine which window this camera is attached to
+            let target_window = match c.target {
+                RenderTarget::Window(wr) => match wr {
+                    WindowRef::Entity(e) => Some(e),
+                    WindowRef::Primary => Some(primary_window.get_single().unwrap()),
+                },
+                _ => None,
+            };
+            let window = windows.get(target_window.unwrap()).unwrap();
+            if mouse.pressed(MouseButton::Middle) {
+                cursor_events
+                    .read()
+                    .filter_map(|CursorMoved { delta, window, .. }| {
+                        (*window == target_window.unwrap()).then_some(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
+                            let (mut yaw, mut pitch, _) = t.rotation.to_euler(EulerRot::YXZ);
+                            let window_scale = window.height().min(window.width());
+                            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);
+                        }
+                    });
+            } else {
+                cursor_events.clear();
+            }
+        });
+    });
+}
diff --git a/src/editor.rs b/src/editor.rs
index adc42ef..cddda68 100644
--- a/src/editor.rs
+++ b/src/editor.rs
@@ -5,117 +5,118 @@ pub(crate) struct EditorPlugin;
 
 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(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, world_plane.run_if(in_state(EditorState::Open)));
-	}
+        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(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, world_plane.run_if(in_state(EditorState::Open)));
+    }
 }
 
 /// State tracking if the editor is open
 #[derive(States, Debug, Clone, PartialEq, Eq, Hash, Default, Component)]
 enum EditorState {
     #[default]
-	Closed,
-	Open,
+    Closed,
+    Open,
 }
 
 #[derive(Component)]
 struct Editor;
 
 /// Spawns all base editor entities including window, camera, and UI elements
-fn init_editor(
-	mut commands: Commands
-) {
-	// Spawn root editor entity hierarchy
-	commands.spawn(SpatialBundle { ..default() })
-		.with_children(|parent| {
-
-			let editor_window = parent.spawn((
-				Editor,
-				Window {
-					title: "Editor".into(),
-					name: Some("Editor".into()),
-					visible: false,
-					..default()
-				},
-			)).id();
+fn init_editor(mut commands: Commands) {
+    // Spawn root editor entity hierarchy
+    commands
+        .spawn(SpatialBundle { ..default() })
+        .with_children(|parent| {
+            let editor_window = parent
+                .spawn((
+                    Editor,
+                    Window {
+                        title: "Editor".into(),
+                        name: Some("Editor".into()),
+                        visible: false,
+                        ..default()
+                    },
+                ))
+                .id();
 
-			// Spawn editor camera
-			let _editor_camera = parent.spawn((
-				Editor,
-				FlyCamera,
-				Camera3dBundle {
-					camera: Camera {
-						target: RenderTarget::Window(WindowRef::Entity(editor_window)),
-						..default()
-					},
-					transform: Transform::from_xyz(1.0, 1.0, 1.0).looking_at(Vec3::ZERO, Vec3::Y),
-					..default()
-				},
-			)).id();
-		});
+            // Spawn editor camera
+            let _editor_camera = parent
+                .spawn((
+                    Editor,
+                    FlyCamera,
+                    Camera3dBundle {
+                        camera: Camera {
+                            target: RenderTarget::Window(WindowRef::Entity(editor_window)),
+                            ..default()
+                        },
+                        transform: Transform::from_xyz(1.0, 1.0, 1.0)
+                            .looking_at(Vec3::ZERO, Vec3::Y),
+                        ..default()
+                    },
+                ))
+                .id();
+        });
 }
 
-fn open_editor(
-	mut ws: Query<&mut Window, With<Editor>>,
-) {
-	ws.iter_mut().for_each(|mut w| {
-		w.visible = true;
-	});
+fn open_editor(mut ws: Query<&mut Window, With<Editor>>) {
+    ws.iter_mut().for_each(|mut w| {
+        w.visible = true;
+    });
 }
 
-fn close_editor(
-	mut ws: Query<&mut Window, With<Editor>>,
-) {
-	ws.iter_mut().for_each(|mut w| {
-		w.visible = false;
-	});
+fn close_editor(mut ws: Query<&mut Window, With<Editor>>) {
+    ws.iter_mut().for_each(|mut w| {
+        w.visible = false;
+    });
 }
 
 fn toggle_editor(
-	state: Res<State<EditorState>>,
-	mut next_state: ResMut<NextState<EditorState>>,
-	keys: Res<ButtonInput<KeyCode>>,
-	mut catch: Local<bool>,
+    state: Res<State<EditorState>>,
+    mut next_state: ResMut<NextState<EditorState>>,
+    keys: Res<ButtonInput<KeyCode>>,
+    mut catch: Local<bool>,
 ) {
-	if keys.pressed(KeyCode::F3) && !*catch {
-		*catch = true;
-		match state.get() {
-			EditorState::Open => next_state.set(EditorState::Closed),
-			EditorState::Closed => next_state.set(EditorState::Open),
-		}
-	} else {
-		*catch = false;
-	}
+    if keys.pressed(KeyCode::F3) && !*catch {
+        *catch = true;
+        match state.get() {
+            EditorState::Open => next_state.set(EditorState::Closed),
+            EditorState::Closed => next_state.set(EditorState::Open),
+        }
+    } else {
+        *catch = false;
+    }
 }
 
-fn origin_directions(
-	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 origin_directions(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(
-	mut gizmos: Gizmos
-) {
-	(-10..=10).into_iter().for_each(|x| {
-		(-10..=10).into_iter().for_each(|z| {
-			{
-				let start = Vec3::new(x as f32, 0.0, -10.0);
-				let end = Vec3::new(x as f32, 0.0, 10.0);
-				gizmos.line(start, end, Color::GRAY);
-			}
-			{
-				let start = Vec3::new(-10.0, 0.0, z as f32);
-				let end = Vec3::new(10.0, 0.0, z as f32);
-				gizmos.line(start, end, Color::GRAY);
-			}
-		});
-	});
-}
\ No newline at end of file
+fn world_plane(mut gizmos: Gizmos) {
+    (-10..=10).into_iter().for_each(|x| {
+        (-10..=10).into_iter().for_each(|z| {
+            {
+                let start = Vec3::new(x as f32, 0.0, -10.0);
+                let end = Vec3::new(x as f32, 0.0, 10.0);
+                gizmos.line(start, end, Color::GRAY);
+            }
+            {
+                let start = Vec3::new(-10.0, 0.0, z as f32);
+                let end = Vec3::new(10.0, 0.0, z as f32);
+                gizmos.line(start, end, Color::GRAY);
+            }
+        });
+    });
+}
diff --git a/src/game/dice.rs b/src/game/dice.rs
index 47a531f..4dc0122 100644
--- a/src/game/dice.rs
+++ b/src/game/dice.rs
@@ -141,22 +141,20 @@ fn move_die(
          }| {
             match state {
                 ButtonState::Pressed => {
-                    q.iter_mut().for_each(|mut t| {
-                        match key_code {
-                            KeyCode::ArrowLeft => {
-                                t.translation -= Vec3::X * time.delta_seconds() * 1000.0
-                            }
-                            KeyCode::ArrowRight => {
-                                t.translation += Vec3::X * time.delta_seconds() * 1000.0
-                            }
-                            KeyCode::ArrowDown => {
-                                t.translation -= Vec3::Y * time.delta_seconds() * 1000.0
-                            }
-                            KeyCode::ArrowUp => {
-                                t.translation += Vec3::Y * time.delta_seconds() * 1000.0
-                            }
-                            _ => (),
+                    q.iter_mut().for_each(|mut t| match key_code {
+                        KeyCode::ArrowLeft => {
+                            t.translation -= Vec3::X * time.delta_seconds() * 1000.0
                         }
+                        KeyCode::ArrowRight => {
+                            t.translation += Vec3::X * time.delta_seconds() * 1000.0
+                        }
+                        KeyCode::ArrowDown => {
+                            t.translation -= Vec3::Y * time.delta_seconds() * 1000.0
+                        }
+                        KeyCode::ArrowUp => {
+                            t.translation += Vec3::Y * time.delta_seconds() * 1000.0
+                        }
+                        _ => (),
                     });
                 }
                 _ => (),
diff --git a/src/main.rs b/src/main.rs
index b4843a3..f4e7939 100644
--- a/src/main.rs
+++ b/src/main.rs
@@ -29,13 +29,14 @@ use crate::prelude::*;
 
 fn main() {
     let mut app = App::new();
-    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::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, 
-        handle_window_close.run_if(on_event::<WindowCloseRequested>())
+    app.add_systems(
+        Update,
+        handle_window_close.run_if(on_event::<WindowCloseRequested>()),
     );
     app.run();
 }
@@ -75,12 +77,9 @@ fn handle_window_close(
         if primary.contains(*window) {
             commands.entity(*window).remove::<Window>();
         } else {
-            secondary
-                .get_mut(*window)
-                .iter_mut()
-                .for_each(|w| {
-                    w.visible = false;
-                });
+            secondary.get_mut(*window).iter_mut().for_each(|w| {
+                w.visible = false;
+            });
         }
     });
-}
\ No newline at end of file
+}
diff --git a/src/prelude.rs b/src/prelude.rs
index c35f949..f161a7b 100644
--- a/src/prelude.rs
+++ b/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;