Updated to latest bevy_ecs_tilemap repo version.

Cargo.toml

@@ -9,7 +9,7 @@ edition = "2018"
 [dependencies]
 bevy = "0.5"
 bevy_egui = "0.4"
-bevy_ecs_tilemap = { git="https://github.com/StarArawn/bevy_ecs_tilemap", rev="eb299daf347fd135149c7135b4b2a60b7b4c4f4f" }
+bevy_ecs_tilemap = { git="https://github.com/StarArawn/bevy_ecs_tilemap", rev="d3b6e3a1a3fab08a417374c826fa8537a896cdf5" }
 big-brain = "0.5"
 noise = "0.7"
 pathfinding = "2.1"

src/game/camera/input.rs

@@ -1,8 +1,5 @@
 use crate::game::GameState;
-use bevy::{prelude::*, render::camera::{Camera, OrthographicProjection}};
-
-use super::CustomOrthographicProjection;
-
+use bevy::{prelude::*, render::camera::Camera};
 pub struct KeyboardConf {
     pub forward: Box<[KeyCode]>,
     pub backward: Box<[KeyCode]>,
@@ -26,11 +23,10 @@ impl Default for KeyboardConf {
 pub fn camera_movement(
     mut game_state: ResMut<State<GameState>>,
     mut keyboard_input: ResMut<Input<KeyCode>>,
-    mut query: Query<(
-        &mut Camera,
+    mut query: Query<
         &mut Transform,
-        &mut OrthographicProjection,
-    )>,
+        With<Camera>
+    >,
     time: Res<Time>,
     _windows: Res<Windows>,
 ) {
@@ -45,7 +41,7 @@ pub fn camera_movement(
         return;
     }
 
-    for (mut _camera, mut transform, mut projection) in query.iter_mut() {
+    for mut transform in query.iter_mut() {
         let mut direction = Vec3::ZERO;
         let scale = transform.scale.x;
 

src/game/camera/mod.rs

@@ -7,10 +7,4 @@ pub use ortho::{CustomOrthographicCameraBundle, CustomOrthographicProjection};
 #[derive(Default)]
 pub struct CurrentCamera {
     pub camera: Option<Entity>,
-}
-
-#[derive(Default)]
-pub struct CameraData {
-    // Used to lerp camera.
-    pub value: f32,
 }

src/game/game_state.rs

@@ -1,9 +1,7 @@
 #[derive(Clone, Eq, PartialEq, Debug, Hash)]
 pub enum GameState {
     Loading,
-    SpawnMap,
     GenerateMap,
-    GenerateRoads,
     MapView,
     BattleView,
 }

src/game/gameplay/camera/movement.rs

@@ -1,22 +1,20 @@
-use bevy::{prelude::*, render::camera::{Camera, CameraProjection, OrthographicProjection}};
+use bevy::{prelude::*, render::camera::Camera};
 
-use crate::game::{camera::{CameraData}, gameplay::character::PlayerSprite};
+use crate::game::{gameplay::character::PlayerSprite};
 
 pub fn movement(
 
     player_query: Query<&Transform, (With<PlayerSprite>, Without<Camera>)>,
-    mut camera_query: Query<(
-        &mut CameraData,
-        &mut Camera,
+    mut camera_query: Query<
         &mut Transform,
-        &mut OrthographicProjection,
-    )>,
+        With<Camera>
+    >,
 ) {
     let mut player_position = Vec3::ZERO;
     for player_transform in player_query.iter() {
         player_position = player_transform.translation;
     }
-    for (_camera_data, mut camera, mut camera_transform, mut projection) in camera_query.iter_mut() {
+    for mut camera_transform in camera_query.iter_mut() {
         let camera_z = camera_transform.translation.z;
 
         camera_transform.translation = camera_transform.translation.truncate().lerp(player_position.truncate(), 0.05).extend(camera_z);

src/game/gameplay/character/mod.rs

@@ -1,5 +1,5 @@
 use bevy::{prelude::*, render::camera::RenderLayers};
-use super::stats::{Stat, StatName};
+// use super::stats::{Stat, StatName};
 
 mod movement;
 mod character;

src/game/gameplay/character/movement.rs

@@ -1,38 +1,35 @@
 use bevy::prelude::*;
 
-use crate::game::map::{MAP_LAYER, MapData, MapQuery};
+use crate::game::map::{MapData};
 
 use super::PlayerSprite;
 
 pub fn movement(
     time: Res<Time>,
     mut player_query: Query<(&mut PlayerSprite, &mut Transform)>,
-    map_query: MapQuery,
     map_data_query: Query<&MapData>,
 ) {
-    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();
+    if let Ok(map_data) = map_data_query.single() {
+        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_data.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;
                     }
                 }
             }

src/game/gameplay/enemy/spawner.rs

@@ -1,5 +1,4 @@
 use bevy::{prelude::*, render::camera::RenderLayers};
-use crate::game::GameState;
 use super::spawn_enemy;
 
 #[derive(Default)]
@@ -17,7 +16,6 @@ pub fn spawn(
     materials: &mut ResMut<Assets<ColorMaterial>>,
     position: Vec2,
 ) {
-    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

src/game/gameplay/modifiers/curse.rs

@@ -1,6 +1,6 @@
 use bevy::prelude::*;
 use serde::{Deserialize, Serialize};
-use crate::game::gameplay::attributes::{AttributeNames};
+// use crate::game::gameplay::attributes::{AttributeNames};
 
 #[derive(Deserialize, Serialize, Debug, Clone, Copy)]
 pub struct Curse {

src/game/gameplay/scenes/battle.rs

@@ -1,6 +1,6 @@
 use bevy::{prelude::*, render::camera::RenderLayers};
 
-use crate::game::{camera::CustomOrthographicCameraBundle, gameplay::{character::Character, enemy::create_battle_enemy, stats::{Stat, StatName, StatsQuery}}, helpers::z_index};
+use crate::game::{camera::CustomOrthographicCameraBundle, gameplay::{character::Character, enemy::create_battle_enemy, stats::{StatName, StatsQuery}}, helpers::z_index};
 
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum BattleLocation {

src/game/gameplay/scenes/map_view.rs

@@ -1,7 +1,6 @@
 use bevy::{prelude::*, render::camera::RenderLayers};
-use bevy_ecs_tilemap::prelude::*;
 
-use crate::game::{camera::{CameraData, CurrentCamera}};
+use crate::game::{camera::{CurrentCamera}};
 
 pub fn spawn(
     mut commands: Commands,
@@ -13,7 +12,6 @@ pub fn spawn(
     let camera_entity = commands
         .spawn()
         .insert_bundle(ortho)
-        .insert(CameraData::default())
         .insert(RenderLayers::layer(0))
         .id();
 

src/game/loading.rs

@@ -7,9 +7,8 @@ pub fn loading(
     mut game_state: ResMut<State<GameState>>,
     loading_handles: Res<LoadingHandles>,
 ) {
-    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();
+        game_state.set(GameState::GenerateMap).unwrap();
     }
 }