use bevy::prelude::*;
use crate::generator::asteroid::{AsteroidConfig, AsteroidGenerator};
use crate::skybox::{SkyboxConfig, SkyboxMode, StarfieldConfig};
use crate::world::ChunkManager;
#[cfg(feature = "crafting")]
use crate::world::manifest::WorldManifest;
#[derive(Debug, Clone, serde::Deserialize)]
pub struct AsteroidConfigToml {
pub seed: u64,
pub count: u32,
pub min_radius: f32,
pub max_radius: f32,
}
impl Default for AsteroidConfigToml {
fn default() -> Self {
Self {
seed: 42,
count: 20,
min_radius: 15.0,
max_radius: 40.0,
}
}
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct SkyboxConfigToml {
pub mode: String,
pub star_count: u32,
pub star_radius: f32,
pub background_color: Option<[f32; 4]>,
}
impl Default for SkyboxConfigToml {
fn default() -> Self {
Self {
mode: "starfield".to_string(),
star_count: 800,
star_radius: 900.0,
background_color: None,
}
}
}
#[derive(Debug, Clone, serde::Deserialize)]
pub struct LightingConfig {
pub sun_illuminance: f32,
pub ambient_brightness: f32,
}
impl Default for LightingConfig {
fn default() -> Self {
Self {
sun_illuminance: 15000.0,
ambient_brightness: 0.1,
}
}
}
fn default_world_name() -> String {
"world".to_string()
}
fn default_example() -> String {
"basic_world".to_string()
}
fn default_seed() -> u64 {
42
}
fn default_load_distance() -> f32 {
150.0
}
fn default_unload_distance() -> f32 {
200.0
}
#[derive(Resource, Debug, Clone, serde::Deserialize)]
pub struct WorldConfig {
#[serde(default = "default_example")]
pub example: String,
#[serde(default = "default_world_name")]
pub world_name: String,
#[serde(default = "default_seed")]
pub seed: u64,
#[serde(default)]
pub spawn_position: [f32; 3],
#[serde(default = "default_load_distance")]
pub load_distance: f32,
#[serde(default = "default_unload_distance")]
pub unload_distance: f32,
#[serde(default)]
pub asteroids: AsteroidConfigToml,
#[serde(default)]
pub lighting: LightingConfig,
#[serde(default)]
pub skybox: SkyboxConfigToml,
}
impl Default for WorldConfig {
fn default() -> Self {
Self {
example: "basic_world".to_string(),
world_name: "world".to_string(),
seed: 42,
spawn_position: [0.0, 0.0, 0.0],
load_distance: 150.0,
unload_distance: 200.0,
asteroids: AsteroidConfigToml::default(),
lighting: LightingConfig::default(),
skybox: SkyboxConfigToml::default(),
}
}
}
impl WorldConfig {
pub fn build_asteroid_generator(&self) -> AsteroidGenerator {
AsteroidGenerator::new(AsteroidConfig {
seed: self.asteroids.seed as u32,
asteroid_count: self.asteroids.count as usize,
min_radius: self.asteroids.min_radius,
max_radius: self.asteroids.max_radius,
..AsteroidConfig::default()
})
}
pub fn build_skybox_config(&self) -> SkyboxConfig {
let mode = match self.skybox.mode.as_str() {
"color" => {
let [r, g, b, a] = self.skybox.background_color.unwrap_or([0.0, 0.0, 0.0, 1.0]);
SkyboxMode::Color(Color::srgba(r, g, b, a))
}
_ => SkyboxMode::Starfield(StarfieldConfig {
count: self.skybox.star_count,
radius: self.skybox.star_radius,
..StarfieldConfig::default()
}),
};
SkyboxConfig { mode }
}
pub fn world_data_dir(&self) -> String {
format!("./worlds/{}", self.world_name)
}
pub fn from_file(path: &str) -> Result<Self, Box<dyn std::error::Error>> {
let content = std::fs::read_to_string(path)?;
Self::from_toml_str(&content)
}
pub fn from_toml_str(s: &str) -> Result<Self, Box<dyn std::error::Error>> {
let config: Self = toml::from_str(s)?;
Ok(config)
}
#[cfg(feature = "crafting")]
pub fn from_world_dir(world_name: &str) -> Self {
let world_dir = std::path::Path::new("worlds").join(world_name);
match WorldManifest::read(&world_dir) {
Ok(manifest) => Self {
world_name: manifest.world_name,
seed: manifest.seed,
spawn_position: manifest.spawn_position,
load_distance: manifest.load_distance,
unload_distance: manifest.unload_distance,
..Self::default()
},
Err(e) => {
eprintln!(
"voxel-framework: could not read worlds/{}/world.json ({e}), using defaults",
world_name
);
Self {
world_name: world_name.to_string(),
..Self::default()
}
}
}
}
}
fn load_world_config(
mut commands: Commands,
mut chunk_manager: ResMut<ChunkManager>,
existing: Option<Res<WorldConfig>>,
) {
if let Some(config) = existing {
chunk_manager.load_distance = config.load_distance;
chunk_manager.unload_distance = config.unload_distance;
return;
}
let config = WorldConfig::from_file("world.toml")
.inspect_err(|e| {
eprintln!(
"voxel-framework: world.toml not found or invalid ({e}), using default WorldConfig"
);
})
.unwrap_or_default();
chunk_manager.load_distance = config.load_distance;
chunk_manager.unload_distance = config.unload_distance;
commands.insert_resource(config);
}
pub struct WorldConfigPlugin;
impl Plugin for WorldConfigPlugin {
fn build(&self, app: &mut App) {
app.add_systems(Startup, load_world_config);
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn test_default_config_values() {
let config = WorldConfig::default();
assert_eq!(config.seed, 42);
assert_eq!(config.spawn_position, [0.0, 0.0, 0.0]);
assert_eq!(config.load_distance, 150.0);
assert_eq!(config.unload_distance, 200.0);
assert_eq!(config.asteroids.seed, 42);
assert_eq!(config.asteroids.count, 20);
assert_eq!(config.asteroids.min_radius, 15.0);
assert_eq!(config.asteroids.max_radius, 40.0);
assert_eq!(config.lighting.sun_illuminance, 15000.0);
assert_eq!(config.lighting.ambient_brightness, 0.1);
}
#[test]
fn test_from_str_parses_correctly() {
let toml = r#"
seed = 99
spawn_position = [1.0, 2.0, 3.0]
load_distance = 120.0
unload_distance = 180.0
[asteroids]
seed = 7
count = 5
min_radius = 10.0
max_radius = 50.0
[lighting]
sun_illuminance = 20000.0
ambient_brightness = 0.2
[skybox]
mode = "starfield"
star_count = 800
star_radius = 900.0
"#;
let config = WorldConfig::from_toml_str(toml).expect("TOML should parse without error");
assert_eq!(config.seed, 99);
assert_eq!(config.spawn_position, [1.0, 2.0, 3.0]);
assert_eq!(config.load_distance, 120.0);
assert_eq!(config.unload_distance, 180.0);
assert_eq!(config.asteroids.seed, 7);
assert_eq!(config.asteroids.count, 5);
assert_eq!(config.asteroids.min_radius, 10.0);
assert_eq!(config.asteroids.max_radius, 50.0);
assert_eq!(config.lighting.sun_illuminance, 20000.0);
assert_eq!(config.lighting.ambient_brightness, 0.2);
}
}