Updated player movement code to be smoother, and added camera smoothing.

Used an event to pass data to the battle view.
Camera now follows player.
Simple Player/Enemy collision detection.

Author: StarArawn

src/game/camera/input.rs

@@ -1,7 +1,5 @@
-use crate::game::{gameplay::scenes, GameState};
-use bevy::render::camera::CameraProjection;
+use crate::game::GameState;
 use bevy::{
-    // input::mouse::{MouseMotion, MouseWheel},
     prelude::*,
     render::camera::Camera,
 };
@@ -29,29 +27,18 @@ impl Default for KeyboardConf {
 }
 
 pub fn camera_movement(
-    asset_server: Res<AssetServer>,
-    mut commands: Commands,
     mut game_state: ResMut<State<GameState>>,
     mut keyboard_input: ResMut<Input<KeyCode>>,
-    mut materials: ResMut<Assets<ColorMaterial>>,
     mut query: Query<(
         &mut Camera,
         &mut Transform,
         &mut CustomOrthographicProjection,
     )>,
     time: Res<Time>,
-    windows: Res<Windows>,
+    _windows: Res<Windows>,
 ) {
     if keyboard_input.just_pressed(KeyCode::P) {
-        if *game_state.current() == GameState::MapView {
-            game_state.set(GameState::BattleView).unwrap();
-            scenes::battle::spawn(
-                scenes::battle::BattleLocation::Mountains,
-                &mut commands,
-                &asset_server,
-                &mut materials,
-            );
-        } else if *game_state.current() == GameState::BattleView {
+        if *game_state.current() == GameState::BattleView {
             game_state.set(GameState::MapView).unwrap();
         }
         keyboard_input.update();
@@ -61,7 +48,7 @@ pub fn camera_movement(
         return;
     }
 
-    for (mut camera, mut transform, mut projection) in query.iter_mut() {
+    for (mut _camera, mut transform, mut projection) in query.iter_mut() {
         let mut direction = Vec3::ZERO;
         let scale = projection.scale;
 
@@ -91,12 +78,7 @@ pub fn camera_movement(
             projection.scale = scale;
         }
 
-        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();
+
 
         transform.translation += time.delta_seconds() * direction * 1000.;
     }

src/game/camera/mod.rs

@@ -7,4 +7,10 @@ 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/gameplay/camera/mod.rs

@@ -0,0 +1,3 @@
+mod movement;
+
+pub use movement::movement;

src/game/gameplay/camera/movement.rs

@@ -0,0 +1,34 @@
+use bevy::{prelude::*, render::camera::{Camera, CameraProjection}};
+
+use crate::game::{camera::{CameraData, CustomOrthographicProjection}, gameplay::player::PlayerSprite};
+
+pub fn movement(
+    time: Res<Time>,
+    windows: Res<Windows>,
+    player_query: Query<&Transform, (With<PlayerSprite>, Without<Camera>)>,
+    mut camera_query: Query<(
+        &mut CameraData,
+        &mut Camera,
+        &mut Transform,
+        &mut CustomOrthographicProjection,
+    )>,
+) {
+    let mut player_position = Vec3::ZERO;
+    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() {
+        let camera_z = camera_transform.translation.z;
+        
+        camera_data.value += 0.01 * time.delta_seconds();
+
+        camera_transform.translation = camera_transform.translation.truncate().lerp(player_position.truncate(), camera_data.value).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();
+    }
+}

src/game/gameplay/enemy/mod.rs

@@ -15,7 +15,7 @@ pub fn spawn_enemy(
     commands
         .spawn()
         .insert(GlobalTransform::default())
-        .insert(Transform::from_xyz(position.x, position.y, 12.0))
+        .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/spider_sprite.png");

src/game/gameplay/mod.rs

@@ -1,3 +1,4 @@
-pub mod scenes;
+pub mod camera;
 pub mod enemy;
 pub mod player;
+pub mod scenes;

src/game/gameplay/player/collision.rs

@@ -0,0 +1,32 @@
+use bevy::prelude::*;
+use crate::game::{GameState, gameplay::{enemy::Enemy, scenes}};
+use super::PlayerSprite;
+
+pub fn check(
+    mut battle_event_writer: EventWriter<scenes::battle::BattleEvent>,
+    mut game_state: ResMut<State<GameState>>,
+    player_query: Query<(&PlayerSprite, &Transform)>,
+    enemy_query: Query<(Entity, &Enemy, &Transform)>,
+) {
+    let mut enemies_within_range = Vec::new();
+    for (_, player_transform) in player_query.iter() {
+        for (enemy_entity, _, enemy_transform) in enemy_query.iter() {
+            let distance = player_transform.translation.distance_squared(enemy_transform.translation);
+            if distance <= 32.0 {
+                enemies_within_range.push((distance, enemy_entity, enemy_transform));
+            }
+        }
+
+        enemies_within_range.sort_by(|a, b| { a.0.partial_cmp(&b.0).unwrap() });
+
+        for (distance, enemy_entity, _enemy_transform) in enemies_within_range.iter() {
+            if *distance < 8.0 {
+                game_state.set(GameState::BattleView).unwrap();
+                battle_event_writer.send(scenes::battle::BattleEvent {
+                    battle_location: scenes::battle::BattleLocation::Mountains,
+                    enemy_entity: *enemy_entity,
+                });
+            }
+        }
+    }
+}

src/game/gameplay/player/mod.rs

@@ -2,43 +2,50 @@ use bevy::{prelude::*, render::camera::RenderLayers};
 
 mod movement;
 mod player;
+pub mod collision;
 pub use player::Player;
 
 pub use movement::movement;
 
+#[derive(Default)]
+pub struct PlayerSprite {
+    // Current index of the road path position that the player is traveling to.
+    pub current_position: usize,
+}
+
 pub fn spawn_player(
     mut commands: Commands,
     asset_server: Res<AssetServer>,
     mut materials: ResMut<Assets<ColorMaterial>>,
     mut texture_atlases: ResMut<Assets<TextureAtlas>>,
 ) {
-    commands.spawn().insert(Player::default())
-    .with_children(|child_builder| {
-        let map_player_texture_handle = asset_server.load("textures/player_sprite.png");
-        let map_player_sprite_material = materials.add(map_player_texture_handle.into());
-        child_builder
-            .spawn_bundle(SpriteBundle {
-                material: map_player_sprite_material,
-                transform: Transform::from_xyz(0.0, 0.0, 10.0),
-                ..Default::default()
-            })
-            .insert(RenderLayers::layer(0));
+    commands.spawn()
+        .insert(Player::default());
+
+    let map_player_texture_handle = asset_server.load("textures/player_sprite.png");
+    let map_player_sprite_material = materials.add(map_player_texture_handle.into());
+    commands
+        .spawn_bundle(SpriteBundle {
+            material: map_player_sprite_material,
+            transform: Transform::from_xyz(0.0, 0.0, 10.0),
+            ..Default::default()
+        })
+        .insert(PlayerSprite::default())
+        .insert(RenderLayers::layer(0));
+
 
-        let battle_player_texture_handle = asset_server.load("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);
-    
-        let mut transform = Transform::from_scale(Vec3::splat(5.0));
-        transform.translation.z = 12.0;
-    
-        child_builder
-            .spawn_bundle(SpriteSheetBundle {
-                texture_atlas: texture_atlas_handle,
-                transform,
-                ..Default::default()
-            })
-            .insert(RenderLayers::layer(1))
-            .insert(Timer::from_seconds(0.1, true));
-    });
+    let battle_player_texture_handle = asset_server.load("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);
+    let mut transform = Transform::from_scale(Vec3::splat(5.0));
+    transform.translation.z = 2.0;
+    commands
+        .spawn_bundle(SpriteSheetBundle {
+            texture_atlas: texture_atlas_handle,
+            transform,
+            ..Default::default()
+        })
+        .insert(RenderLayers::layer(1))
+        .insert(Timer::from_seconds(0.1, true));
 }

src/game/gameplay/player/movement.rs

@@ -1,32 +1,35 @@
-use crate::game::{map::Map, timing::Timing};
+use crate::game::map::Map;
 use bevy::prelude::*;
 
-use super::Player;
+use super::PlayerSprite;
 
 pub fn movement(
-    mut timing: ResMut<Timing>,
+    time: Res<Time>,
     map: Res<Map>,
-    mut player_query: Query<(&mut Player, &mut Transform)>,
+    mut player_query: Query<(&mut PlayerSprite, &mut Transform)>,
 ) {
-    if !timing.should_update {
-        return;
-    }
-
-    timing.should_update = false;
-
     if map.road_path.len() > 0 {
         for (mut player, mut transform) in player_query.iter_mut() {
-            player.current_position += 1;
-            if player.current_position >= map.road_path.len() {
-                player.current_position = 0;
-            }
-
             let current_road_position = map.road_path[player.current_position];
-            transform.translation = Vec3::new(
+            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,
-                10.0,
             );
+            let mut player_position = transform.translation.truncate();
+
+
+            let direction = (current_road_position - player_position).normalize();
+            player_position += direction * 100.0 * time.delta_seconds();
+
+            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;
+                }
+            }
         }
     }
 }

src/game/gameplay/player/player.rs

@@ -1,4 +1,4 @@
 #[derive(Default, Clone, Debug)]
 pub struct Player {
-    pub current_position: usize,
+
 }