bevy_mod_scripting_core 0.18.0

Core traits and structures required for other parts of bevy_mod_scripting
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137

use bevy_mod_scripting_bindings::ScriptValue;

use crate::{
    callbacks::ScriptCallbacks,
    commands::RunScriptCallback,
    event::{IntoCallbackLabel, OnScriptLoaded, OnScriptReloaded, OnScriptUnloaded},
};

use super::*;

const UNLOADED_SCRIPT_STATE_KEY: &str = "state";

pub(crate) struct OnLoadedListener;

impl<P: IntoScriptPluginParams> TransitionListener<ContextAssigned<P>> for OnLoadedListener {
    fn on_enter(
        &self,
        state: &mut ContextAssigned<P>,
        world: &mut World,
        ctxt: &mut Context,
    ) -> Result<(), ScriptError> {
        let world_id = world.id();
        let emit_responses = P::readonly_configuration(world_id).emit_responses;
        let callbacks = world.get_resource_or_init::<ScriptCallbacks<P>>().clone();
        let guard = WorldGuard::new_exclusive(world);
        bevy_log::trace!(
            "Running on_script_loaded hook for script: {}",
            ctxt.attachment
        );
        RunScriptCallback::<P>::new(
            ctxt.attachment.clone(),
            OnScriptLoaded::into_callback_label(),
            vec![],
            emit_responses,
        )
        .run_with_context(guard.clone(), state.context.clone(), callbacks)
        .map(|_| ())
    }
}

pub(crate) struct OnUnloadedForUnloadListener;
impl<P: IntoScriptPluginParams> TransitionListener<UnloadingInitialized<P>>
    for OnUnloadedForUnloadListener
{
    fn on_enter(
        &self,
        state: &mut UnloadingInitialized<P>,
        world: &mut World,
        ctxt: &mut Context,
    ) -> Result<(), ScriptError> {
        let world_id = world.id();
        let emit_responses = P::readonly_configuration(world_id).emit_responses;
        let callbacks = world.get_resource_or_init::<ScriptCallbacks<P>>().clone();
        let guard = WorldGuard::new_exclusive(world);
        bevy_log::trace!(
            "Running on_script_unloaded hook for script: {}",
            ctxt.attachment
        );
        let v = RunScriptCallback::<P>::new(
            ctxt.attachment.clone(),
            OnScriptUnloaded::into_callback_label(),
            vec![],
            emit_responses,
        )
        .run_with_context(guard.clone(), state.existing_context.clone(), callbacks)?;
        ctxt.insert(UNLOADED_SCRIPT_STATE_KEY, v);
        Ok(())
    }
}

pub(crate) struct OnUnloadedForReloadListener;
impl<P: IntoScriptPluginParams> TransitionListener<ReloadingInitialized<P>>
    for OnUnloadedForReloadListener
{
    fn on_enter(
        &self,
        state: &mut ReloadingInitialized<P>,
        world: &mut World,
        ctxt: &mut Context,
    ) -> Result<(), ScriptError> {
        let world_id = world.id();
        let emit_responses = P::readonly_configuration(world_id).emit_responses;
        let callbacks = world.get_resource_or_init::<ScriptCallbacks<P>>().clone();
        let guard = WorldGuard::new_exclusive(world);

        bevy_log::trace!(
            "Running on_script_unloaded for reload hook for script: {}",
            ctxt.attachment
        );

        let v = RunScriptCallback::<P>::new(
            ctxt.attachment.clone(),
            OnScriptUnloaded::into_callback_label(),
            vec![],
            emit_responses,
        )
        .run_with_context(guard.clone(), state.existing_context.clone(), callbacks)?;
        ctxt.insert(UNLOADED_SCRIPT_STATE_KEY, v);
        Ok(())
    }
}

pub(crate) struct OnReloadedListener;
impl<P: IntoScriptPluginParams> TransitionListener<ContextAssigned<P>> for OnReloadedListener {
    fn on_enter(
        &self,
        state: &mut ContextAssigned<P>,
        world: &mut World,
        ctxt: &mut Context,
    ) -> Result<(), ScriptError> {
        let world_id = world.id();
        let emit_responses = P::readonly_configuration(world_id).emit_responses;
        let callbacks = world.get_resource_or_init::<ScriptCallbacks<P>>().clone();
        let guard = WorldGuard::new_exclusive(world);

        if state.is_new_context {
            return Ok(());
        }

        bevy_log::trace!(
            "Running on_script_reloaded hook for script: {}",
            ctxt.attachment
        );

        let unload_state = ctxt.get_first_typed::<ScriptValue>(UNLOADED_SCRIPT_STATE_KEY);
        let unload_state = unload_state.unwrap_or(ScriptValue::Unit);

        RunScriptCallback::<P>::new(
            ctxt.attachment.clone(),
            OnScriptReloaded::into_callback_label(),
            vec![unload_state],
            emit_responses,
        )
        .run_with_context(guard.clone(), state.context.clone(), callbacks)
        .map(|_| ())
    }
}