use std::sync::{Arc, RwLock};
use bevy::ecs::world::EntityWorldMut;
use bevy::platform::collections::HashSet;
use bevy::prelude::*;
use serde::de::DeserializeOwned;
use super::component::{StageTag, StageTags, TagSource};
use super::value::{normalize_key, NormalizedMap};
type Inserter = Arc<dyn Fn(&mut EntityWorldMut, &StageTag) + Send + Sync>;
#[derive(Clone)]
pub struct RegisteredTag {
pub key: String,
insert: Option<Inserter>,
}
impl RegisteredTag {
pub fn apply(&self, entity: &mut EntityWorldMut, tag: &StageTag) {
if let Some(insert) = &self.insert {
insert(entity, tag);
}
}
}
pub type KnownTagNames = Arc<RwLock<HashSet<String>>>;
#[derive(Resource, Default)]
pub struct StageTagRegistry {
entries: NormalizedMap<RegisteredTag>,
known_names: KnownTagNames,
}
impl StageTagRegistry {
pub fn register<T>(&mut self, key: &str)
where
T: Component + DeserializeOwned,
{
let key_owned = key.to_string();
let type_name = std::any::type_name::<T>();
let insert: Inserter = Arc::new(move |entity: &mut EntityWorldMut, tag: &StageTag| {
match tag.params.deserialize::<T>() {
Ok(component) => {
entity.insert(component);
}
Err(error) => {
warn!(
"bevy_stage: tag `{}` on entity {} could not build `{}`: {}",
tag.key,
entity.id(),
type_name,
error,
);
}
}
});
self.entries.insert(
key,
RegisteredTag {
key: key_owned,
insert: Some(insert),
},
);
self.publish(key);
}
pub fn register_marker(&mut self, key: &str) {
self.entries.insert(
key,
RegisteredTag {
key: key.to_string(),
insert: None,
},
);
self.publish(key);
}
fn publish(&self, key: &str) {
if let Ok(mut names) = self.known_names.write() {
names.insert(normalize_key(key));
}
}
pub fn known_names(&self) -> KnownTagNames {
self.known_names.clone()
}
pub fn get(&self, key: &str) -> Option<&RegisteredTag> {
self.entries.get(key)
}
pub fn contains(&self, key: &str) -> bool {
self.entries.contains(key)
}
pub fn is_empty(&self) -> bool {
self.entries.is_empty()
}
}
#[derive(Debug, Default, PartialEq)]
pub struct ResolvedTags {
pub tags: Vec<StageTag>,
pub unknown: Vec<String>,
}
pub fn resolve_tags(tags: &StageTags, registry: &StageTagRegistry) -> ResolvedTags {
let mut resolved: Vec<StageTag> = Vec::new();
let mut seen: HashSet<String> = HashSet::new();
let mut unknown = Vec::new();
for tag in &tags.tags {
let Some(entry) = registry.get(&tag.key) else {
unknown.push(tag.key.clone());
continue;
};
if seen.insert(normalize_key(&tag.key)) {
resolved.push(StageTag {
key: entry.key.clone(),
params: tag.params.clone(),
source: TagSource::Extras,
});
}
}
if let Some(entry) = registry.get(&tags.base_name)
&& seen.insert(normalize_key(&tags.base_name))
{
resolved.push(StageTag {
key: entry.key.clone(),
params: tags.name_params.clone(),
source: TagSource::Name,
});
}
ResolvedTags {
tags: resolved,
unknown,
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::tag::value::{TagParams, TagValue};
#[derive(Component, serde::Deserialize, Default)]
struct SpawnPoint {
#[serde(default)]
#[allow(dead_code)]
team: String,
}
fn registry() -> StageTagRegistry {
let mut registry = StageTagRegistry::default();
registry.register::<SpawnPoint>("spawn_point");
registry
}
#[test]
fn a_node_named_like_a_tag_resolves_with_no_extras_at_all() {
let tags = StageTags {
base_name: "SpawnPoint".into(),
..Default::default()
};
let resolved = resolve_tags(&tags, ®istry());
assert_eq!(resolved.tags.len(), 1);
assert_eq!(resolved.tags[0].key, "spawn_point");
assert_eq!(resolved.tags[0].source, TagSource::Name);
}
#[test]
fn the_explicit_channel_outranks_the_name() {
let tags = StageTags {
base_name: "SpawnPoint".into(),
name_params: TagParams::from_iter([(
"team".to_string(),
TagValue::String("from_name".into()),
)]),
tags: vec![StageTag {
key: "spawn_point".into(),
params: TagParams::from_iter([(
"team".to_string(),
TagValue::String("from_extras".into()),
)]),
source: TagSource::Extras,
}],
..Default::default()
};
let resolved = resolve_tags(&tags, ®istry());
assert_eq!(resolved.tags.len(), 1, "the tag must not be applied twice");
assert_eq!(resolved.tags[0].source, TagSource::Extras);
assert_eq!(resolved.tags[0].params.get_str("team"), Some("from_extras"));
}
#[test]
fn resolution_canonicalizes_to_the_registered_spelling() {
let tags = StageTags {
base_name: "spawn-point".into(),
..Default::default()
};
let resolved = resolve_tags(&tags, ®istry());
assert_eq!(resolved.tags[0].key, "spawn_point");
}
#[test]
fn a_misspelled_tag_is_reported_rather_than_dropped() {
let tags = StageTags {
tags: vec![StageTag::new("spwan_point", TagSource::Extras)],
..Default::default()
};
let resolved = resolve_tags(&tags, ®istry());
assert!(resolved.tags.is_empty());
assert_eq!(resolved.unknown, vec!["spwan_point".to_string()]);
}
#[test]
fn an_ordinary_node_name_is_not_an_unknown_tag() {
let tags = StageTags {
base_name: "Ground".into(),
..Default::default()
};
let resolved = resolve_tags(&tags, ®istry());
assert!(resolved.tags.is_empty());
assert!(
resolved.unknown.is_empty(),
"most nodes are just geometry and must not generate warnings"
);
}
#[test]
fn one_node_can_resolve_several_distinct_tags() {
let mut registry = registry();
registry.register_marker("anchor");
let tags = StageTags {
tags: vec![
StageTag::new("anchor", TagSource::Extras),
StageTag::new("spawn_point", TagSource::Extras),
],
..Default::default()
};
let resolved = resolve_tags(&tags, ®istry);
assert_eq!(resolved.tags.len(), 2);
}
}