From 836e0f5a14cb8d12b5d5b8788ddfd4af12e7a89a Mon Sep 17 00:00:00 2001
From: eri <eri@inventati.org>
Date: Mon, 4 Dec 2023 02:34:52 +0100
Subject: [PATCH] =?UTF-8?q?feat:=20entities=20following=20path=20?=
 =?UTF-8?q?=F0=9F=9B=A3=EF=B8=8F=20yaaaaay=20finally,=20it=20was=20a=20mes?=
 =?UTF-8?q?s=20to=20get=20set=20up=20with=20every=20possibility=20and=20no?=
 =?UTF-8?q?t=20just=20for=20the=20best=20path,=20but=20it=20covers=20a=20l?=
 =?UTF-8?q?ot=20of=20variants=20now,=20specially=20when=20building/rebuild?=
 =?UTF-8?q?ing=20new=20paths.=20i=20am=20sure=20it=20can=20be=20very=20imp?=
 =?UTF-8?q?roved=20upon=20but=20for=20this=20game=20jam=20it=20is=20more?=
 =?UTF-8?q?=20than=20enough?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 src/game.rs    |   4 --
 src/input.rs   |   4 +-
 src/menu.rs    |   2 -
 src/spirits.rs |  98 +++++++++++++++++++++++++------
 src/tilemap.rs | 156 ++++++++++++++++++++++++++++++++++++-------------
 5 files changed, 196 insertions(+), 68 deletions(-)

diff --git a/src/game.rs b/src/game.rs
index 3cfe03c..4325f7e 100644
--- a/src/game.rs
+++ b/src/game.rs
@@ -2,10 +2,6 @@ use bevy::{prelude::*, render::view::RenderLayers};
 
 use crate::GameState;
 
