Template based spawning

Author: rax35

rustlib/rust_workspace/dungeoncrawl/assets/template.ron

@@ -0,0 +1,44 @@
+Templates(
+    entities: [
+        Template(
+            entity_type: Item,
+            name: "Healing Potion",
+            texture: HealthPotion,
+            levels: [0, 1, 2],
+            provides: Some([("Healing", 6)]),
+            frequency: 2,
+        ),
+        Template(
+            entity_type: Item,
+            name: "Map",
+            texture: Map,
+            levels: [0, 1, 2],
+            provides: Some([("Map", 6)]),
+            frequency: 1,
+        ),
+        Template(
+            entity_type: Item,
+            name: "Unsupported Test",
+            texture: Map,
+            levels: [0, 1, 2],
+            provides: Some([("Test", 7)]),
+            frequency: 2,
+        ),
+        Template(
+            entity_type: Enemy,
+            name: "Bat",
+            texture: Bat,
+            levels: [0, 1, 2],
+            frequency: 3,
+            hp: Some(1),
+        ),
+        Template(
+            entity_type: Enemy,
+            name: "Ghost",
+            texture: Ghost,
+            levels: [0, 1, 2],
+            frequency: 2,
+            hp: Some(2),
+        ),
+    ]
+)

rustlib/rust_workspace/dungeoncrawl/src/components.rs

