From 7a46436bc960f85e598c38294aa93a28f7dd9696 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 29 Feb 2024 19:46:34 -0500
Subject: [PATCH 01/21] refactor around an event-based API

---
 src/input_capture.rs  | 155 +++++++++++++++++++++++++++++++++++++++---
 src/input_playback.rs |  96 ++++++++++++++++++++++----
 2 files changed, 230 insertions(+), 21 deletions(-)

diff --git a/src/input_capture.rs b/src/input_capture.rs
index 7bdb886..4b5886e 100644
--- a/src/input_capture.rs
+++ b/src/input_capture.rs
@@ -33,21 +33,58 @@ impl Plugin for InputCapturePlugin {
                 .add_systems(First, frame_counter);
         }
 
-        app.init_resource::<TimestampedInputs>()
-            .init_resource::<InputModesCaptured>()
-            .init_resource::<PlaybackFilePath>()
+        app.add_event::<BeginInputCapture>()
+            .add_event::<EndInputCapture>()
+            .add_systems(First, initiate_input_capture)
             .add_systems(
                 Last,
                 (
                     // Capture any mocked input as well
                     capture_input,
+                    serialize_captured_input_on_final_capture_frame
+                        .run_if(resource_exists::<FinalCaptureFrame>),
+                    serialize_captured_input_on_end_capture_event,
                     serialize_captured_input_on_exit,
                 )
+                    .run_if(resource_exists::<InputModesCaptured>)
                     .chain(),
             );
     }
 }
 
+/// An Event that users can send to initiate input capture.
+///
+/// Data is serialized to the provided `filepath` when either an [`EndInputCapture`] or an [`AppExit`] event is detected.
+#[derive(Debug, Default, Event)]
+pub struct BeginInputCapture {
+    /// The input mechanisms that will be captured, see [`InputModesCaptured`].
+    pub input_modes_captured: InputModesCaptured,
+    /// The filepath at which to serialize captured input data.
+    pub filepath: Option<String>,
+    /// The number of frames for which inputs should be captured.
+    /// If None, inputs will be captured until an [`EndInputCapture`] or [`AppExit`] event is detected.
+    pub frames_to_capture: Option<FrameCount>,
+    /// A `Window` entity which acts as a filter for which inputs will be captured.
+    /// This data will not be serialized, so that a target window can be selected on playback.
+    pub window_to_capture: Option<Entity>,
+}
+
+/// An Event that users can send to end input capture and serialize data to disk.
+#[derive(Debug, Event)]
+pub struct EndInputCapture;
+
+/// The final [`FrameCount`] at which inputs will stop being captured.
+///
+/// If this Resource is attached, [`TimestampedInputs`] will be serialized and input capture will stop once `FrameCount` reaches this value.
+#[derive(Debug, Resource)]
+pub struct FinalCaptureFrame(FrameCount);
+
+/// The `Window` entity for which inputs will be captured.
+///
+/// If this Resource is attached, only input events on the window corresponding to this entity will be captured.
+#[derive(Debug, Resource)]
+pub struct InputCaptureWindow(Entity);
+
 /// The input mechanisms captured via the [`InputCapturePlugin`], configured as a resource.
 ///
 /// By default, all supported input modes will be captured.
@@ -91,6 +128,30 @@ impl Default for InputModesCaptured {
     }
 }
 
+/// Initiates input capture when a [`BeginInputCapture`] is detected.
+pub fn initiate_input_capture(
+    mut commands: Commands,
+    mut begin_capture_events: EventReader<BeginInputCapture>,
+    frame_count: Res<FrameCount>,
+) {
+    if let Some(event) = begin_capture_events.read().next() {
+        commands.init_resource::<TimestampedInputs>();
+        commands.insert_resource(event.input_modes_captured.clone());
+        if let Some(path) = &event.filepath {
+            commands.insert_resource(PlaybackFilePath::new(path));
+        } else {
+            commands.init_resource::<PlaybackFilePath>();
+        }
+        if let Some(final_frame) = event.frames_to_capture {
+            commands.insert_resource(FinalCaptureFrame(*frame_count + final_frame));
+        }
+        if let Some(window_entity) = &event.window_to_capture {
+            commands.insert_resource(InputCaptureWindow(*window_entity));
+        }
+    }
+    begin_capture_events.clear();
+}
+
 /// Captures input from the [`bevy::window`] and [`bevy::input`] event streams.
 ///
 /// The input modes can be controlled via the [`InputModesCaptured`] resource.
