refactored player into own plugin :D

src/player.rs

@@ -1,60 +1,57 @@
-use bevy::prelude::*;
+use bevy::{prelude::*, utils::HashSet};
 use bevy_ecs_ldtk::prelude::*;
-use bevy_rapier2d::dynamics::Velocity;
 
-use crate::{climbing::Climber, inventory::Inventory};
-use crate::{colliders::ColliderBundle, ground_detection::GroundDetection};
+use crate::{Wall, GRID_SIZE};
 
-#[derive(Copy, Clone, Eq, PartialEq, Debug, Default, Component)]
-pub struct Player;
+#[derive(Default, Component)]
+pub(crate) struct Player;
 
-#[derive(Clone, Default, Bundle, LdtkEntity)]
-pub struct PlayerBundle {
-    #[sprite_bundle("player.png")]
-    pub sprite_bundle: SpriteBundle,
-    #[from_entity_instance]
-    pub collider_bundle: ColliderBundle,
-    pub player: Player,
-    #[worldly]
-    pub worldly: Worldly,
-    pub climber: Climber,
-    pub ground_detection: GroundDetection,
-
-    // Build Items Component manually by using `impl From<&EntityInstance>`
-    #[from_entity_instance]
-    items: Inventory,
-
-    // The whole EntityInstance can be stored directly as an EntityInstance component
-    #[from_entity_instance]
-    entity_instance: EntityInstance,
+#[derive(Default, Bundle, LdtkEntity)]
+struct PlayerBundle {
+    player: Player,
+    #[sprite_sheet_bundle]
+    sprite_bundle: LdtkSpriteSheetBundle,
+    #[grid_coords]
+    grid_coords: GridCoords,
 }
 
-pub fn player_movement(
+#[derive(Default, Resource)]
+struct LevelWalls {
+    wall_locations: HashSet<GridCoords>,
+    level_width: i32,
+    level_height: i32,
+}
+impl LevelWalls {
+    fn in_wall(&self, grid_coords: &GridCoords) -> bool {
+        grid_coords.x < 0
+            || grid_coords.y < 0
+            || grid_coords.x >= self.level_width
+            || grid_coords.y >= self.level_height
+            || self.wall_locations.contains(grid_coords)
+    }
+}
+
+fn move_player_from_input(
+    mut players: Query<&mut GridCoords, With<Player>>,
     input: Res<ButtonInput<KeyCode>>,
-    mut query: Query<(&mut Velocity, &mut Climber, &GroundDetection), With<Player>>,
+    level_walls: Res<LevelWalls>,
 ) {
-    for (mut velocity, mut climber, ground_detection) in &mut query {
-        let right = if input.pressed(KeyCode::KeyD) { 1. } else { 0. };
-        let left = if input.pressed(KeyCode::KeyA) { 1. } else { 0. };
+    let movement_direction = if input.just_pressed(KeyCode::KeyW) {
+        GridCoords::new(0, 1)
+    } else if input.just_pressed(KeyCode::KeyA) {
+        GridCoords::new(-1, 0)
+    } else if input.just_pressed(KeyCode::KeyS) {
+        GridCoords::new(0, -1)
+    } else if input.just_pressed(KeyCode::KeyD) {
+        GridCoords::new(1, 0)
+    } else {
+        return;
+    };
 
-        velocity.linvel.x = (right - left) * 200.;
-
-        if climber.intersecting_climbables.is_empty() {
-            climber.climbing = false;
-        } else if input.just_pressed(KeyCode::KeyW) || input.just_pressed(KeyCode::KeyS) {
-            climber.climbing = true;
-        }
-
-        if climber.climbing {
-            let up = if input.pressed(KeyCode::KeyW) { 1. } else { 0. };
-            let down = if input.pressed(KeyCode::KeyS) { 1. } else { 0. };
-
-            velocity.linvel.y = (up - down) * 200.;
-        }
-
-        if input.just_pressed(KeyCode::Space) && (ground_detection.on_ground || climber.climbing) {
-            velocity.linvel.y = 500.;
-            climber.climbing = false;
+    for mut player_grid_coords in players.iter_mut() {
+        let destination = *player_grid_coords + movement_direction;
+        if !level_walls.in_wall(&destination) {
+            *player_grid_coords = destination;
         }
     }
 }
@@ -63,7 +60,37 @@ pub struct PlayerPlugin;
 
 impl Plugin for PlayerPlugin {
     fn build(&self, app: &mut App) {
-        app.add_systems(Update, player_movement)
-            .register_ldtk_entity::<PlayerBundle>("Player");
+        app.add_systems(Update, (move_player_from_input, cache_wall_locations))
+            .register_ldtk_entity::<PlayerBundle>("Player")
+            .init_resource::<LevelWalls>();
+    }
+}
+
+fn cache_wall_locations(
+    mut level_walls: ResMut<LevelWalls>,
+    mut level_events: EventReader<LevelEvent>,
+    walls: Query<&GridCoords, With<Wall>>,
+    ldtk_project_entities: Query<&Handle<LdtkProject>>,
+    ldtk_project_assets: Res<Assets<LdtkProject>>,
+) {
+    for level_event in level_events.read() {
+        if let LevelEvent::Spawned(level_iid) = level_event {
+            let ldtk_project = ldtk_project_assets
+                .get(ldtk_project_entities.single())
+                .expect("LdtkProject should be loaded when level is spawned");
+            let level = ldtk_project
+                .get_raw_level_by_iid(level_iid.get())
+                .expect("spawned level should exist in project");
+
+            let wall_locations = walls.iter().copied().collect();
+
+            let new_level_walls = LevelWalls {
+                wall_locations,
+                level_width: level.px_wid / GRID_SIZE,
+                level_height: level.px_hei / GRID_SIZE,
+            };
+
+            *level_walls = new_level_walls;
+        }
     }
 }