From 78548f1d51a83fe9d44a3076ae80cd66afbd9dd4 Mon Sep 17 00:00:00 2001
From: StarArawn <t>
Date: Fri, 14 May 2021 16:01:09 -0400
Subject: [PATCH] Back to where we were, but now with better tiles.

---
 src/game/gameplay/camera/movement.rs    |  16 +-
 src/game/gameplay/character/mod.rs      |   4 +-
 src/game/gameplay/character/movement.rs |  42 +++--
 src/game/gameplay/enemy/mod.rs          |   4 +-
 src/game/gameplay/enemy/spawner.rs      |   7 +-
 src/game/gameplay/scenes/battle.rs      |   4 +-
 src/game/gameplay/scenes/map_view.rs    |  30 +---
 src/game/loading.rs                     |  12 +-
 src/game/map/generate_map.rs            | 229 +++++++++++++-----------
 src/game/map/map.rs                     |  29 ++-
 src/game/map/mod.rs                     |  26 +--
 src/game/map/spawn_map_entity.rs        |  41 ++---
 src/game/mod.rs                         |  16 +-
 13 files changed, 229 insertions(+), 231 deletions(-)

diff --git a/src/game/gameplay/camera/movement.rs b/src/game/gameplay/camera/movement.rs
index 720939f..c8b149e 100644
--- a/src/game/gameplay/camera/movement.rs
+++ b/src/game/gameplay/camera/movement.rs
@@ -1,10 +1,9 @@
 use bevy::{prelude::*, render::camera::{Camera, CameraProjection, OrthographicProjection}};
 
