use bevy::prelude::*;
use bevy::platform::collections::HashMap;
use serde::de::DeserializeOwned;
use serde_json::Value as JsonValue;
use std::collections::BTreeMap;
use thiserror::Error;
#[derive(Clone, Debug, PartialEq, Reflect, Default)]
pub enum TagValue {
#[default]
Null,
Bool(bool),
Number(f64),
String(String),
List(Vec<TagValue>),
Map(BTreeMap<String, TagValue>),
}
impl TagValue {
pub fn as_bool(&self) -> Option<bool> {
match self {
Self::Bool(b) => Some(*b),
Self::String(s) => match s.trim().to_ascii_lowercase().as_str() {
"true" | "yes" | "1" => Some(true),
"false" | "no" | "0" => Some(false),
_ => None,
},
Self::Number(n) => Some(*n != 0.0),
_ => None,
}
}
pub fn as_f64(&self) -> Option<f64> {
match self {
Self::Number(n) => Some(*n),
Self::String(s) => s.trim().parse().ok(),
Self::Bool(b) => Some(if *b { 1.0 } else { 0.0 }),
_ => None,
}
}
pub fn as_f32(&self) -> Option<f32> {
self.as_f64().map(|n| n as f32)
}
pub fn as_str(&self) -> Option<&str> {
match self {
Self::String(s) => Some(s.as_str()),
_ => None,
}
}
pub fn as_list(&self) -> Option<&[TagValue]> {
match self {
Self::List(v) => Some(v.as_slice()),
_ => None,
}
}
pub fn as_map(&self) -> Option<&BTreeMap<String, TagValue>> {
match self {
Self::Map(m) => Some(m),
_ => None,
}
}
pub fn as_vec3(&self) -> Option<Vec3> {
match self {
Self::List(v) if v.len() == 3 => {
Some(Vec3::new(v[0].as_f32()?, v[1].as_f32()?, v[2].as_f32()?))
}
Self::Map(m) => Some(Vec3::new(
m.get("x")?.as_f32()?,
m.get("y")?.as_f32()?,
m.get("z")?.as_f32()?,
)),
_ => None,
}
}
pub fn is_null(&self) -> bool {
matches!(self, Self::Null)
}
pub fn type_name(&self) -> &'static str {
match self {
Self::Null => "null",
Self::Bool(_) => "bool",
Self::Number(_) => "number",
Self::String(_) => "string",
Self::List(_) => "list",
Self::Map(_) => "map",
}
}
}
#[derive(Clone, Debug, PartialEq, Reflect, Default)]
pub struct TagParams(BTreeMap<String, TagValue>);
impl TagParams {
pub fn new() -> Self {
Self::default()
}
pub fn get(&self, key: &str) -> Option<&TagValue> {
self.0.get(key)
}
pub fn get_bool(&self, key: &str) -> Option<bool> {
self.get(key)?.as_bool()
}
pub fn get_f32(&self, key: &str) -> Option<f32> {
self.get(key)?.as_f32()
}
pub fn get_str(&self, key: &str) -> Option<&str> {
self.get(key)?.as_str()
}
pub fn get_vec3(&self, key: &str) -> Option<Vec3> {
self.get(key)?.as_vec3()
}
pub fn contains(&self, key: &str) -> bool {
self.0.contains_key(key)
}
pub fn iter(&self) -> impl Iterator<Item = (&String, &TagValue)> {
self.0.iter()
}
pub fn len(&self) -> usize {
self.0.len()
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
pub fn insert(&mut self, key: impl Into<String>, value: TagValue) -> Option<TagValue> {
self.0.insert(key.into(), value)
}
pub fn remove(&mut self, key: &str) -> Option<TagValue> {
self.0.remove(key)
}
}
impl From<BTreeMap<String, TagValue>> for TagParams {
fn from(map: BTreeMap<String, TagValue>) -> Self {
Self(map)
}
}
impl FromIterator<(String, TagValue)> for TagParams {
fn from_iter<I: IntoIterator<Item = (String, TagValue)>>(iter: I) -> Self {
Self(iter.into_iter().collect())
}
}
pub fn normalize_key(raw: &str) -> String {
raw.chars()
.filter(|c| c.is_ascii_alphanumeric())
.map(|c| c.to_ascii_lowercase())
.collect()
}
#[derive(Debug, Clone)]
pub struct NormalizedMap<V>(HashMap<String, V>);
impl<V> Default for NormalizedMap<V> {
fn default() -> Self {
Self(HashMap::default())
}
}
impl<V> NormalizedMap<V> {
pub fn insert(&mut self, key: &str, value: V) -> Option<V> {
self.0.insert(normalize_key(key), value)
}
pub fn get(&self, key: &str) -> Option<&V> {
self.0.get(&normalize_key(key))
}
pub fn contains(&self, key: &str) -> bool {
self.0.contains_key(&normalize_key(key))
}
pub fn iter(&self) -> impl Iterator<Item = (&String, &V)> {
self.0.iter()
}
pub fn is_empty(&self) -> bool {
self.0.is_empty()
}
}
#[derive(Debug, Error)]
#[error("could not read tag parameters as `{type_name}`: {message}")]
pub struct TagDeserializeError {
pub type_name: &'static str,
pub message: String,
}
impl TagValue {
pub fn to_json(&self) -> JsonValue {
match self {
Self::Null => JsonValue::Null,
Self::Bool(b) => JsonValue::Bool(*b),
Self::Number(n) => serde_json::Number::from_f64(*n)
.map(JsonValue::Number)
.unwrap_or(JsonValue::Null),
Self::String(s) => JsonValue::String(s.clone()),
Self::List(v) => JsonValue::Array(v.iter().map(TagValue::to_json).collect()),
Self::Map(m) => {
JsonValue::Object(m.iter().map(|(k, v)| (k.clone(), v.to_json())).collect())
}
}
}
}
impl TagParams {
pub fn to_json(&self) -> JsonValue {
JsonValue::Object(self.0.iter().map(|(k, v)| (k.clone(), v.to_json())).collect())
}
pub fn deserialize<T: DeserializeOwned>(&self) -> Result<T, TagDeserializeError> {
serde_json::from_value(self.to_json()).map_err(|e| TagDeserializeError {
type_name: std::any::type_name::<T>(),
message: e.to_string(),
})
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn bool_accepts_the_spellings_dccs_actually_export() {
assert_eq!(TagValue::Bool(true).as_bool(), Some(true));
assert_eq!(TagValue::String("True".into()).as_bool(), Some(true));
assert_eq!(TagValue::String(" no ".into()).as_bool(), Some(false));
assert_eq!(TagValue::Number(1.0).as_bool(), Some(true));
assert_eq!(TagValue::String("maybe".into()).as_bool(), None);
}
#[test]
fn numbers_parse_from_strings_but_strings_do_not_come_from_numbers() {
assert_eq!(TagValue::String("2.5".into()).as_f32(), Some(2.5));
assert_eq!(TagValue::Number(2.5).as_str(), None);
}
#[test]
fn vec3_accepts_both_array_and_object_forms() {
let list = TagValue::List(vec![
TagValue::Number(1.0),
TagValue::Number(2.0),
TagValue::Number(3.0),
]);
assert_eq!(list.as_vec3(), Some(Vec3::new(1.0, 2.0, 3.0)));
let map = TagValue::Map(BTreeMap::from([
("x".to_string(), TagValue::Number(1.0)),
("y".to_string(), TagValue::Number(2.0)),
("z".to_string(), TagValue::Number(3.0)),
]));
assert_eq!(map.as_vec3(), Some(Vec3::new(1.0, 2.0, 3.0)));
let too_short = TagValue::List(vec![TagValue::Number(1.0)]);
assert_eq!(too_short.as_vec3(), None);
}
#[test]
fn normalization_collapses_dcc_and_rust_naming_conventions() {
for spelling in ["SpawnPoint", "spawn_point", "spawn-point", "Spawn Point"] {
assert_eq!(normalize_key(spelling), "spawnpoint", "{spelling}");
}
assert_ne!(normalize_key("spawn_point"), normalize_key("spawn_points"));
}
#[test]
fn params_deserialize_into_a_concrete_type() {
#[derive(serde::Deserialize, Debug, PartialEq)]
struct Spawn {
team: String,
#[serde(default)]
weight: f32,
}
let params = TagParams::from_iter([
("team".to_string(), TagValue::String("red".into())),
("weight".to_string(), TagValue::Number(2.5)),
]);
assert_eq!(
params.deserialize::<Spawn>().unwrap(),
Spawn { team: "red".into(), weight: 2.5 }
);
let sparse = TagParams::from_iter([("team".to_string(), TagValue::String("blue".into()))]);
assert_eq!(sparse.deserialize::<Spawn>().unwrap().weight, 0.0);
let wrong = TagParams::from_iter([("team".to_string(), TagValue::Number(1.0))]);
let err = wrong.deserialize::<Spawn>().unwrap_err();
assert!(err.type_name.contains("Spawn"), "{err}");
}
}