Merge pull request #266 from GlennMacdonald/event-refactor

Event refactor

Author: janhohenheim

crates/bevy_plugin/src/commands/execution.rs

@@ -1,46 +1,29 @@
 use crate::commands::UntypedYarnCommand;
-use crate::dialogue_runner::DialogueExecutionSystemSet;
-use crate::events::ExecuteCommandEvent;
+use crate::events::ExecuteCommand;
 use crate::prelude::*;
-use bevy::ecs::message::MessageCursor;
 use bevy::prelude::*;
 
 pub(crate) fn command_execution_plugin(app: &mut App) {
-    app.add_systems(
-        Update,
-        execute_commands
-            .after(DialogueExecutionSystemSet)
-            .in_set(YarnSpinnerSystemSet),
-    );
+    app.add_observer(execute_commands);
 }
 
-fn execute_commands(world: &mut World, mut cursor: Local<MessageCursor<ExecuteCommandEvent>>) {
-    let events = clone_events(world, &mut cursor);
-    for event in events {
+fn execute_commands(event: On<ExecuteCommand>, mut commands: Commands) {
+    let event = event.clone();
+    commands.queue(move |world: &mut World| {
         let Some(mut command) = clone_command(world, &event) else {
-            continue;
+            return;
         };
+
         let params = event.command.parameters;
         let task_finished_indicator = command.call(params, world);
         if !task_finished_indicator.is_finished() {
-            get_dialogue_runner_mut(world, event.source).add_command_task(task_finished_indicator);
+            get_dialogue_runner_mut(world, event.entity).add_command_task(task_finished_indicator);
         }
-    }
-}
-
-fn clone_events(
-    world: &World,
-    cursor: &mut MessageCursor<ExecuteCommandEvent>,
-) -> Vec<ExecuteCommandEvent> {
-    let events = world.resource::<Messages<ExecuteCommandEvent>>();
-    cursor.read(events).cloned().collect()
+    });
 }
 
-fn clone_command(
-    world: &mut World,
-    event: &ExecuteCommandEvent,
-) -> Option<Box<dyn UntypedYarnCommand>> {
-    let dialogue_runner = get_dialogue_runner(world, event.source);
+fn clone_command(world: &mut World, event: &ExecuteCommand) -> Option<Box<dyn UntypedYarnCommand>> {
+    let dialogue_runner = get_dialogue_runner(world, event.entity);
     let command_name = event.command.name.as_str();
     dialogue_runner
         .commands

crates/bevy_plugin/src/dialogue_runner.rs

@@ -1,6 +1,6 @@
 pub use self::events::{
-    DialogueCompleteEvent, DialogueStartEvent, ExecuteCommandEvent, LineHintsEvent,
-    NodeCompleteEvent, NodeStartEvent, PresentLineEvent, PresentOptionsEvent,
+    DialogueCompleted, DialogueStarted, ExecuteCommand, LineHints, NodeCompleted, NodeStarted,
+    PresentLine, PresentOptions,
 };
 pub use self::{
     builder::DialogueRunnerBuilder,
@@ -18,7 +18,6 @@ use bevy::{
     platform::collections::{HashMap, HashSet},
     prelude::*,
 };
-pub(crate) use runtime_interaction::DialogueExecutionSystemSet;
 use std::any::TypeId;
 use std::fmt::Debug;
 use yarnspinner::core::Library;
@@ -33,7 +32,6 @@ mod runtime_interaction;
 pub(crate) fn dialogue_plugin(app: &mut App) {
     app.add_plugins(runtime_interaction::runtime_interaction_plugin)
         .add_plugins(localized_line::localized_line_plugin)
-        .add_plugins(events::dialogue_runner_events_plugin)
         .add_plugins(dialogue_option::dialogue_option_plugin)
         .add_plugins(builder::dialogue_runner_builder_plugin)
         .add_plugins(inner::inner_dialogue_runner_plugin);
@@ -90,7 +88,7 @@ impl DialogueRunner {
     pub fn select_option(&mut self, option: OptionId) -> Result<&mut Self> {
         if !self.is_running {
             bail!(
-                "Can't select option {option}: the dialogue is currently not running. Please call `DialogueRunner::continue_in_next_update()` only after receiving a `PresentOptionsEvent`."
+                "Can't select option {option}: the dialogue is currently not running. Please call `DialogueRunner::continue_in_next_update()` only after receiving a `PresentOptions` event."
             )
         }
         self.inner_mut()
@@ -138,7 +136,7 @@ impl DialogueRunner {
         self.inner().0.is_waiting_for_option_selection()
     }
 
-    /// If set, every line the user selects will emit a [`PresentLineEvent`]. Defaults to `false`.
+    /// If set, every line the user selects will trigger a [`PresentLine`] event. Defaults to `false`.
     pub fn run_selected_options_as_lines(
         &mut self,
         run_selected_options_as_lines: bool,
@@ -147,13 +145,13 @@ impl DialogueRunner {
         self
     }
 
-    /// If set, every line the user selects will emit a [`PresentLineEvent`]. Defaults to `false`.
+    /// If set, every line the user selects will trigger a [`PresentLine`] event. Defaults to `false`.
     #[must_use]
     pub fn runs_selected_options_as_lines(&self) -> bool {
         self.run_selected_options_as_lines
     }
 
-    /// Stops the execution of the dialogue. Any pending dialogue events will still be sent in the next update, including a [`DialogueCompleteEvent`].
+    /// Stops the execution of the dialogue. Any pending dialogue events will still be sent in the next update, including a [`DialogueCompleted`] event.
     /// After this, [`DialogueRunner::start_node`] must be called before the dialogue can be advanced again.
     pub fn stop(&mut self) -> &mut Self {
         self.is_running = false;

crates/bevy_plugin/src/dialogue_runner/dialogue_option.rs

@@ -5,7 +5,7 @@ use bevy::prelude::*;
 pub(crate) fn dialogue_option_plugin(_app: &mut App) {}
 
 /// An option that can be presented to the user during a dialogue.
-/// Given to you by a [`PresentOptionsEvent`](crate::events::PresentOptionsEvent).
+/// Given to you by a [`PresentOptions`](crate::events::PresentOptions) event.
 #[derive(Debug, Clone, PartialEq)]
 pub struct DialogueOption {
     /// The [`LocalizedLine`] that should be presented to the user for this option.

crates/bevy_plugin/src/dialogue_runner/events.rs

@@ -2,38 +2,27 @@ use crate::UnderlyingYarnCommand;
 use crate::prelude::*;
 use bevy::prelude::*;
 
-pub(crate) fn dialogue_runner_events_plugin(app: &mut App) {
-    app.add_message::<PresentLineEvent>()
-        .add_message::<PresentOptionsEvent>()
-        .add_message::<ExecuteCommandEvent>()
-        .add_message::<NodeCompleteEvent>()
-        .add_message::<NodeStartEvent>()
-        .add_message::<LineHintsEvent>()
-        .add_message::<DialogueCompleteEvent>()
-        .add_message::<DialogueStartEvent>();
-}
-
 /// An event that is fired after a dialogue advances and wishes to present a line to the user.
 /// A dialogue view should listen for this event and draw it to the screen.
 /// Handling this event is **mandatory** for dialogue views.
-#[derive(Debug, Clone, PartialEq, Message)]
-pub struct PresentLineEvent {
+#[derive(Debug, Clone, PartialEq, EntityEvent)]
+pub struct PresentLine {
     /// The line to present to the user.
     pub line: LocalizedLine,
     /// The [`DialogueRunner`] that is presenting this line.
-    pub source: Entity,
+    pub entity: Entity,
 }
 
 /// An event that is fired after a dialogue advances and wishes to present a set of options to the user.
 /// A dialogue view should listen for this event and draw it to the screen.
 /// You need to handle this event by calling [`DialogueRunner::select_option`] with the ID found in the provided [`DialogueOption`]s.
 /// Handling this event is **mandatory** for dialogue views.
-#[derive(Debug, Clone, PartialEq, Message)]
-pub struct PresentOptionsEvent {
+#[derive(Debug, Clone, PartialEq, EntityEvent)]
+pub struct PresentOptions {
     /// The options to present to the user.
     pub options: Vec<DialogueOption>,
     /// The [`DialogueRunner`] that is presenting these options.
-    pub source: Entity,
+    pub entity: Entity,
 }
 
 /// An event that is fired after a dialogue advances and wishes to execute a command.
@@ -42,56 +31,56 @@ pub struct PresentOptionsEvent {
 /// However, a command is allowed much more freedom in its syntax than one might think, and as such, not all commands are registerable.
 /// Thus, you can listen for this event and handle it yourself if you wish to build your own command syntax for e.g. a DSL.
 /// Handling this event is optional for dialogue views.
-#[derive(Debug, Clone, PartialEq, Message)]
-pub struct ExecuteCommandEvent {
+#[derive(Debug, Clone, PartialEq, EntityEvent)]
+pub struct ExecuteCommand {
     /// The command to execute.
     pub command: UnderlyingYarnCommand,
     /// The [`DialogueRunner`] that is executing this command.
-    pub source: Entity,
+    pub entity: Entity,
 }
 
 /// An event that is fired after a node has been completed, i.e. all of its lines, commands, options, etc. have been exhausted.
 /// Handling this event is **optional** for dialogue views.
-#[derive(Debug, Clone, PartialEq, Message)]
-pub struct NodeCompleteEvent {
+#[derive(Debug, Clone, PartialEq, EntityEvent)]
+pub struct NodeCompleted {
     /// The name of the node that has been completed.
     pub node_name: String,
     /// The [`DialogueRunner`] that has completed this node.
-    pub source: Entity,
+    pub entity: Entity,
 }
 
 /// An event that is fired after a node has been started, i.e. the first line, command, option, etc. has been executed.
 /// Handling this event is **optional** for dialogue views
-#[derive(Debug, Clone, PartialEq, Message)]
-pub struct NodeStartEvent {
+#[derive(Debug, Clone, PartialEq, EntityEvent)]
+pub struct NodeStarted {
     /// The name of the node that has been started.
     pub node_name: String,
     /// The [`DialogueRunner`] that has started this node.
-    pub source: Entity,
+    pub entity: Entity,
 }
 
 /// An event that is fired when a new node has been started. Contains the IDs of all lines in the node as a general hint
 /// for asset providing systems to pre-load the lines. The lines are not guaranteed to be presented in the order of the IDs or at all.
 /// Handling this event is **optional** for dialogue views.
-#[derive(Debug, Clone, PartialEq, Message)]
-pub struct LineHintsEvent {
+#[derive(Debug, Clone, PartialEq, EntityEvent)]
+pub struct LineHints {
     /// The IDs of all lines in the node.
     pub line_ids: Vec<LineId>,
     /// The [`DialogueRunner`] that has started this node.
-    pub source: Entity,
+    pub entity: Entity,
 }
 
 /// An event that is fired when a dialogue has been started via [`DialogueRunner::start_node`]/
 /// Handling this event is **optional** for dialogue views.
-#[derive(Debug, Clone, PartialEq, Message)]
-pub struct DialogueStartEvent {
+#[derive(Debug, Clone, PartialEq, EntityEvent)]
+pub struct DialogueStarted {
     /// The [`DialogueRunner`] that has started this dialogue.
-    pub source: Entity,
+    pub entity: Entity,
 }
 
 /// An event that is fired when a dialogue has been completed or stopped via [`DialogueRunner::stop`].
-#[derive(Debug, Clone, PartialEq, Message)]
-pub struct DialogueCompleteEvent {
+#[derive(Debug, Clone, PartialEq, EntityEvent)]
+pub struct DialogueCompleted {
     /// The [`DialogueRunner`] that has completed this dialogue.
-    pub source: Entity,
+    pub entity: Entity,
 }