|
|
|
|
@ -10,7 +10,7 @@ use serde::Deserialize;
|
|
|
|
|
use std::str::Utf8Error;
|
|
|
|
|
use thiserror::Error;
|
|
|
|
|
|
|
|
|
|
/// A Tweakfile is resource used to specify game customization like asset names,
|
|
|
|
|
/// A Tweaks is resource used to specify game customization like asset names,
|
|
|
|
|
/// and non-user customizations made to the game during development.
|
|
|
|
|
pub(crate) struct TweakPlugin;
|
|
|
|
|
|
|
|
|
|
@ -18,156 +18,101 @@ impl Plugin for TweakPlugin {
|
|
|
|
|
fn build(&self, app: &mut App) {
|
|
|
|
|
app.add_systems(OnEnter(GameState::Loading), load_tweakfile);
|
|
|
|
|
|
|
|
|
|
app.init_asset::<Tweakfile>()
|
|
|
|
|
.register_asset_loader(TweakfileLoader);
|
|
|
|
|
app.init_asset::<Tweaks>()
|
|
|
|
|
.register_asset_loader(TweaksLoader);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn load_tweakfile(server: Res<AssetServer>, mut commands: Commands) {
|
|
|
|
|
let handle: Handle<Tweakfile> = server.load("martian.tweak.toml");
|
|
|
|
|
commands.insert_resource(GameTweakfile { handle });
|
|
|
|
|
let handle: Handle<Tweaks> = server.load("martian.tweak.toml");
|
|
|
|
|
commands.insert_resource(GameTweaks { handle });
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Debug, Resource)]
|
|
|
|
|
pub(crate) struct GameTweakfile {
|
|
|
|
|
pub handle: Handle<Tweakfile>,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
/// Tweakfile contains tweaks made to other parts of the game
|
|
|
|
|
#[derive(Debug, Deserialize, TypePath, Asset, Default)]
|
|
|
|
|
pub struct Tweakfile {
|
|
|
|
|
#[serde(default)]
|
|
|
|
|
pub audio: audio::AudioTweaks,
|
|
|
|
|
#[serde(default)]
|
|
|
|
|
pub display3d: display3d::tweaks::Display3dTweaks,
|
|
|
|
|
#[serde(default)]
|
|
|
|
|
pub display2d: display2d::tweaks::Display2dTweaks,
|
|
|
|
|
pub(crate) struct GameTweaks {
|
|
|
|
|
pub handle: Handle<Tweaks>,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Debug, Asset, TypePath)]
|
|
|
|
|
pub struct Tweaks(HashMap<String, TweakValue>);
|
|
|
|
|
pub struct Tweaks {
|
|
|
|
|
table: toml::Table,
|
|
|
|
|
handles: HashMap<String, UntypedHandle>,
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl Tweaks {
|
|
|
|
|
fn from_table(
|
|
|
|
|
table: &toml::Table,
|
|
|
|
|
load_context: &mut LoadContext,
|
|
|
|
|
base: String,
|
|
|
|
|
) -> Vec<(String, TweakValue)> {
|
|
|
|
|
table
|
|
|
|
|
fn from_table(table: &toml::Table, load_context: &mut LoadContext) -> Tweaks {
|
|
|
|
|
let handles = Tweaks::iter_all(table, "")
|
|
|
|
|
.iter()
|
|
|
|
|
.flat_map(|(k, v)| {
|
|
|
|
|
let key = if base.len() > 0 {
|
|
|
|
|
format!("{}_{}", base, k)
|
|
|
|
|
} else {
|
|
|
|
|
k.clone()
|
|
|
|
|
};
|
|
|
|
|
match v {
|
|
|
|
|
toml::Value::Table(t) => Tweaks::from_table(t, load_context, key),
|
|
|
|
|
toml::Value::Datetime(_) => panic!("This type is not supported!"),
|
|
|
|
|
_ => vec![(key, TweakValue::from_toml(v, load_context))],
|
|
|
|
|
}
|
|
|
|
|
.filter_map(|(k, v)| match v {
|
|
|
|
|
toml::Value::String(s) => std::path::Path::new(format!("assets/{}", s).as_str())
|
|
|
|
|
.exists()
|
|
|
|
|
.then(|| (k.clone(), load_context.load_untyped(s).untyped())),
|
|
|
|
|
_ => None,
|
|
|
|
|
})
|
|
|
|
|
.collect()
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn get_handle<T: Asset>(&self, key: &str) -> Option<Handle<T>> {
|
|
|
|
|
self.0.get(key).map(|val| Handle::<T>::from(val.clone()))
|
|
|
|
|
}
|
|
|
|
|
.collect();
|
|
|
|
|
|
|
|
|
|
fn get_int(&self, key: &str) -> Option<i64> {
|
|
|
|
|
self.0.get(key).map(|val| i64::from(val.clone()))
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
fn get_float(&self, key: &str) -> Option<f64> {
|
|
|
|
|
self.0.get(key).map(|val| f64::from(val.clone()))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Debug, Clone)]
|
|
|
|
|
pub enum TweakValue {
|
|
|
|
|
Handle(UntypedHandle),
|
|
|
|
|
Int(i64),
|
|
|
|
|
Float(f64),
|
|
|
|
|
Bool(bool),
|
|
|
|
|
Str(String),
|
|
|
|
|
List(Vec<TweakValue>),
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl TweakValue {
|
|
|
|
|
fn from_toml(val: &toml::Value, load_context: &mut LoadContext) -> TweakValue {
|
|
|
|
|
match val {
|
|
|
|
|
toml::Value::String(s) => {
|
|
|
|
|
if std::path::Path::new(&format!("assets/{}", s)).exists() {
|
|
|
|
|
TweakValue::Handle(load_context.load_untyped(s).untyped())
|
|
|
|
|
} else {
|
|
|
|
|
TweakValue::Str(s.clone())
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
toml::Value::Integer(i) => TweakValue::Int(*i),
|
|
|
|
|
toml::Value::Float(f) => TweakValue::Float(*f),
|
|
|
|
|
toml::Value::Boolean(b) => TweakValue::Bool(*b),
|
|
|
|
|
toml::Value::Array(a) => TweakValue::List(
|
|
|
|
|
a.iter()
|
|
|
|
|
.map(|v| TweakValue::from_toml(v, load_context))
|
|
|
|
|
.collect(),
|
|
|
|
|
),
|
|
|
|
|
toml::Value::Table(_) | toml::Value::Datetime(_) => {
|
|
|
|
|
panic!("This type is not supported!")
|
|
|
|
|
}
|
|
|
|
|
Tweaks {
|
|
|
|
|
table: table.clone(),
|
|
|
|
|
handles,
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl<T: Asset> From<TweakValue> for Handle<T> {
|
|
|
|
|
fn from(src: TweakValue) -> Handle<T> {
|
|
|
|
|
match src {
|
|
|
|
|
TweakValue::Handle(h) => h.clone().typed::<T>(),
|
|
|
|
|
_ => panic!("{:?} is not a handle", src),
|
|
|
|
|
}
|
|
|
|
|
pub fn get_handle<T: Asset>(&self, key: &str) -> Option<Handle<T>> {
|
|
|
|
|
self.handles.get(key).map(|h| h.clone().typed::<T>())
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl From<TweakValue> for String {
|
|
|
|
|
fn from(src: TweakValue) -> String {
|
|
|
|
|
match src {
|
|
|
|
|
TweakValue::Str(s) => s,
|
|
|
|
|
_ => panic!("{:?} is not a bool", src),
|
|
|
|
|
}
|
|
|
|
|
pub fn get_handle_unchecked<T: Asset>(&self, key: &str) -> Option<Handle<T>> {
|
|
|
|
|
self.handles
|
|
|
|
|
.get(key)
|
|
|
|
|
.map(|h| h.clone().typed_unchecked::<T>())
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl From<TweakValue> for i64 {
|
|
|
|
|
fn from(src: TweakValue) -> i64 {
|
|
|
|
|
match src {
|
|
|
|
|
TweakValue::Int(i) => i,
|
|
|
|
|
_ => panic!("{:?} is not an integer", src),
|
|
|
|
|
}
|
|
|
|
|
pub fn get<'de, T: Deserialize<'de>>(&self, key: &str) -> Option<T> {
|
|
|
|
|
Tweaks::locate(&self.table, key)
|
|
|
|
|
.map(|val| val.try_into().ok())
|
|
|
|
|
.flatten()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl From<TweakValue> for f64 {
|
|
|
|
|
fn from(src: TweakValue) -> f64 {
|
|
|
|
|
match src {
|
|
|
|
|
TweakValue::Float(f) => f,
|
|
|
|
|
_ => panic!("{:?} is not a float", src),
|
|
|
|
|
}
|
|
|
|
|
fn iter_all(t: &toml::Table, key: &str) -> Vec<(String, toml::Value)> {
|
|
|
|
|
t.iter()
|
|
|
|
|
.flat_map(|(k, v)| {
|
|
|
|
|
let nk = if key == "" {
|
|
|
|
|
k.to_string()
|
|
|
|
|
} else {
|
|
|
|
|
format!("{}_{}", key, k)
|
|
|
|
|
};
|
|
|
|
|
match v {
|
|
|
|
|
toml::Value::Table(nt) => Tweaks::iter_all(nt, nk.as_str()),
|
|
|
|
|
_ => vec![(nk, v.clone())],
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
.collect()
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl From<TweakValue> for bool {
|
|
|
|
|
fn from(src: TweakValue) -> bool {
|
|
|
|
|
match src {
|
|
|
|
|
TweakValue::Bool(b) => b,
|
|
|
|
|
_ => panic!("{:?} is not a bool", src),
|
|
|
|
|
}
|
|
|
|
|
fn locate(t: &toml::Table, key: &str) -> Option<toml::Value> {
|
|
|
|
|
t.iter().find_map(|(k, v)| {
|
|
|
|
|
if key == k {
|
|
|
|
|
Some(v.clone())
|
|
|
|
|
} else if key.starts_with(k) {
|
|
|
|
|
let prefix = format!("{}_", k);
|
|
|
|
|
match v {
|
|
|
|
|
toml::Value::Table(nt) => {
|
|
|
|
|
Tweaks::locate(nt, key.strip_prefix(prefix.as_str()).unwrap())
|
|
|
|
|
}
|
|
|
|
|
_ => Some(v.clone()),
|
|
|
|
|
}
|
|
|
|
|
} else {
|
|
|
|
|
None
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
#[derive(Default)]
|
|
|
|
|
pub struct TweakfileLoader;
|
|
|
|
|
pub struct TweaksLoader;
|
|
|
|
|
|
|
|
|
|
#[derive(Debug, Error)]
|
|
|
|
|
pub enum TweakfileError {
|
|
|
|
|
pub enum TweaksError {
|
|
|
|
|
#[error("Failed to read file")]
|
|
|
|
|
IO(#[from] std::io::Error),
|
|
|
|
|
#[error("Failed to decode file")]
|
|
|
|
|
@ -176,10 +121,10 @@ pub enum TweakfileError {
|
|
|
|
|
Parse(#[from] toml::de::Error),
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
impl AssetLoader for TweakfileLoader {
|
|
|
|
|
type Asset = Tweakfile;
|
|
|
|
|
impl AssetLoader for TweaksLoader {
|
|
|
|
|
type Asset = Tweaks;
|
|
|
|
|
type Settings = ();
|
|
|
|
|
type Error = TweakfileError;
|
|
|
|
|
type Error = TweaksError;
|
|
|
|
|
|
|
|
|
|
fn load<'a>(
|
|
|
|
|
&'a self,
|
|
|
|
|
@ -191,11 +136,16 @@ impl AssetLoader for TweakfileLoader {
|
|
|
|
|
let mut bytes = Vec::new();
|
|
|
|
|
reader.read_to_end(&mut bytes).await?;
|
|
|
|
|
let s = std::str::from_utf8(bytes.as_slice())?;
|
|
|
|
|
let parsed = toml::from_str::<toml::Table>(s)?;
|
|
|
|
|
let list = Tweaks::from_table(&parsed, load_context, String::new());
|
|
|
|
|
let result: HashMap<String, TweakValue> = list.into_iter().collect();
|
|
|
|
|
// Ok(Tweaks(result))
|
|
|
|
|
Ok(Tweakfile::default())
|
|
|
|
|
match toml::from_str::<toml::Table>(s) {
|
|
|
|
|
Ok(parsed) => {
|
|
|
|
|
let result = Tweaks::from_table(&parsed, load_context);
|
|
|
|
|
Ok(result)
|
|
|
|
|
}
|
|
|
|
|
Err(e) => {
|
|
|
|
|
println!("Error parsing tweaks: {:?}", e.message());
|
|
|
|
|
Err(TweaksError::Parse(e))
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
})
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
Elijah Voigt
2 years ago