feat: add deposit spawns with perlin noise (#67)

Author: ssouthcity

Cargo.lock

@@ -9,6 +9,7 @@ bevy-inspector-egui = "0.35.0"
 bevy_aseprite_ultra = "0.7.0"
 bevy_ecs_tilemap = { version = "0.17.0" }
 humantime-serde = "1.1.1"
+noise = "0.9.0"
 rand = "0.9.2"
 serde = { version = "1.0.228", features = ["derive"] }
 thiserror = "2.0.17"

Cargo.toml

@@ -1,4 +1,4 @@
 id = "fauna_a"
 name = "Fauna A Deposit"
 recipe_id = "fauna_a"
-quantity = 10
+seed = 463724

assets/manifests/deposits/fauna_a.deposit.toml

@@ -1,4 +1,4 @@
 id = "flora_a"
 name = "Flora A Deposit"
 recipe_id = "flora_a"
-quantity = 10
+seed = 821954

assets/manifests/deposits/flora_a.deposit.toml

@@ -1,44 +1,47 @@
 use bevy::prelude::*;
 
-const CAMERA_DRAG_SMOOTHING: f32 = 1.0;
+const CAMERA_DRAG_SCALING: f32 = 1.0;
 
-const CAMERA_ZOOM_INTERVAL: f32 = 0.1;
+const CAMERA_ZOOM_SCALING: f32 = 0.1;
 const CAMERA_ZOOM_MIN: f32 = 0.25;
-const CAMERA_ZOOM_MAX: f32 = 2.0;
+const CAMERA_ZOOM_MAX: f32 = 4.0;
 
 pub fn plugin(app: &mut App) {
     app.add_systems(Startup, setup_camera);
-    app.add_systems(Update, (move_camera, zoom_camera));
+    app.add_observer(move_camera);
+    app.add_observer(zoom_camera);
 }
 
 fn setup_camera(mut commands: Commands) {
     commands.spawn((Camera2d, Msaa::Off));
 }
 
 fn move_camera(
-    mut pointer_drags: MessageReader<Pointer<Drag>>,
-    mut camera_position: Single<&mut Transform, With<Camera>>,
+    pointer_drag: On<Pointer<Drag>>,
+    mut camera: Single<(&mut Transform, &Projection), With<Camera>>,
 ) {
-    for pointer_drag in pointer_drags.read() {
-        if pointer_drag.button != PointerButton::Secondary {
-            return;
-        }
-
-        camera_position.translation +=
-            pointer_drag.delta.extend(0.0) * Vec3::new(-1.0, 1.0, 1.0) * CAMERA_DRAG_SMOOTHING;
+    if pointer_drag.button != PointerButton::Secondary {
+        return;
     }
+
+    let Projection::Orthographic(ortho) = camera.1 else {
+        return;
+    };
+
+    camera.0.translation += pointer_drag.delta.extend(0.0)
+        * ortho.scale
+        * Vec3::new(-1.0, 1.0, 1.0)
+        * CAMERA_DRAG_SCALING;
 }
 
 fn zoom_camera(
-    mut pointer_scrolls: MessageReader<Pointer<Scroll>>,
-    projection: Single<&mut Projection, With<Camera>>,
+    pointer_scroll: On<Pointer<Scroll>>,
+    mut projection: Single<&mut Projection, With<Camera>>,
 ) {
-    let Projection::Orthographic(ref mut ortho) = *projection.into_inner() else {
+    let Projection::Orthographic(ref mut ortho) = **projection else {
         return;
     };
 
-    for pointer_scroll in pointer_scrolls.read() {
-        ortho.scale *= 1.0 - (pointer_scroll.y * CAMERA_ZOOM_INTERVAL);
-        ortho.scale = ortho.scale.clamp(CAMERA_ZOOM_MIN, CAMERA_ZOOM_MAX);
-    }
+    ortho.scale *= 1.0 - (pointer_scroll.y * CAMERA_ZOOM_SCALING);
+    ortho.scale = ortho.scale.clamp(CAMERA_ZOOM_MIN, CAMERA_ZOOM_MAX);
 }

src/camera.rs

@@ -15,11 +15,10 @@ pub struct ZIndexSprite(pub u32);
 
 fn sort_sprites(query: Query<(&mut Transform, &ZIndexSprite, Option<&YSortSprite>)>) {
     for (mut transform, z_index, y_sort) in query {
-        let mut z_coordinate = z_index.0 as f32;
+        let mut z_coordinate = z_index.0 as f32 * 10.0;
 
         if y_sort.is_some() {
-            let atan_mapping = 1.0 - transform.translation.y.atan() / std::f32::consts::PI + 0.5;
-            z_coordinate += atan_mapping;
+            z_coordinate -= transform.translation.y * 0.001;
         }
 
         transform.translation.z = z_coordinate;

src/gameplay/sprite_sort.rs

@@ -1,37 +1,42 @@
+use std::collections::HashMap;
+
 use bevy::{asset::LoadedFolder, prelude::*, sprite::Anchor};
-use rand::Rng;
+use noise::{Fbm, MultiFractal, NoiseFn, Perlin};
 use serde::Deserialize;
 
 use crate::{
     assets::{loaders::toml::TomlAssetPlugin, tracking::LoadResource},
     gameplay::{
         sprite_sort::{YSortSprite, ZIndexSprite},
         world::{
-            WorldSpawnSystems,
             construction::Constructions,
-            tilemap::{CHUNK_SIZE, TILE_SIZE, coord::Coord},
+            tilemap::{
+                CHUNK_SIZE, TILE_SIZE,
+                chunk::{Chunk, ChunkLoaded, ChunkUnloaded},
+                coord::Coord,
+            },
         },
     },
     screens::Screen,
 };
 
 pub fn plugin(app: &mut App) {
     app.add_plugins(TomlAssetPlugin::<DepositDef>::extensions(&["deposit.toml"]));
-
     app.load_resource::<DepositAssets>();
 
-    app.add_systems(
-        OnEnter(Screen::Gameplay),
-        spawn_deposits.in_set(WorldSpawnSystems::SpawnDeposits),
-    );
+    app.init_resource::<DepositNoise>();
+    app.add_systems(OnEnter(Screen::Gameplay), create_noise);
+
+    app.add_observer(spawn_deposits);
+    app.add_observer(unload_deposits);
 }
 
 #[derive(Asset, Deserialize, Reflect)]
 pub struct DepositDef {
     pub id: String,
     pub name: String,
     pub recipe_id: String,
-    pub quantity: u32,
+    pub seed: u32,
 }
 
 #[derive(Asset, Resource, Reflect, Clone)]
@@ -56,38 +61,100 @@ impl FromWorld for DepositAssets {
 #[reflect(Component)]
 pub struct DepositRecipe(pub String);
 
+#[derive(Resource, Debug, Default)]
+pub struct DepositNoise {
+    pub noises: HashMap<AssetId<DepositDef>, Fbm<Perlin>>,
+}
+
+fn create_noise(
+    mut deposit_noise: ResMut<DepositNoise>,
+    deposit_definitions: Res<Assets<DepositDef>>,
+) {
+    for (deposit_id, deposit_def) in deposit_definitions.iter() {
+        let fbm = Fbm::<Perlin>::new(deposit_def.seed)
+            .set_octaves(5)
+            .set_frequency(1.0 / 70.0)
+            .set_lacunarity(2.5)
+            .set_persistence(0.45);
+
+        deposit_noise.noises.insert(deposit_id, fbm);
+    }
+}
+
 fn spawn_deposits(
+    chunk_loaded: On<ChunkLoaded>,
+    chunk_query: Query<&Chunk>,
     mut commands: Commands,
     deposit_definitions: Res<Assets<DepositDef>>,
     asset_server: Res<AssetServer>,
+    deposit_noise: Res<DepositNoise>,
+    mut constructions: ResMut<Constructions>,
+) {
+    let chunk = chunk_query.get(chunk_loaded.chunk).unwrap();
+
+    let absolute_chunk_position = chunk.0 * CHUNK_SIZE.as_ivec2();
+
+    for (deposit_id, deposit_def) in deposit_definitions.iter() {
+        let Some(fbm) = deposit_noise.noises.get(&deposit_id) else {
+            return;
+        };
+
+        for x in 0..CHUNK_SIZE.x {
+            for y in 0..CHUNK_SIZE.y {
+                let absolute_tile_pos = absolute_chunk_position + ivec2(x as i32, y as i32);
+                if constructions.contains_key(&absolute_tile_pos) {
+                    continue;
+                }
+
+                let value = fbm.get(absolute_tile_pos.as_dvec2().into());
+                let normalized_value = (value + 1.0) / 2.0;
+                if normalized_value < 0.75 {
+                    continue;
+                }
+
+                let entity = commands
+                    .spawn((
+                        Name::new(deposit_def.name.clone()),
+                        Coord(absolute_tile_pos),
+                        Anchor(Vec2::new(0.0, -0.25)),
+                        YSortSprite,
+                        ZIndexSprite(10),
+                        Sprite {
+                            image: asset_server
+                                .load(format!("sprites/deposits/{}.png", deposit_def.id)),
+                            custom_size: Vec2::new(TILE_SIZE.x, TILE_SIZE.y).into(),
+                            ..default()
+                        },
+                        DepositRecipe(deposit_def.recipe_id.clone()),
+                    ))
+                    .id();
+
+                constructions.insert(absolute_tile_pos, entity);
+            }
+        }
+    }
+}
+
+fn unload_deposits(
+    chunk_unloaded: On<ChunkUnloaded>,
+    chunk_query: Query<&Chunk>,
     mut constructions: ResMut<Constructions>,
+    mut commands: Commands,
 ) {
-    let mut rng = rand::rng();
-
-    for (_, deposit) in deposit_definitions.iter() {
-        for _ in 0..deposit.quantity {
-            let pos = IVec2::new(
-                rng.random_range(-(CHUNK_SIZE.x as i32)..CHUNK_SIZE.x as i32),
-                rng.random_range(-(CHUNK_SIZE.y as i32)..CHUNK_SIZE.y as i32),
-            );
-
-            let entity = commands
-                .spawn((
-                    Name::new(deposit.name.clone()),
-                    Coord(pos),
-                    Anchor(Vec2::new(0.0, -0.25)),
-                    YSortSprite,
-                    ZIndexSprite(10),
-                    Sprite {
-                        image: asset_server.load(format!("sprites/deposits/{}.png", deposit.id)),
-                        custom_size: Vec2::new(TILE_SIZE.x, TILE_SIZE.y).into(),
-                        ..default()
-                    },
-                    DepositRecipe(deposit.recipe_id.clone()),
-                ))
-                .id();
-
-            constructions.insert(pos, entity);
+    let chunk = chunk_query.get(chunk_unloaded.chunk).unwrap();
+
+    let absolute_chunk_position = chunk.0 * CHUNK_SIZE.as_ivec2();
+
+    for x in 0..CHUNK_SIZE.x {
+        for y in 0..CHUNK_SIZE.y {
+            let absolute_tile_pos = absolute_chunk_position + ivec2(x as i32, y as i32);
+
+            let Some(construction) = constructions.get(&absolute_tile_pos) else {
+                continue;
+            };
+
+            commands.entity(*construction).despawn();
+            constructions.remove(&absolute_tile_pos);
         }
     }
 }