-use crate::game::{camera::{CameraData, CustomOrthographicProjection}, gameplay::character::PlayerSprite};
+use crate::game::{camera::{CameraData}, gameplay::character::PlayerSprite};
 
 pub fn movement(
-    time: Res<Time>,
-    windows: Res<Windows>,
+
     player_query: Query<&Transform, (With<PlayerSprite>, Without<Camera>)>,
     mut camera_query: Query<(
         &mut CameraData,
@@ -17,16 +16,9 @@ pub fn movement(
     for player_transform in player_query.iter() {
         player_position = player_transform.translation;
     }
-    for (mut camera_data, mut camera, mut camera_transform, mut projection) in camera_query.iter_mut() {
+    for (_camera_data, mut camera, mut camera_transform, mut projection) in camera_query.iter_mut() {
         let camera_z = camera_transform.translation.z;
         
-        // camera_transform.translation = camera_transform.translation.truncate().lerp(player_position.truncate(), 0.01).extend(camera_z);
-
-        projection.update(
-            windows.get_primary().unwrap().width(),
-            windows.get_primary().unwrap().height(),
-        );
-        camera.projection_matrix = projection.get_projection_matrix();
-        camera.depth_calculation = projection.depth_calculation();
+        camera_transform.translation = camera_transform.translation.truncate().lerp(player_position.truncate(), 0.05).extend(camera_z);
     }
 }
\ No newline at end of file
diff --git a/src/game/gameplay/character/mod.rs b/src/game/gameplay/character/mod.rs
index b4b1158..90e1e41 100644
--- a/src/game/gameplay/character/mod.rs
+++ b/src/game/gameplay/character/mod.rs
@@ -27,7 +27,7 @@ pub fn spawn_player(
         .id();
     build_basic_character_attributes(&mut commands, character);
 
-    let map_player_texture_handle = asset_server.load("textures/player_sprite.png");
+    let map_player_texture_handle = asset_server.get_handle("textures/player_sprite.png");
     let map_player_sprite_material = materials.add(map_player_texture_handle.into());
     commands
         .spawn_bundle(SpriteBundle {
@@ -39,7 +39,7 @@ pub fn spawn_player(
         .insert(RenderLayers::layer(0));
 
 
-    let battle_player_texture_handle = asset_server.load("textures/characters/huntress/idle.png");
+    let battle_player_texture_handle = asset_server.get_handle("textures/characters/huntress/idle.png");
     let texture_atlas =
         TextureAtlas::from_grid(battle_player_texture_handle, Vec2::new(150.0, 150.0), 8, 1);
     let texture_atlas_handle = texture_atlases.add(texture_atlas);
diff --git a/src/game/gameplay/character/movement.rs b/src/game/gameplay/character/movement.rs
index 16d0d86..7c84483 100644
--- a/src/game/gameplay/character/movement.rs
+++ b/src/game/gameplay/character/movement.rs
@@ -1,33 +1,39 @@
-use crate::game::map::MapData;
 use bevy::prelude::*;
 
+use crate::game::map::{MAP_LAYER, MapData, MapQuery};
+
 use super::PlayerSprite;
 
 pub fn movement(
     time: Res<Time>,
-    map: Res<MapData>,
     mut player_query: Query<(&mut PlayerSprite, &mut Transform)>,
+    map_query: MapQuery,
+    map_data_query: Query<&MapData>,
 ) {
-    if map.road_path.len() > 0 {
-        for (mut player, mut transform) in player_query.iter_mut() {
-            let current_road_position = map.road_path[player.current_position];
-            let current_road_position = Vec2::new(
-                (current_road_position.0 as f32 * 16.0) + 8.0,
-                (current_road_position.1 as f32 * 16.0) + 8.0,
-            );
-            let mut player_position = transform.translation.truncate();
+    if let Some((entity, _)) = map_query.get_layer(MAP_LAYER) {
+        if let Ok(map_data) = map_data_query.get(entity) {
+            if map_data.road_path.len() > 0 {
+                for (mut player, mut transform) in player_query.iter_mut() {
+                    let current_road_position = map_data.road_path[player.current_position];
+                    let current_road_position = Vec2::new(
+                        (current_road_position.x as f32 * 16.0) + 8.0,
+                        (current_road_position.y as f32 * 16.0) + 8.0,
+                    );
+                    let mut player_position = transform.translation.truncate();
 
 
-            let direction = (current_road_position - player_position).normalize();
-            player_position += direction * 100.0 * time.delta_seconds();
+                    let direction = (current_road_position - player_position).normalize();
+                    player_position += direction * 100.0 * time.delta_seconds();
 
-            transform.translation = player_position.extend(10.0);            
+                    transform.translation = player_position.extend(10.0);            
 
-            let distance = current_road_position.distance_squared(player_position);
-            if distance <= 1.0 {
-                player.current_position += 1;
-                if player.current_position >= map.road_path.len() {
-                    player.current_position = 0;
+                    let distance = current_road_position.distance_squared(player_position);
+                    if distance <= 1.0 {
+                        player.current_position += 1;
+                        if player.current_position >= map_data.road_path.len() {
+                            player.current_position = 0;
+                        }
+                    }
                 }
             }
         }
diff --git a/src/game/gameplay/enemy/mod.rs b/src/game/gameplay/enemy/mod.rs
index fd45ab4..eabcd36 100644
--- a/src/game/gameplay/enemy/mod.rs
+++ b/src/game/gameplay/enemy/mod.rs
@@ -22,7 +22,7 @@ pub fn spawn_enemy(
         .insert(Transform::from_xyz(position.x, position.y, 11.0))
         .insert(Enemy::default())
         .with_children(|child_builder| {
-            let texture_handle: Handle<Texture> = asset_server.load("textures/enemies/skeleton/idle.png");
+            let texture_handle: Handle<Texture> = asset_server.get_handle("textures/enemies/skeleton/idle.png");
             let texture_atlas = TextureAtlas::from_grid(texture_handle, Vec2::new(150.0, 150.0), 4, 1);
             let texture_atlas_handle = texture_atlases.add(texture_atlas);
             child_builder    
@@ -46,7 +46,7 @@ pub fn create_battle_enemy(
     asset_server: &Res<AssetServer>,
     texture_atlases: &mut ResMut<Assets<TextureAtlas>>,
 ) {
-    let texture_handle: Handle<Texture> = asset_server.load("textures/enemies/skeleton/idle.png");
+    let texture_handle: Handle<Texture> = asset_server.get_handle("textures/enemies/skeleton/idle.png");
     let texture_atlas = TextureAtlas::from_grid(texture_handle, Vec2::new(150.0, 150.0), 4, 1);
     let texture_atlas_handle = texture_atlases.add(texture_atlas);
 
diff --git a/src/game/gameplay/enemy/spawner.rs b/src/game/gameplay/enemy/spawner.rs
index 623d7fd..2febbd7 100644
--- a/src/game/gameplay/enemy/spawner.rs
+++ b/src/game/gameplay/enemy/spawner.rs
@@ -1,4 +1,4 @@
-use bevy::prelude::*;
+use bevy::{prelude::*, render::camera::RenderLayers};
 use crate::game::GameState;
 use super::spawn_enemy;
 
@@ -17,7 +17,8 @@ pub fn spawn(
     materials: &mut ResMut<Assets<ColorMaterial>>,
     position: Vec2,
 ) {
-    let texture_handle: Handle<Texture> = asset_server.load("textures/cave_sprite.png");
+    dbg!(position);
+    let texture_handle: Handle<Texture> = asset_server.get_handle("textures/cave_sprite.png");
     let cave_sprite_material = materials.add(texture_handle.into());
     commands
         .spawn_bundle(SpriteBundle {
@@ -25,7 +26,7 @@ pub fn spawn(
             transform: Transform::from_xyz(position.x, position.y, 10.0),
             ..Default::default()
         })
-        .insert(GameState::MapView)
+        .insert(RenderLayers::layer(0))
         .insert(Spawner {
             wait_time: 10.0,
             last_time: 0.0,
diff --git a/src/game/gameplay/scenes/battle.rs b/src/game/gameplay/scenes/battle.rs
index ecc4286..bce7dcd 100644
--- a/src/game/gameplay/scenes/battle.rs
+++ b/src/game/gameplay/scenes/battle.rs
@@ -39,7 +39,7 @@ pub fn handle_battle_events(
 ) {
     for event in battle_events.iter() {
         let texture_handle: Handle<Texture> =
-            asset_server.load(get_battle_location_texture(event.battle_location));
+            asset_server.get_handle(get_battle_location_texture(event.battle_location));
         let background_sprite = materials.add(texture_handle.into());
 
         // Get character entity..
@@ -103,7 +103,7 @@ pub fn handle_battle_events(
                         // Accepts a `String` or any type that converts into a `String`, such as `&str`
                         "Health: ",
                         TextStyle {
-                            font: asset_server.load("FiraMono-Medium.ttf"),
+                            font: asset_server.get_handle("FiraMono-Medium.ttf"),
                             font_size: 24.0,
                             color: Color::WHITE,
                         },
diff --git a/src/game/gameplay/scenes/map_view.rs b/src/game/gameplay/scenes/map_view.rs
index 724deea..e5fbeda 100644
--- a/src/game/gameplay/scenes/map_view.rs
+++ b/src/game/gameplay/scenes/map_view.rs
@@ -6,7 +6,6 @@ use crate::game::{camera::{CameraData, CurrentCamera}};
 pub fn spawn(
     mut commands: Commands,
     mut current_camera: ResMut<CurrentCamera>,
-    mut tilemap_query: Query<&mut Map>,
 ) {
     let mut ortho = OrthographicCameraBundle::new_2d();
     ortho.orthographic_projection.scale = 0.5;
@@ -15,42 +14,15 @@ pub fn spawn(
         .spawn()
         .insert_bundle(ortho)
         .insert(CameraData::default())
-        // .insert(RenderLayers::layer(0))
+        .insert(RenderLayers::layer(0))
         .id();
 
     current_camera.camera = Some(camera_entity);
-
-    for mut tilemap in tilemap_query.iter_mut() {
-        // let map_width = tilemap.width().unwrap() as i32;
-        // let map_height = tilemap.height().unwrap() as i32;
-        // let half_map_width = map_width / 2;
-        // let half_map_height = map_height / 2;
-
-        // for x in -half_map_width..half_map_width {
-        //     for y in -half_map_height..half_map_height {
-        //         tilemap.spawn_chunk((x, y)).unwrap();
-        //     }
-        // }
-    }
 }
 
 pub fn destroy(
     mut commands: Commands,
     mut current_camera: ResMut<CurrentCamera>,
-    mut tilemap_query: Query<&mut Map>,
 ) {
     commands.entity(current_camera.camera.take().unwrap()).despawn_recursive();
-
-    for mut tilemap in tilemap_query.iter_mut() {
-        // let map_width = tilemap.width().unwrap() as i32;
-        // let map_height = tilemap.height().unwrap() as i32;
-        // let half_map_width = map_width / 2;
-        // let half_map_height = map_height / 2;
-
-        // for x in -half_map_width..half_map_width {
-        //     for y in -half_map_height..half_map_height {
-        //         tilemap.despawn_chunk((x, y)).unwrap();
-        //     }
-        // }
-    }
 }
\ No newline at end of file
diff --git a/src/game/loading.rs b/src/game/loading.rs
index 8978877..45aa6ec 100644
--- a/src/game/loading.rs
+++ b/src/game/loading.rs
@@ -1,18 +1,14 @@
 use bevy::{asset::LoadState, prelude::*};
-use super::map::TilemapAtlasHandles;
-use super::{map::get_has_map_assets, GameState};
+use super::{GameState, LoadingHandles};
 
 // A system to determin if we have finished loading and should change states.
 pub fn loading(
     asset_server: Res<AssetServer>,
     mut game_state: ResMut<State<GameState>>,
-    tilemap_atlas_handles: Res<TilemapAtlasHandles>,
-    textures: Res<Assets<Texture>>,
+    loading_handles: Res<LoadingHandles>,
 ) {
-    asset_server.load::<Font, &'static str>("FiraMono-Medium.ttf");
-
-    if asset_server.get_group_load_state(textures.iter().map(|(handle_id, _)| handle_id)) == LoadState::Loaded &&
-        get_has_map_assets(asset_server, tilemap_atlas_handles)
+    dbg!(loading_handles.0.len());
+    if asset_server.get_group_load_state(loading_handles.0.iter().map(|handle_id| handle_id.id)) == LoadState::Loaded
     {
         game_state.set(GameState::SpawnMap).unwrap();
     }
diff --git a/src/game/map/generate_map.rs b/src/game/map/generate_map.rs
index 5a4614a..0e41216 100644
--- a/src/game/map/generate_map.rs
+++ b/src/game/map/generate_map.rs
@@ -1,9 +1,9 @@
 use crate::game::{gameplay::enemy::spawner, GameState};
-use bevy::prelude::*;
+use bevy::{asset::Asset, prelude::*};
 use bevy_ecs_tilemap::prelude::*;
 use noise::{Fbm, MultiFractal, NoiseFn, Seedable};
 use pathfinding::prelude::{absdiff, astar};
-use super::map::{MapLayer, MapSeed, RoadLayer};
+use super::{map::{MapData, MAP_LAYER, MapQuery, MapSeed, ROAD_LAYER}};
 
 fn get_island_shape(x: f64, y: f64) -> f64 {
     let a = 1.0;
@@ -17,139 +17,168 @@ pub fn generate_road(
     mut commands: Commands,
     mut game_state: ResMut<State<GameState>>,
     tile_query: Query<&Tile>,
-    map_query: Query<(&Map, &MapSeed), (With<MapLayer>, Without<RoadLayer>)>,
-    mut road_query: Query<&mut Map, (With<RoadLayer>, Without<MapLayer>)>,
+    mut map_query: MapQuery,
+    asset_server: Res<AssetServer>,
+    mut materials: ResMut<Assets<ColorMaterial>>,
 ) {
-    if let Ok(mut road_layer) = road_query.single_mut() {
-        if let Ok((map_layer, _map_seed)) = map_query.single() {            
-            let angle_increment: u32 = 15;
-            let random_angle = fastrand::u32(0..360) as f32;
-
-            let mut angles = Vec::new();
-            for angle_index in 0..(360 / angle_increment) {
-                let mut current_angle = (angle_increment * angle_index) as f32 + random_angle;
-                current_angle = current_angle % 360.0;
-                if current_angle < 0.0 {
-                    current_angle += 360.0;
-                }
-
-                angles.push(current_angle);
+    let mut road_points = Vec::new();
+    if let Some((_, map_layer)) = map_query.get_layer(MAP_LAYER) {            
+        let angle_increment: u32 = 15;
+        let random_angle = fastrand::u32(0..360) as f32;
+
+        let mut angles = Vec::new();
+        for angle_index in 0..(360 / angle_increment) {
+            let mut current_angle = (angle_increment * angle_index) as f32 + random_angle;
+            current_angle = current_angle % 360.0;
+            if current_angle < 0.0 {
+                current_angle += 360.0;
             }
 
-            angles.sort_by(|a, b| a.partial_cmp(b).unwrap());
-
-            let map_center = (map_layer.settings.map_size * map_layer.settings.chunk_size).as_f32() / 2.0;
-            
-            let mut road_points = Vec::new();
-            for angle in angles {
-                let current_direction =
-                    Vec2::new(angle.to_radians().cos(), angle.to_radians().sin()).normalize();
-
-                for ray_index in 2..1000 {
-                    let check_position: Vec2 = map_center + (current_direction * ray_index as f32);
-
-                    if let Some(tile_entity) = map_layer.get_tile(check_position.as_i32()) {
-                        if let Ok(tile_data) = tile_query.get(tile_entity) {
-                            if tile_data.texture_index == 19 {
-                                let range = 30..(ray_index - 2);
-                                let random_ray_position = fastrand::i32(range);
-                                let road_position: Vec2 = map_center + current_direction * (random_ray_position as f32);
-                                road_points.push(road_position);
-                                break;
-                            }
-                        } 
-                    } else {
-                        break;
-                    }
+            angles.push(current_angle);
+        }
+
+        angles.sort_by(|a, b| a.partial_cmp(b).unwrap());
+
+        let map_center = (map_layer.settings.map_size * map_layer.settings.chunk_size).as_f32() / 2.0;
+        
+        for angle in angles {
+            let current_direction =
+                Vec2::new(angle.to_radians().cos(), angle.to_radians().sin()).normalize();
+
+            for ray_index in 2..1000 {
+                let check_position: Vec2 = map_center + (current_direction * ray_index as f32);
+
+                if let Some(tile_entity) = map_layer.get_tile(check_position.as_i32()) {
+                    if let Ok(tile_data) = tile_query.get(tile_entity) {
+                        if tile_data.texture_index == 19 {
+                            let range = 30..(ray_index - 2);
+                            let random_ray_position = fastrand::i32(range);
+                            let road_position: Vec2 = map_center + current_direction * (random_ray_position as f32);
+                            road_points.push(road_position);
+                            break;
+                        }
+                    } 
+                } else {
+                    break;
                 }
             }
+        }
+    }
 
-            for road_point in road_points.iter() {
-                let tile = Tile {
-                    texture_index: 36,
-                    ..Default::default()
-                };
+    if let Some((_, mut road_layer)) = map_query.get_layer_mut(ROAD_LAYER) {
+        for road_point in road_points.iter() {
+            let tile = Tile {
+                texture_index: 36,
+                ..Default::default()
+            };
 
-                road_layer.add_tile(&mut commands, road_point.as_u32(), tile, true).unwrap();
-            }
+            road_layer.add_tile(&mut commands, road_point.as_u32(), tile, true).unwrap();
+        }
+    }
 
-            road_points.push(road_points[0]);
+    road_points.push(road_points[0]);
 
-            find_road_path(&mut commands, &tile_query, &mut road_layer, &map_layer, &road_points);
+    let road_path = find_road_path(&mut commands, &tile_query, &mut map_query, &road_points);
 
-            game_state.set(GameState::MapView).unwrap();
-        }
+    for _ in 0..10 {
+        let random_road_index = fastrand::usize(0..road_path.len() - 1);
+        let road_point = road_path[random_road_index];
+        dbg!(road_point);
+        spawner::spawn(
+            &mut commands,
+            &asset_server,
+            &mut materials,
+            Vec2::new(road_point.x as f32 * 16.0, road_point.y as f32 * 16.0) + Vec2::new(8.0, 8.0),
+        );
     }
+
+    if let Some((map_entity, _)) = map_query.get_layer(MAP_LAYER) {
+        commands.entity(map_entity).insert(
+            MapData {
+                road_path,
+            }
+        );
+    }
+
+    game_state.set(GameState::MapView).unwrap();
 }
 
 pub fn find_road_path(
     commands: &mut Commands,
     tile_query: &Query<&Tile>,
-    road_layer: &mut Map,
-    map_layer: &Map,
+    map_query: &mut MapQuery,
     road_points: &Vec<Vec2>,
-) -> Vec<(i32, i32)> {
+) -> Vec<IVec2> {
     let mut road_path = Vec::new();
-
     let mut starting_point = (road_points[0].x as i32, road_points[0].y as i32);
-    for road_point_index in 1..road_points.len() {
-        let goal = (
-            road_points[road_point_index].x as i32,
-            road_points[road_point_index].y as i32,
-        );
-        // Do pathfinding
-        let path = astar(
-            &starting_point,
-            |&(x, y)| {
-                let neighbors = map_layer.get_tile_neighbors(UVec2::new(x as u32, y as u32));
-                
-                neighbors
-                    .iter()
-                    .filter(|(p, entity)| {
-                        if entity.is_some() {
-                            if let Ok(tile) = tile_query.get(entity.unwrap()) {
-                                // 19 is water.
-                                if tile.texture_index != 19 {
-                                    return true;
+
+    if let Some((_, map_layer)) = map_query.get_layer(MAP_LAYER) {
+        for road_point_index in 1..road_points.len() {
+            let goal = (
+                road_points[road_point_index].x as i32,
+                road_points[road_point_index].y as i32,
+            );
+            // Do pathfinding
+            let path = astar(
+                &starting_point,
+                |&(x, y)| {
+                    let neighbors = map_layer.get_tile_neighbors(UVec2::new(x as u32, y as u32));
+                    
+                    neighbors
+                        .iter()
+                        .filter(|(p, entity)| {
+                            if entity.is_some() {
+                                if let Ok(tile) = tile_query.get(entity.unwrap()) {
+                                    // 19 is water.
+                                    if tile.texture_index != 19 {
+                                        return true;
+                                    }
                                 }
                             }
-                        }
-                        return false;
-                    })
-                    .map(|(p, _)| ((p.x, p.y), 1))
-                    .collect::<Vec<((i32, i32), i32)>>().into_iter()
-            },
-            |&(x, y)| absdiff(x, goal.0) + absdiff(y, goal.1),
-            |&p| p == goal,
-        );
-
-        road_path.extend(path.unwrap().0);
-
-        starting_point = goal.clone();
+                            return false;
+                        })
+                        .map(|(p, _)| ((p.x, p.y), 1))
+                        .collect::<Vec<((i32, i32), i32)>>().into_iter()
+                },
+                |&(x, y)| absdiff(x, goal.0) + absdiff(y, goal.1),
+                |&p| p == goal,
+            ).unwrap().0.iter().map(|(x, y)| IVec2::new(*x, *y)).collect::<Vec<IVec2>>();
+
+            road_path.extend(path);
+
+            starting_point = goal.clone();
+        }
     }
 
-    for road_point in road_path.iter() {
-        let has_no_tile = road_layer.get_tile(IVec2::new(road_point.0, road_point.1)).is_none();
+    if let Some((_, mut road_layer)) = map_query.get_layer_mut(ROAD_LAYER) {
+        for road_point in road_path.iter() {
+            let has_no_tile = road_layer.get_tile(*road_point).is_none();
 
-        if has_no_tile {
-            let tile = Tile {
-                texture_index: 7,
-                ..Default::default()
-            };
+            if has_no_tile {
+                let tile = Tile {
+                    texture_index: 7,
+                    ..Default::default()
+                };
 
-            road_layer.add_tile(commands, UVec2::new(road_point.0 as u32, road_point.1 as u32), tile, true).unwrap();
+                road_layer.add_tile(commands, road_point.as_u32(), tile, true).unwrap();
+            }
         }
     }
 
+    if let Some((_, map_layer)) = map_query.get_layer(MAP_LAYER) {
+        let half_map_size = (map_layer.settings.map_size * map_layer.settings.chunk_size).as_i32() / 2;
+        road_path = road_path.iter().map(|vec| IVec2::new(vec.x - half_map_size.x, vec.y - half_map_size.y)).collect();
+    }
+    
     road_path
 }
 
 pub fn generate_map(
     mut commands: Commands,
     mut game_state: ResMut<State<GameState>>,
-    mut map_query: Query<(Entity, &mut Map), With<MapLayer>>,
+    mut map_query: MapQuery,
 ) {
-    if let Ok((map_entity, mut map_layer)) = map_query.single_mut() {
+    if let Some((map_entity, mut map_layer)) = map_query.get_layer_mut(MAP_LAYER) {
         // Generate a seed for the map
         let seed: u32 = fastrand::u32(..);
         fastrand::seed(seed as u64);
diff --git a/src/game/map/map.rs b/src/game/map/map.rs
index 877ea89..35bc177 100644
--- a/src/game/map/map.rs
+++ b/src/game/map/map.rs
@@ -1,10 +1,31 @@
+use bevy::{ecs::system::SystemParam, prelude::*};
+use bevy_ecs_tilemap::prelude::*;
+
 #[derive(Default)]
 pub struct MapData {
-    pub road_path: Vec<(i32, i32)>,
+    pub road_path: Vec<IVec2>,
     // TODO: Add more map things like: Towns, Dungeons, etc.
 }
 
-pub struct MapLayer;
-pub struct RoadLayer;
+pub struct MapSeed(pub u32);
+
+#[derive(SystemParam)]
+pub struct MapQuery<'a> {
+    map_query_set: QuerySet<(
+        Query<'a, (Entity, &'static mut Map)>,
+        Query<'a, (Entity, &'static Map)>,
+    )>,
+}
+
+pub const MAP_LAYER: u32 = 0;
+pub const ROAD_LAYER: u32 = 1;
+
+impl<'a> MapQuery<'a> {
+    pub fn get_layer(&self, layer_id: u32) -> Option<(Entity, &Map)> {
+        self.map_query_set.q1().iter().find(|map| map.1.settings.layer_id == layer_id)
+    }
 
-pub struct MapSeed(pub u32);
\ No newline at end of file
+    pub fn get_layer_mut(&mut self, layer_id: u32) -> Option<(Entity, Mut<'_, Map>)> {
+        self.map_query_set.q0_mut().iter_mut().find(|map| map.1.settings.layer_id == layer_id)
+    }
+}
\ No newline at end of file
diff --git a/src/game/map/mod.rs b/src/game/map/mod.rs
index 9924153..552ed35 100644
--- a/src/game/map/mod.rs
+++ b/src/game/map/mod.rs
@@ -1,31 +1,7 @@
-use bevy::prelude::*;
-
 mod generate_map;
-mod get_has_map_assets;
 mod map;
 mod spawn_map_entity;
 
-pub use self::map::MapData;
-pub use get_has_map_assets::get_has_map_assets;
-pub use spawn_map_entity::TilemapAtlasHandles;
-
 pub use generate_map::{generate_map, generate_road};
 pub use spawn_map_entity::spawn_map_entity;
-
-pub fn setup(
-    asset_server: Res<AssetServer>,
-    mut tilemap_atlas_handles: ResMut<TilemapAtlasHandles>,
-) {
-    // asset_server.load_folder("textures").unwrap();
-    tilemap_atlas_handles.handles = asset_server.load_folder("textures/map").unwrap();
-}
-
-pub struct MapPlugin;
-
-impl Plugin for MapPlugin {
-    fn build(&self, app: &mut AppBuilder) {
-        app.init_resource::<TilemapAtlasHandles>()
-            .init_resource::<MapData>()
-            .add_startup_system(setup.system());
-    }
-}
+pub use map::*;
\ No newline at end of file
diff --git a/src/game/map/spawn_map_entity.rs b/src/game/map/spawn_map_entity.rs
index 82ac6f6..7b087db 100644
--- a/src/game/map/spawn_map_entity.rs
+++ b/src/game/map/spawn_map_entity.rs
@@ -3,8 +3,6 @@ use bevy_ecs_tilemap::prelude::*;
 
 use crate::game::GameState;
 
-use super::map::{MapLayer, RoadLayer};
-
 #[derive(Default, Clone)]
 pub struct TilemapAtlasHandles {
     pub handles: Vec<HandleUntyped>,
@@ -13,39 +11,32 @@ pub struct TilemapAtlasHandles {
 pub fn spawn_map_entity(
     mut commands: Commands,
     mut game_state: ResMut<State<GameState>>,
-    tilemap_atlas_handles: Res<TilemapAtlasHandles>,
     mut textures: ResMut<Assets<Texture>>,
     mut materials: ResMut<Assets<ColorMaterial>>,
     mut meshes: ResMut<Assets<Mesh>>,
+    asset_server: Res<AssetServer>,
 ) {
-    let tilemap_atlas_handle = tilemap_atlas_handles.handles[0].clone().typed::<Texture>();
+    let tilemap_atlas_handle = asset_server.get_handle("textures/map/road-sprites.png");
     let atlas_texture = textures.get_mut(tilemap_atlas_handle.clone()).unwrap();
     atlas_texture.sampler.min_filter = bevy::render::texture::FilterMode::Nearest;
     let material_handle = materials.add(ColorMaterial::texture(tilemap_atlas_handle));
 
     let map_settings = MapSettings::new(UVec2::new(10, 10), UVec2::new(32, 32), Vec2::new(16.0, 16.0), Vec2::new(96.0, 256.0), 0);
 
-    let mut layer_settings = map_settings.clone();
-    layer_settings.layer_id = 0;
-    let map_layer_entity = commands.spawn().id();
-    let mut map_layer = Map::new(layer_settings);
-    map_layer.build(&mut commands, &mut meshes, material_handle.clone(), map_layer_entity, false);
-    commands.entity(map_layer_entity).insert_bundle(MapBundle {
-        map: map_layer,
-        transform: Transform::from_xyz(-2560.0, -2560.0, 0.0),
-        ..Default::default()
-    }).insert(MapLayer);
-
-    let mut layer_settings = map_settings.clone();
-    layer_settings.layer_id = 1;
-    let road_layer_entity = commands.spawn().id();
-    let mut road_layer = Map::new(layer_settings);
-    road_layer.build(&mut commands, &mut meshes, material_handle.clone(), road_layer_entity, false);
-    commands.entity(road_layer_entity).insert_bundle(MapBundle {
-        map: road_layer,
-        transform: Transform::from_xyz(-2560.0, -2560.0, 1.0),
-        ..Default::default()
-    }).insert(RoadLayer);
+    let layer_count = 2;
+
+    for i in 0..layer_count {
+        let mut layer_settings = map_settings.clone();
+        layer_settings.layer_id = i;
+        let map_layer_entity = commands.spawn().id();
+        let mut map_layer = Map::new(layer_settings);
+        map_layer.build(&mut commands, &mut meshes, material_handle.clone(), map_layer_entity, false);
+        commands.entity(map_layer_entity).insert_bundle(MapBundle {
+            map: map_layer,
+            transform: Transform::from_xyz(-2560.0, -2560.0, i as f32),
+            ..Default::default()
+        });
+    }
 
     game_state.set(GameState::GenerateMap);
 }
diff --git a/src/game/mod.rs b/src/game/mod.rs
index 61a2816..6b58570 100644
--- a/src/game/mod.rs
+++ b/src/game/mod.rs
@@ -14,14 +14,28 @@ pub use game_state::GameState;
 
 pub struct GamePlugin;
 
+#[derive(Default)]
+pub struct LoadingHandles(Vec<HandleUntyped>);
+
+fn load_data(
+    asset_server: Res<AssetServer>,
+    mut loading_handles: ResMut<LoadingHandles>,
+) {
+    let load_handles = asset_server.load_folder("textures").unwrap();
+    asset_server.load::<Font, &'static str>("FiraMono-Medium.ttf");
+
+    loading_handles.0 = load_handles;
+}
+
 impl Plugin for GamePlugin {
     fn build(&self, app: &mut AppBuilder) {
         app.add_state(GameState::default())
-            .add_plugin(map::MapPlugin)
+            .init_resource::<LoadingHandles>()
             .init_resource::<timing::Timing>()
             .init_resource::<camera::CurrentCamera>()
             .register_type::<CustomOrthographicProjection>()
             .add_event::<scenes::battle::BattleEvent>()
+            .add_startup_system(load_data.system())
             .add_system(timing::update.system())
             .add_system(animation::animate_sprite_system.system())
             .add_system(scenes::battle::handle_battle_events.system())