@@ -103,6 +164,7 @@ pub fn capture_input(
     mut gamepad_events: EventReader<GamepadEvent>,
     mut app_exit_events: EventReader<AppExit>,
     mut timestamped_input: ResMut<TimestampedInputs>,
+    window_to_capture: Option<Res<InputCaptureWindow>>,
     input_modes_captured: Res<InputModesCaptured>,
     frame_count: Res<FrameCount>,
     time: Res<Time>,
@@ -118,13 +180,29 @@ pub fn capture_input(
         timestamped_input.send_multiple(
             frame,
             time_since_startup,
-            mouse_button_events.read().cloned(),
+            mouse_button_events
+                .read()
+                .filter(|event| {
+                    window_to_capture
+                        .as_deref()
+                        .map(|window| window.0 == event.window)
+                        .unwrap_or(true)
+                })
+                .cloned(),
         );
 
         timestamped_input.send_multiple(
             frame,
             time_since_startup,
-            mouse_wheel_events.read().cloned(),
+            mouse_wheel_events
+                .read()
+                .filter(|event| {
+                    window_to_capture
+                        .as_deref()
+                        .map(|window| window.0 == event.window)
+                        .unwrap_or(true)
+                })
+                .cloned(),
         );
     } else {
         mouse_button_events.clear();
@@ -135,14 +213,34 @@ pub fn capture_input(
         timestamped_input.send_multiple(
             frame,
             time_since_startup,
-            cursor_moved_events.read().cloned(),
+            cursor_moved_events
+                .read()
+                .filter(|event| {
+                    window_to_capture
+                        .as_deref()
+                        .map(|window| window.0 == event.window)
+                        .unwrap_or(true)
+                })
+                .cloned(),
         );
     } else {
         cursor_moved_events.clear();
     }
 
     if input_modes_captured.keyboard {
-        timestamped_input.send_multiple(frame, time_since_startup, keyboard_events.read().cloned());
+        timestamped_input.send_multiple(
+            frame,
+            time_since_startup,
+            keyboard_events
+                .read()
+                .filter(|event| {
+                    window_to_capture
+                        .as_deref()
+                        .map(|window| window.0 == event.window)
+                        .unwrap_or(true)
+                })
+                .cloned(),
+        );
     } else {
         keyboard_events.clear()
     }
@@ -156,9 +254,8 @@ pub fn capture_input(
     timestamped_input.send_multiple(frame, time_since_startup, app_exit_events.read().cloned())
 }
 
-/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource.
+/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource once [`AppExit`] is sent.
 ///
-/// This data is only serialized once when [`AppExit`] is sent.
 /// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
 pub fn serialize_captured_input_on_exit(
     app_exit_events: EventReader<AppExit>,
@@ -170,6 +267,46 @@ pub fn serialize_captured_input_on_exit(
     }
 }
 
+/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource once the provided number of frames have elapsed.
+///
+/// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
+pub fn serialize_captured_input_on_final_capture_frame(
+    mut commands: Commands,
+    frame_count: Res<FrameCount>,
+    final_frame: Res<FinalCaptureFrame>,
+    playback_file: Res<PlaybackFilePath>,
+    captured_inputs: Res<TimestampedInputs>,
+) {
+    if *frame_count == final_frame.0 {
+        serialize_timestamped_inputs(&captured_inputs, &playback_file);
+        commands.remove_resource::<PlaybackFilePath>();
+        commands.remove_resource::<TimestampedInputs>();
+        commands.remove_resource::<InputModesCaptured>();
+        commands.remove_resource::<FinalCaptureFrame>();
+        commands.remove_resource::<InputCaptureWindow>();
+    }
+}
+
+/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource when an [`EndInputCapture`] is detected.
+///
+/// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
+pub fn serialize_captured_input_on_end_capture_event(
+    mut commands: Commands,
+    mut end_capture_events: EventReader<EndInputCapture>,
+    playback_file: Res<PlaybackFilePath>,
+    captured_inputs: Res<TimestampedInputs>,
+) {
+    if !end_capture_events.is_empty() {
+        serialize_timestamped_inputs(&captured_inputs, &playback_file);
+        end_capture_events.clear();
+        commands.remove_resource::<PlaybackFilePath>();
+        commands.remove_resource::<TimestampedInputs>();
+        commands.remove_resource::<InputModesCaptured>();
+        commands.remove_resource::<FinalCaptureFrame>();
+        commands.remove_resource::<InputCaptureWindow>();
+    }
+}
+
 /// Writes the `timestamped_inputs` to the provided `path` (which should store [`Some(PathBuf)`]).
 pub fn serialize_timestamped_inputs(
     timestamped_inputs: &TimestampedInputs,
diff --git a/src/input_playback.rs b/src/input_playback.rs
index 8b3ed6e..64e41c4 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -36,15 +36,88 @@ impl Plugin for InputPlaybackPlugin {
                 .add_systems(First, frame_counter);
         }
 
-        app.init_resource::<TimestampedInputs>()
-            .init_resource::<PlaybackProgress>()
-            .init_resource::<PlaybackStrategy>()
-            .init_resource::<PlaybackFilePath>()
-            .add_systems(Startup, deserialize_timestamped_inputs)
-            .add_systems(First, playback_timestamped_input.after(frame_counter));
+        app.add_event::<BeginInputPlayback>()
+            .add_event::<EndInputPlayback>()
+            .add_systems(
+                First,
+                (handle_end_playback_event, initiate_input_playback).chain(),
+            )
+            .add_systems(
+                First,
+                playback_timestamped_input
+                    .run_if(resource_exists::<PlaybackProgress>)
+                    .after(frame_counter)
+                    .after(initiate_input_playback),
+            );
+    }
+}
+
+/// An Event that users can send to initiate input capture.
+///
+/// Data is serialized to the provided `filepath` when either an [`EndCaptureEvent`] or an [`AppExit`] event is detected.
+#[derive(Debug, Default, Event)]
+pub struct BeginInputPlayback {
+    /// The filepath at which to serialize captured input data.
+    pub filepath: String,
+    /// Controls the approach used for playing back recorded inputs.
+    ///
+    /// See [`PlaybackStrategy`] for more information.
+    pub playback_strategy: PlaybackStrategy,
+    /// A entity corresponding to the [`bevy::window::Window`] which will receive input events.
+    /// If unspecified, input events will target the serialized window entity, which may be fragile.
+    pub playback_window: Option<Entity>,
+}
+
+/// Initiates input playback when a [`BeginInputPlayback`] is detected.
+pub fn initiate_input_playback(
+    mut commands: Commands,
+    mut begin_capture_events: EventReader<BeginInputPlayback>,
+) {
+    if let Some(event) = begin_capture_events.read().next() {
+        commands.init_resource::<TimestampedInputs>();
+        commands.init_resource::<PlaybackProgress>();
+        commands.insert_resource(event.playback_strategy.clone());
+        let playback_path = PlaybackFilePath::new(&event.filepath);
+        if let Some(path) = playback_path.path() {
+            let file = File::open(path).unwrap();
+            let timestamped_inputs: TimestampedInputs = from_reader(file).unwrap();
+            commands.insert_resource(timestamped_inputs);
+        }
+        commands.insert_resource(playback_path);
+        if let Some(playback_window) = event.playback_window {
+            commands.insert_resource(PlaybackWindow(playback_window));
+        }
     }
+    begin_capture_events.clear();
 }
 
+/// An Event that users can send to end input playback prematurely.
+#[derive(Debug, Event)]
+pub struct EndInputPlayback;
+
+/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource when an [`EndInputCapture`] is detected.
+///
+/// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
+pub fn handle_end_playback_event(
+    mut commands: Commands,
+    mut end_capture_events: EventReader<EndInputPlayback>,
+) {
+    if !end_capture_events.is_empty() {
+        end_capture_events.clear();
+        commands.remove_resource::<PlaybackFilePath>();
+        commands.remove_resource::<TimestampedInputs>();
+        commands.remove_resource::<PlaybackProgress>();
+        commands.remove_resource::<PlaybackStrategy>();
+        commands.remove_resource::<PlaybackWindow>();
+    }
+}
+
+/// The `Window` entity for which inputs will be captured.
+///
+/// If this Resource is attached, input events will be forwarded to this window entity rather than the serialized window entity.
+#[derive(Debug, Resource)]
+pub struct PlaybackWindow(Entity);
+
 /// Controls the approach used for playing back recorded inputs
 ///
 /// [`PlaybackStrategy::Time`] is the default strategy.
@@ -219,13 +292,12 @@ fn send_playback_events(
 
 /// Reads the stored file paths from the [`PlaybackFilePath`] location (if any)
 pub fn deserialize_timestamped_inputs(
-    mut timestamped_inputs: ResMut<TimestampedInputs>,
-    playback_path: Res<PlaybackFilePath>,
-) {
-    if let Some(file_path) = playback_path.path() {
+    playback_path: &PlaybackFilePath,
+)-> Option<Result<TimestampedInputs, ron::de::SpannedError>> {
+    playback_path.path().as_ref().map(|file_path| {
         let file = File::open(file_path).unwrap();
-        *timestamped_inputs = from_reader(file).unwrap();
-    }
+        from_reader(file)
+    })
 }
 
 /// How far through the current cycle of input playback we've gotten.

From 88b5fe5aa46649bb41834001ef488ed72fab1384 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 29 Feb 2024 22:49:06 -0500
Subject: [PATCH 02/21] remove random git file oops

---
 git | 41 -----------------------------------------
 1 file changed, 41 deletions(-)
 delete mode 100644 git

diff --git a/git b/git
deleted file mode 100644
index 21055ef..0000000
--- a/git
+++ /dev/null
@@ -1,41 +0,0 @@
-Diff in /home/snen/dev/github/leafwing_input_playback/examples/gamepad.rs at line 182:
-                 triangle: meshes
-                     .add(RegularPolygon::new(BUTTON_RADIUS, 3).mesh())
-                     .into(),
--                start_pause: meshes.add(Rectangle::new(START_SIZE.x, START_SIZE.y).mesh()).into(),
-(B-                trigger: meshes.add(Rectangle::new(TRIGGER_SIZE.x, TRIGGER_SIZE.y).mesh()).into(),
-(B+                start_pause: meshes
-(B+                    .add(Rectangle::new(START_SIZE.x, START_SIZE.y).mesh())
-(B+                    .into(),
-(B+                trigger: meshes
-(B+                    .add(Rectangle::new(TRIGGER_SIZE.x, TRIGGER_SIZE.y).mesh())
-(B+                    .into(),
-(B             }
-         }
-     }
-Diff in /home/snen/dev/github/leafwing_input_playback/src/input_playback.rs at line 189:
-         match timestamped_input_event.input_event {
-             Keyboard(e) => {
-                 input_writers.keyboard_input.send(e);
--            },
-(B+            }
-(B             MouseButton(e) => {
-                 input_writers.mouse_button_input.send(e);
--            },
-(B+            }
-(B             MouseWheel(e) => {
-                 input_writers.mouse_wheel.send(e);
--            },
-(B+            }
-(B             // Window events MUST update the `Window` struct itself
-             // BLOCKED: https://github.com/bevyengine/bevy/issues/6163
-             CursorMoved(e) => {
-Diff in /home/snen/dev/github/leafwing_input_playback/src/input_playback.rs at line 212:
-             }
-             AppExit => {
-                 input_writers.app_exit.send_default();
--            },
-(B+            }
-(B         };
-     }
- }

From 5c7dd21e0817feec02cd7c99950906f75367f74e Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 29 Feb 2024 23:02:03 -0500
Subject: [PATCH 03/21] fmt?

---
 src/input_playback.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/input_playback.rs b/src/input_playback.rs
index 64e41c4..8d16f49 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -293,7 +293,7 @@ fn send_playback_events(
 /// Reads the stored file paths from the [`PlaybackFilePath`] location (if any)
 pub fn deserialize_timestamped_inputs(
     playback_path: &PlaybackFilePath,
-)-> Option<Result<TimestampedInputs, ron::de::SpannedError>> {
+) -> Option<Result<TimestampedInputs, ron::de::SpannedError>> {
     playback_path.path().as_ref().map(|file_path| {
         let file = File::open(file_path).unwrap();
         from_reader(file)

From 2fd56670e561c05b25ac698208d5db11d1c76d85 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 29 Feb 2024 23:04:08 -0500
Subject: [PATCH 04/21] more fmt

---
 src/input_playback.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/input_playback.rs b/src/input_playback.rs
index 8d16f49..1c71602 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -2,7 +2,7 @@
 //!
 //! These are played back by emulating assorted Bevy input events.
 
-use bevy::app::{App, AppExit, First, Plugin, Startup};
+use bevy::app::{App, AppExit, First, Plugin};
 use bevy::ecs::{prelude::*, system::SystemParam};
 use bevy::input::gamepad::GamepadEvent;
 use bevy::input::{
@@ -76,7 +76,7 @@ pub fn initiate_input_playback(
     if let Some(event) = begin_capture_events.read().next() {
         commands.init_resource::<TimestampedInputs>();
         commands.init_resource::<PlaybackProgress>();
-        commands.insert_resource(event.playback_strategy.clone());
+        commands.insert_resource(event.playback_strategy);
         let playback_path = PlaybackFilePath::new(&event.filepath);
         if let Some(path) = playback_path.path() {
             let file = File::open(path).unwrap();

From cb4e70e3248dfd455e2c2cc274c6bb99a229a361 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 22 Aug 2024 17:23:30 -0400
Subject: [PATCH 05/21] make PlaybackWindow field pub

---
 src/input_playback.rs | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/input_playback.rs b/src/input_playback.rs
index 506a7b6..8971fa7 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -116,7 +116,7 @@ pub fn handle_end_playback_event(
 ///
 /// If this Resource is attached, input events will be forwarded to this window entity rather than the serialized window entity.
 #[derive(Debug, Resource)]
-pub struct PlaybackWindow(Entity);
+pub struct PlaybackWindow(pub Entity);
 
 /// Controls the approach used for playing back recorded inputs
 ///

From 691aeb631f0006af81c488487fbb3320a6ab9a52 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 22 Aug 2024 17:24:06 -0400
Subject: [PATCH 06/21] insist that serializer systems only run if a capture
 path is provided

---
 src/input_capture.rs | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/input_capture.rs b/src/input_capture.rs
index 1360d07..cecb1ad 100644
--- a/src/input_capture.rs
+++ b/src/input_capture.rs
@@ -41,10 +41,13 @@ impl Plugin for InputCapturePlugin {
                 (
                     // Capture any mocked input as well
                     capture_input,
-                    serialize_captured_input_on_final_capture_frame
-                        .run_if(resource_exists::<FinalCaptureFrame>),
-                    serialize_captured_input_on_end_capture_event,
-                    serialize_captured_input_on_exit,
+                    (
+                        serialize_captured_input_on_final_capture_frame
+                            .run_if(resource_exists::<FinalCaptureFrame>),
+                        serialize_captured_input_on_end_capture_event,
+                        serialize_captured_input_on_exit,
+                    )
+                        .run_if(resource_exists::<PlaybackFilePath>),
                 )
                     .run_if(resource_exists::<InputModesCaptured>)
                     .chain(),

From 46da6c632e4409a29f12a7a8d52535cf2182cf51 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 22 Aug 2024 17:25:04 -0400
Subject: [PATCH 07/21] allow users to select the source of input data when
 initiating playback events

---
 src/input_playback.rs | 71 +++++++++++++++++++++++++++++++++----------
 1 file changed, 55 insertions(+), 16 deletions(-)

diff --git a/src/input_playback.rs b/src/input_playback.rs
index 8971fa7..c1ab764 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -57,8 +57,8 @@ impl Plugin for InputPlaybackPlugin {
 /// Data is serialized to the provided `filepath` when either an [`EndCaptureEvent`] or an [`AppExit`] event is detected.
 #[derive(Debug, Default, Event)]
 pub struct BeginInputPlayback {
-    /// The filepath at which to serialize captured input data.
-    pub filepath: String,
+    /// The source from which to read input data. Do not provide a `source` if the expected `TimestampedInputs` should already be present in `World`.
+    pub source: Option<InputPlaybackSource>,
     /// Controls the approach used for playing back recorded inputs.
     ///
     /// See [`PlaybackStrategy`] for more information.
@@ -68,26 +68,65 @@ pub struct BeginInputPlayback {
     pub playback_window: Option<Entity>,
 }
 
+/// The source of input data for playback.
+///
+/// Typically users should expect to provide a
+
+#[derive(Debug)]
+pub enum InputPlaybackSource {
+    /// Reads from a file and deserializes the content into a `TimestampedInputs`.
+    File(PlaybackFilePath),
+    /// Uses the provided `TimestampedInputs` parameter as the source of input data.
+    TimestampedInputs(TimestampedInputs),
+}
+
+impl InputPlaybackSource {
+    /// Reads source data from a file using the provided filepath.
+    pub fn from_file(filepath: impl AsRef<String>) -> Self {
+        InputPlaybackSource::File(PlaybackFilePath::new(filepath.as_ref()))
+    }
+
+    /// Defines source data using raw data.
+    pub fn from_inputs(inputs: TimestampedInputs) -> Self {
+        InputPlaybackSource::TimestampedInputs(inputs)
+    }
+}
+
+impl Default for InputPlaybackSource {
+    fn default() -> Self {
+        Self::TimestampedInputs(TimestampedInputs::default())
+    }
+}
+
 /// Initiates input playback when a [`BeginInputPlayback`] is detected.
 pub fn initiate_input_playback(
     mut commands: Commands,
     mut begin_capture_events: EventReader<BeginInputPlayback>,
 ) {
-    if let Some(event) = begin_capture_events.read().next() {
-        commands.init_resource::<TimestampedInputs>();
-        commands.init_resource::<PlaybackProgress>();
-        commands.insert_resource(event.playback_strategy);
-        let playback_path = PlaybackFilePath::new(&event.filepath);
-        if let Some(path) = playback_path.path() {
-            let file = File::open(path).unwrap();
-            let timestamped_inputs: TimestampedInputs = from_reader(file).unwrap();
-            commands.insert_resource(timestamped_inputs);
-        }
-        commands.insert_resource(playback_path);
-        if let Some(playback_window) = event.playback_window {
-            commands.insert_resource(PlaybackWindow(playback_window));
-        }
+    let Some(event) = begin_capture_events.read().next() else {
+        return;
+    };
+
+    commands.init_resource::<PlaybackProgress>();
+    commands.insert_resource(event.playback_strategy);
+
+    if let Some(source) = event.source.as_ref() {
+        let timestamped_inputs = match source {
+            InputPlaybackSource::TimestampedInputs(inputs) => inputs.clone(),
+            InputPlaybackSource::File(playback_path) => {
+                commands.insert_resource(playback_path.clone());
+                deserialize_timestamped_inputs(&playback_path)
+                    .unwrap()
+                    .unwrap()
+            }
+        };
+        commands.insert_resource(timestamped_inputs);
     }
+
+    if let Some(playback_window) = event.playback_window {
+        commands.insert_resource(PlaybackWindow(playback_window));
+    }
+
     begin_capture_events.clear();
 }
 

From 1794b75c86468305787df4abf6241a3f35ee11fb Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 22 Aug 2024 17:25:45 -0400
Subject: [PATCH 08/21] make deserialize_timestamped_inputs panic-free

---
 src/input_playback.rs | 35 ++++++++++++++++++++++++++++++++---
 1 file changed, 32 insertions(+), 3 deletions(-)

diff --git a/src/input_playback.rs b/src/input_playback.rs
index c1ab764..b5291e2 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -332,13 +332,42 @@ fn send_playback_events(
 /// Reads the stored file paths from the [`PlaybackFilePath`] location (if any)
 pub fn deserialize_timestamped_inputs(
     playback_path: &PlaybackFilePath,
-) -> Option<Result<TimestampedInputs, ron::de::SpannedError>> {
+) -> Option<Result<TimestampedInputs, TimestampedInputsError>> {
     playback_path.path().as_ref().map(|file_path| {
-        let file = File::open(file_path).unwrap();
-        from_reader(file)
+        let file = File::open(file_path).map_err(|error| TimestampedInputsError::Fs(error))?;
+        from_reader(file).map_err(|error| TimestampedInputsError::Ron(error))
     })
 }
 
+/// An error type that wraps the possible error variants when deserializing `TimestampedInputs` from a file.
+#[derive(Debug)]
+pub enum TimestampedInputsError {
+    /// The error case where the filesystem failed to open the desired file path.
+    Fs(std::io::Error),
+    /// The error case where the content at the provided filepath did not have valid RON content.
+    Ron(ron::de::SpannedError),
+}
+
+impl std::fmt::Display for TimestampedInputsError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            TimestampedInputsError::Fs(_error) => write!(f, "could not find playback file "),
+            TimestampedInputsError::Ron(_error) => {
+                write!(f, "the provided file did not have valid RON-formatted data")
+            }
+        }
+    }
+}
+
+impl std::error::Error for TimestampedInputsError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            TimestampedInputsError::Fs(ref error) => Some(error),
+            TimestampedInputsError::Ron(ref error) => Some(error),
+        }
+    }
+}
+
 /// How far through the current cycle of input playback we've gotten.
 ///
 /// The `initial_time` and `initial_frame` are stored to be able to compute

From 5b388d1f9661adbf98fa59e6ba0c751b3292933f Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 22 Aug 2024 17:26:06 -0400
Subject: [PATCH 09/21] ensure all playback systems happen after frame_counter

---
 src/input_playback.rs | 10 +++++++---
 1 file changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/input_playback.rs b/src/input_playback.rs
index b5291e2..4f1f275 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -40,13 +40,17 @@ impl Plugin for InputPlaybackPlugin {
             .add_event::<EndInputPlayback>()
             .add_systems(
                 First,
-                (handle_end_playback_event, initiate_input_playback).chain(),
+                (handle_end_playback_event, initiate_input_playback)
+                    .after(frame_counter)
+                    .chain(),
             )
             .add_systems(
                 First,
                 playback_timestamped_input
-                    .run_if(resource_exists::<PlaybackProgress>)
-                    .after(frame_counter)
+                    .run_if(
+                        resource_exists::<PlaybackProgress>
+                            .and_then(resource_exists::<TimestampedInputs>),
+                    )
                     .after(initiate_input_playback),
             );
     }

From efc00138ea0b20e8285e8c964665b0b92992861e Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 22 Aug 2024 17:26:15 -0400
Subject: [PATCH 10/21] fix tests

---
 tests/input_capture.rs  |  3 ++-
 tests/input_playback.rs | 20 +++++++++++++-------
 2 files changed, 15 insertions(+), 8 deletions(-)

diff --git a/tests/input_capture.rs b/tests/input_capture.rs
index 3583511..6eee593 100644
--- a/tests/input_capture.rs
+++ b/tests/input_capture.rs
@@ -7,6 +7,7 @@ use bevy::prelude::*;
 
 use bevy::window::WindowPlugin;
 use leafwing_input_playback::frame_counting::FrameCount;
+use leafwing_input_playback::input_capture::BeginInputCapture;
 use leafwing_input_playback::input_capture::{InputCapturePlugin, InputModesCaptured};
 use leafwing_input_playback::timestamped_input::{
     InputEvent, TimestampedInputEvent, TimestampedInputs,
@@ -41,7 +42,7 @@ fn capture_app() -> App {
         InputPlugin,
         InputCapturePlugin,
     ));
-
+    app.world_mut().send_event(BeginInputCapture::default());
     app
 }
 
diff --git a/tests/input_playback.rs b/tests/input_playback.rs
index 4417992..b8bc295 100644
--- a/tests/input_playback.rs
+++ b/tests/input_playback.rs
@@ -13,6 +13,7 @@ use bevy::window::WindowPlugin;
 use leafwing_input_playback::frame_counting::FrameCount;
 use leafwing_input_playback::input_capture::InputCapturePlugin;
 use leafwing_input_playback::input_capture::InputModesCaptured;
+use leafwing_input_playback::input_playback::BeginInputPlayback;
 use leafwing_input_playback::input_playback::InputPlaybackPlugin;
 use leafwing_input_playback::input_playback::PlaybackStrategy;
 use leafwing_input_playback::timestamped_input::TimestampedInputs;
@@ -44,7 +45,10 @@ fn playback_app(strategy: PlaybackStrategy) -> App {
     let mut registry = app.world_mut().resource_mut::<EventRegistry>();
     registry.should_update = ShouldUpdateEvents::Always;
 
-    *app.world_mut().resource_mut::<PlaybackStrategy>() = strategy;
+    app.world_mut().send_event(BeginInputPlayback {
+        playback_strategy: strategy,
+        ..Default::default()
+    });
 
     app
 }
@@ -74,7 +78,7 @@ fn minimal_playback() {
     let input_events = app.world().resource::<Events<KeyboardInput>>();
     assert_eq!(input_events.len(), 0);
 
-    *app.world_mut().resource_mut::<TimestampedInputs>() = simple_timestamped_input();
+    app.insert_resource(simple_timestamped_input());
 
     app.update();
 
@@ -97,6 +101,7 @@ fn capture_and_playback() {
     let mut app = playback_app(PlaybackStrategy::default());
     app.add_plugins(InputCapturePlugin);
     app.insert_resource(PlaybackStrategy::Paused);
+    app.insert_resource(TimestampedInputs::default());
 
     let mut input_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
     input_events.send(TEST_PRESS);
@@ -133,7 +138,8 @@ fn repeated_playback() {
     let input_events = app.world().resource::<Events<KeyboardInput>>();
     assert_eq!(input_events.len(), 0);
 
-    *app.world_mut().resource_mut::<TimestampedInputs>() = simple_timestamped_input();
+    app.insert_resource(simple_timestamped_input());
+
     for _ in 1..10 {
         app.update();
     }
@@ -156,7 +162,7 @@ fn repeated_playback() {
 #[test]
 fn playback_strategy_paused() {
     let mut app = playback_app(PlaybackStrategy::Paused);
-    *app.world_mut().resource_mut::<TimestampedInputs>() = complex_timestamped_input();
+    app.insert_resource(complex_timestamped_input());
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);
@@ -172,7 +178,7 @@ fn playback_strategy_paused() {
 #[test]
 fn playback_strategy_frame() {
     let mut app = playback_app(PlaybackStrategy::FrameCount);
-    *app.world_mut().resource_mut::<TimestampedInputs>() = complex_timestamped_input();
+    app.insert_resource(complex_timestamped_input());
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);
@@ -195,7 +201,7 @@ fn playback_strategy_frame() {
 fn playback_strategy_frame_range_once() {
     let strategy = PlaybackStrategy::FrameRangeOnce(FrameCount(2), FrameCount(5));
     let mut app = playback_app(strategy);
-    *app.world_mut().resource_mut::<TimestampedInputs>() = complex_timestamped_input();
+    app.insert_resource(complex_timestamped_input());
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);
@@ -234,7 +240,7 @@ fn playback_strategy_frame_range_once() {
 fn playback_strategy_frame_range_loop() {
     let strategy = PlaybackStrategy::FrameRangeLoop(FrameCount(2), FrameCount(5));
     let mut app = playback_app(strategy);
-    *app.world_mut().resource_mut::<TimestampedInputs>() = complex_timestamped_input();
+    app.insert_resource(complex_timestamped_input());
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);

From 86f3095bd266103d3ee0c94d31aacb067c744b4b Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Thu, 22 Aug 2024 17:26:58 -0400
Subject: [PATCH 11/21] cargo clippy

---
 src/input_playback.rs | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/input_playback.rs b/src/input_playback.rs
index 4f1f275..afe9a9a 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -119,7 +119,7 @@ pub fn initiate_input_playback(
             InputPlaybackSource::TimestampedInputs(inputs) => inputs.clone(),
             InputPlaybackSource::File(playback_path) => {
                 commands.insert_resource(playback_path.clone());
-                deserialize_timestamped_inputs(&playback_path)
+                deserialize_timestamped_inputs(playback_path)
                     .unwrap()
                     .unwrap()
             }
@@ -338,8 +338,8 @@ pub fn deserialize_timestamped_inputs(
     playback_path: &PlaybackFilePath,
 ) -> Option<Result<TimestampedInputs, TimestampedInputsError>> {
     playback_path.path().as_ref().map(|file_path| {
-        let file = File::open(file_path).map_err(|error| TimestampedInputsError::Fs(error))?;
-        from_reader(file).map_err(|error| TimestampedInputsError::Ron(error))
+        let file = File::open(file_path).map_err(TimestampedInputsError::Fs)?;
+        from_reader(file).map_err(TimestampedInputsError::Ron)
     })
 }
 

From 46122188dc942692db67b2d5edb6331ed8514875 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <sullivansean27@gmail.com>
Date: Wed, 18 Sep 2024 01:03:39 -0400
Subject: [PATCH 12/21] Refactor to use observers in capture and fix/test
 EndInputCapture behavior

---
 src/input_capture.rs   | 141 ++++++++++++++++++-----------------------
 tests/input_capture.rs |  58 ++++++++++++++++-
 2 files changed, 118 insertions(+), 81 deletions(-)

diff --git a/src/input_capture.rs b/src/input_capture.rs
index 816e2ca..565129e 100644
--- a/src/input_capture.rs
+++ b/src/input_capture.rs
@@ -2,7 +2,7 @@
 //!
 //! These are unified into a single [`TimestampedInputs`](crate::timestamped_input::TimestampedInputs) resource, which can be played back.
 
-use bevy::app::{App, AppExit, First, Last, Plugin};
+use bevy::app::{App, AppExit, Last, Plugin};
 use bevy::core::{update_frame_count, FrameCount};
 use bevy::ecs::prelude::*;
 use bevy::input::gamepad::GamepadEvent;
@@ -27,23 +27,15 @@ pub struct InputCapturePlugin;
 
 impl Plugin for InputCapturePlugin {
     fn build(&self, app: &mut App) {
-        app.add_event::<BeginInputCapture>()
-            .add_event::<EndInputCapture>()
-            .add_systems(First, initiate_input_capture)
+        app.observe(BeginInputCapture::observer)
+            .observe(EndInputCapture::observer)
             .add_systems(
                 Last,
                 (
                     // Capture any mocked input as well
                     capture_input,
-                    (
-                        serialize_captured_input_on_final_capture_frame
-                            .run_if(resource_exists::<FinalCaptureFrame>),
-                        serialize_captured_input_on_end_capture_event,
-                        serialize_captured_input_on_exit,
-                    )
-                        .run_if(resource_exists::<PlaybackFilePath>),
+                    handle_final_capture_frame.run_if(resource_exists::<FinalCaptureFrame>),
                 )
-                    .run_if(resource_exists::<InputModesCaptured>)
                     .chain()
                     .before(update_frame_count),
             );
@@ -67,10 +59,51 @@ pub struct BeginInputCapture {
     pub window_to_capture: Option<Entity>,
 }
 
-/// An Event that users can send to end input capture and serialize data to disk.
+impl BeginInputCapture {
+    /// Initiates input capture when a [`BeginInputCapture`] is detected.
+    pub fn observer(trigger: Trigger<Self>, mut commands: Commands, frame_count: Res<FrameCount>) {
+        let event = trigger.event();
+        commands.init_resource::<TimestampedInputs>();
+        commands.insert_resource(event.input_modes_captured.clone());
+        if let Some(path) = &event.filepath {
+            commands.insert_resource(PlaybackFilePath::new(path));
+        }
+        if let Some(final_frame) = event.frames_to_capture {
+            commands.insert_resource(FinalCaptureFrame(FrameCount(
+                frame_count.0.wrapping_add(final_frame.0),
+            )));
+        }
+        if let Some(window_entity) = &event.window_to_capture {
+            commands.insert_resource(InputCaptureWindow(*window_entity));
+        }
+    }
+}
+
+/// An Observer Trigger that users can send to end input capture and serialize data to disk.
 #[derive(Debug, Event)]
 pub struct EndInputCapture;
 
+impl EndInputCapture {
+    /// An ObserverSystem for `EndInputCapture` that removes all capture-related resources and serializes timestamps if `PlaybackFilePath` exists
+    pub fn observer(
+        _trigger: Trigger<Self>,
+        mut commands: Commands,
+        captured_inputs: Res<TimestampedInputs>,
+        playback_file: Option<Res<PlaybackFilePath>>,
+    ) {
+        // if a PlaybackFilePath exists, serialize `TimestampedInputs` and remove it
+        if let Some(playback_file) = playback_file.as_deref() {
+            serialize_timestamped_inputs(&captured_inputs, playback_file);
+            commands.remove_resource::<TimestampedInputs>();
+            commands.remove_resource::<PlaybackFilePath>();
+        }
+        // also remove capture-related resources
+        commands.remove_resource::<InputModesCaptured>();
+        commands.remove_resource::<FinalCaptureFrame>();
+        commands.remove_resource::<InputCaptureWindow>();
+    }
+}
+
 /// The final [`FrameCount`] at which inputs will stop being captured.
 ///
 /// If this Resource is attached, [`TimestampedInputs`] will be serialized and input capture will stop once `FrameCount` reaches this value.
@@ -126,32 +159,6 @@ impl Default for InputModesCaptured {
     }
 }
 
-/// Initiates input capture when a [`BeginInputCapture`] is detected.
-pub fn initiate_input_capture(
-    mut commands: Commands,
-    mut begin_capture_events: EventReader<BeginInputCapture>,
-    frame_count: Res<FrameCount>,
-) {
-    if let Some(event) = begin_capture_events.read().next() {
-        commands.init_resource::<TimestampedInputs>();
-        commands.insert_resource(event.input_modes_captured.clone());
-        if let Some(path) = &event.filepath {
-            commands.insert_resource(PlaybackFilePath::new(path));
-        } else {
-            commands.init_resource::<PlaybackFilePath>();
-        }
-        if let Some(final_frame) = event.frames_to_capture {
-            commands.insert_resource(FinalCaptureFrame(FrameCount(
-                frame_count.0.wrapping_add(final_frame.0),
-            )));
-        }
-        if let Some(window_entity) = &event.window_to_capture {
-            commands.insert_resource(InputCaptureWindow(*window_entity));
-        }
-    }
-    begin_capture_events.clear();
-}
-
 /// Captures input from the [`bevy::window`] and [`bevy::input`] event streams.
 ///
 /// The input modes can be controlled via the [`InputModesCaptured`] resource.
@@ -165,10 +172,20 @@ pub fn capture_input(
     mut app_exit_events: EventReader<AppExit>,
     mut timestamped_input: ResMut<TimestampedInputs>,
     window_to_capture: Option<Res<InputCaptureWindow>>,
-    input_modes_captured: Res<InputModesCaptured>,
+    input_modes_captured: Option<Res<InputModesCaptured>>,
     frame_count: Res<FrameCount>,
     time: Res<Time>,
 ) {
+    let Some(input_modes_captured) = input_modes_captured else {
+        mouse_button_events.clear();
+        mouse_wheel_events.clear();
+        cursor_moved_events.clear();
+        keyboard_events.clear();
+        gamepad_events.clear();
+        app_exit_events.clear();
+        return;
+    };
+
     let time_since_startup = time.elapsed();
     let frame = *frame_count;
 
@@ -255,55 +272,23 @@ pub fn capture_input(
 }
 
 /// Serializes captured input to the path given in the [`PlaybackFilePath`] resource once [`AppExit`] is sent.
-///
-/// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
-pub fn serialize_captured_input_on_exit(
+pub fn trigger_input_capture_on_exit(
     app_exit_events: EventReader<AppExit>,
-    playback_file: Res<PlaybackFilePath>,
-    captured_inputs: Res<TimestampedInputs>,
+    mut commands: Commands,
 ) {
     if !app_exit_events.is_empty() {
-        serialize_timestamped_inputs(&captured_inputs, &playback_file);
+        commands.trigger(EndInputCapture);
     }
 }
 
-/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource once the provided number of frames have elapsed.
-///
-/// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
-pub fn serialize_captured_input_on_final_capture_frame(
+/// Triggers `EndInputCapture` once the provided number of frames have elapsed.
+pub fn handle_final_capture_frame(
     mut commands: Commands,
     frame_count: Res<FrameCount>,
     final_frame: Res<FinalCaptureFrame>,
-    playback_file: Res<PlaybackFilePath>,
-    captured_inputs: Res<TimestampedInputs>,
 ) {
     if *frame_count == final_frame.0 {
-        serialize_timestamped_inputs(&captured_inputs, &playback_file);
-        commands.remove_resource::<PlaybackFilePath>();
-        commands.remove_resource::<TimestampedInputs>();
-        commands.remove_resource::<InputModesCaptured>();
-        commands.remove_resource::<FinalCaptureFrame>();
-        commands.remove_resource::<InputCaptureWindow>();
-    }
-}
-
-/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource when an [`EndInputCapture`] is detected.
-///
-/// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
-pub fn serialize_captured_input_on_end_capture_event(
-    mut commands: Commands,
-    mut end_capture_events: EventReader<EndInputCapture>,
-    playback_file: Res<PlaybackFilePath>,
-    captured_inputs: Res<TimestampedInputs>,
-) {
-    if !end_capture_events.is_empty() {
-        serialize_timestamped_inputs(&captured_inputs, &playback_file);
-        end_capture_events.clear();
-        commands.remove_resource::<PlaybackFilePath>();
-        commands.remove_resource::<TimestampedInputs>();
-        commands.remove_resource::<InputModesCaptured>();
-        commands.remove_resource::<FinalCaptureFrame>();
-        commands.remove_resource::<InputCaptureWindow>();
+        commands.trigger(EndInputCapture);
     }
 }
 
diff --git a/tests/input_capture.rs b/tests/input_capture.rs
index b897934..add58cf 100644
--- a/tests/input_capture.rs
+++ b/tests/input_capture.rs
@@ -7,8 +7,10 @@ use bevy::input::InputPlugin;
 use bevy::prelude::*;
 use bevy::window::WindowPlugin;
 
-use leafwing_input_playback::input_capture::BeginInputCapture;
-use leafwing_input_playback::input_capture::{InputCapturePlugin, InputModesCaptured};
+use leafwing_input_playback::input_capture::EndInputCapture;
+use leafwing_input_playback::input_capture::{
+    BeginInputCapture, InputCapturePlugin, InputModesCaptured,
+};
 use leafwing_input_playback::timestamped_input::{
     InputEvent, TimestampedInputEvent, TimestampedInputs,
 };
@@ -42,13 +44,13 @@ fn capture_app() -> App {
         InputPlugin,
         InputCapturePlugin,
     ));
-    app.world_mut().send_event(BeginInputCapture::default());
     app
 }
 
 #[test]
 fn capture_sent_events() {
     let mut app = capture_app();
+    app.world_mut().trigger(BeginInputCapture::default());
 
     let mut keyboard_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
     keyboard_events.send(TEST_PRESS);
@@ -62,6 +64,7 @@ fn capture_sent_events() {
 #[test]
 fn identity_of_sent_events() {
     let mut app = capture_app();
+    app.world_mut().trigger(BeginInputCapture::default());
 
     let mut keyboard_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
     keyboard_events.send(TEST_PRESS);
@@ -90,6 +93,7 @@ fn identity_of_sent_events() {
 #[test]
 fn framecount_of_sent_events() {
     let mut app = capture_app();
+    app.world_mut().trigger(BeginInputCapture::default());
 
     let mut keyboard_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
     keyboard_events.send(TEST_PRESS);
@@ -113,6 +117,7 @@ fn framecount_of_sent_events() {
 #[test]
 fn toggle_input_capture() {
     let mut app = capture_app();
+    app.world_mut().trigger(BeginInputCapture::default());
 
     let mut keyboard_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
     keyboard_events.send(TEST_PRESS);
@@ -158,3 +163,50 @@ fn toggle_input_capture() {
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.len(), 3);
 }
+
+#[test]
+fn end_input_capture() {
+    let mut app = capture_app();
+    app.world_mut().trigger(BeginInputCapture::default());
+
+    let mut keyboard_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
+    keyboard_events.send(TEST_PRESS);
+
+    app.update();
+
+    // Inputs are captured while input capturing is enabled by default
+    let timestamped_input = app.world().resource::<TimestampedInputs>();
+    assert_eq!(timestamped_input.len(), 1);
+
+    // End input capture
+    app.world_mut().trigger(EndInputCapture);
+
+    let mut keyboard_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
+    keyboard_events.send(TEST_RELEASE);
+
+    app.update();
+
+    // Inputs are not captured once capture is ended.
+    // Since we have not provided a file path, TimestampedInputs remains.
+    let timestamped_input = app.world().resource::<TimestampedInputs>();
+    assert_eq!(timestamped_input.len(), 1);
+
+    // Beginning capture again also works.
+    app.world_mut().trigger(BeginInputCapture::default());
+
+    app.update();
+
+    // The previous results have not been overwritten.
+    let timestamped_input = app.world().resource::<TimestampedInputs>();
+    eprintln!("{timestamped_input:?}");
+    assert_eq!(timestamped_input.len(), 1);
+
+    let mut keyboard_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
+    keyboard_events.send(TEST_RELEASE);
+
+    app.update();
+
+    // New inputs are still accepted.
+    let timestamped_input = app.world().resource::<TimestampedInputs>();
+    assert_eq!(timestamped_input.len(), 2);
+}

From 45a39fe3570dc5584c331f8fc6a450fe2236fd23 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <me@snen.dev>
Date: Fri, 15 Nov 2024 16:07:57 -0500
Subject: [PATCH 13/21] tmp

---
 src/input_playback.rs   | 91 +++++++++++++++++------------------------
 tests/input_playback.rs | 90 ++++++++++++++++++++++++++++------------
 2 files changed, 101 insertions(+), 80 deletions(-)

diff --git a/src/input_playback.rs b/src/input_playback.rs
index 158e10e..1ac04fc 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -5,8 +5,8 @@
 use bevy::app::{App, AppExit, First, Plugin};
 use bevy::core::FrameCount;
 use bevy::ecs::{prelude::*, system::SystemParam};
-use bevy::input::gamepad::GamepadEvent;
 use bevy::input::{
+    gamepad::GamepadEvent,
     keyboard::KeyboardInput,
     mouse::{MouseButtonInput, MouseWheel},
 };
@@ -30,14 +30,8 @@ pub struct InputPlaybackPlugin;
 
 impl Plugin for InputPlaybackPlugin {
     fn build(&self, app: &mut App) {
-        app.add_event::<BeginInputPlayback>()
-            .add_event::<EndInputPlayback>()
-            .add_systems(
-                First,
-                (handle_end_playback_event, initiate_input_playback)
-                    .chain()
-                    .after(bevy::ecs::event::EventUpdates),
-            )
+        app.observe(BeginInputPlayback::observer)
+            .observe(EndInputPlayback::observer)
             .add_systems(
                 First,
                 playback_timestamped_input
@@ -45,7 +39,7 @@ impl Plugin for InputPlaybackPlugin {
                         resource_exists::<PlaybackProgress>
                             .and_then(resource_exists::<TimestampedInputs>),
                     )
-                    .after(initiate_input_playback),
+                    .after(bevy::ecs::event::EventUpdates),
             );
     }
 }
@@ -66,10 +60,35 @@ pub struct BeginInputPlayback {
     pub playback_window: Option<Entity>,
 }
 
+impl BeginInputPlayback {
+    /// Initiates input playback and deserializes timestamped inputs from the provided playback source.
+    pub fn observer(trigger: Trigger<BeginInputPlayback>, mut commands: Commands) {
+        let event = trigger.event();
+        commands.init_resource::<PlaybackProgress>();
+        commands.insert_resource(event.playback_strategy);
+
+        if let Some(source) = event.source.as_ref() {
+            let timestamped_inputs = match source {
+                InputPlaybackSource::TimestampedInputs(inputs) => inputs.clone(),
+                InputPlaybackSource::File(playback_path) => {
+                    commands.insert_resource(playback_path.clone());
+                    deserialize_timestamped_inputs(playback_path)
+                        .unwrap()
+                        .unwrap()
+                }
+            };
+            commands.insert_resource(timestamped_inputs);
+        }
+
+        if let Some(playback_window) = event.playback_window {
+            commands.insert_resource(PlaybackWindow(playback_window));
+        }
+    }
+}
+
 /// The source of input data for playback.
 ///
-/// Typically users should expect to provide a
-
+/// Typically users should expect to provide a FilePath, but `TimestampedInputs` can still be provided manually.
 #[derive(Debug)]
 pub enum InputPlaybackSource {
     /// Reads from a file and deserializes the content into a `TimestampedInputs`.
@@ -96,51 +115,15 @@ impl Default for InputPlaybackSource {
     }
 }
 
-/// Initiates input playback when a [`BeginInputPlayback`] is detected.
-pub fn initiate_input_playback(
-    mut commands: Commands,
-    mut begin_capture_events: EventReader<BeginInputPlayback>,
-) {
-    let Some(event) = begin_capture_events.read().next() else {
-        return;
-    };
-
-    commands.init_resource::<PlaybackProgress>();
-    commands.insert_resource(event.playback_strategy);
-
-    if let Some(source) = event.source.as_ref() {
-        let timestamped_inputs = match source {
-            InputPlaybackSource::TimestampedInputs(inputs) => inputs.clone(),
-            InputPlaybackSource::File(playback_path) => {
-                commands.insert_resource(playback_path.clone());
-                deserialize_timestamped_inputs(playback_path)
-                    .unwrap()
-                    .unwrap()
-            }
-        };
-        commands.insert_resource(timestamped_inputs);
-    }
-
-    if let Some(playback_window) = event.playback_window {
-        commands.insert_resource(PlaybackWindow(playback_window));
-    }
-
-    begin_capture_events.clear();
-}
-
 /// An Event that users can send to end input playback prematurely.
 #[derive(Debug, Event)]
 pub struct EndInputPlayback;
 
-/// Serializes captured input to the path given in the [`PlaybackFilePath`] resource when an [`EndInputCapture`] is detected.
-///
-/// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
-pub fn handle_end_playback_event(
-    mut commands: Commands,
-    mut end_capture_events: EventReader<EndInputPlayback>,
-) {
-    if !end_capture_events.is_empty() {
-        end_capture_events.clear();
+impl EndInputPlayback {
+    /// Serializes captured input to the path given in the [`PlaybackFilePath`] resource when an [`EndInputCapture`] is detected.
+    ///
+    /// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
+    fn observer(_trigger: Trigger<EndInputPlayback>, mut commands: Commands) {
         commands.remove_resource::<PlaybackFilePath>();
         commands.remove_resource::<TimestampedInputs>();
         commands.remove_resource::<PlaybackProgress>();
@@ -294,7 +277,9 @@ fn send_playback_events(
     timestamped_input_events: impl IntoIterator<Item = TimestampedInputEvent>,
     input_writers: &mut InputWriters,
 ) {
+    eprintln!("Adding events:");
     for timestamped_input_event in timestamped_input_events {
+        eprintln!("{timestamped_input_event:?}");
         use crate::timestamped_input::InputEvent::*;
         match timestamped_input_event.input_event {
             Keyboard(e) => {
diff --git a/tests/input_playback.rs b/tests/input_playback.rs
index 564ed08..4f7d211 100644
--- a/tests/input_playback.rs
+++ b/tests/input_playback.rs
@@ -1,7 +1,6 @@
 // BLOCKED: add time strategy tests: https://github.com/bevyengine/bevy/issues/6146
 
 use bevy::core::FrameCount;
-use bevy::ecs::event::EventRegistry;
 use bevy::input::keyboard::Key;
 use bevy::input::keyboard::KeyboardInput;
 use bevy::input::ButtonState;
@@ -15,6 +14,7 @@ use leafwing_input_playback::input_capture::InputCapturePlugin;
 use leafwing_input_playback::input_capture::InputModesCaptured;
 use leafwing_input_playback::input_playback::BeginInputPlayback;
 use leafwing_input_playback::input_playback::InputPlaybackPlugin;
+use leafwing_input_playback::input_playback::InputPlaybackSource;
 use leafwing_input_playback::input_playback::PlaybackStrategy;
 use leafwing_input_playback::timestamped_input::TimestampedInputs;
 
@@ -32,7 +32,7 @@ const TEST_RELEASE: KeyboardInput = KeyboardInput {
     window: Entity::PLACEHOLDER,
 };
 
-fn playback_app(strategy: PlaybackStrategy) -> App {
+fn playback_app() -> App {
     let mut app = App::new();
 
     app.add_plugins((
@@ -42,14 +42,6 @@ fn playback_app(strategy: PlaybackStrategy) -> App {
         InputPlaybackPlugin,
     ));
 
-    let mut registry = app.world_mut().resource_mut::<EventRegistry>();
-    registry.should_update = ShouldUpdateEvents::Always;
-
-    app.world_mut().send_event(BeginInputPlayback {
-        playback_strategy: strategy,
-        ..Default::default()
-    });
-
     app
 }
 
@@ -74,12 +66,18 @@ fn complex_timestamped_input() -> TimestampedInputs {
 
 #[test]
 fn minimal_playback() {
-    let mut app = playback_app(PlaybackStrategy::FrameCount);
+    let mut app = playback_app();
+
+    app.world_mut().trigger(BeginInputPlayback {
+        playback_strategy: PlaybackStrategy::FrameCount,
+        source: Some(InputPlaybackSource::from_inputs(simple_timestamped_input())),
+        ..Default::default()
+    });
+    app.world_mut().flush_commands();
+
     let input_events = app.world().resource::<Events<KeyboardInput>>();
     assert_eq!(input_events.len(), 0);
 
-    app.insert_resource(simple_timestamped_input());
-
     app.update();
 
     // By default, only events up to the current frame are played back
@@ -98,10 +96,15 @@ fn minimal_playback() {
 
 #[test]
 fn capture_and_playback() {
-    let mut app = playback_app(PlaybackStrategy::default());
+    let mut app = playback_app();
     app.add_plugins(InputCapturePlugin);
-    app.insert_resource(PlaybackStrategy::Paused);
-    app.insert_resource(TimestampedInputs::default());
+
+    app.world_mut().trigger(BeginInputPlayback {
+        playback_strategy: PlaybackStrategy::Paused,
+        source: Some(InputPlaybackSource::from_inputs(Default::default())),
+        ..Default::default()
+    });
+    app.world_mut().flush_commands();
 
     let mut input_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
     input_events.send(TEST_PRESS);
@@ -131,15 +134,20 @@ fn capture_and_playback() {
 #[test]
 fn repeated_playback() {
     // Play all of the events each pass
-    let mut app = playback_app(PlaybackStrategy::default());
+    let mut app = playback_app();
     app.world_mut()
         .insert_resource(TimeUpdateStrategy::ManualDuration(Duration::from_secs(1)));
 
+    app.world_mut().trigger(BeginInputPlayback {
+        playback_strategy: PlaybackStrategy::default(),
+        source: Some(InputPlaybackSource::from_inputs(simple_timestamped_input())),
+        ..Default::default()
+    });
+    app.world_mut().flush_commands();
+
     let input_events = app.world().resource::<Events<KeyboardInput>>();
     assert_eq!(input_events.len(), 0);
 
-    app.insert_resource(simple_timestamped_input());
-
     for _ in 1..10 {
         app.update();
     }
@@ -161,8 +169,14 @@ fn repeated_playback() {
 
 #[test]
 fn playback_strategy_paused() {
-    let mut app = playback_app(PlaybackStrategy::Paused);
-    app.insert_resource(complex_timestamped_input());
+    let mut app = playback_app();
+
+    app.world_mut().trigger(BeginInputPlayback {
+        playback_strategy: PlaybackStrategy::Paused,
+        source: Some(InputPlaybackSource::from_inputs(complex_timestamped_input())),
+        ..Default::default()
+    });
+    app.world_mut().flush_commands();
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);
@@ -177,8 +191,14 @@ fn playback_strategy_paused() {
 
 #[test]
 fn playback_strategy_frame() {
-    let mut app = playback_app(PlaybackStrategy::FrameCount);
-    app.insert_resource(complex_timestamped_input());
+    let mut app = playback_app();
+
+    app.world_mut().trigger(BeginInputPlayback {
+        playback_strategy: PlaybackStrategy::FrameCount,
+        source: Some(InputPlaybackSource::from_inputs(complex_timestamped_input())),
+        ..Default::default()
+    });
+    app.world_mut().flush_commands();
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);
@@ -203,9 +223,15 @@ fn playback_strategy_frame() {
 
 #[test]
 fn playback_strategy_frame_range_once() {
+    let mut app = playback_app();
+
     let strategy = PlaybackStrategy::FrameRangeOnce(FrameCount(2), FrameCount(5));
-    let mut app = playback_app(strategy);
-    app.insert_resource(complex_timestamped_input());
+    app.world_mut().trigger(BeginInputPlayback {
+        playback_strategy: strategy,
+        source: Some(InputPlaybackSource::from_inputs(complex_timestamped_input())),
+        ..Default::default()
+    });
+    app.world_mut().flush_commands();
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);
@@ -217,17 +243,20 @@ fn playback_strategy_frame_range_once() {
     app.update();
 
     let input_events = app.world().resource::<Events<KeyboardInput>>();
+    eprintln!("{input_events:?}");
     assert_eq!(input_events.len(), 2);
 
     // Frame 3 (events are double buffered)
     app.update();
     let input_events = app.world().resource::<Events<KeyboardInput>>();
+    eprintln!("{input_events:?}");
     assert_eq!(input_events.len(), 3);
 
     // Frame 4 (events are double buffered)
     app.update();
     let input_events = app.world().resource::<Events<KeyboardInput>>();
     assert_eq!(*app.world().resource::<PlaybackStrategy>(), strategy);
+    eprintln!("{input_events:?}");
     assert_eq!(input_events.len(), 1);
 
     // Paused
@@ -242,9 +271,16 @@ fn playback_strategy_frame_range_once() {
 
 #[test]
 fn playback_strategy_frame_range_loop() {
+    let mut app = playback_app();
+
     let strategy = PlaybackStrategy::FrameRangeLoop(FrameCount(2), FrameCount(5));
-    let mut app = playback_app(strategy);
-    app.insert_resource(complex_timestamped_input());
+    app.world_mut().trigger(BeginInputPlayback {
+        playback_strategy: strategy,
+        source: Some(InputPlaybackSource::from_inputs(complex_timestamped_input())),
+        ..Default::default()
+    });
+
+    app.update();
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);

From 10d0ea05241057c8370697b5aa6947c186412e55 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <me@snen.dev>
Date: Sat, 16 Nov 2024 21:44:51 -0500
Subject: [PATCH 14/21] tell event registry to always update test events

---
 tests/input_playback.rs | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/tests/input_playback.rs b/tests/input_playback.rs
index 4f7d211..ffec466 100644
--- a/tests/input_playback.rs
+++ b/tests/input_playback.rs
@@ -1,6 +1,7 @@
 // BLOCKED: add time strategy tests: https://github.com/bevyengine/bevy/issues/6146
 
 use bevy::core::FrameCount;
+use bevy::ecs::event::EventRegistry;
 use bevy::input::keyboard::Key;
 use bevy::input::keyboard::KeyboardInput;
 use bevy::input::ButtonState;
@@ -42,6 +43,9 @@ fn playback_app() -> App {
         InputPlaybackPlugin,
     ));
 
+    let mut event_registry = app.world_mut().resource_mut::<EventRegistry>();
+    event_registry.should_update = ShouldUpdateEvents::Always;
+
     app
 }
 

From d1b339e02bfc803f4ffe7d1d815d741d1563c296 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <me@snen.dev>
Date: Sat, 16 Nov 2024 21:46:49 -0500
Subject: [PATCH 15/21] fix update -> flush_commands

---
 tests/input_playback.rs | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/tests/input_playback.rs b/tests/input_playback.rs
index ffec466..c07c6d5 100644
--- a/tests/input_playback.rs
+++ b/tests/input_playback.rs
@@ -283,8 +283,7 @@ fn playback_strategy_frame_range_loop() {
         source: Some(InputPlaybackSource::from_inputs(complex_timestamped_input())),
         ..Default::default()
     });
-
-    app.update();
+    app.world_mut().flush_commands();
 
     let timestamped_input = app.world().resource::<TimestampedInputs>();
     assert_eq!(timestamped_input.cursor, 0);

From df215ad880265fb852034c2f62324fa4d76865bd Mon Sep 17 00:00:00 2001
From: Sean Sullivan <me@snen.dev>
Date: Sat, 16 Nov 2024 21:54:33 -0500
Subject: [PATCH 16/21] remove log lines

---
 src/input_playback.rs   | 2 --
 tests/input_capture.rs  | 1 -
 tests/input_playback.rs | 3 ---
 3 files changed, 6 deletions(-)

diff --git a/src/input_playback.rs b/src/input_playback.rs
index 1ac04fc..5d5a562 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -277,9 +277,7 @@ fn send_playback_events(
     timestamped_input_events: impl IntoIterator<Item = TimestampedInputEvent>,
     input_writers: &mut InputWriters,
 ) {
-    eprintln!("Adding events:");
     for timestamped_input_event in timestamped_input_events {
-        eprintln!("{timestamped_input_event:?}");
         use crate::timestamped_input::InputEvent::*;
         match timestamped_input_event.input_event {
             Keyboard(e) => {
diff --git a/tests/input_capture.rs b/tests/input_capture.rs
index add58cf..d2c4b13 100644
--- a/tests/input_capture.rs
+++ b/tests/input_capture.rs
@@ -198,7 +198,6 @@ fn end_input_capture() {
 
     // The previous results have not been overwritten.
     let timestamped_input = app.world().resource::<TimestampedInputs>();
-    eprintln!("{timestamped_input:?}");
     assert_eq!(timestamped_input.len(), 1);
 
     let mut keyboard_events = app.world_mut().resource_mut::<Events<KeyboardInput>>();
diff --git a/tests/input_playback.rs b/tests/input_playback.rs
index c07c6d5..7a0d618 100644
--- a/tests/input_playback.rs
+++ b/tests/input_playback.rs
@@ -247,20 +247,17 @@ fn playback_strategy_frame_range_once() {
     app.update();
 
     let input_events = app.world().resource::<Events<KeyboardInput>>();
-    eprintln!("{input_events:?}");
     assert_eq!(input_events.len(), 2);
 
     // Frame 3 (events are double buffered)
     app.update();
     let input_events = app.world().resource::<Events<KeyboardInput>>();
-    eprintln!("{input_events:?}");
     assert_eq!(input_events.len(), 3);
 
     // Frame 4 (events are double buffered)
     app.update();
     let input_events = app.world().resource::<Events<KeyboardInput>>();
     assert_eq!(*app.world().resource::<PlaybackStrategy>(), strategy);
-    eprintln!("{input_events:?}");
     assert_eq!(input_events.len(), 1);
 
     // Paused

From 3e9f79e55e2bfb26d854bac5d0d44e70ba308043 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <me@snen.dev>
Date: Sat, 16 Nov 2024 22:03:09 -0500
Subject: [PATCH 17/21] put the old name back for a var

---
 tests/input_playback.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/input_playback.rs b/tests/input_playback.rs
index 7a0d618..e8ecb57 100644
--- a/tests/input_playback.rs
+++ b/tests/input_playback.rs
@@ -43,8 +43,8 @@ fn playback_app() -> App {
         InputPlaybackPlugin,
     ));
 
-    let mut event_registry = app.world_mut().resource_mut::<EventRegistry>();
-    event_registry.should_update = ShouldUpdateEvents::Always;
+    let mut registry = app.world_mut().resource_mut::<EventRegistry>();
+    registry.should_update = ShouldUpdateEvents::Always;
 
     app
 }

From fbe0c4e38b670a0c363f190e68169271dbd39f7c Mon Sep 17 00:00:00 2001
From: Sean Sullivan <me@snen.dev>
Date: Sat, 16 Nov 2024 22:05:48 -0500
Subject: [PATCH 18/21] clippy

---
 src/input_capture.rs     |  2 +-
 src/input_playback.rs    |  2 +-
 src/timestamped_input.rs | 12 ++++++------
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/input_capture.rs b/src/input_capture.rs
index 565129e..6e0443c 100644
--- a/src/input_capture.rs
+++ b/src/input_capture.rs
@@ -84,7 +84,7 @@ impl BeginInputCapture {
 pub struct EndInputCapture;
 
 impl EndInputCapture {
-    /// An ObserverSystem for `EndInputCapture` that removes all capture-related resources and serializes timestamps if `PlaybackFilePath` exists
+    /// An `ObserverSystem` for `EndInputCapture` that removes all capture-related resources and serializes timestamps if `PlaybackFilePath` exists
     pub fn observer(
         _trigger: Trigger<Self>,
         mut commands: Commands,
diff --git a/src/input_playback.rs b/src/input_playback.rs
index 5d5a562..2bcc164 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -88,7 +88,7 @@ impl BeginInputPlayback {
 
 /// The source of input data for playback.
 ///
-/// Typically users should expect to provide a FilePath, but `TimestampedInputs` can still be provided manually.
+/// Typically users should expect to provide a `FilePath`, but `TimestampedInputs` can still be provided manually.
 #[derive(Debug)]
 pub enum InputPlaybackSource {
     /// Reads from a file and deserializes the content into a `TimestampedInputs`.
diff --git a/src/timestamped_input.rs b/src/timestamped_input.rs
index a9c514a..e8821ee 100644
--- a/src/timestamped_input.rs
+++ b/src/timestamped_input.rs
@@ -423,27 +423,27 @@ mod tests {
         inputs.send(
             FrameCount(0),
             Duration::from_secs(0),
-            LEFT_CLICK_PRESS.into(),
+            LEFT_CLICK_PRESS,
         );
         inputs.send(
             FrameCount(1),
             Duration::from_secs(1),
-            LEFT_CLICK_RELEASE.into(),
+            LEFT_CLICK_RELEASE,
         );
         inputs.send(
             FrameCount(2),
             Duration::from_secs(2),
-            LEFT_CLICK_PRESS.into(),
+            LEFT_CLICK_PRESS,
         );
         inputs.send(
             FrameCount(2),
             Duration::from_secs(3),
-            LEFT_CLICK_PRESS.into(),
+            LEFT_CLICK_PRESS,
         );
         inputs.send(
             FrameCount(3),
             Duration::from_secs(3),
-            LEFT_CLICK_PRESS.into(),
+            LEFT_CLICK_PRESS,
         );
 
         inputs
@@ -466,7 +466,7 @@ mod tests {
         let events = [LEFT_CLICK_PRESS, LEFT_CLICK_RELEASE];
 
         // This sends all events received simultaneously
-        timestamped_input.send_multiple(FrameCount(0), Duration::ZERO, events.into_iter());
+        timestamped_input.send_multiple(FrameCount(0), Duration::ZERO, events);
 
         assert_eq!(timestamped_input.len(), 2);
         assert_eq!(timestamped_input.last_framecount(), None);

From 6a1d7f6f28fc57f91172d0840440b22e8bdf3109 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <me@snen.dev>
Date: Sat, 16 Nov 2024 22:09:00 -0500
Subject: [PATCH 19/21] fmt

---
 src/timestamped_input.rs | 30 +++++-------------------------
 1 file changed, 5 insertions(+), 25 deletions(-)

diff --git a/src/timestamped_input.rs b/src/timestamped_input.rs
index e8821ee..873d601 100644
--- a/src/timestamped_input.rs
+++ b/src/timestamped_input.rs
@@ -420,31 +420,11 @@ mod tests {
 
     fn complex_timestamped_input() -> TimestampedInputs {
         let mut inputs = TimestampedInputs::default();
-        inputs.send(
-            FrameCount(0),
-            Duration::from_secs(0),
-            LEFT_CLICK_PRESS,
-        );
-        inputs.send(
-            FrameCount(1),
-            Duration::from_secs(1),
-            LEFT_CLICK_RELEASE,
-        );
-        inputs.send(
-            FrameCount(2),
-            Duration::from_secs(2),
-            LEFT_CLICK_PRESS,
-        );
-        inputs.send(
-            FrameCount(2),
-            Duration::from_secs(3),
-            LEFT_CLICK_PRESS,
-        );
-        inputs.send(
-            FrameCount(3),
-            Duration::from_secs(3),
-            LEFT_CLICK_PRESS,
-        );
+        inputs.send(FrameCount(0), Duration::from_secs(0), LEFT_CLICK_PRESS);
+        inputs.send(FrameCount(1), Duration::from_secs(1), LEFT_CLICK_RELEASE);
+        inputs.send(FrameCount(2), Duration::from_secs(2), LEFT_CLICK_PRESS);
+        inputs.send(FrameCount(2), Duration::from_secs(3), LEFT_CLICK_PRESS);
+        inputs.send(FrameCount(3), Duration::from_secs(3), LEFT_CLICK_PRESS);
 
         inputs
     }

From 663858d7ff41c36c54854f887b1c73839ad86624 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <me@snen.dev>
Date: Fri, 29 Nov 2024 21:52:33 -0500
Subject: [PATCH 20/21] Improve docs, fix data samples, fix examples, use
 PlaybackWindow to control playback

---
 data/app_exit.ron                     |    2 +-
 data/hello_world.ron                  |  579 ++++++------
 examples/gamepad.rs                   | 1220 ++++++++++++-------------
 examples/input_capture.rs             |   12 +-
 examples/input_playback.rs            |  269 +++---
 examples/playback_serialized_input.rs |   43 +-
 examples/serialize_captured_input.rs  |   22 +-
 examples/useless_machine.rs           |   32 +-
 src/input_capture.rs                  |   10 +-
 src/input_playback.rs                 |  911 +++++++++---------
 10 files changed, 1588 insertions(+), 1512 deletions(-)

diff --git a/data/app_exit.ron b/data/app_exit.ron
index b843f5f..da5cac9 100644
--- a/data/app_exit.ron
+++ b/data/app_exit.ron
@@ -1,7 +1,7 @@
 (
     events: [
         (
-            frame: (71),
+            frame: 71,
             time_since_startup: (
                 secs: 1,
                 nanos: 592977800,
diff --git a/data/hello_world.ron b/data/hello_world.ron
index d721bd7..bf58ae8 100644
--- a/data/hello_world.ron
+++ b/data/hello_world.ron
@@ -1,269 +1,312 @@
-(
-    events: [
-        (
-            frame: (116),
-            time_since_startup: (
-                secs: 2,
-                nanos: 380259200,
-            ),
-            input_event: Keyboard((
-                scan_code: 35,
-                key_code: Some(H),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (120),
-            time_since_startup: (
-                secs: 2,
-                nanos: 446911200,
-            ),
-            input_event: Keyboard((
-                scan_code: 35,
-                key_code: Some(H),
-                state: Released,
-            )),
-        ),
-        (
-            frame: (177),
-            time_since_startup: (
-                secs: 3,
-                nanos: 396952300,
-            ),
-            input_event: Keyboard((
-                scan_code: 18,
-                key_code: Some(E),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (180),
-            time_since_startup: (
-                secs: 3,
-                nanos: 446934100,
-            ),
-            input_event: Keyboard((
-                scan_code: 18,
-                key_code: Some(E),
-                state: Released,
-            )),
-        ),
-        (
-            frame: (220),
-            time_since_startup: (
-                secs: 4,
-                nanos: 113641400,
-            ),
-            input_event: Keyboard((
-                scan_code: 38,
-                key_code: Some(L),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (224),
-            time_since_startup: (
-                secs: 4,
-                nanos: 180281900,
-            ),
-            input_event: Keyboard((
-                scan_code: 38,
-                key_code: Some(L),
-                state: Released,
-            )),
-        ),
-        (
-            frame: (249),
-            time_since_startup: (
-                secs: 4,
-                nanos: 596947200,
-            ),
-            input_event: Keyboard((
-                scan_code: 38,
-                key_code: Some(L),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (255),
-            time_since_startup: (
-                secs: 4,
-                nanos: 697010200,
-            ),
-            input_event: Keyboard((
-                scan_code: 38,
-                key_code: Some(L),
-                state: Released,
-            )),
-        ),
-        (
-            frame: (285),
-            time_since_startup: (
-                secs: 5,
-                nanos: 197035600,
-            ),
-            input_event: Keyboard((
-                scan_code: 24,
-                key_code: Some(O),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (290),
-            time_since_startup: (
-                secs: 5,
-                nanos: 280284800,
-            ),
-            input_event: Keyboard((
-                scan_code: 24,
-                key_code: Some(O),
-                state: Released,
-            )),
-        ),
-        (
-            frame: (316),
-            time_since_startup: (
-                secs: 5,
-                nanos: 713653300,
-            ),
-            input_event: Keyboard((
-                scan_code: 57,
-                key_code: Some(Space),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (321),
-            time_since_startup: (
-                secs: 5,
-                nanos: 796981700,
-            ),
-            input_event: Keyboard((
-                scan_code: 57,
-                key_code: Some(Space),
-                state: Released,
-            )),
-        ),
-        (
-            frame: (346),
-            time_since_startup: (
-                secs: 6,
-                nanos: 213645600,
-            ),
-            input_event: Keyboard((
-                scan_code: 17,
-                key_code: Some(W),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (349),
-            time_since_startup: (
-                secs: 6,
-                nanos: 263658900,
-            ),
-            input_event: Keyboard((
-                scan_code: 17,
-                key_code: Some(W),
-                state: Released,
-            )),
-        ),
-        (
-            frame: (365),
-            time_since_startup: (
-                secs: 6,
-                nanos: 530358800,
-            ),
-            input_event: Keyboard((
-                scan_code: 24,
-                key_code: Some(O),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (369),
-            time_since_startup: (
-                secs: 6,
-                nanos: 597034800,
-            ),
-            input_event: Keyboard((
-                scan_code: 24,
-                key_code: Some(O),
-                state: Released,
-            )),
-        ),
-        (
-            frame: (380),
-            time_since_startup: (
-                secs: 6,
-                nanos: 780319600,
-            ),
-            input_event: Keyboard((
-                scan_code: 19,
-                key_code: Some(R),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (384),
-            time_since_startup: (
-                secs: 6,
-                nanos: 847000600,
-            ),
-            input_event: Keyboard((
-                scan_code: 19,
-                key_code: Some(R),
-                state: Released,
-            )),
-        ),
-        (
-            frame: (404),
-            time_since_startup: (
-                secs: 7,
-                nanos: 180385800,
-            ),
-            input_event: Keyboard((
-                scan_code: 38,
-                key_code: Some(L),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (410),
-            time_since_startup: (
-                secs: 7,
-                nanos: 280361100,
-            ),
-            input_event: Keyboard((
-                scan_code: 38,
-                key_code: Some(L),
-                state: Released,
-            )),
-        ),
-        (
-            frame: (413),
-            time_since_startup: (
-                secs: 7,
-                nanos: 330342400,
-            ),
-            input_event: Keyboard((
-                scan_code: 32,
-                key_code: Some(D),
-                state: Pressed,
-            )),
-        ),
-        (
-            frame: (418),
-            time_since_startup: (
-                secs: 7,
-                nanos: 413715800,
-            ),
-            input_event: Keyboard((
-                scan_code: 32,
-                key_code: Some(D),
-                state: Released,
-            )),
-        ),
-    ],
-    cursor: 0,
+(
+    events: [
+        (
+            frame: 72,
+            time_since_startup: (
+                secs: 1,
+                nanos: 171552588,
+            ),
+            input_event: Keyboard((
+                key_code: KeyH,
+                logical_key: Character("h"),
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 76,
+            time_since_startup: (
+                secs: 1,
+                nanos: 237682433,
+            ),
+            input_event: Keyboard((
+                key_code: KeyE,
+                logical_key: Character("e"),
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 79,
+            time_since_startup: (
+                secs: 1,
+                nanos: 287808619,
+            ),
+            input_event: Keyboard((
+                key_code: KeyH,
+                logical_key: Character("h"),
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 83,
+            time_since_startup: (
+                secs: 1,
+                nanos: 354264132,
+            ),
+            input_event: Keyboard((
+                key_code: KeyE,
+                logical_key: Character("e"),
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 84,
+            time_since_startup: (
+                secs: 1,
+                nanos: 371552096,
+            ),
+            input_event: Keyboard((
+                key_code: KeyL,
+                logical_key: Character("l"),
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 87,
+            time_since_startup: (
+                secs: 1,
+                nanos: 420491538,
+            ),
+            input_event: Keyboard((
+                key_code: KeyL,
+                logical_key: Character("l"),
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 91,
+            time_since_startup: (
+                secs: 1,
+                nanos: 487469805,
+            ),
+            input_event: Keyboard((
+                key_code: KeyL,
+                logical_key: Character("l"),
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 97,
+            time_since_startup: (
+                secs: 1,
+                nanos: 587663589,
+            ),
+            input_event: Keyboard((
+                key_code: KeyL,
+                logical_key: Character("l"),
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 102,
+            time_since_startup: (
+                secs: 1,
+                nanos: 670926111,
+            ),
+            input_event: Keyboard((
+                key_code: KeyO,
+                logical_key: Character("o"),
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 108,
+            time_since_startup: (
+                secs: 1,
+                nanos: 770864645,
+            ),
+            input_event: Keyboard((
+                key_code: KeyO,
+                logical_key: Character("o"),
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 126,
+            time_since_startup: (
+                secs: 2,
+                nanos: 70705952,
+            ),
+            input_event: Keyboard((
+                key_code: Space,
+                logical_key: Space,
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 130,
+            time_since_startup: (
+                secs: 2,
+                nanos: 137360743,
+            ),
+            input_event: Keyboard((
+                key_code: Space,
+                logical_key: Space,
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 131,
+            time_since_startup: (
+                secs: 2,
+                nanos: 154046279,
+            ),
+            input_event: Keyboard((
+                key_code: KeyW,
+                logical_key: Character("w"),
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 135,
+            time_since_startup: (
+                secs: 2,
+                nanos: 220650318,
+            ),
+            input_event: Keyboard((
+                key_code: KeyW,
+                logical_key: Character("w"),
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 140,
+            time_since_startup: (
+                secs: 2,
+                nanos: 303982817,
+            ),
+            input_event: Keyboard((
+                key_code: KeyO,
+                logical_key: Character("o"),
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 142,
+            time_since_startup: (
+                secs: 2,
+                nanos: 337671183,
+            ),
+            input_event: Keyboard((
+                key_code: KeyR,
+                logical_key: Character("r"),
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 145,
+            time_since_startup: (
+                secs: 2,
+                nanos: 386928375,
+            ),
+            input_event: Keyboard((
+                key_code: KeyO,
+                logical_key: Character("o"),
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 146,
+            time_since_startup: (
+                secs: 2,
+                nanos: 402879424,
+            ),
+            input_event: Keyboard((
+                key_code: KeyR,
+                logical_key: Character("r"),
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 150,
+            time_since_startup: (
+                secs: 2,
+                nanos: 470161663,
+            ),
+            input_event: Keyboard((
+                key_code: KeyL,
+                logical_key: Character("l"),
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 151,
+            time_since_startup: (
+                secs: 2,
+                nanos: 486047197,
+            ),
+            input_event: Keyboard((
+                key_code: KeyD,
+                logical_key: Character("d"),
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 154,
+            time_since_startup: (
+                secs: 2,
+                nanos: 536300612,
+            ),
+            input_event: Keyboard((
+                key_code: KeyL,
+                logical_key: Character("l"),
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 156,
+            time_since_startup: (
+                secs: 2,
+                nanos: 569849084,
+            ),
+            input_event: Keyboard((
+                key_code: KeyD,
+                logical_key: Character("d"),
+                state: Released,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 161,
+            time_since_startup: (
+                secs: 2,
+                nanos: 653288844,
+            ),
+            input_event: Keyboard((
+                key_code: AltLeft,
+                logical_key: Alt,
+                state: Pressed,
+                window: 4294967296,
+            )),
+        ),
+        (
+            frame: 170,
+            time_since_startup: (
+                secs: 2,
+                nanos: 802678637,
+            ),
+            input_event: AppExit,
+        ),
+    ],
+    cursor: 0,
 )
\ No newline at end of file
diff --git a/examples/gamepad.rs b/examples/gamepad.rs
index 8942f38..9cf95dc 100644
--- a/examples/gamepad.rs
+++ b/examples/gamepad.rs
@@ -1,610 +1,610 @@
-//! Demonstrates input capture and playback of gamepad inputs
-//!
-//! This example is modified from https://github.com/bevyengine/bevy/blob/main/examples/tools/gamepad_viewer.rs,
-//! which is used here under the MIT License <3
-
-//! Shows a visualization of gamepad buttons, sticks, and triggers
-
-use bevy::prelude::*;
-use leafwing_input_playback::{
-    input_capture::{InputCapturePlugin, InputModesCaptured},
-    input_playback::{InputPlaybackPlugin, PlaybackStrategy},
-    timestamped_input::TimestampedInputs,
-};
-
-fn main() {
-    use gamepad_viewer_example::*;
-
-    App::new()
-        // This plugin contains all the code from the original example
-        .add_plugins((
-            GamepadViewerExample,
-            InputCapturePlugin,
-            InputPlaybackPlugin,
-        ))
-        // Disable all input capture and playback to start
-        .insert_resource(InputModesCaptured::DISABLE_ALL)
-        .insert_resource(PlaybackStrategy::Paused)
-        // Toggle between playback and capture using Space
-        .insert_resource(InputStrategy::Playback)
-        .add_systems(Update, toggle_capture_vs_playback)
-        .run();
-}
-
-#[derive(Resource, PartialEq)]
-enum InputStrategy {
-    Capture,
-    Playback,
-}
-
-fn toggle_capture_vs_playback(
-    mut input_modes: ResMut<InputModesCaptured>,
-    mut playback_strategy: ResMut<PlaybackStrategy>,
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut timestamped_input: ResMut<TimestampedInputs>,
-    mut input_strategy: ResMut<InputStrategy>,
-) {
-    if keyboard_input.just_pressed(KeyCode::Space) {
-        *input_strategy = match *input_strategy {
-            InputStrategy::Capture => {
-                // Disable input capture
-                *input_modes = InputModesCaptured::DISABLE_ALL;
-                // Enable input playback
-                *playback_strategy = if let Some((start, end)) =
-                    // Play back all recorded inputs at the same rate they were input
-                    timestamped_input.frame_range()
-                {
-                    PlaybackStrategy::FrameRangeOnce(start, end)
-                } else {
-                    // Do not play back events if none were recorded
-                    PlaybackStrategy::Paused
-                };
-
-                info!("Now playing back input.");
-                InputStrategy::Playback
-            }
-            InputStrategy::Playback => {
-                // Enable input capture
-                *input_modes = InputModesCaptured::ENABLE_ALL;
-                // Disable input playback
-                *playback_strategy = PlaybackStrategy::Paused;
-
-                // Reset all input data, starting a new recording
-                *timestamped_input = TimestampedInputs::default();
-
-                info!("Now capturing input.");
-                InputStrategy::Capture
-            }
-        };
-    }
-}
-
-mod gamepad_viewer_example {
-    /// This is the main function from the example adapted from
-    /// https://github.com/bevyengine/bevy/blob/main/examples/tools/gamepad_viewer.rs
-    pub struct GamepadViewerExample;
-
-    impl Plugin for GamepadViewerExample {
-        fn build(&self, app: &mut App) {
-            app.add_plugins(DefaultPlugins)
-                .init_resource::<ButtonMaterials>()
-                .init_resource::<ButtonMeshes>()
-                .init_resource::<FontHandle>()
-                .add_systems(
-                    Startup,
-                    (setup, setup_sticks, setup_triggers, setup_connected),
-                )
-                .add_systems(
-                    Update,
-                    (
-                        update_buttons,
-                        update_button_values,
-                        update_axes,
-                        update_connected,
-                    ),
-                );
-        }
-    }
-
-    use std::f32::consts::PI;
-
-    use bevy::{
-        color::palettes,
-        input::gamepad::{GamepadButton, GamepadButtonChangedEvent, GamepadEvent, GamepadSettings},
-        prelude::*,
-        sprite::{MaterialMesh2dBundle, Mesh2dHandle},
-    };
-
-    const BUTTON_RADIUS: f32 = 25.;
-    const BUTTON_CLUSTER_RADIUS: f32 = 50.;
-    const START_SIZE: Vec2 = Vec2::new(30., 15.);
-    const TRIGGER_SIZE: Vec2 = Vec2::new(70., 20.);
-    const STICK_BOUNDS_SIZE: f32 = 100.;
-
-    const BUTTONS_X: f32 = 150.;
-    const BUTTONS_Y: f32 = 80.;
-    const STICKS_X: f32 = 150.;
-    const STICKS_Y: f32 = -135.;
-
-    const NORMAL_BUTTON_COLOR: Color = Color::srgb(0.2, 0.2, 0.2);
-    const ACTIVE_BUTTON_COLOR: Color = Color::Srgba(palettes::css::PURPLE);
-    const LIVE_COLOR: Color = Color::srgb(0.4, 0.4, 0.4);
-    const DEAD_COLOR: Color = Color::srgb(0.3, 0.3, 0.3);
-    const EXTENT_COLOR: Color = Color::srgb(0.3, 0.3, 0.3);
-    const TEXT_COLOR: Color = Color::WHITE;
-
-    #[derive(Component, Deref)]
-    struct ReactTo(GamepadButtonType);
-    #[derive(Component)]
-    struct MoveWithAxes {
-        x_axis: GamepadAxisType,
-        y_axis: GamepadAxisType,
-        scale: f32,
-    }
-    #[derive(Component)]
-    struct TextWithAxes {
-        x_axis: GamepadAxisType,
-        y_axis: GamepadAxisType,
-    }
-    #[derive(Component, Deref)]
-    struct TextWithButtonValue(GamepadButtonType);
-
-    #[derive(Component)]
-    struct ConnectedGamepadsText;
-
-    #[derive(Resource)]
-    struct ButtonMaterials {
-        normal: Handle<ColorMaterial>,
-        active: Handle<ColorMaterial>,
-    }
-
-    impl FromWorld for ButtonMaterials {
-        fn from_world(world: &mut World) -> Self {
-            let mut materials = world.resource_mut::<Assets<ColorMaterial>>();
-            Self {
-                normal: materials.add(ColorMaterial::from(NORMAL_BUTTON_COLOR)),
-                active: materials.add(ColorMaterial::from(ACTIVE_BUTTON_COLOR)),
-            }
-        }
-    }
-    #[derive(Resource)]
-    struct ButtonMeshes {
-        circle: Mesh2dHandle,
-        triangle: Mesh2dHandle,
-        start_pause: Mesh2dHandle,
-        trigger: Mesh2dHandle,
-    }
-
-    impl FromWorld for ButtonMeshes {
-        fn from_world(world: &mut World) -> Self {
-            let mut meshes = world.resource_mut::<Assets<Mesh>>();
-            Self {
-                circle: meshes.add(Circle::new(BUTTON_RADIUS).mesh()).into(),
-                triangle: meshes
-                    .add(RegularPolygon::new(BUTTON_RADIUS, 3).mesh())
-                    .into(),
-                start_pause: meshes
-                    .add(Rectangle::new(START_SIZE.x, START_SIZE.y).mesh())
-                    .into(),
-                trigger: meshes
-                    .add(Rectangle::new(TRIGGER_SIZE.x, TRIGGER_SIZE.y).mesh())
-                    .into(),
-            }
-        }
-    }
-    #[derive(Resource, Deref)]
-    struct FontHandle(Handle<Font>);
-    impl FromWorld for FontHandle {
-        fn from_world(world: &mut World) -> Self {
-            let asset_server = world.resource::<AssetServer>();
-            Self(asset_server.load("fonts/FiraSans-Bold.ttf"))
-        }
-    }
-
-    fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<ButtonMaterials>) {
-        commands.spawn(Camera2dBundle::default());
-
-        // Buttons
-
-        commands
-            .spawn(SpatialBundle {
-                transform: Transform::from_xyz(BUTTONS_X, BUTTONS_Y, 0.),
-                ..default()
-            })
-            .with_children(|parent| {
-                parent
-                    .spawn(MaterialMesh2dBundle {
-                        mesh: meshes.circle.clone(),
-                        material: materials.normal.clone(),
-                        transform: Transform::from_xyz(0., BUTTON_CLUSTER_RADIUS, 0.),
-                        ..default()
-                    })
-                    .insert(ReactTo(GamepadButtonType::North));
-                parent
-                    .spawn(MaterialMesh2dBundle {
-                        mesh: meshes.circle.clone(),
-                        material: materials.normal.clone(),
-                        transform: Transform::from_xyz(0., -BUTTON_CLUSTER_RADIUS, 0.),
-                        ..default()
-                    })
-                    .insert(ReactTo(GamepadButtonType::South));
-                parent
-                    .spawn(MaterialMesh2dBundle {
-                        mesh: meshes.circle.clone(),
-                        material: materials.normal.clone(),
-                        transform: Transform::from_xyz(-BUTTON_CLUSTER_RADIUS, 0., 0.),
-                        ..default()
-                    })
-                    .insert(ReactTo(GamepadButtonType::West));
-                parent
-                    .spawn(MaterialMesh2dBundle {
-                        mesh: meshes.circle.clone(),
-                        material: materials.normal.clone(),
-                        transform: Transform::from_xyz(BUTTON_CLUSTER_RADIUS, 0., 0.),
-
-                        ..default()
-                    })
-                    .insert(ReactTo(GamepadButtonType::East));
-            });
-
-        // Start and Pause
-
-        commands
-            .spawn(MaterialMesh2dBundle {
-                mesh: meshes.start_pause.clone(),
-                material: materials.normal.clone(),
-                transform: Transform::from_xyz(-30., BUTTONS_Y, 0.),
-                ..default()
-            })
-            .insert(ReactTo(GamepadButtonType::Select));
-
-        commands
-            .spawn(MaterialMesh2dBundle {
-                mesh: meshes.start_pause.clone(),
-                material: materials.normal.clone(),
-                transform: Transform::from_xyz(30., BUTTONS_Y, 0.),
-                ..default()
-            })
-            .insert(ReactTo(GamepadButtonType::Start));
-
-        // D-Pad
-
-        commands
-            .spawn(SpatialBundle {
-                transform: Transform::from_xyz(-BUTTONS_X, BUTTONS_Y, 0.),
-                ..default()
-            })
-            .with_children(|parent| {
-                parent
-                    .spawn(MaterialMesh2dBundle {
-                        mesh: meshes.triangle.clone(),
-                        material: materials.normal.clone(),
-                        transform: Transform::from_xyz(0., BUTTON_CLUSTER_RADIUS, 0.),
-                        ..default()
-                    })
-                    .insert(ReactTo(GamepadButtonType::DPadUp));
-                parent
-                    .spawn(MaterialMesh2dBundle {
-                        mesh: meshes.triangle.clone(),
-                        material: materials.normal.clone(),
-                        transform: Transform::from_xyz(0., -BUTTON_CLUSTER_RADIUS, 0.)
-                            .with_rotation(Quat::from_rotation_z(PI)),
-                        ..default()
-                    })
-                    .insert(ReactTo(GamepadButtonType::DPadDown));
-                parent
-                    .spawn(MaterialMesh2dBundle {
-                        mesh: meshes.triangle.clone(),
-                        material: materials.normal.clone(),
-                        transform: Transform::from_xyz(-BUTTON_CLUSTER_RADIUS, 0., 0.)
-                            .with_rotation(Quat::from_rotation_z(PI / 2.)),
-                        ..default()
-                    })
-                    .insert(ReactTo(GamepadButtonType::DPadLeft));
-                parent
-                    .spawn(MaterialMesh2dBundle {
-                        mesh: meshes.triangle.clone(),
-                        material: materials.normal.clone(),
-                        transform: Transform::from_xyz(BUTTON_CLUSTER_RADIUS, 0., 0.)
-                            .with_rotation(Quat::from_rotation_z(-PI / 2.)),
-                        ..default()
-                    })
-                    .insert(ReactTo(GamepadButtonType::DPadRight));
-            });
-
-        // Triggers
-
-        commands
-            .spawn(MaterialMesh2dBundle {
-                mesh: meshes.trigger.clone(),
-                material: materials.normal.clone(),
-                transform: Transform::from_xyz(-BUTTONS_X, BUTTONS_Y + 115., 0.),
-                ..default()
-            })
-            .insert(ReactTo(GamepadButtonType::LeftTrigger));
-
-        commands
-            .spawn(MaterialMesh2dBundle {
-                mesh: meshes.trigger.clone(),
-                material: materials.normal.clone(),
-                transform: Transform::from_xyz(BUTTONS_X, BUTTONS_Y + 115., 0.),
-                ..default()
-            })
-            .insert(ReactTo(GamepadButtonType::RightTrigger));
-    }
-
-    fn setup_sticks(
-        mut commands: Commands,
-        meshes: Res<ButtonMeshes>,
-        materials: Res<ButtonMaterials>,
-        gamepad_settings: Res<GamepadSettings>,
-        font: Res<FontHandle>,
-    ) {
-        let dead_upper =
-            STICK_BOUNDS_SIZE * gamepad_settings.default_axis_settings.deadzone_upperbound();
-        let dead_lower =
-            STICK_BOUNDS_SIZE * gamepad_settings.default_axis_settings.deadzone_lowerbound();
-        let dead_size = dead_lower.abs() + dead_upper.abs();
-        let dead_mid = (dead_lower + dead_upper) / 2.0;
-
-        let live_upper =
-            STICK_BOUNDS_SIZE * gamepad_settings.default_axis_settings.livezone_upperbound();
-        let live_lower =
-            STICK_BOUNDS_SIZE * gamepad_settings.default_axis_settings.livezone_lowerbound();
-        let live_size = live_lower.abs() + live_upper.abs();
-        let live_mid = (live_lower + live_upper) / 2.0;
-
-        let mut spawn_stick = |x_pos, y_pos, x_axis, y_axis, button| {
-            commands
-                .spawn(SpatialBundle {
-                    transform: Transform::from_xyz(x_pos, y_pos, 0.),
-                    ..default()
-                })
-                .with_children(|parent| {
-                    // full extent
-                    parent.spawn(SpriteBundle {
-                        sprite: Sprite {
-                            custom_size: Some(Vec2::splat(STICK_BOUNDS_SIZE * 2.)),
-                            color: EXTENT_COLOR,
-                            ..default()
-                        },
-                        ..default()
-                    });
-                    // live zone
-                    parent.spawn(SpriteBundle {
-                        transform: Transform::from_xyz(live_mid, live_mid, 2.),
-                        sprite: Sprite {
-                            custom_size: Some(Vec2::new(live_size, live_size)),
-                            color: LIVE_COLOR,
-                            ..default()
-                        },
-                        ..default()
-                    });
-                    // dead zone
-                    parent.spawn(SpriteBundle {
-                        transform: Transform::from_xyz(dead_mid, dead_mid, 3.),
-                        sprite: Sprite {
-                            custom_size: Some(Vec2::new(dead_size, dead_size)),
-                            color: DEAD_COLOR,
-                            ..default()
-                        },
-                        ..default()
-                    });
-                    // text
-                    let style = TextStyle {
-                        font_size: 16.,
-                        color: TEXT_COLOR,
-                        font: font.clone(),
-                    };
-                    parent
-                        .spawn(Text2dBundle {
-                            transform: Transform::from_xyz(0., STICK_BOUNDS_SIZE + 2., 4.),
-                            text: Text::from_sections([
-                                TextSection {
-                                    value: format!("{:.3}", 0.),
-                                    style: style.clone(),
-                                },
-                                TextSection {
-                                    value: ", ".to_string(),
-                                    style: style.clone(),
-                                },
-                                TextSection {
-                                    value: format!("{:.3}", 0.),
-                                    style,
-                                },
-                            ])
-                            .with_justify(JustifyText::Center),
-                            ..default()
-                        })
-                        .insert(TextWithAxes { x_axis, y_axis });
-                    // cursor
-                    parent
-                        .spawn(MaterialMesh2dBundle {
-                            mesh: meshes.circle.clone(),
-                            material: materials.normal.clone(),
-                            transform: Transform::from_xyz(0., 0., 5.)
-                                .with_scale(Vec2::splat(0.2).extend(1.)),
-                            ..default()
-                        })
-                        .insert(MoveWithAxes {
-                            x_axis,
-                            y_axis,
-                            scale: STICK_BOUNDS_SIZE,
-                        })
-                        .insert(ReactTo(button));
-                });
-        };
-
-        spawn_stick(
-            -STICKS_X,
-            STICKS_Y,
-            GamepadAxisType::LeftStickX,
-            GamepadAxisType::LeftStickY,
-            GamepadButtonType::LeftThumb,
-        );
-        spawn_stick(
-            STICKS_X,
-            STICKS_Y,
-            GamepadAxisType::RightStickX,
-            GamepadAxisType::RightStickY,
-            GamepadButtonType::RightThumb,
-        );
-    }
-
-    fn setup_triggers(
-        mut commands: Commands,
-        meshes: Res<ButtonMeshes>,
-        materials: Res<ButtonMaterials>,
-        font: Res<FontHandle>,
-    ) {
-        let mut spawn_trigger = |x, y, button_type| {
-            commands
-                .spawn(MaterialMesh2dBundle {
-                    mesh: meshes.trigger.clone(),
-                    material: materials.normal.clone(),
-                    transform: Transform::from_xyz(x, y, 0.),
-                    ..default()
-                })
-                .insert(ReactTo(button_type))
-                .with_children(|parent| {
-                    parent
-                        .spawn(Text2dBundle {
-                            transform: Transform::from_xyz(0., 0., 1.),
-                            text: Text::from_section(
-                                format!("{:.3}", 0.),
-                                TextStyle {
-                                    font: font.clone(),
-                                    font_size: 16.,
-                                    color: TEXT_COLOR,
-                                },
-                            )
-                            .with_justify(JustifyText::Center),
-                            ..default()
-                        })
-                        .insert(TextWithButtonValue(button_type));
-                });
-        };
-
-        spawn_trigger(
-            -BUTTONS_X,
-            BUTTONS_Y + 145.,
-            GamepadButtonType::LeftTrigger2,
-        );
-        spawn_trigger(
-            BUTTONS_X,
-            BUTTONS_Y + 145.,
-            GamepadButtonType::RightTrigger2,
-        );
-    }
-
-    fn setup_connected(mut commands: Commands, font: Res<FontHandle>) {
-        let style = TextStyle {
-            color: TEXT_COLOR,
-            font_size: 30.,
-            font: font.clone(),
-        };
-        commands
-            .spawn(TextBundle::from_sections([
-                TextSection {
-                    value: "Connected Gamepads\n".to_string(),
-                    style: style.clone(),
-                },
-                TextSection {
-                    value: "None".to_string(),
-                    style,
-                },
-            ]))
-            .insert(ConnectedGamepadsText);
-    }
-
-    fn update_buttons(
-        gamepads: Res<Gamepads>,
-        button_inputs: Res<ButtonInput<GamepadButton>>,
-        materials: Res<ButtonMaterials>,
-        mut query: Query<(&mut Handle<ColorMaterial>, &ReactTo)>,
-    ) {
-        for gamepad in gamepads.iter() {
-            for (mut handle, react_to) in query.iter_mut() {
-                if button_inputs.just_pressed(GamepadButton::new(gamepad, **react_to)) {
-                    *handle = materials.active.clone();
-                }
-                if button_inputs.just_released(GamepadButton::new(gamepad, **react_to)) {
-                    *handle = materials.normal.clone();
-                }
-            }
-        }
-    }
-
-    fn update_button_values(
-        mut events: EventReader<GamepadEvent>,
-        mut query: Query<(&mut Text, &TextWithButtonValue)>,
-    ) {
-        for event in events.read() {
-            if let GamepadEvent::Button(GamepadButtonChangedEvent {
-                gamepad: _,
-                button_type,
-                value,
-            }) = event
-            {
-                for (mut text, text_with_button_value) in query.iter_mut() {
-                    if *button_type == **text_with_button_value {
-                        text.sections[0].value = format!("{:.3}", value);
-                    }
-                }
-            }
-        }
-    }
-
-    fn update_axes(
-        mut events: EventReader<GamepadEvent>,
-        mut query: Query<(&mut Transform, &MoveWithAxes)>,
-        mut text_query: Query<(&mut Text, &TextWithAxes)>,
-    ) {
-        for event in events.read() {
-            if let GamepadEvent::Axis(axis_changed_event) = event {
-                let axis_type = axis_changed_event.axis_type;
-                let value = axis_changed_event.value;
-
-                for (mut transform, move_with) in query.iter_mut() {
-                    if axis_type == move_with.x_axis {
-                        transform.translation.x = value * move_with.scale;
-                    }
-                    if axis_type == move_with.y_axis {
-                        transform.translation.y = value * move_with.scale;
-                    }
-                }
-                for (mut text, text_with_axes) in text_query.iter_mut() {
-                    if axis_type == text_with_axes.x_axis {
-                        text.sections[0].value = format!("{:.3}", value);
-                    }
-                    if axis_type == text_with_axes.y_axis {
-                        text.sections[2].value = format!("{:.3}", value);
-                    }
-                }
-            }
-        }
-    }
-
-    fn update_connected(
-        gamepads: Res<Gamepads>,
-        mut query: Query<&mut Text, With<ConnectedGamepadsText>>,
-    ) {
-        if !gamepads.is_changed() {
-            return;
-        }
-
-        let mut text = query.single_mut();
-
-        let formatted = gamepads
-            .iter()
-            .map(|g| format!("{:?}", g))
-            .collect::<Vec<_>>()
-            .join("\n");
-
-        text.sections[1].value = if !formatted.is_empty() {
-            formatted
-        } else {
-            "None".to_string()
-        }
-    }
-}
+//! Demonstrates input capture and playback of gamepad inputs
+//!
+//! This example is modified from https://github.com/bevyengine/bevy/blob/main/examples/tools/gamepad_viewer.rs,
+//! which is used here under the MIT License <3
+
+//! Shows a visualization of gamepad buttons, sticks, and triggers
+
+use bevy::prelude::*;
+use leafwing_input_playback::{
+    input_capture::{BeginInputCapture, EndInputCapture, InputCapturePlugin},
+    input_playback::{BeginInputPlayback, EndInputPlayback, InputPlaybackPlugin, PlaybackStrategy},
+    timestamped_input::TimestampedInputs,
+};
+
+fn main() {
+    use gamepad_viewer_example::*;
+
+    let mut app = App::new();
+    app.add_plugins((
+        // This plugin contains all the code from the original example
+        GamepadViewerExample,
+        InputCapturePlugin,
+        InputPlaybackPlugin,
+    ))
+    // Toggle between playback and capture using Space
+    .insert_resource(InputStrategy::Playback)
+    .add_systems(Update, toggle_capture_vs_playback);
+
+    app.run();
+}
+
+#[derive(Resource, PartialEq)]
+enum InputStrategy {
+    Capture,
+    Playback,
+}
+
+fn toggle_capture_vs_playback(
+    mut commands: Commands,
+    mut input_strategy: ResMut<InputStrategy>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    timestamped_input: Option<ResMut<TimestampedInputs>>,
+) {
+    if keyboard_input.just_pressed(KeyCode::Space) {
+        *input_strategy = match *input_strategy {
+            InputStrategy::Capture => {
+                // Disable input capture
+                commands.trigger(EndInputCapture);
+                // Enable input playback
+                if let Some((start, end)) =
+                    // Play back all recorded inputs at the same rate they were input
+                    timestamped_input
+                        .and_then(|timestamped_input| timestamped_input.frame_range())
+                {
+                    commands.trigger(BeginInputPlayback {
+                        playback_strategy: PlaybackStrategy::FrameRangeOnce(start, end),
+                        ..default()
+                    });
+                    info!("Now playing back input.");
+                } else {
+                    info!("No input to replay.");
+                }
+
+                InputStrategy::Playback
+            }
+            InputStrategy::Playback => {
+                // Disable input playback, resetting all input data.
+                commands.trigger(EndInputPlayback);
+                // Enable input capture
+                commands.trigger(BeginInputCapture {
+                    filepath: Some("./data/hello_world.ron".to_string()),
+                    ..default()
+                });
+
+                info!("Now capturing input.");
+                InputStrategy::Capture
+            }
+        };
+    }
+}
+
+mod gamepad_viewer_example {
+    /// This is the main function from the example adapted from
+    /// https://github.com/bevyengine/bevy/blob/main/examples/tools/gamepad_viewer.rs
+    pub struct GamepadViewerExample;
+
+    impl Plugin for GamepadViewerExample {
+        fn build(&self, app: &mut App) {
+            app.add_plugins(DefaultPlugins)
+                .init_resource::<ButtonMaterials>()
+                .init_resource::<ButtonMeshes>()
+                .init_resource::<FontHandle>()
+                .add_systems(
+                    Startup,
+                    (setup, setup_sticks, setup_triggers, setup_connected),
+                )
+                .add_systems(
+                    Update,
+                    (
+                        update_buttons,
+                        update_button_values,
+                        update_axes,
+                        update_connected,
+                    ),
+                );
+        }
+    }
+
+    use std::f32::consts::PI;
+
+    use bevy::{
+        color::palettes,
+        input::gamepad::{GamepadButton, GamepadButtonChangedEvent, GamepadEvent, GamepadSettings},
+        prelude::*,
+        sprite::{MaterialMesh2dBundle, Mesh2dHandle},
+    };
+
+    const BUTTON_RADIUS: f32 = 25.;
+    const BUTTON_CLUSTER_RADIUS: f32 = 50.;
+    const START_SIZE: Vec2 = Vec2::new(30., 15.);
+    const TRIGGER_SIZE: Vec2 = Vec2::new(70., 20.);
+    const STICK_BOUNDS_SIZE: f32 = 100.;
+
+    const BUTTONS_X: f32 = 150.;
+    const BUTTONS_Y: f32 = 80.;
+    const STICKS_X: f32 = 150.;
+    const STICKS_Y: f32 = -135.;
+
+    const NORMAL_BUTTON_COLOR: Color = Color::srgb(0.2, 0.2, 0.2);
+    const ACTIVE_BUTTON_COLOR: Color = Color::Srgba(palettes::css::PURPLE);
+    const LIVE_COLOR: Color = Color::srgb(0.4, 0.4, 0.4);
+    const DEAD_COLOR: Color = Color::srgb(0.3, 0.3, 0.3);
+    const EXTENT_COLOR: Color = Color::srgb(0.3, 0.3, 0.3);
+    const TEXT_COLOR: Color = Color::WHITE;
+
+    #[derive(Component, Deref)]
+    struct ReactTo(GamepadButtonType);
+    #[derive(Component)]
+    struct MoveWithAxes {
+        x_axis: GamepadAxisType,
+        y_axis: GamepadAxisType,
+        scale: f32,
+    }
+    #[derive(Component)]
+    struct TextWithAxes {
+        x_axis: GamepadAxisType,
+        y_axis: GamepadAxisType,
+    }
+    #[derive(Component, Deref)]
+    struct TextWithButtonValue(GamepadButtonType);
+
+    #[derive(Component)]
+    struct ConnectedGamepadsText;
+
+    #[derive(Resource)]
+    struct ButtonMaterials {
+        normal: Handle<ColorMaterial>,
+        active: Handle<ColorMaterial>,
+    }
+
+    impl FromWorld for ButtonMaterials {
+        fn from_world(world: &mut World) -> Self {
+            let mut materials = world.resource_mut::<Assets<ColorMaterial>>();
+            Self {
+                normal: materials.add(ColorMaterial::from(NORMAL_BUTTON_COLOR)),
+                active: materials.add(ColorMaterial::from(ACTIVE_BUTTON_COLOR)),
+            }
+        }
+    }
+    #[derive(Resource)]
+    struct ButtonMeshes {
+        circle: Mesh2dHandle,
+        triangle: Mesh2dHandle,
+        start_pause: Mesh2dHandle,
+        trigger: Mesh2dHandle,
+    }
+
+    impl FromWorld for ButtonMeshes {
+        fn from_world(world: &mut World) -> Self {
+            let mut meshes = world.resource_mut::<Assets<Mesh>>();
+            Self {
+                circle: meshes.add(Circle::new(BUTTON_RADIUS).mesh()).into(),
+                triangle: meshes
+                    .add(RegularPolygon::new(BUTTON_RADIUS, 3).mesh())
+                    .into(),
+                start_pause: meshes
+                    .add(Rectangle::new(START_SIZE.x, START_SIZE.y).mesh())
+                    .into(),
+                trigger: meshes
+                    .add(Rectangle::new(TRIGGER_SIZE.x, TRIGGER_SIZE.y).mesh())
+                    .into(),
+            }
+        }
+    }
+    #[derive(Resource, Deref)]
+    struct FontHandle(Handle<Font>);
+    impl FromWorld for FontHandle {
+        fn from_world(world: &mut World) -> Self {
+            let asset_server = world.resource::<AssetServer>();
+            Self(asset_server.load("fonts/FiraSans-Bold.ttf"))
+        }
+    }
+
+    fn setup(mut commands: Commands, meshes: Res<ButtonMeshes>, materials: Res<ButtonMaterials>) {
+        commands.spawn(Camera2dBundle::default());
+
+        // Buttons
+
+        commands
+            .spawn(SpatialBundle {
+                transform: Transform::from_xyz(BUTTONS_X, BUTTONS_Y, 0.),
+                ..default()
+            })
+            .with_children(|parent| {
+                parent
+                    .spawn(MaterialMesh2dBundle {
+                        mesh: meshes.circle.clone(),
+                        material: materials.normal.clone(),
+                        transform: Transform::from_xyz(0., BUTTON_CLUSTER_RADIUS, 0.),
+                        ..default()
+                    })
+                    .insert(ReactTo(GamepadButtonType::North));
+                parent
+                    .spawn(MaterialMesh2dBundle {
+                        mesh: meshes.circle.clone(),
+                        material: materials.normal.clone(),
+                        transform: Transform::from_xyz(0., -BUTTON_CLUSTER_RADIUS, 0.),
+                        ..default()
+                    })
+                    .insert(ReactTo(GamepadButtonType::South));
+                parent
+                    .spawn(MaterialMesh2dBundle {
+                        mesh: meshes.circle.clone(),
+                        material: materials.normal.clone(),
+                        transform: Transform::from_xyz(-BUTTON_CLUSTER_RADIUS, 0., 0.),
+                        ..default()
+                    })
+                    .insert(ReactTo(GamepadButtonType::West));
+                parent
+                    .spawn(MaterialMesh2dBundle {
+                        mesh: meshes.circle.clone(),
+                        material: materials.normal.clone(),
+                        transform: Transform::from_xyz(BUTTON_CLUSTER_RADIUS, 0., 0.),
+
+                        ..default()
+                    })
+                    .insert(ReactTo(GamepadButtonType::East));
+            });
+
+        // Start and Pause
+
+        commands
+            .spawn(MaterialMesh2dBundle {
+                mesh: meshes.start_pause.clone(),
+                material: materials.normal.clone(),
+                transform: Transform::from_xyz(-30., BUTTONS_Y, 0.),
+                ..default()
+            })
+            .insert(ReactTo(GamepadButtonType::Select));
+
+        commands
+            .spawn(MaterialMesh2dBundle {
+                mesh: meshes.start_pause.clone(),
+                material: materials.normal.clone(),
+                transform: Transform::from_xyz(30., BUTTONS_Y, 0.),
+                ..default()
+            })
+            .insert(ReactTo(GamepadButtonType::Start));
+
+        // D-Pad
+
+        commands
+            .spawn(SpatialBundle {
+                transform: Transform::from_xyz(-BUTTONS_X, BUTTONS_Y, 0.),
+                ..default()
+            })
+            .with_children(|parent| {
+                parent
+                    .spawn(MaterialMesh2dBundle {
+                        mesh: meshes.triangle.clone(),
+                        material: materials.normal.clone(),
+                        transform: Transform::from_xyz(0., BUTTON_CLUSTER_RADIUS, 0.),
+                        ..default()
+                    })
+                    .insert(ReactTo(GamepadButtonType::DPadUp));
+                parent
+                    .spawn(MaterialMesh2dBundle {
+                        mesh: meshes.triangle.clone(),
+                        material: materials.normal.clone(),
+                        transform: Transform::from_xyz(0., -BUTTON_CLUSTER_RADIUS, 0.)
+                            .with_rotation(Quat::from_rotation_z(PI)),
+                        ..default()
+                    })
+                    .insert(ReactTo(GamepadButtonType::DPadDown));
+                parent
+                    .spawn(MaterialMesh2dBundle {
+                        mesh: meshes.triangle.clone(),
+                        material: materials.normal.clone(),
+                        transform: Transform::from_xyz(-BUTTON_CLUSTER_RADIUS, 0., 0.)
+                            .with_rotation(Quat::from_rotation_z(PI / 2.)),
+                        ..default()
+                    })
+                    .insert(ReactTo(GamepadButtonType::DPadLeft));
+                parent
+                    .spawn(MaterialMesh2dBundle {
+                        mesh: meshes.triangle.clone(),
+                        material: materials.normal.clone(),
+                        transform: Transform::from_xyz(BUTTON_CLUSTER_RADIUS, 0., 0.)
+                            .with_rotation(Quat::from_rotation_z(-PI / 2.)),
+                        ..default()
+                    })
+                    .insert(ReactTo(GamepadButtonType::DPadRight));
+            });
+
+        // Triggers
+
+        commands
+            .spawn(MaterialMesh2dBundle {
+                mesh: meshes.trigger.clone(),
+                material: materials.normal.clone(),
+                transform: Transform::from_xyz(-BUTTONS_X, BUTTONS_Y + 115., 0.),
+                ..default()
+            })
+            .insert(ReactTo(GamepadButtonType::LeftTrigger));
+
+        commands
+            .spawn(MaterialMesh2dBundle {
+                mesh: meshes.trigger.clone(),
+                material: materials.normal.clone(),
+                transform: Transform::from_xyz(BUTTONS_X, BUTTONS_Y + 115., 0.),
+                ..default()
+            })
+            .insert(ReactTo(GamepadButtonType::RightTrigger));
+    }
+
+    fn setup_sticks(
+        mut commands: Commands,
+        meshes: Res<ButtonMeshes>,
+        materials: Res<ButtonMaterials>,
+        gamepad_settings: Res<GamepadSettings>,
+        font: Res<FontHandle>,
+    ) {
+        let dead_upper =
+            STICK_BOUNDS_SIZE * gamepad_settings.default_axis_settings.deadzone_upperbound();
+        let dead_lower =
+            STICK_BOUNDS_SIZE * gamepad_settings.default_axis_settings.deadzone_lowerbound();
+        let dead_size = dead_lower.abs() + dead_upper.abs();
+        let dead_mid = (dead_lower + dead_upper) / 2.0;
+
+        let live_upper =
+            STICK_BOUNDS_SIZE * gamepad_settings.default_axis_settings.livezone_upperbound();
+        let live_lower =
+            STICK_BOUNDS_SIZE * gamepad_settings.default_axis_settings.livezone_lowerbound();
+        let live_size = live_lower.abs() + live_upper.abs();
+        let live_mid = (live_lower + live_upper) / 2.0;
+
+        let mut spawn_stick = |x_pos, y_pos, x_axis, y_axis, button| {
+            commands
+                .spawn(SpatialBundle {
+                    transform: Transform::from_xyz(x_pos, y_pos, 0.),
+                    ..default()
+                })
+                .with_children(|parent| {
+                    // full extent
+                    parent.spawn(SpriteBundle {
+                        sprite: Sprite {
+                            custom_size: Some(Vec2::splat(STICK_BOUNDS_SIZE * 2.)),
+                            color: EXTENT_COLOR,
+                            ..default()
+                        },
+                        ..default()
+                    });
+                    // live zone
+                    parent.spawn(SpriteBundle {
+                        transform: Transform::from_xyz(live_mid, live_mid, 2.),
+                        sprite: Sprite {
+                            custom_size: Some(Vec2::new(live_size, live_size)),
+                            color: LIVE_COLOR,
+                            ..default()
+                        },
+                        ..default()
+                    });
+                    // dead zone
+                    parent.spawn(SpriteBundle {
+                        transform: Transform::from_xyz(dead_mid, dead_mid, 3.),
+                        sprite: Sprite {
+                            custom_size: Some(Vec2::new(dead_size, dead_size)),
+                            color: DEAD_COLOR,
+                            ..default()
+                        },
+                        ..default()
+                    });
+                    // text
+                    let style = TextStyle {
+                        font_size: 16.,
+                        color: TEXT_COLOR,
+                        font: font.clone(),
+                    };
+                    parent
+                        .spawn(Text2dBundle {
+                            transform: Transform::from_xyz(0., STICK_BOUNDS_SIZE + 2., 4.),
+                            text: Text::from_sections([
+                                TextSection {
+                                    value: format!("{:.3}", 0.),
+                                    style: style.clone(),
+                                },
+                                TextSection {
+                                    value: ", ".to_string(),
+                                    style: style.clone(),
+                                },
+                                TextSection {
+                                    value: format!("{:.3}", 0.),
+                                    style,
+                                },
+                            ])
+                            .with_justify(JustifyText::Center),
+                            ..default()
+                        })
+                        .insert(TextWithAxes { x_axis, y_axis });
+                    // cursor
+                    parent
+                        .spawn(MaterialMesh2dBundle {
+                            mesh: meshes.circle.clone(),
+                            material: materials.normal.clone(),
+                            transform: Transform::from_xyz(0., 0., 5.)
+                                .with_scale(Vec2::splat(0.2).extend(1.)),
+                            ..default()
+                        })
+                        .insert(MoveWithAxes {
+                            x_axis,
+                            y_axis,
+                            scale: STICK_BOUNDS_SIZE,
+                        })
+                        .insert(ReactTo(button));
+                });
+        };
+
+        spawn_stick(
+            -STICKS_X,
+            STICKS_Y,
+            GamepadAxisType::LeftStickX,
+            GamepadAxisType::LeftStickY,
+            GamepadButtonType::LeftThumb,
+        );
+        spawn_stick(
+            STICKS_X,
+            STICKS_Y,
+            GamepadAxisType::RightStickX,
+            GamepadAxisType::RightStickY,
+            GamepadButtonType::RightThumb,
+        );
+    }
+
+    fn setup_triggers(
+        mut commands: Commands,
+        meshes: Res<ButtonMeshes>,
+        materials: Res<ButtonMaterials>,
+        font: Res<FontHandle>,
+    ) {
+        let mut spawn_trigger = |x, y, button_type| {
+            commands
+                .spawn(MaterialMesh2dBundle {
+                    mesh: meshes.trigger.clone(),
+                    material: materials.normal.clone(),
+                    transform: Transform::from_xyz(x, y, 0.),
+                    ..default()
+                })
+                .insert(ReactTo(button_type))
+                .with_children(|parent| {
+                    parent
+                        .spawn(Text2dBundle {
+                            transform: Transform::from_xyz(0., 0., 1.),
+                            text: Text::from_section(
+                                format!("{:.3}", 0.),
+                                TextStyle {
+                                    font: font.clone(),
+                                    font_size: 16.,
+                                    color: TEXT_COLOR,
+                                },
+                            )
+                            .with_justify(JustifyText::Center),
+                            ..default()
+                        })
+                        .insert(TextWithButtonValue(button_type));
+                });
+        };
+
+        spawn_trigger(
+            -BUTTONS_X,
+            BUTTONS_Y + 145.,
+            GamepadButtonType::LeftTrigger2,
+        );
+        spawn_trigger(
+            BUTTONS_X,
+            BUTTONS_Y + 145.,
+            GamepadButtonType::RightTrigger2,
+        );
+    }
+
+    fn setup_connected(mut commands: Commands, font: Res<FontHandle>) {
+        let style = TextStyle {
+            color: TEXT_COLOR,
+            font_size: 30.,
+            font: font.clone(),
+        };
+        commands
+            .spawn(TextBundle::from_sections([
+                TextSection {
+                    value: "Connected Gamepads\n".to_string(),
+                    style: style.clone(),
+                },
+                TextSection {
+                    value: "None".to_string(),
+                    style,
+                },
+            ]))
+            .insert(ConnectedGamepadsText);
+    }
+
+    fn update_buttons(
+        gamepads: Res<Gamepads>,
+        button_inputs: Res<ButtonInput<GamepadButton>>,
+        materials: Res<ButtonMaterials>,
+        mut query: Query<(&mut Handle<ColorMaterial>, &ReactTo)>,
+    ) {
+        for gamepad in gamepads.iter() {
+            for (mut handle, react_to) in query.iter_mut() {
+                if button_inputs.just_pressed(GamepadButton::new(gamepad, **react_to)) {
+                    *handle = materials.active.clone();
+                }
+                if button_inputs.just_released(GamepadButton::new(gamepad, **react_to)) {
+                    *handle = materials.normal.clone();
+                }
+            }
+        }
+    }
+
+    fn update_button_values(
+        mut events: EventReader<GamepadEvent>,
+        mut query: Query<(&mut Text, &TextWithButtonValue)>,
+    ) {
+        for event in events.read() {
+            if let GamepadEvent::Button(GamepadButtonChangedEvent {
+                gamepad: _,
+                button_type,
+                value,
+            }) = event
+            {
+                for (mut text, text_with_button_value) in query.iter_mut() {
+                    if *button_type == **text_with_button_value {
+                        text.sections[0].value = format!("{:.3}", value);
+                    }
+                }
+            }
+        }
+    }
+
+    fn update_axes(
+        mut events: EventReader<GamepadEvent>,
+        mut query: Query<(&mut Transform, &MoveWithAxes)>,
+        mut text_query: Query<(&mut Text, &TextWithAxes)>,
+    ) {
+        for event in events.read() {
+            if let GamepadEvent::Axis(axis_changed_event) = event {
+                let axis_type = axis_changed_event.axis_type;
+                let value = axis_changed_event.value;
+
+                for (mut transform, move_with) in query.iter_mut() {
+                    if axis_type == move_with.x_axis {
+                        transform.translation.x = value * move_with.scale;
+                    }
+                    if axis_type == move_with.y_axis {
+                        transform.translation.y = value * move_with.scale;
+                    }
+                }
+                for (mut text, text_with_axes) in text_query.iter_mut() {
+                    if axis_type == text_with_axes.x_axis {
+                        text.sections[0].value = format!("{:.3}", value);
+                    }
+                    if axis_type == text_with_axes.y_axis {
+                        text.sections[2].value = format!("{:.3}", value);
+                    }
+                }
+            }
+        }
+    }
+
+    fn update_connected(
+        gamepads: Res<Gamepads>,
+        mut query: Query<&mut Text, With<ConnectedGamepadsText>>,
+    ) {
+        if !gamepads.is_changed() {
+            return;
+        }
+
+        let mut text = query.single_mut();
+
+        let formatted = gamepads
+            .iter()
+            .map(|g| format!("{:?}", g))
+            .collect::<Vec<_>>()
+            .join("\n");
+
+        text.sections[1].value = if !formatted.is_empty() {
+            formatted
+        } else {
+            "None".to_string()
+        }
+    }
+}
diff --git a/examples/input_capture.rs b/examples/input_capture.rs
index 25161c5..4f8739a 100644
--- a/examples/input_capture.rs
+++ b/examples/input_capture.rs
@@ -1,13 +1,15 @@
 use bevy::prelude::*;
 use leafwing_input_playback::{
-    input_capture::InputCapturePlugin, timestamped_input::TimestampedInputs,
+    input_capture::{BeginInputCapture, InputCapturePlugin},
+    timestamped_input::TimestampedInputs,
 };
 
 fn main() -> AppExit {
-    App::new()
-        .add_plugins((DefaultPlugins, InputCapturePlugin))
-        .add_systems(Update, debug_input_capture)
-        .run()
+    let mut app = App::new();
+    app.add_plugins((DefaultPlugins, InputCapturePlugin));
+    app.add_systems(Update, debug_input_capture);
+    app.world_mut().trigger(BeginInputCapture::default());
+    app.run()
 }
 
 // TimestampedInput is an iterator, so we require mutable access to track which events we've seen
diff --git a/examples/input_playback.rs b/examples/input_playback.rs
index f75fac3..5bceb77 100644
--- a/examples/input_playback.rs
+++ b/examples/input_playback.rs
@@ -1,139 +1,130 @@
-use bevy::{color::palettes, prelude::*, window::PrimaryWindow};
-
-use leafwing_input_playback::{
-    input_capture::{InputCapturePlugin, InputModesCaptured},
-    input_playback::{InputPlaybackPlugin, PlaybackStrategy},
-    timestamped_input::TimestampedInputs,
-};
-
-fn main() -> AppExit {
-    App::new()
-        .add_plugins((DefaultPlugins, InputCapturePlugin, InputPlaybackPlugin))
-        // Disable all input capture and playback to start
-        .insert_resource(InputModesCaptured::DISABLE_ALL)
-        .insert_resource(PlaybackStrategy::Paused)
-        // Creates a little game that spawns decaying boxes where the player clicks
-        .insert_resource(ClearColor(Color::srgb(0.9, 0.9, 0.9)))
-        .add_systems(Startup, setup)
-        .add_systems(
-            Update,
-            (spawn_boxes, decay_boxes, toggle_capture_vs_playback),
-        )
-        // Toggle between playback and capture by pressing Space
-        .insert_resource(InputStrategy::Playback)
-        .run()
-}
-
-#[derive(Resource, PartialEq)]
-enum InputStrategy {
-    Capture,
-    Playback,
-}
-
-fn setup(mut commands: Commands) {
-    commands.spawn(Camera2dBundle::default());
-}
-
-pub fn cursor_pos_as_world_pos(
-    current_window: &Window,
-    camera_query: &Query<(&Transform, &Camera)>,
-) -> Option<Vec2> {
-    current_window.cursor_position().map(|cursor_pos| {
-        let (cam_t, cam) = camera_query.single();
-        let window_size = Vec2::new(current_window.width(), current_window.height());
-
-        // Convert screen position [0..resolution] to ndc [-1..1]
-        let ndc_to_world = cam_t.compute_matrix() * cam.clip_from_view().inverse();
-        let ndc = (Vec2::new(cursor_pos.x, cursor_pos.y) / window_size) * 2.0 - Vec2::ONE;
-        let world_pos = ndc_to_world.project_point3(ndc.extend(-1.0));
-        world_pos.truncate()
-    })
-}
-
-#[derive(Component)]
-struct Box;
-
-fn spawn_boxes(
-    mut commands: Commands,
-    windows: Query<&Window, With<PrimaryWindow>>,
-    mouse_input: Res<ButtonInput<MouseButton>>,
-    camera_query: Query<(&Transform, &Camera)>,
-) {
-    const BOX_SCALE: f32 = 50.0;
-
-    if mouse_input.pressed(MouseButton::Left) {
-        let primary_window = windows.single();
-        // Don't break if we leave the window
-        if let Some(cursor_pos) = cursor_pos_as_world_pos(primary_window, &camera_query) {
-            commands
-                .spawn(SpriteBundle {
-                    sprite: Sprite {
-                        color: Color::Srgba(palettes::css::DARK_GREEN),
-                        ..default()
-                    },
-                    transform: Transform {
-                        translation: cursor_pos.extend(0.0),
-                        scale: Vec3::splat(BOX_SCALE),
-                        ..default()
-                    },
-                    ..default()
-                })
-                .insert(Box);
-        }
-    }
-}
-
-fn decay_boxes(mut query: Query<(Entity, &mut Transform), With<Box>>, mut commands: Commands) {
-    const MIN_SCALE: f32 = 1.;
-    const SHRINK_FACTOR: f32 = 0.95;
-
-    for (entity, mut transform) in query.iter_mut() {
-        if transform.scale.x < MIN_SCALE {
-            commands.entity(entity).despawn();
-        } else {
-            transform.scale *= SHRINK_FACTOR;
-        }
-    }
-}
-
-fn toggle_capture_vs_playback(
-    mut input_modes: ResMut<InputModesCaptured>,
-    mut playback_strategy: ResMut<PlaybackStrategy>,
-    keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut timestamped_input: ResMut<TimestampedInputs>,
-    mut input_strategy: ResMut<InputStrategy>,
-) {
-    if keyboard_input.just_pressed(KeyCode::Space) {
-        *input_strategy = match *input_strategy {
-            InputStrategy::Capture => {
-                // Disable input capture
-                *input_modes = InputModesCaptured::DISABLE_ALL;
-                // Enable input playback
-                *playback_strategy = if let Some((start, end)) =
-                    // Play back all recorded inputs at the same rate they were input
-                    timestamped_input.frame_range()
-                {
-                    PlaybackStrategy::FrameRangeOnce(start, end)
-                } else {
-                    // Do not play back events if none were recorded
-                    PlaybackStrategy::Paused
-                };
-
-                info!("Now playing back input.");
-                InputStrategy::Playback
-            }
-            InputStrategy::Playback => {
-                // Enable input capture
-                *input_modes = InputModesCaptured::ENABLE_ALL;
-                // Disable input playback
-                *playback_strategy = PlaybackStrategy::Paused;
-
-                // Reset all input data, starting a new recording
-                *timestamped_input = TimestampedInputs::default();
-
-                info!("Now capturing input.");
-                InputStrategy::Capture
-            }
-        };
-    }
-}
+use bevy::{color::palettes, prelude::*, window::PrimaryWindow};
+
+use leafwing_input_playback::{
+    input_capture::{BeginInputCapture, EndInputCapture, InputCapturePlugin},
+    input_playback::{BeginInputPlayback, EndInputPlayback, InputPlaybackPlugin, PlaybackStrategy},
+    timestamped_input::TimestampedInputs,
+};
+
+fn main() -> AppExit {
+    let mut app = App::new();
+    app.add_plugins((DefaultPlugins, InputCapturePlugin, InputPlaybackPlugin))
+        // Creates a little game that spawns decaying boxes where the player clicks
+        .insert_resource(ClearColor(Color::srgb(0.9, 0.9, 0.9)))
+        // Toggle between playback and capture by pressing Space
+        .insert_resource(InputStrategy::Playback)
+        .add_systems(Startup, setup)
+        .add_systems(
+            Update,
+            (spawn_boxes, decay_boxes, toggle_capture_vs_playback),
+        );
+    app.run()
+}
+
+#[derive(Resource, PartialEq)]
+enum InputStrategy {
+    Capture,
+    Playback,
+}
+
+fn setup(mut commands: Commands) {
+    commands.spawn(Camera2dBundle::default());
+}
+
+pub fn cursor_pos_as_world_pos(
+    current_window: &Window,
+    camera_query: &Query<(&GlobalTransform, &Camera)>,
+) -> Option<Vec2> {
+    let (camera_transform, camera) = camera_query.single();
+    current_window
+        .cursor_position()
+        .and_then(|cursor| camera.viewport_to_world(camera_transform, cursor))
+        .map(|ray| ray.origin.truncate())
+}
+
+#[derive(Component)]
+struct Box;
+
+fn spawn_boxes(
+    mut commands: Commands,
+    windows: Query<&Window, With<PrimaryWindow>>,
+    mouse_input: Res<ButtonInput<MouseButton>>,
+    camera_query: Query<(&GlobalTransform, &Camera)>,
+) {
+    const BOX_SCALE: f32 = 50.0;
+
+    if mouse_input.pressed(MouseButton::Left) {
+        let primary_window = windows.single();
+        // Don't break if we leave the window
+        if let Some(cursor_pos) = cursor_pos_as_world_pos(primary_window, &camera_query) {
+            commands
+                .spawn(SpriteBundle {
+                    sprite: Sprite {
+                        color: Color::Srgba(palettes::css::DARK_GREEN),
+                        ..default()
+                    },
+                    transform: Transform {
+                        translation: cursor_pos.extend(0.0),
+                        scale: Vec3::splat(BOX_SCALE),
+                        ..default()
+                    },
+                    ..default()
+                })
+                .insert(Box);
+        }
+    }
+}
+
+fn decay_boxes(mut query: Query<(Entity, &mut Transform), With<Box>>, mut commands: Commands) {
+    const MIN_SCALE: f32 = 1.;
+    const SHRINK_FACTOR: f32 = 0.95;
+
+    for (entity, mut transform) in query.iter_mut() {
+        if transform.scale.x < MIN_SCALE {
+            commands.entity(entity).despawn();
+        } else {
+            transform.scale *= SHRINK_FACTOR;
+        }
+    }
+}
+
+fn toggle_capture_vs_playback(
+    mut commands: Commands,
+    mut input_strategy: ResMut<InputStrategy>,
+    keyboard_input: Res<ButtonInput<KeyCode>>,
+    timestamped_input: Option<ResMut<TimestampedInputs>>,
+) {
+    if keyboard_input.just_pressed(KeyCode::Space) {
+        *input_strategy = match *input_strategy {
+            InputStrategy::Capture => {
+                // Disable input capture
+                commands.trigger(EndInputCapture);
+                // Enable input playback
+                if let Some((start, end)) =
+                    // Play back all recorded inputs at the same rate they were input
+                    timestamped_input
+                        .and_then(|timestamped_input| timestamped_input.frame_range())
+                {
+                    commands.trigger(BeginInputPlayback {
+                        playback_strategy: PlaybackStrategy::FrameRangeOnce(start, end),
+                        ..default()
+                    });
+                    info!("Now playing back input.");
+                } else {
+                    info!("No input to replay.");
+                }
+
+                InputStrategy::Playback
+            }
+            InputStrategy::Playback => {
+                // Disable input playback, resetting all input data.
+                commands.trigger(EndInputPlayback);
+                // Enable input capture
+                commands.trigger(BeginInputCapture::default());
+
+                info!("Now capturing input.");
+                InputStrategy::Capture
+            }
+        };
+    }
+}
diff --git a/examples/playback_serialized_input.rs b/examples/playback_serialized_input.rs
index 33a98fc..ef1e40b 100644
--- a/examples/playback_serialized_input.rs
+++ b/examples/playback_serialized_input.rs
@@ -1,19 +1,24 @@
-/// Demonstrates reading saved inputs from disk, and playing them back.
-use bevy::input::keyboard::KeyboardInput;
-use bevy::prelude::*;
-use leafwing_input_playback::input_playback::InputPlaybackPlugin;
-use leafwing_input_playback::serde::PlaybackFilePath;
-
-fn main() {
-    App::new()
-        .add_plugins((DefaultPlugins, InputPlaybackPlugin))
-        .insert_resource(PlaybackFilePath::new("./data/hello_world.ron"))
-        .add_systems(Update, debug_keyboard_inputs)
-        .run();
-}
-
-fn debug_keyboard_inputs(mut keyboard_events: EventReader<KeyboardInput>) {
-    for keyboard_event in keyboard_events.read() {
-        dbg!(keyboard_event);
-    }
-}
+/// Demonstrates reading saved inputs from disk, and playing them back.
+use bevy::input::keyboard::KeyboardInput;
+use bevy::prelude::*;
+use leafwing_input_playback::input_playback::{
+    BeginInputPlayback, InputPlaybackPlugin, InputPlaybackSource,
+};
+
+fn main() {
+    let mut app = App::new();
+    app.add_plugins((DefaultPlugins, InputPlaybackPlugin));
+    app.add_systems(Update, debug_keyboard_inputs);
+
+    app.world_mut().trigger(BeginInputPlayback {
+        source: Some(InputPlaybackSource::from_file("./data/hello_world.ron")),
+        ..Default::default()
+    });
+    app.run();
+}
+
+fn debug_keyboard_inputs(mut keyboard_events: EventReader<KeyboardInput>) {
+    for keyboard_event in keyboard_events.read() {
+        dbg!(keyboard_event);
+    }
+}
diff --git a/examples/serialize_captured_input.rs b/examples/serialize_captured_input.rs
index c1d6e89..386a50d 100644
--- a/examples/serialize_captured_input.rs
+++ b/examples/serialize_captured_input.rs
@@ -2,17 +2,21 @@
 ///
 /// Just enter inputs, and watch them be serialized to disk.
 use bevy::prelude::*;
-use leafwing_input_playback::input_capture::{InputCapturePlugin, InputModesCaptured};
-use leafwing_input_playback::serde::PlaybackFilePath;
+use leafwing_input_playback::input_capture::{
+    trigger_input_capture_on_exit, BeginInputCapture, InputCapturePlugin, InputModesCaptured,
+};
 
 fn main() {
-    App::new()
-        .add_plugins((DefaultPlugins, InputCapturePlugin))
-        .insert_resource(PlaybackFilePath::new("./data/test_playback.ron"))
-        // In this example, we're only capturing keyboard inputs
-        .insert_resource(InputModesCaptured {
+    let mut app = App::new();
+    app.add_plugins((DefaultPlugins, InputCapturePlugin))
+        .add_systems(Last, trigger_input_capture_on_exit);
+    app.world_mut().trigger(BeginInputCapture {
+        input_modes_captured: InputModesCaptured {
             keyboard: true,
             ..InputModesCaptured::DISABLE_ALL
-        })
-        .run();
+        },
+        filepath: Some("./data/test_playback.ron".to_string()),
+        ..Default::default()
+    });
+    app.run();
 }
diff --git a/examples/useless_machine.rs b/examples/useless_machine.rs
index e5cd4c3..d2c31bb 100644
--- a/examples/useless_machine.rs
+++ b/examples/useless_machine.rs
@@ -1,14 +1,18 @@
-//! [`AppExit`] events are played back and captured too!
-//!
-//! This example loads the file, which only contains an `AppExit`,
-//! and then immediately quits itself as soon as it is encountered.
-use bevy::prelude::*;
-use leafwing_input_playback::input_playback::InputPlaybackPlugin;
-use leafwing_input_playback::serde::PlaybackFilePath;
-
-fn main() {
-    App::new()
-        .add_plugins((DefaultPlugins, InputPlaybackPlugin))
-        .insert_resource(PlaybackFilePath::new("./data/app_exit.ron"))
-        .run();
-}
+//! [`AppExit`] events are played back and captured too!
+//!
+//! This example loads the file, which only contains an `AppExit`,
+//! and then immediately quits itself as soon as it is encountered.
+use bevy::prelude::*;
+use leafwing_input_playback::input_playback::{
+    BeginInputPlayback, InputPlaybackPlugin, InputPlaybackSource,
+};
+
+fn main() {
+    let mut app = App::new();
+    app.add_plugins((DefaultPlugins, InputPlaybackPlugin));
+    app.world_mut().trigger(BeginInputPlayback {
+        source: Some(InputPlaybackSource::from_file("./data/app_exit.ron")),
+        ..Default::default()
+    });
+    app.run();
+}
diff --git a/src/input_capture.rs b/src/input_capture.rs
index 6e0443c..7b32182 100644
--- a/src/input_capture.rs
+++ b/src/input_capture.rs
@@ -33,7 +33,7 @@ impl Plugin for InputCapturePlugin {
                 Last,
                 (
                     // Capture any mocked input as well
-                    capture_input,
+                    capture_input.run_if(resource_exists::<TimestampedInputs>),
                     handle_final_capture_frame.run_if(resource_exists::<FinalCaptureFrame>),
                 )
                     .chain()
@@ -42,7 +42,7 @@ impl Plugin for InputCapturePlugin {
     }
 }
 
-/// An Event that users can send to initiate input capture.
+/// An Observer that users can trigger to initiate input capture.
 ///
 /// Data is serialized to the provided `filepath` when either an [`EndInputCapture`] or an [`AppExit`] event is detected.
 #[derive(Debug, Default, Event)]
@@ -60,7 +60,7 @@ pub struct BeginInputCapture {
 }
 
 impl BeginInputCapture {
-    /// Initiates input capture when a [`BeginInputCapture`] is detected.
+    /// An `ObserverSystem` for `BeginInputCapture` that attaches all capture-related resources.
     pub fn observer(trigger: Trigger<Self>, mut commands: Commands, frame_count: Res<FrameCount>) {
         let event = trigger.event();
         commands.init_resource::<TimestampedInputs>();
@@ -79,12 +79,12 @@ impl BeginInputCapture {
     }
 }
 
-/// An Observer Trigger that users can send to end input capture and serialize data to disk.
+/// An Observer that users can trigger to end input capture and serialize data to disk.
 #[derive(Debug, Event)]
 pub struct EndInputCapture;
 
 impl EndInputCapture {
-    /// An `ObserverSystem` for `EndInputCapture` that removes all capture-related resources and serializes timestamps if `PlaybackFilePath` exists
+    /// An `ObserverSystem` for `EndInputCapture` that removes all capture-related resources and serializes timestamps if `PlaybackFilePath` exists.
     pub fn observer(
         _trigger: Trigger<Self>,
         mut commands: Commands,
diff --git a/src/input_playback.rs b/src/input_playback.rs
index 2bcc164..2068e71 100644
--- a/src/input_playback.rs
+++ b/src/input_playback.rs
@@ -1,442 +1,469 @@
-//! Reads user input from a single [`TimestampedInputs`](crate::timestamped_input::TimestampedInputs) resource.
-//!
-//! These are played back by emulating assorted Bevy input events.
-
-use bevy::app::{App, AppExit, First, Plugin};
-use bevy::core::FrameCount;
-use bevy::ecs::{prelude::*, system::SystemParam};
-use bevy::input::{
-    gamepad::GamepadEvent,
-    keyboard::KeyboardInput,
-    mouse::{MouseButtonInput, MouseWheel},
-};
-use bevy::log::warn;
-use bevy::time::Time;
-use bevy::utils::Duration;
-use bevy::window::{CursorMoved, Window};
-use ron::de::from_reader;
-use std::fs::File;
-
-use crate::serde::PlaybackFilePath;
-use crate::timestamped_input::{TimestampedInputEvent, TimestampedInputs};
-
-/// Reads from the [`TimestampedInputs`] event stream to determine which events to play back.
-///
-/// Events are played back during the [`First`] schedule to accurately mimic the behavior of native `winit`-based inputs.
-/// Which events are played back are controlled via the [`PlaybackStrategy`] resource.
-///  
-/// Input is deserialized on app startup from the path stored in the [`PlaybackFilePath`] resource, if any.
-pub struct InputPlaybackPlugin;
-
-impl Plugin for InputPlaybackPlugin {
-    fn build(&self, app: &mut App) {
-        app.observe(BeginInputPlayback::observer)
-            .observe(EndInputPlayback::observer)
-            .add_systems(
-                First,
-                playback_timestamped_input
-                    .run_if(
-                        resource_exists::<PlaybackProgress>
-                            .and_then(resource_exists::<TimestampedInputs>),
-                    )
-                    .after(bevy::ecs::event::EventUpdates),
-            );
-    }
-}
-
-/// An Event that users can send to initiate input capture.
-///
-/// Data is serialized to the provided `filepath` when either an [`EndCaptureEvent`] or an [`AppExit`] event is detected.
-#[derive(Debug, Default, Event)]
-pub struct BeginInputPlayback {
-    /// The source from which to read input data. Do not provide a `source` if the expected `TimestampedInputs` should already be present in `World`.
-    pub source: Option<InputPlaybackSource>,
-    /// Controls the approach used for playing back recorded inputs.
-    ///
-    /// See [`PlaybackStrategy`] for more information.
-    pub playback_strategy: PlaybackStrategy,
-    /// A entity corresponding to the [`bevy::window::Window`] which will receive input events.
-    /// If unspecified, input events will target the serialized window entity, which may be fragile.
-    pub playback_window: Option<Entity>,
-}
-
-impl BeginInputPlayback {
-    /// Initiates input playback and deserializes timestamped inputs from the provided playback source.
-    pub fn observer(trigger: Trigger<BeginInputPlayback>, mut commands: Commands) {
-        let event = trigger.event();
-        commands.init_resource::<PlaybackProgress>();
-        commands.insert_resource(event.playback_strategy);
-
-        if let Some(source) = event.source.as_ref() {
-            let timestamped_inputs = match source {
-                InputPlaybackSource::TimestampedInputs(inputs) => inputs.clone(),
-                InputPlaybackSource::File(playback_path) => {
-                    commands.insert_resource(playback_path.clone());
-                    deserialize_timestamped_inputs(playback_path)
-                        .unwrap()
-                        .unwrap()
-                }
-            };
-            commands.insert_resource(timestamped_inputs);
-        }
-
-        if let Some(playback_window) = event.playback_window {
-            commands.insert_resource(PlaybackWindow(playback_window));
-        }
-    }
-}
-
-/// The source of input data for playback.
-///
-/// Typically users should expect to provide a `FilePath`, but `TimestampedInputs` can still be provided manually.
-#[derive(Debug)]
-pub enum InputPlaybackSource {
-    /// Reads from a file and deserializes the content into a `TimestampedInputs`.
-    File(PlaybackFilePath),
-    /// Uses the provided `TimestampedInputs` parameter as the source of input data.
-    TimestampedInputs(TimestampedInputs),
-}
-
-impl InputPlaybackSource {
-    /// Reads source data from a file using the provided filepath.
-    pub fn from_file(filepath: impl AsRef<String>) -> Self {
-        InputPlaybackSource::File(PlaybackFilePath::new(filepath.as_ref()))
-    }
-
-    /// Defines source data using raw data.
-    pub fn from_inputs(inputs: TimestampedInputs) -> Self {
-        InputPlaybackSource::TimestampedInputs(inputs)
-    }
-}
-
-impl Default for InputPlaybackSource {
-    fn default() -> Self {
-        Self::TimestampedInputs(TimestampedInputs::default())
-    }
-}
-
-/// An Event that users can send to end input playback prematurely.
-#[derive(Debug, Event)]
-pub struct EndInputPlayback;
-
-impl EndInputPlayback {
-    /// Serializes captured input to the path given in the [`PlaybackFilePath`] resource when an [`EndInputCapture`] is detected.
-    ///
-    /// Use the [`serialized_timestamped_inputs`] function directly if you want to implement custom checkpointing strategies.
-    fn observer(_trigger: Trigger<EndInputPlayback>, mut commands: Commands) {
-        commands.remove_resource::<PlaybackFilePath>();
-        commands.remove_resource::<TimestampedInputs>();
-        commands.remove_resource::<PlaybackProgress>();
-        commands.remove_resource::<PlaybackStrategy>();
-        commands.remove_resource::<PlaybackWindow>();
-    }
-}
-
-/// The `Window` entity for which inputs will be captured.
-///
-/// If this Resource is attached, input events will be forwarded to this window entity rather than the serialized window entity.
-#[derive(Debug, Resource)]
-pub struct PlaybackWindow(pub Entity);
-
-/// Controls the approach used for playing back recorded inputs
-///
-/// [`PlaybackStrategy::Time`] is the default strategy.
-#[derive(Resource, Debug, Clone, Copy, PartialEq, Eq, Default)]
-pub enum PlaybackStrategy {
-    /// Plays events up to (but not past) the current [`Time`].
-    ///
-    /// This strategy is more reliable, as it will ensure that systems which rely on elapsed time function correctly.
-    #[default]
-    Time,
-    /// Plays events up to (but not past) the current [`FrameCount`].
-    ///
-    /// This strategy is faster, as you can turn off any frame rate limiting mechanism.
-    FrameCount,
-    /// Plays events between the first and second [`Duration`] once, measured in time since app startup.
-    ///
-    /// The events are played back at the same rate they were captured.
-    /// This range includes events sent at the start of the range, but not the end.
-    TimeRangeOnce(Duration, Duration),
-    /// Plays events between the first and second [`Duration`] indefinitely, measured in time since app startup.
-    ///
-    /// The events are played back at the same rate they were captured.
-    /// This range includes events sent at the start of the range, but not the end.
-    /// There will always be one frame between the end of the previous loop and the start of the next.
-    TimeRangeLoop(Duration, Duration),
-    /// Plays events between the first and second [`FrameCount`] once.
-    ///
-    /// The events are played back at the same rate they were captured.
-    /// This range includes events sent at the start of the range, but not the end.
-    FrameRangeOnce(FrameCount, FrameCount),
-    /// Plays events between the first and second [`FrameCount`] indefinitely.
-    ///
-    /// The events are played back at the same rate they were captured.
-    /// This range includes events sent at the start of the range, but not the end.
-    /// There will always be one frame between the end of the previous loop and the start of the next.
-    FrameRangeLoop(FrameCount, FrameCount),
-    /// Does not playback any events.
-    ///
-    /// This is useful for interactive use cases, to temporarily disable sending events.
-    Paused,
-}
-
-/// The [`EventWriter`] types that correspond to the input event types stored in [`InputEvent`](crate::timestamped_input::InputEvent)
-#[derive(SystemParam)]
-#[allow(missing_docs)]
-pub struct InputWriters<'w, 's> {
-    pub keyboard_input: EventWriter<'w, KeyboardInput>,
-    pub mouse_button_input: EventWriter<'w, MouseButtonInput>,
-    pub mouse_wheel: EventWriter<'w, MouseWheel>,
-    pub cursor_moved: EventWriter<'w, CursorMoved>,
-    pub windows: Query<'w, 's, &'static mut Window>,
-    pub gamepad: EventWriter<'w, GamepadEvent>,
-    pub app_exit: EventWriter<'w, AppExit>,
-}
-
-// `TimestampedInputs` is an iterator, so we need mutable access to be able to track which events we've seen
-/// A system that reads from the [`TimestampedInputs`] resources and plays back the contained events.
-///
-/// The strategy used is based on [`PlaybackStrategy`].
-pub fn playback_timestamped_input(
-    mut timestamped_input: ResMut<TimestampedInputs>,
-    mut playback_strategy: ResMut<PlaybackStrategy>,
-    time: Res<Time>,
-    frame_count: Res<FrameCount>,
-    mut input_writers: InputWriters,
-    mut playback_progress: ResMut<PlaybackProgress>,
-) {
-    // We cannot store the iterator, as different opaque return types are used
-    match *playback_strategy {
-        PlaybackStrategy::Time => {
-            let input_events = timestamped_input.iter_until_time(time.elapsed());
-            send_playback_events(input_events, &mut input_writers);
-        }
-        PlaybackStrategy::FrameCount => {
-            let input_events = timestamped_input.iter_until_frame(*frame_count);
-            send_playback_events(input_events, &mut input_writers);
-        }
-        PlaybackStrategy::TimeRangeOnce(start, end) => {
-            let input_events = timestamped_input.iter_between_times(
-                playback_progress.current_time(start),
-                playback_progress.next_time(time.delta(), start),
-            );
-            send_playback_events(input_events, &mut input_writers);
-
-            // If we've covered the entire range, reset our progress
-            if playback_progress.current_time(start) > end {
-                playback_progress.reset(timestamped_input.into_inner());
-                // We only want to play back once, so pause.
-                *playback_strategy = PlaybackStrategy::Paused;
-            }
-        }
-        PlaybackStrategy::FrameRangeOnce(start, end) => {
-            let input_events = timestamped_input.iter_between_frames(
-                playback_progress.current_frame(start),
-                playback_progress.next_frame(start),
-            );
-            send_playback_events(input_events, &mut input_writers);
-
-            // If we've covered the entire range, reset our progress
-            if playback_progress.current_frame(start) > end {
-                playback_progress.reset(timestamped_input.into_inner());
-                // We only want to play back once, so pause.
-                *playback_strategy = PlaybackStrategy::Paused;
-            }
-        }
-        PlaybackStrategy::TimeRangeLoop(start, end) => {
-            let input_events = timestamped_input.iter_between_times(
-                playback_progress.current_time(start),
-                playback_progress.next_time(time.delta(), start),
-            );
-            send_playback_events(input_events, &mut input_writers);
-
-            // If we've covered the entire range, reset our progress
-            if playback_progress.current_time(start) > end {
-                playback_progress.reset(timestamped_input.into_inner());
-            }
-        }
-        PlaybackStrategy::FrameRangeLoop(start, end) => {
-            let input_events = timestamped_input.iter_between_frames(
-                playback_progress.current_frame(start),
-                playback_progress.next_frame(start),
-            );
-            send_playback_events(input_events, &mut input_writers);
-
-            // If we've covered the entire range, reset our progress
-            if playback_progress.current_frame(start) > end {
-                playback_progress.reset(timestamped_input.into_inner());
-            }
-        }
-        PlaybackStrategy::Paused => {
-            // Do nothing
-        }
-    };
-}
-
-fn send_playback_events(
-    timestamped_input_events: impl IntoIterator<Item = TimestampedInputEvent>,
-    input_writers: &mut InputWriters,
-) {
-    for timestamped_input_event in timestamped_input_events {
-        use crate::timestamped_input::InputEvent::*;
-        match timestamped_input_event.input_event {
-            Keyboard(e) => {
-                input_writers.keyboard_input.send(e);
-            }
-            MouseButton(e) => {
-                input_writers.mouse_button_input.send(e);
-            }
-            MouseWheel(e) => {
-                input_writers.mouse_wheel.send(e);
-            }
-            // Window events MUST update the `Window` struct itself
-            // BLOCKED: https://github.com/bevyengine/bevy/issues/6163
-            CursorMoved(e) => {
-                if let Ok(mut window) = input_writers.windows.get_mut(e.window) {
-                    window.set_cursor_position(Some(e.position));
-                } else {
-                    warn!("Window entity was not found when attempting to play back {e:?}")
-                }
-
-                input_writers.cursor_moved.send(e);
-            }
-            Gamepad(e) => {
-                input_writers.gamepad.send(e);
-            }
-            AppExit => {
-                input_writers.app_exit.send_default();
-            }
-        };
-    }
-}
-
-/// Reads the stored file paths from the [`PlaybackFilePath`] location (if any)
-pub fn deserialize_timestamped_inputs(
-    playback_path: &PlaybackFilePath,
-) -> Option<Result<TimestampedInputs, TimestampedInputsError>> {
-    playback_path.path().as_ref().map(|file_path| {
-        let file = File::open(file_path).map_err(TimestampedInputsError::Fs)?;
-        from_reader(file).map_err(TimestampedInputsError::Ron)
-    })
-}
-
-/// An error type that wraps the possible error variants when deserializing `TimestampedInputs` from a file.
-#[derive(Debug)]
-pub enum TimestampedInputsError {
-    /// The error case where the filesystem failed to open the desired file path.
-    Fs(std::io::Error),
-    /// The error case where the content at the provided filepath did not have valid RON content.
-    Ron(ron::de::SpannedError),
-}
-
-impl std::fmt::Display for TimestampedInputsError {
-    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
-        match self {
-            TimestampedInputsError::Fs(_error) => write!(f, "could not find playback file "),
-            TimestampedInputsError::Ron(_error) => {
-                write!(f, "the provided file did not have valid RON-formatted data")
-            }
-        }
-    }
-}
-
-impl std::error::Error for TimestampedInputsError {
-    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
-        match *self {
-            TimestampedInputsError::Fs(ref error) => Some(error),
-            TimestampedInputsError::Ron(ref error) => Some(error),
-        }
-    }
-}
-
-/// How far through the current cycle of input playback we've gotten.
-///
-/// The `initial_time` and `initial_frame` are stored to be able to compute
-/// the offset between the actual time (frame count) and the time (frame count) of the recording.
-///
-/// Used in the [`playback_timestamped_input`] system to track progress.
-#[derive(Resource, Default, Debug, PartialEq, Eq, Clone)]
-pub struct PlaybackProgress {
-    /// The [`Duration`] that this playback loop has been running for
-    pub elapsed_time: Duration,
-    /// The number of frames that this playback loop has been running for
-    pub elapsed_frames: FrameCount,
-}
-
-impl PlaybackProgress {
-    /// Gets the current frame.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `self.initial_frame` is `None`. Make sure to call `set_initial_frame` first!
-    pub fn current_frame(&self, start: FrameCount) -> FrameCount {
-        FrameCount(start.0.wrapping_add(self.elapsed_frames.0))
-    }
-
-    /// Gets the current time.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `self.initial_time` is `None`. Make sure to call `set_initial_time` first!
-    pub fn current_time(&self, start: Duration) -> Duration {
-        start + self.elapsed_time
-    }
-
-    /// Get the start of the next frame window to play back.
-    ///
-    /// This also records that one frame has elapsed.
-    pub fn next_frame(&mut self, start: FrameCount) -> FrameCount {
-        self.elapsed_frames = FrameCount(self.elapsed_frames.0.wrapping_add(1));
-        // The frame count has been advanced, so this returns the correct value
-        self.current_frame(start)
-    }
-
-    /// Get the start of the next time window to play back.
-    ///
-    /// This also records that a `delta` of time has elapsed.
-    pub fn next_time(&mut self, delta: Duration, start: Duration) -> Duration {
-        self.elapsed_time += delta;
-        // Time has been advanced, so this returns the correct value
-        self.current_time(start)
-    }
-
-    /// Resets all tracked progress.
-    ///
-    /// This is called when the current pass of the playback loop elapses.
-    pub fn reset(&mut self, timestamped_input: &mut TimestampedInputs) {
-        timestamped_input.reset_cursor();
-        *self = Self::default();
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::*;
-
-    #[test]
-    fn current_time() {
-        let mut progress = PlaybackProgress::default();
-        let start = Duration::from_secs(1);
-
-        assert_eq!(progress.current_time(start), start);
-
-        let delta = Duration::from_secs(1);
-        let next_time = progress.next_time(delta, start);
-        assert_eq!(next_time, start + delta);
-        assert_eq!(progress.elapsed_time, delta);
-    }
-
-    #[test]
-    fn current_frame() {
-        let mut progress = PlaybackProgress::default();
-
-        let start = FrameCount(1);
-
-        assert_eq!(progress.current_frame(start), start);
-
-        let delta = FrameCount(1);
-        let next_frame = progress.next_frame(start);
-        assert_eq!(next_frame.0, start.0.wrapping_add(delta.0));
-        assert_eq!(progress.elapsed_frames, delta);
-    }
-}
+//! Reads user input from a single [`TimestampedInputs`](crate::timestamped_input::TimestampedInputs) resource.
+//!
+//! These are played back by emulating assorted Bevy input events.
+
+use bevy::app::{App, AppExit, First, Plugin};
+use bevy::core::FrameCount;
+use bevy::ecs::{prelude::*, system::SystemParam};
+use bevy::input::{
+    gamepad::GamepadEvent,
+    keyboard::KeyboardInput,
+    mouse::{MouseButtonInput, MouseWheel},
+};
+use bevy::log::warn;
+use bevy::time::Time;
+use bevy::utils::Duration;
+use bevy::window::{CursorMoved, PrimaryWindow, Window};
+use ron::de::from_reader;
+use std::fs::File;
+
+use crate::serde::PlaybackFilePath;
+use crate::timestamped_input::{TimestampedInputEvent, TimestampedInputs};
+
+/// Reads from the [`TimestampedInputs`] event stream to determine which events to play back.
+///
+/// Events are played back during the [`First`] schedule to accurately mimic the behavior of native `winit`-based inputs.
+/// Which events are played back are controlled via the [`PlaybackStrategy`] resource.
+///  
+/// Input is deserialized on app startup from the path stored in the [`PlaybackFilePath`] resource, if any.
+pub struct InputPlaybackPlugin;
+
+impl Plugin for InputPlaybackPlugin {
+    fn build(&self, app: &mut App) {
+        app.observe(BeginInputPlayback::observer)
+            .observe(EndInputPlayback::observer)
+            .add_systems(
+                First,
+                playback_timestamped_input
+                    .run_if(
+                        resource_exists::<PlaybackProgress>
+                            .and_then(resource_exists::<TimestampedInputs>),
+                    )
+                    .after(bevy::ecs::event::EventUpdates),
+            );
+    }
+}
+
+/// An Observer that users can trigger to initiate input capture.
+///
+/// Data is serialized to the provided `filepath` when either an [`EndCaptureEvent`] or an [`AppExit`] event is detected.
+#[derive(Debug, Default, Event)]
+pub struct BeginInputPlayback {
+    /// The source from which to read input data. Do not provide a `source` if the expected `TimestampedInputs` should already be present in `World`.
+    pub source: Option<InputPlaybackSource>,
+    /// Controls the approach used for playing back recorded inputs.
+    ///
+    /// See [`PlaybackStrategy`] for more information.
+    pub playback_strategy: PlaybackStrategy,
+    /// A entity corresponding to the [`bevy::window::Window`] which will receive input events.
+    /// If unspecified, input events will target the serialized window entity, which may be fragile.
+    pub playback_window: Option<PlaybackWindow>,
+}
+
+impl BeginInputPlayback {
+    /// An `ObserverSystem` for `BeginInputPlayback` that deserializes timestamped inputs from a playback source (if provided) and attaches all playback-related resources.
+    pub fn observer(trigger: Trigger<BeginInputPlayback>, mut commands: Commands) {
+        let event = trigger.event();
+        commands.init_resource::<PlaybackProgress>();
+        commands.insert_resource(event.playback_strategy);
+
+        if let Some(source) = event.source.as_ref() {
+            let timestamped_inputs = match source {
+                InputPlaybackSource::TimestampedInputs(inputs) => inputs.clone(),
+                InputPlaybackSource::File(playback_path) => {
+                    commands.insert_resource(playback_path.clone());
+                    deserialize_timestamped_inputs(playback_path)
+                        .unwrap()
+                        .unwrap()
+                }
+            };
+            commands.insert_resource(timestamped_inputs);
+        }
+
+        if let Some(playback_window) = &event.playback_window {
+            commands.insert_resource(playback_window.clone());
+        }
+    }
+}
+
+/// The source of input data for playback.
+///
+/// Typically users should expect to provide a `FilePath`, but `TimestampedInputs` can still be provided manually.
+#[derive(Debug)]
+pub enum InputPlaybackSource {
+    /// Reads from a file and deserializes the content into a `TimestampedInputs`.
+    File(PlaybackFilePath),
+    /// Uses the provided `TimestampedInputs` parameter as the source of input data.
+    TimestampedInputs(TimestampedInputs),
+}
+
+impl InputPlaybackSource {
+    /// Reads source data from a file using the provided filepath.
+    pub fn from_file(filepath: impl Into<String>) -> Self {
+        InputPlaybackSource::File(PlaybackFilePath::new(&filepath.into()))
+    }
+
+    /// Defines source data using raw data.
+    pub fn from_inputs(inputs: TimestampedInputs) -> Self {
+        InputPlaybackSource::TimestampedInputs(inputs)
+    }
+}
+
+impl Default for InputPlaybackSource {
+    fn default() -> Self {
+        Self::TimestampedInputs(TimestampedInputs::default())
+    }
+}
+
+/// An Observer that users can trigger to end input playback prematurely.
+#[derive(Debug, Event)]
+pub struct EndInputPlayback;
+
+impl EndInputPlayback {
+    /// An `ObserverSystem` for `EndInputPlayback` that removes playback-related resources including previously-recorded inputs.
+    fn observer(_trigger: Trigger<EndInputPlayback>, mut commands: Commands) {
+        commands.remove_resource::<PlaybackFilePath>();
+        commands.remove_resource::<TimestampedInputs>();
+        commands.remove_resource::<PlaybackProgress>();
+        commands.remove_resource::<PlaybackStrategy>();
+        commands.remove_resource::<PlaybackWindow>();
+    }
+}
+
+/// The `Window` entity that will receive capture events from the .
+///
+/// If this Resource is attached, input events will be forwarded to this window entity rather than the serialized window entity.
+#[derive(Clone, Debug, Default, Resource)]
+pub enum PlaybackWindow {
+    /// Overrides the serialized window entity with the current `PrimaryWindow` entity.
+    ///
+    /// This is the most common behavior.
+    #[default]
+    PrimaryWindow,
+    /// Overrides the serialized window entity with a specific Window entity.
+    ///
+    /// This can be used for input playback in multi-window applications.
+    Window(Entity),
+}
+
+/// Controls the approach used for playing back recorded inputs
+///
+/// [`PlaybackStrategy::Time`] is the default strategy.
+#[derive(Resource, Debug, Clone, Copy, PartialEq, Eq, Default)]
+pub enum PlaybackStrategy {
+    /// Plays events up to (but not past) the current [`Time`].
+    ///
+    /// This strategy is more reliable, as it will ensure that systems which rely on elapsed time function correctly.
+    #[default]
+    Time,
+    /// Plays events up to (but not past) the current [`FrameCount`].
+    ///
+    /// This strategy is faster, as you can turn off any frame rate limiting mechanism.
+    FrameCount,
+    /// Plays events between the first and second [`Duration`] once, measured in time since app startup.
+    ///
+    /// The events are played back at the same rate they were captured.
+    /// This range includes events sent at the start of the range, but not the end.
+    TimeRangeOnce(Duration, Duration),
+    /// Plays events between the first and second [`Duration`] indefinitely, measured in time since app startup.
+    ///
+    /// The events are played back at the same rate they were captured.
+    /// This range includes events sent at the start of the range, but not the end.
+    /// There will always be one frame between the end of the previous loop and the start of the next.
+    TimeRangeLoop(Duration, Duration),
+    /// Plays events between the first and second [`FrameCount`] once.
+    ///
+    /// The events are played back at the same rate they were captured.
+    /// This range includes events sent at the start of the range, but not the end.
+    FrameRangeOnce(FrameCount, FrameCount),
+    /// Plays events between the first and second [`FrameCount`] indefinitely.
+    ///
+    /// The events are played back at the same rate they were captured.
+    /// This range includes events sent at the start of the range, but not the end.
+    /// There will always be one frame between the end of the previous loop and the start of the next.
+    FrameRangeLoop(FrameCount, FrameCount),
+    /// Does not playback any events.
+    ///
+    /// This is useful for interactive use cases, to temporarily disable sending events.
+    Paused,
+}
+
+/// The [`EventWriter`] types that correspond to the input event types stored in [`InputEvent`](crate::timestamped_input::InputEvent)
+#[derive(SystemParam)]
+#[allow(missing_docs)]
+pub struct InputWriters<'w, 's> {
+    pub keyboard_input: EventWriter<'w, KeyboardInput>,
+    pub mouse_button_input: EventWriter<'w, MouseButtonInput>,
+    pub mouse_wheel: EventWriter<'w, MouseWheel>,
+    pub cursor_moved: EventWriter<'w, CursorMoved>,
+    pub windows: Query<'w, 's, &'static mut Window>,
+    pub gamepad: EventWriter<'w, GamepadEvent>,
+    pub app_exit: EventWriter<'w, AppExit>,
+}
+
+// `TimestampedInputs` is an iterator, so we need mutable access to be able to track which events we've seen
+/// A system that reads from the [`TimestampedInputs`] resources and plays back the contained events.
+///
+/// The strategy used is based on [`PlaybackStrategy`].
+/// Additionally, `Keyboard`, `MouseButton`, and `MouseWheel` events may target `Window` entities according to the [`PlaybackWindow`].
+#[allow(clippy::too_many_arguments)]
+pub fn playback_timestamped_input(
+    mut timestamped_input: ResMut<TimestampedInputs>,
+    mut playback_strategy: ResMut<PlaybackStrategy>,
+    playback_window: Option<Res<PlaybackWindow>>,
+    time: Res<Time>,
+    primary_window: Query<Entity, (With<Window>, With<PrimaryWindow>)>,
+    frame_count: Res<FrameCount>,
+    mut input_writers: InputWriters,
+    mut playback_progress: ResMut<PlaybackProgress>,
+) {
+    let window_override = match playback_window.as_deref() {
+        Some(PlaybackWindow::PrimaryWindow) => Some(primary_window.single()),
+        Some(PlaybackWindow::Window(entity)) => Some(*entity),
+        None => None,
+    };
+    // We cannot store the iterator, as different opaque return types are used
+    match *playback_strategy {
+        PlaybackStrategy::Time => {
+            let input_events = timestamped_input.iter_until_time(time.elapsed());
+            send_playback_events(input_events, &mut input_writers, window_override);
+        }
+        PlaybackStrategy::FrameCount => {
+            let input_events = timestamped_input.iter_until_frame(*frame_count);
+            send_playback_events(input_events, &mut input_writers, window_override);
+        }
+        PlaybackStrategy::TimeRangeOnce(start, end) => {
+            let input_events = timestamped_input.iter_between_times(
+                playback_progress.current_time(start),
+                playback_progress.next_time(time.delta(), start),
+            );
+            send_playback_events(input_events, &mut input_writers, window_override);
+
+            // If we've covered the entire range, reset our progress
+            if playback_progress.current_time(start) > end {
+                playback_progress.reset(timestamped_input.into_inner());
+                // We only want to play back once, so pause.
+                *playback_strategy = PlaybackStrategy::Paused;
+            }
+        }
+        PlaybackStrategy::FrameRangeOnce(start, end) => {
+            let input_events = timestamped_input.iter_between_frames(
+                playback_progress.current_frame(start),
+                playback_progress.next_frame(start),
+            );
+            send_playback_events(input_events, &mut input_writers, window_override);
+
+            // If we've covered the entire range, reset our progress
+            if playback_progress.current_frame(start) > end {
+                playback_progress.reset(timestamped_input.into_inner());
+                // We only want to play back once, so pause.
+                *playback_strategy = PlaybackStrategy::Paused;
+            }
+        }
+        PlaybackStrategy::TimeRangeLoop(start, end) => {
+            let input_events = timestamped_input.iter_between_times(
+                playback_progress.current_time(start),
+                playback_progress.next_time(time.delta(), start),
+            );
+            send_playback_events(input_events, &mut input_writers, window_override);
+
+            // If we've covered the entire range, reset our progress
+            if playback_progress.current_time(start) > end {
+                playback_progress.reset(timestamped_input.into_inner());
+            }
+        }
+        PlaybackStrategy::FrameRangeLoop(start, end) => {
+            let input_events = timestamped_input.iter_between_frames(
+                playback_progress.current_frame(start),
+                playback_progress.next_frame(start),
+            );
+            send_playback_events(input_events, &mut input_writers, window_override);
+
+            // If we've covered the entire range, reset our progress
+            if playback_progress.current_frame(start) > end {
+                playback_progress.reset(timestamped_input.into_inner());
+            }
+        }
+        PlaybackStrategy::Paused => {
+            // Do nothing
+        }
+    };
+}
+
+fn send_playback_events(
+    timestamped_input_events: impl IntoIterator<Item = TimestampedInputEvent>,
+    input_writers: &mut InputWriters,
+    window_override: Option<Entity>,
+) {
+    for timestamped_input_event in timestamped_input_events {
+        use crate::timestamped_input::InputEvent::*;
+        match timestamped_input_event.input_event {
+            Keyboard(mut e) => {
+                if let Some(entity) = window_override {
+                    e.window = entity;
+                }
+                input_writers.keyboard_input.send(e);
+            }
+            MouseButton(mut e) => {
+                if let Some(entity) = window_override {
+                    e.window = entity;
+                }
+                input_writers.mouse_button_input.send(e);
+            }
+            MouseWheel(mut e) => {
+                if let Some(entity) = window_override {
+                    e.window = entity;
+                }
+                input_writers.mouse_wheel.send(e);
+            }
+            // Window events MUST update the `Window` struct itself
+            // BLOCKED: https://github.com/bevyengine/bevy/issues/6163
+            CursorMoved(e) => {
+                if let Ok(mut window) = input_writers.windows.get_mut(e.window) {
+                    window.set_cursor_position(Some(e.position));
+                } else {
+                    warn!("Window entity was not found when attempting to play back {e:?}")
+                }
+
+                input_writers.cursor_moved.send(e);
+            }
+            Gamepad(e) => {
+                input_writers.gamepad.send(e);
+            }
+            AppExit => {
+                input_writers.app_exit.send_default();
+            }
+        };
+    }
+}
+
+/// Reads the stored file paths from the [`PlaybackFilePath`] location (if any)
+pub fn deserialize_timestamped_inputs(
+    playback_path: &PlaybackFilePath,
+) -> Option<Result<TimestampedInputs, TimestampedInputsError>> {
+    playback_path.path().as_ref().map(|file_path| {
+        let file = File::open(file_path).map_err(TimestampedInputsError::Fs)?;
+        from_reader(file).map_err(TimestampedInputsError::Ron)
+    })
+}
+
+/// An error type that wraps the possible error variants when deserializing `TimestampedInputs` from a file.
+#[derive(Debug)]
+pub enum TimestampedInputsError {
+    /// The error case where the filesystem failed to open the desired file path.
+    Fs(std::io::Error),
+    /// The error case where the content at the provided filepath did not have valid RON content.
+    Ron(ron::de::SpannedError),
+}
+
+impl std::fmt::Display for TimestampedInputsError {
+    fn fmt(&self, f: &mut std::fmt::Formatter) -> std::fmt::Result {
+        match self {
+            TimestampedInputsError::Fs(_error) => write!(f, "could not find playback file "),
+            TimestampedInputsError::Ron(_error) => {
+                write!(f, "the provided file did not have valid RON-formatted data")
+            }
+        }
+    }
+}
+
+impl std::error::Error for TimestampedInputsError {
+    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
+        match *self {
+            TimestampedInputsError::Fs(ref error) => Some(error),
+            TimestampedInputsError::Ron(ref error) => Some(error),
+        }
+    }
+}
+
+/// How far through the current cycle of input playback we've gotten.
+///
+/// The `initial_time` and `initial_frame` are stored to be able to compute
+/// the offset between the actual time (frame count) and the time (frame count) of the recording.
+///
+/// Used in the [`playback_timestamped_input`] system to track progress.
+#[derive(Resource, Default, Debug, PartialEq, Eq, Clone)]
+pub struct PlaybackProgress {
+    /// The [`Duration`] that this playback loop has been running for
+    pub elapsed_time: Duration,
+    /// The number of frames that this playback loop has been running for
+    pub elapsed_frames: FrameCount,
+}
+
+impl PlaybackProgress {
+    /// Gets the current frame.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self.initial_frame` is `None`. Make sure to call `set_initial_frame` first!
+    pub fn current_frame(&self, start: FrameCount) -> FrameCount {
+        FrameCount(start.0.wrapping_add(self.elapsed_frames.0))
+    }
+
+    /// Gets the current time.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `self.initial_time` is `None`. Make sure to call `set_initial_time` first!
+    pub fn current_time(&self, start: Duration) -> Duration {
+        start + self.elapsed_time
+    }
+
+    /// Get the start of the next frame window to play back.
+    ///
+    /// This also records that one frame has elapsed.
+    pub fn next_frame(&mut self, start: FrameCount) -> FrameCount {
+        self.elapsed_frames = FrameCount(self.elapsed_frames.0.wrapping_add(1));
+        // The frame count has been advanced, so this returns the correct value
+        self.current_frame(start)
+    }
+
+    /// Get the start of the next time window to play back.
+    ///
+    /// This also records that a `delta` of time has elapsed.
+    pub fn next_time(&mut self, delta: Duration, start: Duration) -> Duration {
+        self.elapsed_time += delta;
+        // Time has been advanced, so this returns the correct value
+        self.current_time(start)
+    }
+
+    /// Resets all tracked progress.
+    ///
+    /// This is called when the current pass of the playback loop elapses.
+    pub fn reset(&mut self, timestamped_input: &mut TimestampedInputs) {
+        timestamped_input.reset_cursor();
+        *self = Self::default();
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn current_time() {
+        let mut progress = PlaybackProgress::default();
+        let start = Duration::from_secs(1);
+
+        assert_eq!(progress.current_time(start), start);
+
+        let delta = Duration::from_secs(1);
+        let next_time = progress.next_time(delta, start);
+        assert_eq!(next_time, start + delta);
+        assert_eq!(progress.elapsed_time, delta);
+    }
+
+    #[test]
+    fn current_frame() {
+        let mut progress = PlaybackProgress::default();
+
+        let start = FrameCount(1);
+
+        assert_eq!(progress.current_frame(start), start);
+
+        let delta = FrameCount(1);
+        let next_frame = progress.next_frame(start);
+        assert_eq!(next_frame.0, start.0.wrapping_add(delta.0));
+        assert_eq!(progress.elapsed_frames, delta);
+    }
+}

From 55f12cc6660e76e30a30fbce16a73d2b28716682 Mon Sep 17 00:00:00 2001
From: Sean Sullivan <me@snen.dev>
Date: Mon, 2 Dec 2024 02:42:20 -0500
Subject: [PATCH 21/21] add releases note

---
 RELEASES.md | 1 +
 1 file changed, 1 insertion(+)

diff --git a/RELEASES.md b/RELEASES.md
index 935e690..c4983a2 100644
--- a/RELEASES.md
+++ b/RELEASES.md
@@ -4,6 +4,7 @@
 
 - migrated to Bevy 0.14
 - replaced `FrameCount` with its Bevy counterpart and updated system scheduling constraints to match the new `FrameCount`'s behavior, which updates in `Last` rather than `First`
+- refactored so that playback and capture are now initiated via Observers
 
 ## Version 0.5