Features/pathfinding

Cargo.toml

@@ -32,6 +32,7 @@ members = [
     "src/game_systems/src/background",
     "src/game_systems/src/interactions",
     "src/game_systems/src/mobs",
+    "src/game_systems/src/pathfinding",
     "src/game_systems/src/packets",
     "src/game_systems/src/physics",
     "src/game_systems/src/player",
@@ -179,7 +180,7 @@ rusty_pool = "0.7.0"
 crossbeam-queue = "0.3.12"
 
 # Network
-reqwest = { version = "0.13.2", features = ["json", "native-tls", "blocking", "http2"], default-features = false }
+reqwest = { version = "0.13.3", features = ["json", "native-tls", "blocking", "http2"], default-features = false }
 
 # Error handling
 thiserror = "2.0.18"
@@ -219,6 +220,7 @@ dashmap = { version = "7.0.0-rc2", features = ["serde"] }
 uuid = { version = "1.23.1", features = ["v4", "v3", "serde"] }
 indexmap = { version = "2.14.0", features = ["serde"] }
 bimap = "0.6.3"
+arrayvec = "0.7.6"
 
 # Macros
 lazy_static = "1.5.0"
@@ -232,7 +234,7 @@ type_hash = "0.3.0"
 
 # Magic
 dhat = "0.3.3"
-ctor = "0.10.1"
+ctor = "0.11.1"
 
 # Compression/Decompression
 yazi = "0.2.1"
@@ -252,6 +254,7 @@ num_cpus = "1.17.0"
 typename = "0.1.2"
 bevy_ecs = { version = "0.18.1", features = ["multi_threaded", "trace", "debug"], default-features = false }
 bevy_math = { version = "0.18.1", features = ["serialize"] }
+rustc-hash = "2.1.2"
 once_cell = "1.21.4"
 mime_guess = "2.0.5"
 

flake.nix

@@ -45,6 +45,7 @@
           nativeBuildInputs = [
             rust-toolchain
             pkgs.pkg-config
+            pkgs.cargo-nextest
           ];
           buildInputs = [
             pkgs.openssl

src/components/src/lib.rs

@@ -10,6 +10,7 @@ pub mod combat;
 pub mod last_chunk_pos;
 pub mod last_synced_position;
 pub mod metadata;
+pub mod pathfinder;
 pub mod physical;
 pub mod spawn;
 

src/components/src/pathfinder.rs

@@ -0,0 +1,68 @@
+use bevy_ecs::prelude::*;
+use temper_core::pos::BlockPos;
+
+const DEFAULT_BUDGET_PER_TICK: usize = 20;
+const DEFAULT_MAX_NODES: usize = 500;
+
+/// Pathfinding component for land mob entities.
+/// Set `target` each tick (or periodically) from mob AI. The system `tick_pathfinder`
+/// advances the A* search incrementally (budget_per_tick nodes/tick) and updates `path`.
+/// The mob AI reads `current_waypoint()` and calls `advance_waypoint()` when it arrives.
+#[derive(Component)]
+pub struct Pathfinder {
+    /// Target block to navigate to. Changing this restarts the search.
+    pub target: Option<BlockPos>,
+    /// Current computed path (nodes from start to goal).
+    pub path: Vec<BlockPos>,
+    /// Index of the waypoint the mob is currently heading toward.
+    pub waypoint: usize,
+    /// A* node expansions allowed per tick.
+    pub budget_per_tick: usize,
+    /// Maximum total A* expansions before giving up.
+    pub max_nodes: usize,
+    /// True while a search is in progress. Set by `tick_pathfinder`.
+    pub is_searching: bool,
+    #[doc(hidden)]
+    pub last_target: Option<BlockPos>,
+}
+
+impl Pathfinder {
+    pub fn new(budget_per_tick: usize, max_nodes: usize) -> Self {
+        Self {
+            target: None,
+            path: Vec::new(),
+            waypoint: 0,
+            budget_per_tick,
+            max_nodes,
+            is_searching: false,
+            last_target: None,
+        }
+    }
+
+    /// The block the mob should currently move toward.
+    pub fn current_waypoint(&self) -> Option<BlockPos> {
+        self.path.get(self.waypoint).copied()
+    }
+
+    /// Move to the next waypoint after reaching the current one.
+    pub fn advance_waypoint(&mut self) {
+        self.waypoint += 1;
+    }
+
+    /// True if a path is available and not yet exhausted.
+    pub fn has_path(&self) -> bool {
+        self.waypoint < self.path.len()
+    }
+
+    /// Force a new search on the next tick, even if the target hasn't changed.
+    pub fn request_repath(&mut self) {
+        self.last_target = None;
+        self.is_searching = false;
+    }
+}
+
+impl Default for Pathfinder {
+    fn default() -> Self {
+        Self::new(DEFAULT_BUDGET_PER_TICK, DEFAULT_MAX_NODES)
+    }
+}

src/core/src/block_properties.rs

@@ -0,0 +1,128 @@
+use std::sync::LazyLock;
+
+use crate::block_data::BlockData;
+use crate::block_state_id::{BlockStateId, ID2BLOCK};
+
+/// Precomputed solidity for all block states.
+/// A block is solid if it has a full collision box that entities cannot walk through.
+/// Indexed by `BlockStateId::raw()`.
+static SOLID_BLOCKS: LazyLock<Vec<bool>> = LazyLock::new(|| {
+    ID2BLOCK
+        .get_or_init(|| crate::block_state_id::create_block_mappings().0)
+        .iter()
+        .map(compute_solid)
+        .collect()
+});
+
+/// Returns whether a block is solid (has a full collision box).
+///
+/// This is the single source of truth for solidity, used by both the collision
+/// system and the pathfinding system.
+#[inline]
+pub fn is_solid(id: BlockStateId) -> bool {
+    SOLID_BLOCKS
+        .get(id.raw() as usize)
+        .copied()
+        .unwrap_or(false)
+}
+
+/// Determine whether a block data entry represents a solid block.
+fn compute_solid(data: &BlockData) -> bool {
+    let name = data.name.trim_start_matches("minecraft:");
+
+    // Air variants are never solid
+    if name.ends_with("air") {
+        return false;
+    }
+
+    // Liquids
+    if matches!(name, "water" | "lava" | "bubble_column") {
+        return false;
+    }
+
+    // Fire
+    if matches!(name, "fire" | "soul_fire") {
+        return false;
+    }
+    if name.ends_with("_campfire") {
+        // Campfires are solid blocks you can stand on, but lit ones deal damage
+        return true;
+    }
+
+    // Doors, fence gates, trapdoors: solid only when closed
+    if name.ends_with("_door") || name.ends_with("_fence_gate") || name.ends_with("_trapdoor") {
+        let open = data
+            .properties
+            .as_ref()
+            .and_then(|p| p.get("open"))
+            .is_some_and(|v| v == "true");
+        return !open;
+    }
+
+    // Non-solid vegetation and decorations
+    if is_non_solid_decoration(name) {
+        return false;
+    }
+
+    // Default: solid
+    true
+}
+
+/// Returns true for blocks that have no collision box (decorative, vegetation, etc.)
+pub fn is_non_solid_decoration(name: &str) -> bool {
+    if matches!(
+        name,
+        "grass"
+            | "short_grass"
+            | "tall_grass"
+            | "fern"
+            | "large_fern"
+            | "dead_bush"
+            | "snow"
+            | "string"
+            | "nether_portal"
+            | "spore_blossom"
+            | "glow_lichen"
+            | "dandelion"
+            | "poppy"
+            | "blue_orchid"
+            | "allium"
+            | "azure_bluet"
+            | "oxeye_daisy"
+            | "cornflower"
+            | "lily_of_the_valley"
+            | "wither_rose"
+            | "sunflower"
+            | "lilac"
+            | "rose_bush"
+            | "peony"
+            | "torchflower"
+            | "pitcher_plant"
+            | "pitcher_pod"
+            | "sweet_berry_bush"
+            | "cobweb"
+            | "powder_snow"
+            | "redstone_wire"
+            | "rail"
+            | "powered_rail"
+            | "detector_rail"
+            | "activator_rail"
+            | "tripwire"
+            | "tripwire_hook"
+            | "structure_void"
+    ) {
+        return true;
+    }
+
+    name.ends_with("_button")
+        || name.ends_with("_pressure_plate")
+        || name.ends_with("_sign")
+        || name.ends_with("_banner")
+        || name.ends_with("_carpet")
+        || name.ends_with("_torch")
+        || name.ends_with("_sapling")
+        || name.ends_with("_mushroom")
+        || name.ends_with("_flower")
+        || name.ends_with("_vine")
+        || name.ends_with("_roots")
+}

src/core/src/lib.rs

@@ -2,6 +2,7 @@ pub mod errors;
 
 // Core structs/types. Usually used in ECS Components.
 pub mod block_data;
+pub mod block_properties;
 pub mod block_state_id;
 pub mod color;
 pub mod dimension;

src/data/src/tests/blocks.rs

@@ -193,11 +193,8 @@ fn test_blocks_api_improved() {
     assert_eq!(blocks::STONE.id, blocks::stone::STONE.id);
 
     // Test total blocks count
-    assert!(!blocks::ALL_BLOCKS.is_empty());
     assert!(blocks::ALL_BLOCKS.len() > 100); // Should have many blocks
-
-    // Test shapes count
-    assert!(!blocks::shapes::SHAPES.is_empty());
+    assert!(blocks::shapes::SHAPES.len() > 100);
 }
 
 #[test]

src/game_systems/Cargo.toml

@@ -6,13 +6,14 @@ version.workspace = true
 [dependencies]
 background = { path = "./src/background" }
 mobs = { path = "./src/mobs" }
+pathfinding = { path = "./src/pathfinding" }
 packets = { path = "./src/packets" }
 physics = { path = "./src/physics" }
 player = { path = "./src/player" }
 shutdown = { path = "./src/shutdown" }
 world = { path = "./src/world" }
 interactions = { path = "./src/interactions" }
-
+tempfile = { workspace = true }
 bevy_ecs = { workspace = true }
 temper-commands = { workspace = true }
 temper-config = { workspace = true }

src/game_systems/src/mobs/Cargo.toml

@@ -5,11 +5,15 @@ edition = "2024"
 
 [dependencies]
 bevy_ecs = { workspace = true }
+bevy_math = { workspace = true }
+pathfinding = { path = "../pathfinding" }
 temper-components = { workspace = true }
 temper-entities = { workspace = true }
 temper-messages = { workspace = true }
 temper-state = { workspace = true }
 temper-core = { workspace = true }
+temper-particles = { workspace = true }
+temper-utils = { workspace = true }
 bitcode = { workspace = true }
 tracing = { workspace = true }
 temper-protocol = { workspace = true }