use super::{InteropError, ScriptComponentRegistration, ScriptEventRegistration, ScriptValue};
use crate::ScriptNamespaceAppExt;
use ::{
bevy_app::{App, Plugin},
bevy_ecs::component::{Component, Mutable, StorageType},
};
use bevy_ecs::{entity::Entity, resource::Resource, world::World};
use bevy_mod_scripting_script::ScriptAttachment;
use bevy_platform::collections::HashMap;
use bevy_reflect::{Reflect, std_traits::ReflectDefault};
use parking_lot::RwLock;
use std::sync::Arc;
#[derive(Reflect, Clone, Default, Debug)]
#[reflect(Default)]
pub struct DynamicComponent {
data: ScriptValue,
}
impl DynamicComponent {
pub fn new(data: ScriptValue) -> Self {
Self { data }
}
pub fn data(&self) -> &ScriptValue {
&self.data
}
}
pub const SCRIPT_NAMESPACE_PREFIX: &str = "script.";
pub fn script_path(namespace: &str, name: &str) -> String {
format!("{namespace}.{name}")
}
pub fn validate_script_namespace_and_name(namespace: &str, name: &str) -> Result<(), InteropError> {
let invalid_segment = |segment: &str| {
segment.is_empty() || !segment.chars().all(|c| c.is_alphanumeric() || c == '_')
};
let Some(rest) = namespace.strip_prefix(SCRIPT_NAMESPACE_PREFIX) else {
return Err(InteropError::string(format!(
"script namespaces must start with `{SCRIPT_NAMESPACE_PREFIX}` (i.e. `{SCRIPT_NAMESPACE_PREFIX}my_game`), got `{namespace}`. \
Other namespaces are the names of crates, which scripts cannot add to."
)));
};
if rest.split('.').any(invalid_segment) {
return Err(InteropError::string(format!(
"invalid script namespace `{namespace}`: after `{SCRIPT_NAMESPACE_PREFIX}` it must be made up of non empty segments \
of letters, digits and underscores separated by dots"
)));
}
if name.is_empty() || name.contains('.') {
return Err(InteropError::string(format!(
"invalid name `{name}` for something registered in `{namespace}`: it cannot be empty or contain dots"
)));
}
Ok(())
}
#[derive(Clone, Debug)]
pub struct ScriptExport {
pub name: String,
pub namespace: String,
pub owner: ScriptAttachment,
pub label: String,
}
impl ScriptExport {
pub fn path(&self) -> String {
script_path(&self.namespace, &self.name)
}
}
#[derive(Component, Clone, Debug)]
pub struct ScriptObserverOwner(pub ScriptAttachment);
pub fn remove_script_registrations(world: &mut World, attachment: &ScriptAttachment) {
if let Some(registry) = world.get_resource::<AppScriptComponentRegistry>() {
let mut registry = registry.write();
registry.remove_exports_of(attachment);
registry.remove_system_sets_of(attachment);
}
let observers = world
.query::<(Entity, &ScriptObserverOwner)>()
.iter(world)
.filter(|(_, owner)| owner.0 == *attachment)
.map(|(entity, _)| entity)
.collect::<Vec<_>>();
for observer in observers {
world.despawn(observer);
}
}
pub struct DynamicComponentInfo {
pub name: String,
pub namespace: String,
pub registration: ScriptComponentRegistration,
}
impl DynamicComponentInfo {
pub fn path(&self) -> String {
script_path(&self.namespace, &self.name)
}
}
impl Component for DynamicComponent {
const STORAGE_TYPE: StorageType = StorageType::Table;
type Mutability = Mutable;
}
#[derive(Clone, Resource, Default)]
pub struct AppScriptComponentRegistry(pub Arc<RwLock<ScriptComponentRegistry>>);
#[profiling::all_functions]
impl AppScriptComponentRegistry {
pub fn read(&self) -> parking_lot::RwLockReadGuard<'_, ScriptComponentRegistry> {
self.0.read()
}
pub fn write(&self) -> parking_lot::RwLockWriteGuard<'_, ScriptComponentRegistry> {
self.0.write()
}
}
#[derive(Default)]
pub struct ScriptComponentRegistry {
components: HashMap<String, DynamicComponentInfo>,
events: HashMap<String, ScriptEventRegistration>,
exports: HashMap<String, ScriptExport>,
system_sets: HashMap<String, ScriptAttachment>,
generation: u64,
}
#[profiling::all_functions]
impl ScriptComponentRegistry {
pub fn register(&mut self, info: DynamicComponentInfo) {
self.components.insert(info.path(), info);
self.generation += 1;
}
pub fn get(&self, path: &str) -> Option<&DynamicComponentInfo> {
self.components.get(path)
}
pub fn find(&self, path: &str) -> Option<&DynamicComponentInfo> {
self.components.get(path)
}
pub fn generation(&self) -> u64 {
self.generation
}
pub fn iter_components(&self) -> impl Iterator<Item = &DynamicComponentInfo> {
self.components.values()
}
pub fn register_event(&mut self, registration: ScriptEventRegistration) {
self.events
.insert(registration.name.to_string(), registration);
}
pub fn get_event(&self, name: &str) -> Option<&ScriptEventRegistration> {
self.events.get(name)
}
pub fn register_export(&mut self, export: ScriptExport) -> Result<(), InteropError> {
let path = export.path();
if let Some(existing) = self.exports.get(&path)
&& existing.owner != export.owner
{
return Err(InteropError::string(format!(
"`{path}` is already exported by script {}, exports have to be unique",
existing.owner
)));
}
if self.components.contains_key(&path)
|| self.events.contains_key(&path)
|| self.system_sets.contains_key(&path)
{
return Err(InteropError::string(format!(
"cannot export `{path}`: a script registered component, event or system set has that path"
)));
}
self.exports.insert(path, export);
Ok(())
}
pub fn remove_exports_of(&mut self, owner: &ScriptAttachment) -> usize {
let before = self.exports.len();
self.exports.retain(|_, export| export.owner != *owner);
before - self.exports.len()
}
pub fn get_export(&self, path: &str) -> Option<&ScriptExport> {
self.exports.get(path)
}
pub fn iter_exports_in<'a>(
&'a self,
namespace: &'a str,
) -> impl Iterator<Item = &'a ScriptExport> {
self.exports
.values()
.filter(move |e| e.namespace == namespace)
}
pub fn iter_events_in<'a>(
&'a self,
namespace: &'a str,
) -> impl Iterator<Item = (&'a str, &'a ScriptEventRegistration)> {
self.events.iter().filter_map(move |(path, event)| {
let (event_namespace, name) = path.rsplit_once('.')?;
(event_namespace == namespace).then_some((name, event))
})
}
pub fn export_and_event_namespaces(&self) -> impl Iterator<Item = &str> {
self.exports.values().map(|e| e.namespace.as_str()).chain(
self.events
.keys()
.chain(self.system_sets.keys())
.filter_map(|p| Some(p.rsplit_once('.')?.0)),
)
}
pub fn register_system_set(&mut self, path: String, owner: ScriptAttachment) {
self.system_sets.insert(path, owner);
}
pub fn get_system_set_owner(&self, path: &str) -> Option<&ScriptAttachment> {
self.system_sets.get(path)
}
pub fn remove_system_sets_of(&mut self, owner: &ScriptAttachment) -> usize {
let before = self.system_sets.len();
self.system_sets.retain(|_, set_owner| set_owner != owner);
before - self.system_sets.len()
}
pub fn iter_system_sets_in<'a>(
&'a self,
namespace: &'a str,
) -> impl Iterator<Item = (&'a str, &'a str)> {
self.system_sets.keys().filter_map(move |path| {
let (set_namespace, name) = path.rsplit_once('.')?;
(set_namespace == namespace).then_some((path.as_str(), name))
})
}
}
pub struct DynamicScriptComponentPlugin;
impl Plugin for DynamicScriptComponentPlugin {
fn build(&self, app: &mut App) {
app.init_resource::<AppScriptComponentRegistry>()
.register_type::<DynamicComponent>()
.override_script_namespace::<DynamicComponent>("bms");
}
}
#[cfg(test)]
mod test {
use bevy_ecs::world::World;
use bevy_mod_scripting_world::{WorldAccessGuard, WorldGuard};
use crate::{CurrentScriptAttachment, WorldExtensions};
use super::*;
#[test]
fn test_script_component() {
let mut world = World::new();
world.init_resource::<AppScriptComponentRegistry>();
let cache = WorldGuard::setup_cache(&world, CurrentScriptAttachment::empty());
let registration = {
let guard = WorldAccessGuard::new_exclusive(&mut world, cache);
guard
.register_script_component("script.test", "ScriptTest", false)
.unwrap()
};
let registry = world.get_resource::<AppScriptComponentRegistry>().unwrap();
let registry = registry.read();
let info = registry.get("script.test.ScriptTest").unwrap();
assert_eq!(info.registration.component_id, registration.component_id);
assert_eq!(info.name, "ScriptTest");
assert_eq!(info.registration.namespace(), "script.test");
let component = world
.components()
.get_info(info.registration.component_id)
.unwrap();
assert_eq!(component.name(), "script.test.ScriptTest".into());
}
}