@@ -68,7 +68,7 @@ impl DerefMut for SelectedItemIndex {
 // TODO Make the texture a Rect or something
 #[derive(Component, Debug)]
 pub struct Render {
-    pub texture: EntityType,
+    pub texture: RenderKey,
 }
 
 #[derive(Component, Debug)]
@@ -133,7 +133,7 @@ impl PlayerBundle {
                 max: 20,
             },
             render: Render {
-                texture: EntityType::Player,
+                texture: RenderKey::Player,
             },
             field_of_view: FieldOfView::new(8),
             timer: Timer { time: 0.0 },

rustlib/rust_workspace/dungeoncrawl/src/lib.rs

@@ -14,6 +14,7 @@ use crate::movement::movement_system;
 use crate::prelude::advance_level::advance_level;
 use crate::prelude::event_readers::use_item;
 use crate::prelude::player_input::player_menu_input_system;
+use crate::prelude::template::Templates;
 use crate::prelude::*;
 use crate::resources::FontResource;
 use bevy_app::prelude::*;
@@ -254,4 +255,7 @@ async fn async_bevy_setup(app: &mut App) {
 
     app.insert_resource(sprite_sheet);
     app.insert_resource(FontResource(font));
+
+    let template = Templates::load().await;
+    app.insert_resource(template);
 }

rustlib/rust_workspace/dungeoncrawl/src/spawner.rs

@@ -1,29 +1,30 @@
-use crate::prelude::*;
+use crate::{prelude::*, spawner::template::Templates};
+pub mod template;
 
 pub fn spawn_player(ecs: &mut Commands, pos: TilePoint) {
     ecs.spawn(PlayerBundle::new(pos));
 }
 
-pub fn spawn_enemy(ecs: &mut Commands, rng: &mut Rng, pos: TilePoint) {
-    let (hp, name, render_type) = match rng.i8(0..=10) {
-        1..=7 => bat(),
-        _ => giant(),
-    };
-    ecs.spawn(EnemyBundle {
-        enemy: Enemy,
-        pos,
-        name: EntityName(name),
-        health: Health {
-            current: hp,
-            max: hp,
-        },
-        render: Render {
-            texture: render_type,
-        },
-        field_of_view: FieldOfView::new(6),
-        movement_behaviour: ChasePlayer,
-    });
-}
+// pub fn spawn_enemy(ecs: &mut Commands, rng: &mut Rng, pos: TilePoint) {
+//     let (hp, name, render_type) = match rng.i8(0..=10) {
+//         1..=7 => bat(),
+//         _ => giant(),
+//     };
+//     ecs.spawn(EnemyBundle {
+//         enemy: Enemy,
+//         pos,
+//         name: EntityName(name),
+//         health: Health {
+//             current: hp,
+//             max: hp,
+//         },
+//         render: Render {
+//             texture: render_type,
+//         },
+//         field_of_view: FieldOfView::new(6),
+//         movement_behaviour: ChasePlayer,
+//     });
+// }
 
 pub fn spawn_amulet(ecs: &mut Commands, pos: TilePoint) {
     ecs.spawn(AmuletBundle {
@@ -32,47 +33,57 @@ pub fn spawn_amulet(ecs: &mut Commands, pos: TilePoint) {
         pos,
         name: EntityName("Amulet".to_string()),
         render: Render {
-            texture: EntityType::Amulet,
+            texture: RenderKey::Amulet,
         },
     });
 }
 
-pub fn spawn_healing_potion(ecs: &mut Commands, pos: TilePoint) {
-    ecs.spawn((
-        Item,
-        pos,
-        EntityName("Health Potion".to_string()),
-        ProvidesHealing { amount: 6 },
-        Render {
-            texture: EntityType::HealthPotion,
-        },
-    ));
+pub fn spawn_level(
+    ecs: &mut Commands,
+    template: &Templates,
+    rng: &mut Rng,
+    level: usize,
+    spawn_points: &[TilePoint],
+) {
+    template.spawn_entities(ecs, rng, level, spawn_points);
 }
 
-pub fn spawn_magic_mapper(ecs: &mut Commands, pos: TilePoint) {
-    ecs.spawn((
-        Item,
-        pos,
-        EntityName("Mapper".to_string()),
-        ProvidesDungeonMap,
-        Render {
-            texture: EntityType::Map,
-        },
-    ));
-}
+// pub fn spawn_healing_potion(ecs: &mut Commands, pos: TilePoint) {
+//     ecs.spawn((
+//         Item,
+//         pos,
+//         EntityName("Health Potion".to_string()),
+//         ProvidesHealing { amount: 6 },
+//         Render {
+//             texture: RenderKey::HealthPotion,
+//         },
+//     ));
+// }
 
-pub fn spawn_entity(ecs: &mut Commands, pos: TilePoint, rng: &mut Rng) {
-    match rng.u8(0..6) {
-        1 => spawn_healing_potion(ecs, pos),
-        2 => spawn_magic_mapper(ecs, pos),
-        _ => spawn_enemy(ecs, rng, pos),
-    }
-}
+// pub fn spawn_magic_mapper(ecs: &mut Commands, pos: TilePoint) {
+//     ecs.spawn((
+//         Item,
+//         pos,
+//         EntityName("Mapper".to_string()),
+//         ProvidesDungeonMap,
+//         Render {
+//             texture: RenderKey::Map,
+//         },
+//     ));
+// }
 
-fn bat() -> (i32, String, EntityType) {
-    (1, "Goblin".to_string(), EntityType::Bat)
-}
+// pub fn spawn_entity(ecs: &mut Commands, pos: TilePoint, rng: &mut Rng) {
+//     match rng.u8(0..6) {
+//         1 => spawn_healing_potion(ecs, pos),
+//         2 => spawn_magic_mapper(ecs, pos),
+//         _ => spawn_enemy(ecs, rng, pos),
+//     }
+// }
 
-fn giant() -> (i32, String, EntityType) {
-    (2, "Giant".to_string(), EntityType::Cyclops)
-}
+// fn bat() -> (i32, String, RenderKey) {
+//     (1, "Goblin".to_string(), RenderKey::Bat)
+// }
+
+// fn giant() -> (i32, String, RenderKey) {
+//     (2, "Giant".to_string(), RenderKey::Cyclops)
+// }

rustlib/rust_workspace/dungeoncrawl/src/spawner/template.rs

@@ -0,0 +1,107 @@
+use std::collections::HashSet;
+
+use crate::prelude::*;
+use serde::Deserialize;
+
+#[derive(Deserialize, Clone, Debug)]
+pub struct Template {
+    pub entity_type: EntityType,
+    pub levels: HashSet<usize>,
+    pub frequency: i8,
+    pub name: String,
+    pub texture: RenderKey,
+    pub provides: Option<Vec<(String, i32)>>,
+    pub hp: Option<i32>,
+}
+
+#[derive(Deserialize, Clone, Copy, PartialEq, Debug)]
+pub enum EntityType {
+    Enemy,
+    Item,
+}
+
+#[derive(Resource, Deserialize, Debug)]
+pub struct Templates {
+    entities: Vec<Template>,
+}
+
+impl Templates {
+    pub async fn load() -> Self {
+        let template_file = load_file("template.ron").await.expect("Template file");
+        let t = String::from_utf8(template_file.clone()).unwrap();
+        debug!("{}", t);
+        match ron::de::from_bytes(&template_file) {
+            Ok(template) => template,
+            Err(error) => {
+                error!("{}", error);
+                panic!("{}", error);
+            }
+        }
+    }
+
+    pub fn spawn_entities(
+        &self,
+        commands: &mut Commands,
+        rng: &mut Rng,
+        level: usize,
+        spawn_points: &[TilePoint],
+    ) {
+        let mut available_entities = Vec::new();
+        self.entities
+            .iter()
+            .filter(|e| e.levels.contains(&level))
+            .for_each(|e| {
+                for _ in 0..e.frequency {
+                    available_entities.push(e)
+                }
+            });
+
+        spawn_points.iter().for_each(|pt| {
+            if let Some(entity) = rng.choice(&available_entities) {
+                self.spawn_entity(pt, entity, commands);
+            }
+        });
+    }
+
+    fn spawn_entity(&self, pt: &TilePoint, template: &Template, commands: &mut Commands) {
+        let mut entity = commands.spawn((
+            *pt,
+            Render {
+                texture: template.texture,
+            },
+            EntityName(template.name.clone()),
+        ));
+
+        match template.entity_type {
+            EntityType::Item => {
+                entity.insert(Item);
+            }
+            EntityType::Enemy => {
+                entity
+                    .insert(Enemy)
+                    .insert(FieldOfView::new(6))
+                    .insert(ChasePlayer)
+                    .insert(Health {
+                        current: template.hp.unwrap(),
+                        max: template.hp.unwrap(),
+                    });
+            }
+        }
+
+        if let Some(effects) = &template.provides {
+            effects
+                .iter()
+                .for_each(|(effect, n)| match effect.as_str() {
+                    "Healing" => {
+                        entity.insert(ProvidesHealing { amount: *n });
+                    }
+
+                    "Map" => {
+                        entity.insert(ProvidesDungeonMap);
+                    }
+
+                    _ => error!("Unsupported Effect: {}", effect),
+                });
+        }
+    }
+}

rustlib/rust_workspace/dungeoncrawl/src/systems.rs

@@ -16,14 +16,15 @@ pub mod update_pathfinding;
 use crate::PathfindingMap;
 use crate::events::{ActivateItem, WantsToAttack, WantsToMove};
 use crate::resources::FontResource;
+use crate::template::Templates;
 use crate::{TurnState, prelude::*};
 use bevy_app::Startup;
 use bevy_ecs::system::SystemState;
 use bevy_state::commands::CommandsStatesExt;
 use bracket_pathfinding::prelude::Algorithm2D;
 
 // TODO Make a better way to restart
-pub fn setup_system(world: &mut World, p_commands: &mut SystemState<Commands>) {
+pub fn setup_system(world: &mut World, p_commands: &mut SystemState<(Commands, Res<Templates>)>) {
     info!("setup start");
 
     world.clear_entities();
@@ -41,7 +42,7 @@ pub fn setup_system(world: &mut World, p_commands: &mut SystemState<Commands>) {
         .clear();
 
     {
-        let mut commands = p_commands.get_mut(world);
+        let (mut commands, template) = p_commands.get_mut(world);
 
         commands.insert_resource(Controller::new());
         commands.insert_resource(input_lib::ButtonState::new());
@@ -59,10 +60,13 @@ pub fn setup_system(world: &mut World, p_commands: &mut SystemState<Commands>) {
             .point2d_to_index(map_builder.amulet_start.into());
         map_builder.map.tiles[exit_idx] = TileType::Stair;
 
-        map_builder
-            .monster_spawns
-            .iter()
-            .for_each(|pos| spawn_entity(&mut commands, *pos, &mut rng));
+        spawn_level(
+            &mut commands,
+            &template,
+            &mut rng,
+            0,
+            &map_builder.monster_spawns,
+        );
 
         commands.insert_resource(Viewport::new(map_builder.player_start));
         commands.insert_resource(PathfindingMap::new(&[player_idx], &map_builder.map));