-// TODO: Spawn entities, follow pathfinding
-// TODO: Collisions between entities (traffic)
-// TODO: Multiple spawn points
-
 pub struct CharonPlugin;
 
 impl Plugin for CharonPlugin {
diff --git a/src/input.rs b/src/input.rs
index be09445..a686f90 100644
--- a/src/input.rs
+++ b/src/input.rs
@@ -7,7 +7,7 @@ use bevy::{
 use bevy_persistent::Persistent;
 use serde::{Deserialize, Serialize};
 
-use crate::config::Keybinds;
+use crate::{config::Keybinds, game::GameCam};
 
 // TODO: Mouse movement and gamepad axis
 
@@ -123,7 +123,7 @@ fn clear_input(mut input: ResMut<Input<Bind>>) {
 }
 
 fn handle_mouse_moved(
-    camera: Query<(&GlobalTransform, &Camera)>, // TODO: Create game camera and filter it here
+    camera: Query<(&GlobalTransform, &Camera), With<GameCam>>,
     mut events: EventReader<CursorMoved>,
     mut mouse: ResMut<MousePosition>,
 ) {
diff --git a/src/menu.rs b/src/menu.rs
index 2ae411e..43c96b6 100644
--- a/src/menu.rs
+++ b/src/menu.rs
@@ -339,8 +339,6 @@ fn layout_keybinds(mut cmd: Commands, node: Entity, style: &UIStyle, keybinds: &
         node.with_children(|parent| {
             UIText::new(style, "Keybinds").with_title().add(parent);
 
-            // TODO: Scrollable section (Requires #8104 to be merged in 0.13)
-
             for (i, value) in keybinds.iter_fields().enumerate() {
                 let field_name = keybinds.name_at(i).unwrap();
                 if let Some(value) = value.downcast_ref::<Vec<Bind>>() {
diff --git a/src/spirits.rs b/src/spirits.rs
index bf88dd2..90d5983 100644
--- a/src/spirits.rs
+++ b/src/spirits.rs
@@ -3,7 +3,7 @@ use bevy_ecs_tilemap::prelude::*;
 
 use crate::{
     load::GameAssets,
-    tilemap::{get_neighbours, pos_to_tile, tile_to_pos, PathTile, StartTile},
+    tilemap::{get_neighbours, pos_to_tile, tile_to_pos, EndTile, PathTile, StartTile},
     GameState,
 };
 
@@ -17,7 +17,10 @@ impl Plugin for SpiritPlugin {
     fn build(&self, app: &mut App) {
         app.insert_resource(SpawnTimer::default())
             .insert_resource(MoveTimer::default())
-            .add_systems(Update, move_spirit.run_if(in_state(GameState::Play)));
+            .add_systems(
+                Update,
+                (spawn_spirit, move_spirit).run_if(in_state(GameState::Play)),
+            );
     }
 }
 
@@ -39,7 +42,7 @@ struct MoveTimer(Timer);
 
 impl Default for MoveTimer {
     fn default() -> Self {
-        Self(Timer::from_seconds(1.0, TimerMode::Repeating))
+        Self(Timer::from_seconds(0.5, TimerMode::Repeating))
     }
 }
 
@@ -47,14 +50,16 @@ impl Default for MoveTimer {
 // Components
 // ··········
 
-#[derive(Component)]
-pub struct Spirit;
+#[derive(Component, Default)]
+pub struct Spirit {
+    prev: Option<TilePos>,
+}
 
 // ·······
 // Systems
 // ·······
 
-fn _spawn_spirit(
+fn spawn_spirit(
     mut cmd: Commands,
     mut timer: ResMut<SpawnTimer>,
     time: Res<Time>,
@@ -80,7 +85,7 @@ fn _spawn_spirit(
                         transform: Transform::from_translation(pos).with_scale(Vec3::splat(0.3)),
                         ..default()
                     },
-                    Spirit,
+                    Spirit::default(),
                 ));
             }
         }
@@ -88,10 +93,12 @@ fn _spawn_spirit(
 }
 
 fn move_spirit(
+    mut cmd: Commands,
     mut timer: ResMut<MoveTimer>,
     time: Res<Time>,
-    mut spirit: Query<&mut Transform, With<Spirit>>,
-    paths: Query<&TilePos, With<PathTile>>,
+    mut spirit: Query<(Entity, &mut Transform, &mut Spirit)>,
+    paths: Query<(&TilePos, &PathTile)>,
+    end: Query<Entity, With<EndTile>>,
     tilemap: Query<
         (
             &TilemapSize,
@@ -105,7 +112,7 @@ fn move_spirit(
 ) {
     if timer.0.tick(time.delta()).just_finished() {
         if let Ok((map_size, grid_size, map_type, storage, map_trans)) = tilemap.get_single() {
-            for mut trans in spirit.iter_mut() {
+            for (spirit_entity, mut trans, mut spirit) in spirit.iter_mut() {
                 if let Some(tile_pos) = pos_to_tile(
                     &trans.translation.xy(),
                     map_size,
@@ -113,17 +120,72 @@ fn move_spirit(
                     map_type,
                     map_trans,
                 ) {
-                    for neighbour in get_neighbours(&tile_pos, map_size) {
-                        if let Some(entity) = storage.get(&neighbour) {
-                            // TODO: Get neighbours that are paths and get lower
-                            // TODO: Check collisions
-                            if let Ok(path) = paths.get(entity) {
-                                let new_pos = tile_to_pos(&path, grid_size, map_type, map_trans);
-                                trans.translation = new_pos.extend(1.);
-                                break;
+                    let mut curr = std::f32::MAX;
+                    if let Some(entity) = storage.get(&tile_pos) {
+                        if let Ok((_, path)) = paths.get(entity) {
+                            if let Some(i) = path.0 {
+                                curr = i;
+                            }
+                        }
+                    };
+
+                    let prev = spirit.prev.unwrap_or(tile_pos);
+
+                    let neighbours = get_neighbours(&tile_pos, map_size);
+                    let next_it = neighbours
+                        .iter()
+                        .filter_map(|pos| storage.get(pos))
+                        .filter_map(|entity| {
+                            if let Ok((pos, path)) = paths.get(entity) {
+                                if pos == &prev {
+                                    None
+                                } else if let Some(i) = path.0 {
+                                    if i <= curr {
+                                        Some((pos, i))
+                                    } else {
+                                        None
+                                    }
+                                } else {
+                                    None
+                                }
+                            } else {
+                                None
+                            }
+                        });
+
+                    // Move to next tile
+                    if let Some((next, _)) =
+                        next_it.min_by(|(_, a), (_, b)| a.partial_cmp(b).unwrap())
+                    {
+                        let new_pos = tile_to_pos(next, grid_size, map_type, map_trans);
+
+                        // TODO: Check if there is a spirit on the next tile
+                        // I'm going to need to break this down into subsistems to be able to
+                        // borrow the spirit list
+                        // That or register the spirit in the tile is in (but that doesn't let me
+                        // do fancy collisions later
+                        // This needs reworking anyways so that the movement is not tile by tile
+
+                        trans.translation = new_pos.extend(1.);
+
+                        // If the next tile has the end as a neighbour, despawn
+                        for neighbour in get_neighbours(next, map_size) {
+                            if let Some(entity) = storage.get(&neighbour) {
+                                if end.get(entity).is_ok() {
+                                    cmd.get_entity(spirit_entity).unwrap().despawn_recursive();
+                                }
+                            }
+                        }
+                    } else {
+                        // If there is no next tile and you have been stuck, despawn
+                        if let Some(prev) = spirit.prev {
+                            if prev == tile_pos {
+                                cmd.get_entity(spirit_entity).unwrap().despawn_recursive();
                             }
                         }
                     }
+
+                    spirit.prev = Some(tile_pos);
                 }
             }
         }
diff --git a/src/tilemap.rs b/src/tilemap.rs
index cb089a6..d2f0145 100644
--- a/src/tilemap.rs
+++ b/src/tilemap.rs
@@ -1,5 +1,8 @@
+#![allow(clippy::too_many_arguments)]
 #![allow(clippy::type_complexity)]
 
+use std::collections::{HashMap, VecDeque};
+
 use bevy::prelude::*;
 use bevy_ecs_tilemap::{helpers::square_grid::neighbors::SquareDirection, prelude::*};
 use bevy_persistent::Persistent;
@@ -11,9 +14,8 @@ use crate::{
     GameState,
 };
 
-// TODO: Astar algorithm to generate pathfinding
-// TODO: Run astar only when some tile change
 // TODO: Automatically select path sprite (corner, straight, intersection)
+// TODO: Multiple start/end points
 
 const MAP_SIZE: TilemapSize = TilemapSize { x: 15, y: 10 };
 const TILE_SIZE: TilemapTileSize = TilemapTileSize { x: 64., y: 64. };
@@ -152,6 +154,8 @@ fn click_tile(
     mut changed: ResMut<TileChanged>,
     mut prev: Local<Option<(bool, Option<TilePos>, Option<TilePos>)>>,
 ) {
+    // TODO: Make sure that the paths are adjacent, maybe change the way they are drawn
+
     let select = keybinds.interact.iter().any(|bind| {
         if prev.is_none() {
             input.just_pressed(*bind)
@@ -192,14 +196,14 @@ fn click_tile(
 
                             // If the new tile is also a neighbour of the one two ago, delete the previous one
                             if prev_neighbours.iter().any(|p| p == pos) {
-                                let entity = storage.get(&one).unwrap();
+                                let entity = storage.get(one).unwrap();
                                 cmd.entity(entity).remove::<PathTile>();
-                                one_ago.replace(pos.clone());
+                                one_ago.replace(*pos);
                                 return;
                             }
                         }
                     }
-                    *two_ago = one_ago.replace(pos.clone());
+                    *two_ago = one_ago.replace(*pos);
                 }
             }
             return;
@@ -224,8 +228,8 @@ fn highlight_tile(
             *tex = TileTextureIndex(3);
         } else if path.is_some() {
             *tex = TileTextureIndex(3);
-            if let Some(value) = path.unwrap().0 {
-                *color = TileColor(Color::rgb(value as f32 / 20., 1. - value as f32 / 20., 0.));
+            if let Some(i) = path.unwrap().0 {
+                *color = TileColor(Color::rgb(i / 30., 1. - i / 30., 0.));
             }
         } else if start.is_some() || end.is_some() {
             *tex = TileTextureIndex(2);
@@ -243,35 +247,29 @@ fn pathfinding(
 ) {
     if let Ok((size, storage)) = tilemap.get_single() {
         if let (Ok(start), Ok(end)) = (start.get_single(), end.get_single()) {
-            let mut open = PriorityQueue::new(end.clone());
+            let mut open = PathfindingQueue::new(*end);
             let mut closed = Vec::new();
-            open.push(start.clone(), 0.);
+
+            open.push(*start, None, 0.);
 
             // Iterate the pathfinding queue
             while !open.is_empty() {
-                let (current, g) = open.pop().unwrap();
+                let (current, g, _) = open.pop().unwrap();
 
                 // Get the neighbouring tiles
                 let neighbours = get_neighbours(&current, size);
 
-                // TODO: Order with heuristic
                 for neighbour in neighbours {
                     // If the tile is already closed, skip it
                     if !closed.contains(&neighbour) {
                         if let Some(entity) = storage.get(&neighbour) {
-                            // If the goal is reached, stop
-                            if neighbour == *end {
-                                break;
-                            }
-
-                            match paths.get_mut(entity) {
+                            if let Ok(mut path) = paths.get_mut(entity) {
                                 // If the tile is a path, update its value and add it to the queue
-                                Ok(mut path) => {
-                                    path.0 = Some(g + 1.);
-                                    open.push(neighbour, path.0.unwrap());
-                                }
-                                // If it is not, skip it
-                                Err(_) => continue,
+                                open.push(neighbour, Some(current), g + 1.);
+                                path.0 = None;
+                            } else if neighbour == *end {
+                                // If the tile is the end, finish the queue
+                                open.push(neighbour, Some(current), g + 1.);
                             }
                         }
                     }
@@ -280,6 +278,16 @@ fn pathfinding(
                 // Mark the current tile as done
                 closed.push(current);
             }
+
+            // Create the paths and update the tiles
+            let built_paths = open.create_paths();
+            for (pos, i) in built_paths {
+                if let Some(entity) = storage.get(&pos) {
+                    if let Ok(mut path) = paths.get_mut(entity) {
+                        path.0 = Some(i as f32);
+                    }
+                }
+            }
         }
     }
 }
@@ -295,44 +303,106 @@ const DIRECTIONS: [SquareDirection; 4] = [
     SquareDirection::West,
 ];
 
-struct PriorityQueue {
-    heap: Vec<(TilePos, f32)>,
+struct PathfindingQueue {
+    heap: Vec<(TilePos, f32, f32)>,
+    came_from: HashMap<TilePos, Vec<TilePos>>,
     end: TilePos,
 }
 
-impl PriorityQueue {
+impl PathfindingQueue {
     fn new(end: TilePos) -> Self {
         Self {
             heap: Vec::new(),
+            came_from: HashMap::new(),
             end,
         }
     }
 
-    fn push(&mut self, pos: TilePos, g: f32) {
-        // TODO: Fix multiple paths
-        if let Some((_, old_g)) = self.heap.iter().find(|(p, _)| p == &pos) {
-            if g < *old_g {
-                self.heap.retain(|(p, _)| p != &pos);
+    fn push(&mut self, pos: TilePos, from: Option<TilePos>, g: f32) {
+        self.heap.push((pos, g, heuristic(&pos, &self.end)));
+        self.heap
+            .sort_by(|(_, a_g, a_h), (_, b_g, b_h)| (a_g + a_h).partial_cmp(&(b_g + b_h)).unwrap());
+        self.heap.reverse();
+
+        if let Some(from) = from {
+            if let Some(path) = self.came_from.get_mut(&pos) {
+                path.push(from);
             } else {
-                return;
+                self.came_from.insert(pos, vec![from]);
             }
         }
-        self.heap.push((pos, g));
-        self.heap.sort_by(|(a_pos, a_g), (b_pos, b_g)| {
-            astar_f(a_pos, &self.end, *a_g)
-                .partial_cmp(&astar_f(b_pos, &self.end, *b_g))
-                .unwrap()
-        });
-        self.heap.reverse();
     }
 
-    fn pop(&mut self) -> Option<(TilePos, f32)> {
+    fn pop(&mut self) -> Option<(TilePos, f32, f32)> {
         self.heap.pop()
     }
 
     fn is_empty(&self) -> bool {
         self.heap.is_empty()
     }
+
+    fn create_paths(&self) -> HashMap<TilePos, i32> {
+        let mut paths: HashMap<TilePos, i32> = HashMap::new();
+        let mut queue: VecDeque<(TilePos, i32)> = VecDeque::new();
+
+        paths.insert(self.end, 0);
+        queue.push_back((self.end, 0));
+
+        // Create finished paths
+        while let Some((node, priority)) = queue.pop_front() {
+            if let Some(neighbors) = self.came_from.get(&node) {
+                for neighbor in neighbors {
+                    let new_priority = priority + 1;
+                    match paths.get(neighbor) {
+                        Some(&current_priority) if current_priority < new_priority => (),
+                        _ => {
+                            paths.insert(*neighbor, new_priority);
+                            queue.push_back((*neighbor, new_priority));
+                        }
+                    }
+                }
+            }
+        }
+
+        // For each tile without a path, create a path
+        let outliers: Vec<TilePos> = self
+            .came_from
+            .keys()
+            .filter(|k| !paths.contains_key(k))
+            .cloned()
+            .collect();
+
+        let max_priority = *paths.values().max().unwrap_or(&0);
+        let main_paths: Vec<TilePos> = paths.keys().cloned().collect();
+
+        for outlier in &outliers {
+            let distance_to_main_path = main_paths
+                .iter()
+                .map(|main_path| manhattan_distance(outlier, main_path))
+                .min()
+                .unwrap_or(100000);
+            let priority = max_priority + distance_to_main_path;
+            paths.insert(*outlier, priority);
+            queue.push_back((*outlier, priority));
+        }
+
+        while let Some((node, priority)) = queue.pop_front() {
+            if let Some(neighbors) = self.came_from.get(&node) {
+                for neighbor in neighbors {
+                    let new_priority = priority + 1;
+                    match paths.get(neighbor) {
+                        Some(&current_priority) if current_priority < new_priority => (),
+                        _ => {
+                            paths.insert(*neighbor, new_priority);
+                            queue.push_back((*neighbor, new_priority));
+                        }
+                    }
+                }
+            }
+        }
+
+        paths
+    }
 }
 
 pub fn get_neighbours(pos: &TilePos, size: &TilemapSize) -> Vec<TilePos> {
@@ -353,8 +423,10 @@ fn heuristic(pos: &TilePos, end: &TilePos) -> f32 {
     (dx * dx + dy * dy).sqrt()
 }
 
-fn astar_f(pos: &TilePos, end: &TilePos, g: f32) -> f32 {
-    g + heuristic(pos, end)
+pub fn manhattan_distance(pos1: &TilePos, pos2: &TilePos) -> i32 {
+    let dx = (pos1.x as i32 - pos2.x as i32).abs();
+    let dy = (pos1.y as i32 - pos2.y as i32).abs();
+    dx + dy
 }
 
 pub fn pos_to_tile(