it works!

Author: makspll

crates/bevy_mod_scripting_core/src/extractors.rs

@@ -75,20 +75,23 @@ unsafe impl<T: Resource + Default> SystemParam for ResScope<'_, T> {
     type Item<'world, 'state> = ResScope<'state, T>;
 
     fn init_state(
-        world: &mut World,
+        _world: &mut World,
         system_meta: &mut bevy::ecs::system::SystemMeta,
     ) -> Self::State {
         system_meta.set_has_deferred();
-        (world.remove_resource().unwrap_or_default(), false)
+        (T::default(), false)
     }
 
     unsafe fn get_param<'world, 'state>(
         state: &'state mut Self::State,
         _system_meta: &bevy::ecs::system::SystemMeta,
-        _world: bevy::ecs::world::unsafe_world_cell::UnsafeWorldCell<'world>,
+        world: bevy::ecs::world::unsafe_world_cell::UnsafeWorldCell<'world>,
         _change_tick: bevy::ecs::component::Tick,
     ) -> Self::Item<'world, 'state> {
         state.1 = true;
+        if let Some(mut r) = world.get_resource_mut::<T>() {
+            std::mem::swap(&mut state.0, &mut r);
+        }
         ResScope(&mut state.0)
     }
 
@@ -104,7 +107,7 @@ unsafe impl<T: Resource + Default> SystemParam for ResScope<'_, T> {
     }
 }
 
-/// A version of [`EventReader`] which behaves with the same semantics as [`ResScope`].
+/// A version of [`bevy::ecs::event::EventReader`] which behaves just like [`ResScope`].
 #[derive(SystemParam)]
 pub struct EventReaderScope<'s, T: Event> {
     events: ResScope<'s, Events<T>>,
@@ -359,6 +362,7 @@ mod test {
             component::Component,
             event::{Event, EventReader},
             system::{Query, ResMut, Resource},
+            world::FromWorld,
         },
     };
     use test_utils::make_test_plugin;
@@ -448,4 +452,15 @@ mod test {
         // check the resources are re-inserted
         assert!(app.world().contains_resource::<Res>());
     }
+
+    #[test]
+    pub fn rescope_does_not_remove_until_system_call() {
+        let mut world = World::new();
+        world.insert_resource(Res);
+
+        // this will call init, and that should't remove the resource
+        assert!(world.contains_resource::<Res>());
+        SystemState::<ResScope<Res>>::from_world(&mut world);
+        assert!(world.contains_resource::<Res>());
+    }
 }

crates/bevy_mod_scripting_core/src/handler.rs

@@ -19,7 +19,7 @@ use bevy::{
         system::{Local, Resource, SystemState},
         world::{Mut, World},
     },
-    log::trace_once,
+    log::{self, trace_once},
     prelude::{Events, Ref},
 };
 
@@ -108,13 +108,11 @@ macro_rules! push_err_and_continue {
 /// If any of the resources required for the handler are missing, the system will log this issue and do nothing.
 pub fn event_handler<L: IntoCallbackLabel, P: IntoScriptPluginParams>(
     world: &mut World,
-    mut state: Local<
-        SystemState<(
-            Local<QueryState<(Entity, Ref<ScriptComponent>)>>,
-            EventReaderScope<ScriptCallbackEvent>,
-            WithWorldGuard<HandlerContext<P>>,
-        )>,
-    >,
+    state: &mut SystemState<(
+        Local<QueryState<(Entity, Ref<ScriptComponent>)>>,
+        EventReaderScope<ScriptCallbackEvent>,
+        WithWorldGuard<HandlerContext<P>>,
+    )>,
 ) {
     // we wrap the inner event handler, so that we can immediately re-insert all the resources back.
     // otherwise this would happen in the next schedule
@@ -132,6 +130,12 @@ fn event_handler_inner<L: IntoCallbackLabel, P: IntoScriptPluginParams>(
     mut handler_ctxt: WithWorldGuard<HandlerContext<P>>,
 ) {
     let (guard, handler_ctxt) = handler_ctxt.get_mut();
+    // bevy::log::debug!(
+    //     "{}: scripts:{} contexts:{}",
+    //     P::LANGUAGE,
+    //     handler_ctxt.scripts.scripts.len(),
+    //     handler_ctxt.script_contexts.contexts.len()
+    // );
     let mut errors = Vec::default();
 
     let events = script_events.read().cloned().collect::<Vec<_>>();
@@ -183,15 +187,17 @@ fn event_handler_inner<L: IntoCallbackLabel, P: IntoScriptPluginParams>(
                     {
                         continue
                     }
-                    _ => (),
+                    _ => {}
                 }
 
-                match handler_ctxt.call::<L>(
+                let call_result = handler_ctxt.call::<L>(
                     script_id.clone(),
                     *entity,
                     event.args.clone(),
                     guard.clone(),
-                ) {
+                );
+
+                match call_result {
                     Ok(_) => {}
                     Err(e) => {
                         match e.downcast_interop_inner() {
@@ -249,7 +255,12 @@ pub fn handle_script_errors<I: Iterator<Item = ScriptError> + Clone>(world: Worl
 mod test {
     use std::{borrow::Cow, collections::HashMap};
 
-    use bevy::app::{App, Update};
+    use bevy::{
+        app::{App, Update},
+        asset::AssetPlugin,
+        diagnostic::DiagnosticsPlugin,
+        ecs::world::FromWorld,
+    };
     use test_utils::make_test_plugin;
 
     use crate::{
@@ -545,4 +556,33 @@ mod test {
             ]
         );
     }
+
+    #[test]
+    fn event_handler_reinserts_resources() {
+        let mut app = App::new();
+        app.add_plugins((
+            AssetPlugin::default(),
+            DiagnosticsPlugin,
+            TestPlugin::default(),
+        ));
+
+        assert!(app
+            .world()
+            .get_resource::<Events<ScriptCallbackEvent>>()
+            .is_some());
+
+        let mut local = SystemState::from_world(app.world_mut());
+
+        assert!(!app
+            .world()
+            .get_resource::<Events<ScriptCallbackEvent>>()
+            .is_some());
+
+        event_handler::<OnTestCallback, TestPlugin>(app.world_mut(), &mut local);
+
+        assert!(app
+            .world()
+            .get_resource::<Events<ScriptCallbackEvent>>()
+            .is_some());
+    }
 }

examples/game_of_life.rs

@@ -111,7 +111,7 @@ pub enum GameOfLifeCommand {
     /// Stop the game of life by dropping a handle to the game_of_life script
     Stop,
 }
-
+use bevy_mod_scripting_core::ConfigureScriptPlugin;
 // ------------- GAME OF LIFE
 fn game_of_life_app(app: &mut App) -> &mut App {
     app.insert_resource(Time::<Fixed>::from_seconds(UPDATE_FREQUENCY.into()))