level resource

src/level_instantiation/mod.rs

@@ -14,7 +14,7 @@ use crate::{
 pub fn map_plugin(app: &mut App) {
     app.add_systems(
         OnEnter(GameState::Playing),
-        (spawn_level, spawn_objects).chain(),
+        (spawn_level, spawn_objects, spawn_doors).chain(),
     );
 }
 
@@ -120,15 +120,15 @@ fn spawn_level(
     // ));
     // let map = GameMap::test();
 
-    let maps = create_maps(3);
+    let levels = create_levels(3);
 
-    for map in maps {
+    for level in &levels {
-        for ((x, z), node) in map.nodes.into_iter() {
+        for ((x, z), node) in level.nodes.iter() {
             let values = {
                 // corners are handled later, for now just a wall to test
                 let node = node.clone();
-                let pos = Transform::from_xyz(2.0*x as f32, 0.0, -2.0*z as f32);
 
+                let pos = Transform::from_xyz(2.0*(*x) as f32, 0.0, -2.0*(*z) as f32);
                 use Side::{Connection, Closed};
                 match (node.north, node.east, node.south, node.west) {
                     // hallway horizontal
@@ -249,19 +249,20 @@ fn spawn_level(
                 });
             }
         }
-        let (x,z) = map.end_node;
+        let (x,z) = level.end_node;
         commands.spawn((
             Mesh3d(meshes.add(Cuboid::new(1.0, 20.0, 1.0))),
             MeshMaterial3d(materials.add(Color::srgb_u8(255, 0, 0))),
             Transform::from_xyz(2.0*x as f32, 0.5, -2.0*z as f32),
         ));
     }
+    commands.insert_resource(GameLevels {levels});
 }
 
 
-fn create_maps(n: i32) -> Vec<GameMap> {
+fn create_levels(n: i32) -> Vec<GameLevel> {
     let mut maps = Vec::new();
-    let mut initial_node = MapNode::new();
+    let mut initial_node = LevelNode::new();
     initial_node.east = Side::Closed;
     initial_node.south = Side::Closed;
     initial_node.west = Side::Closed;
@@ -269,7 +270,7 @@ fn create_maps(n: i32) -> Vec<GameMap> {
 
     let pos = (0, 0);
 
-    let map = GameMap::new(pos, initial_node.clone(), 5);
+    let map = GameLevel::new(pos, initial_node.clone(), 5);
 
     maps.push(map);
 
@@ -277,7 +278,7 @@ fn create_maps(n: i32) -> Vec<GameMap> {
         let map = maps.last().unwrap();
         let mut pos = map.end_node.clone();
 
-        let mut next_node = MapNode::new();
+        let mut next_node = LevelNode::new();
         next_node.east = Side::Connection;
         next_node.south = Side::Connection;
         next_node.west = Side::Connection;
@@ -294,7 +295,7 @@ fn create_maps(n: i32) -> Vec<GameMap> {
         }
 
         initial_node = next_node;
-        let map = GameMap::new(pos, initial_node.clone(), 5);
+        let map = GameLevel::new(pos, initial_node.clone(), 5);
         maps.push(map);
     }
 
@@ -309,16 +310,16 @@ enum Side {
 }
 
 #[derive(Clone, Debug)]
-struct MapNode {
+struct LevelNode {
     north: Side,
     south: Side,
     east: Side,
     west: Side,
 }
 
-impl MapNode {
+impl LevelNode {
     fn new() -> Self {
-        MapNode {
+        LevelNode {
             north: Side::Empty,
             south: Side::Empty,
             east: Side::Empty,
@@ -327,18 +328,23 @@ impl MapNode {
     }
 }
 
-struct GameMap {
+#[derive(Resource)]
-    nodes: HashMap<(i32, i32), MapNode>,
+struct GameLevels {
+   pub levels: Vec<GameLevel>
+}
+
+struct GameLevel {
+    nodes: HashMap<(i32, i32), LevelNode>,
     end_node: (i32, i32),
     grid_size: i32,
     initial_point: (i32, i32)
 }
 
-impl GameMap {
+impl GameLevel {
-    fn new(initial_point: (i32, i32), node: MapNode, grid_size: i32) -> Self {
+    fn new(initial_point: (i32, i32), node: LevelNode, grid_size: i32) -> Self {
         let mut nodes = HashMap::new();
         nodes.insert(initial_point, node);
-        let mut m = GameMap { initial_point, nodes, grid_size, end_node: initial_point};
+        let mut m = GameLevel { initial_point, nodes, grid_size, end_node: initial_point};
         m.generate_map();
         m
     }
@@ -367,7 +373,7 @@ impl GameMap {
         }
     }
 
-    fn ensure_connection(&self, node: &mut MapNode, (x, y): (i32, i32)) {
+    fn ensure_connection(&self, node: &mut LevelNode, (x, y): (i32, i32)) {
         let am_connections = (node.north == Side::Connection) as u8 +
             (node.south == Side::Connection) as u8 +
             (node.east == Side::Connection) as u8 +
@@ -398,7 +404,7 @@ impl GameMap {
             }
 
             let (x, y) = current_idx;
-            let mut new_node = MapNode::new();
+            let mut new_node = LevelNode::new();
 
             if x >= self.end_node.0 && y >= self.end_node.1 {
                 self.end_node = (x, y);
@@ -473,7 +479,6 @@ fn spawn_objects(
     gltf_assets: Res<GltfAssets>,
     image_assets: Res<ImageAssets>,
 ) {
-
     // id card
     let card = models.get(&gltf_assets.card).unwrap();
     let asset = card.default_scene.as_ref().unwrap();
@@ -507,3 +512,57 @@ fn spawn_objects(
             ));
         });
 }
+
+
+fn spawn_doors(
+    mut commands: Commands,
+    levels: Res<GameLevels>,
+    models: Res<Assets<Gltf>>,
+    gltf_assets: Res<GltfAssets>
+){
+    let collider: Vec<(Collider, Transform)> = vec![(
+        Collider::cuboid(1.0, 1.0, 0.1),
+        Transform::from_xyz(0.0, 1.0, -1.0),
+    )];
+    let path = format!("meshes/library/space_round_door.glb", );
+    let handle = gltf_assets
+        .library
+        .get(&path)
+        .unwrap();
+    let gltf = models
+        .get(handle)
+        .unwrap();
+
+    let asset = gltf
+        .default_scene
+        .as_ref()
+        .unwrap();
+    let scene_root = SceneRoot(asset.clone());
+
+
+    for level in levels.levels.iter() {
+        let (x, z) = level.end_node;
+        if x <= z {
+            commands.spawn((
+                RigidBody::Fixed,
+                Transform::from_xyz(2.0 * x as f32, 0.0, -2.0 * z as f32)
+                    .with_rotation(Quat::from_rotation_y(90.0_f32.to_radians())),
+                scene_root.clone(),
+            )).with_children(|parent| {
+                for (collider, transform) in collider.clone() {
+                    parent.spawn((collider, transform));
+                }
+            });
+        } else {
+            commands.spawn((
+                RigidBody::Dynamic,
+                Transform::from_xyz(2.0 * x as f32, 0.0, -2.0 * z as f32),
+                scene_root.clone(),
+            )).with_children(|parent| {
+                for (collider, transform) in collider.clone() {
+                    parent.spawn((collider, transform));
+                }
+            });
+        }
+    }
+}