1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131

//! Defines the `BiomeData` resource.
use bevy::prelude::*;
use bevy::reflect::Reflect;
use rand::{seq::SliceRandom, SeedableRng};
use std::hash::Hash;

use crate::{
    enums::biome::{Altitude, Biome, Humidity, Latitude},
    noise::OBJECT_POOL,
};

/// The biome system is a list of 1 - 10 "biomes" that are then used to determine the actual
/// biome of the world. This is then used to determine the type of terrain and the type of
/// objects that are placed in the world. This is then used to determine the actual biome
/// of the world.
#[derive(Debug, Clone, Resource, Reflect, Default, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
#[allow(clippy::module_name_repetitions)]
pub struct BiomeData {
    /// The actual biome of the world.
    pub biome: Biome,
    /// The altitude (and temperature) of the biome.
    pub altitude: Altitude,
    /// The humidity of the biome.
    pub humidity: Humidity,
    /// The latitudinal band of the biome.
    pub latitude: Latitude,
    /// Details about the ground tileset for the biome
    pub ground_tilesets: Vec<TilesetDetail>,
    /// Details about the various "single-tile" objects that can be placed in the biome.
    pub simple_objects: Vec<SimpleObjectDetail>,
}

impl BiomeData {
    /// Creates a new barren biome
    #[must_use]
    pub const fn barren() -> Self {
        Self {
            biome: Biome::Barren,
            altitude: Altitude::Montane,
            humidity: Humidity::Arid,
            latitude: Latitude::WarmTemperate,
            ground_tilesets: Vec::new(),
            simple_objects: Vec::new(),
        }
    }
    /// Return a random tile from the ground tilesets.
    pub fn random_ground_tile(&self) -> Option<(&str, usize)> {
        let mut rng = rand::thread_rng();
        if self.ground_tilesets.is_empty() {
            tracing::error!("random_ground_tile: no ground tilesets!");
            return None;
        }

        let Some(tileset) = self.ground_tilesets.choose(&mut rng) else {
            tracing::error!("random_ground_tile: unable to get random tilset!");
            return None;
        };

        let Ok(tile) = tileset
            .weights
            .choose_weighted(&mut rng, |item| item.weight)
        else {
            tracing::error!("random_ground_tile: unable to get random tile!");
            return None;
        };
        Some((tileset.id.as_str(), tile.tile))
    }

    /// Flat map of objects against the `OJECT_POOL` for the biome.
    #[must_use]
    pub fn object_pool(&self, seed: u64) -> Vec<Option<&str>> {
        let mut pool = Vec::with_capacity(OBJECT_POOL);

        for object in &self.simple_objects {
            for _ in 0..object.weight {
                pool.push(Some(object.id.as_str()));
            }
        }

        while pool.len() < OBJECT_POOL {
            pool.push(None);
        }

        // Shuffle the pool so that the objects are placed randomly. Seeded.
        let mut rng = rand::rngs::SmallRng::seed_from_u64(seed);
        pool.shuffle(&mut rng);

        pool
    }
}

/// Details about the tileset for the realm.
#[derive(Debug, Clone, Resource, Reflect, Default, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TilesetDetail {
    /// The unique identifier for the tileset.
    pub id: String,
    /// Weight details for the individual tiles in the tileset.
    pub weights: Vec<TilesetWeight>,
}

/// The weight details for the individual tiles in the tileset.
#[derive(Debug, Clone, Resource, Reflect, Default, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct TilesetWeight {
    /// The tile index
    pub tile: usize,
    /// The weight of the tile
    pub weight: f32,
}

impl Hash for BiomeData {
    fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
        self.biome.hash(state);
        self.altitude.hash(state);
        self.humidity.hash(state);
        self.latitude.hash(state);
    }
}

/// Details about the various "simple" objects that can be placed in the biome.
#[derive(Debug, Clone, Resource, Reflect, Default, serde::Serialize, serde::Deserialize)]
#[serde(rename_all = "camelCase")]
pub struct SimpleObjectDetail {
    /// The unique identifier for the object.
    pub id: String,
    /// The "objective" weight for the object. This is some value that is weighted against
    /// a total of [`crate::noise::OBJECT_POOL`] to be spawned in the world.
    pub weight: usize,
}