popertots/dorf
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

feat: fix log fixture passthrough, improve collision, add move_direction

Browse Source 
Fix 1 — insert_fixture now updates ChunkData bitsets:
  Log trunks (can_stand_in=false) now block movement in is_standable.
  Leaf canopy (can_stand_in=true) remains walkable.

Fix 2 — Diagonal-aware collision avoidance:
  Sidestep priority: left+forward, left, right+forward, right.
  If all blocked: push through (excuse me), advance path, apply one-step
  delay (speed-modulated recovery). Does not stack delays.

Fix 3 — Movement direction tracking:
  Ambulatory now has move_direction (Vec2) and step_history ([i16; 4]).
  TileOccupancy tracks per-tile direction hints for Stage 2 collision
  (convoy skip, E/S yield) via direction_at().
  move_direction is smoothed from: 2 historical steps, current confirmed
  step, and 2-step path lookahead.

Ignore: add *.patch and *.diff to .gitignore
This commit is contained in:
popertots
2026-03-21 11:07:35 +00:00
parent f0cb86e73c
commit d325aa6488
8 changed files with 168 additions and 31 deletions
Download Patch File Download Diff File Expand all files Collapse all files
src/entities/livestock/pig.rs
+2
View File
@@ -30,6 +30,8 @@ impl Pig {
path_index: 0,
step_recovery: 0,
validation_cooldown: 0,
move_direction: Vec2::ZERO,
step_history: [0i16; 4],
},
sprite: Sprite {
image: asset_server.load("pig.png"),
src/entities/livestock/rabbit.rs
+2
View File
@@ -27,6 +27,8 @@ impl Rabbit {
path_index: 0,
step_recovery: 0,
validation_cooldown: 0,
move_direction: Vec2::ZERO,
step_history: [0i16; 4],
},
sprite: Sprite {
image: asset_server.load("rabbit.png"),
src/entities/sentient/dorf.rs
+2
View File
@@ -27,6 +27,8 @@ impl Dorf {
path_index: 0,
step_recovery: 0,
validation_cooldown: 0,
move_direction: Vec2::ZERO,
step_history: [0i16; 4],
},
sprite: Sprite {
image: asset_server.load("dorf.png"),
src/entities/shared_components/ambulatory.rs
+4
View File
@@ -10,6 +10,8 @@ pub struct Ambulatory {
pub target: Option<Vec3>,
pub step_recovery: u32,
pub validation_cooldown: u8,
pub move_direction: Vec2,
pub step_history: [i16; 4],
}
impl Default for Ambulatory {
@@ -22,6 +24,8 @@ impl Default for Ambulatory {
target: None,
step_recovery: 0,
validation_cooldown: 0,
move_direction: Vec2::ZERO,
step_history: [0i16; 4],
}
}
}
src/entities/shared_systems/occupancy.rs
+16 -2
View File
@@ -6,6 +6,7 @@ use rustc_hash::FxHashMap;
#[derive(Resource, Default)]
pub struct TileOccupancy {
pub counts: FxHashMap<(i32, i32), u8>,
pub directions: FxHashMap<(i32, i32), Vec2>,
}
impl TileOccupancy {
@@ -15,19 +16,32 @@ impl TileOccupancy {
let ty = (world_pos.y as i32) / ITILE_SIZE;
*self.counts.get(&(tx, ty)).unwrap_or(&0)
}
#[inline]
pub fn direction_at(&self, world_pos: Vec3) -> Vec2 {
let tx = (world_pos.x as i32) / ITILE_SIZE;
let ty = (world_pos.y as i32) / ITILE_SIZE;
*self.directions.get(&(tx, ty)).unwrap_or(&Vec2::ZERO)
}
}
pub fn rebuild_tile_occupancy(
mut occupancy: ResMut<TileOccupancy>,
query: Query<&Transform, With<Ambulatory>>,
query: Query<(&Transform, &Ambulatory)>,
) {
occupancy.counts.clear();
for transform in query.iter() {
occupancy.directions.clear();
for (transform, ambulatory) in query.iter() {
let tx = (transform.translation.x as i32) / ITILE_SIZE;
let ty = (transform.translation.y as i32) / ITILE_SIZE;
let count = occupancy.counts.entry((tx, ty)).or_insert(0);
if *count < 255 {
*count += 1;
}
if ambulatory.move_direction != Vec2::ZERO {
occupancy
.directions
.insert((tx, ty), ambulatory.move_direction);
}
}
}
src/entities/shared_systems/pathfinding.rs
+134 -28
View File
@@ -594,48 +594,145 @@ pub fn movement(
if let Some(path) = &ambulatory.current_path {
if ambulatory.path_index < path.len() {
let old_translation = transform.translation;
let next_point = path[ambulatory.path_index];
let current_count = occupancy.count_at(transform.translation);
let next_count = occupancy.count_at(next_point);
let current_crowded = current_count > 3;
let occupied = !current_crowded && next_count > current_count;
if occupied {
let move_dir = next_point - transform.translation;
if move_dir.length_squared() > 0.0 {
let left_dir =
Vec3::new(-move_dir.y, move_dir.x, 0.0).normalize() * TILE_SIZE;
let left_raw = transform.translation + left_dir;
let left_point = Vec3::new(
(left_raw.x / TILE_SIZE).round() * TILE_SIZE,
(left_raw.y / TILE_SIZE).round() * TILE_SIZE,
transform.translation.z,
);
let left_free = tilemap.is_standable(left_point.as_ivec3())
&& occupancy.count_at(left_point) == 0;
if left_free {
if left_dir.x > 0.0 {
transform.scale.x = PIXEL_RATIO;
} else if left_dir.x < 0.0 {
transform.scale.x = -PIXEL_RATIO;
}
transform.translation = left_point;
let actual_move: Vec3;
let advance_path: bool;
let move_dir = next_point - transform.translation;
if occupied && move_dir.length_squared() > 0.0 {
let forward_2d = Vec2::new(move_dir.x, move_dir.y).normalize();
let left_2d = Vec2::new(-forward_2d.y, forward_2d.x);
let right_2d = Vec2::new(forward_2d.y, -forward_2d.x);
let cur_z = transform.translation.z;
let candidates = [
snap_to_grid(
transform.translation
+ Vec3::new(
(left_2d.x + forward_2d.x).signum() * TILE_SIZE,
(left_2d.y + forward_2d.y).signum() * TILE_SIZE,
0.0,
),
cur_z,
TILE_SIZE,
),
snap_to_grid(
transform.translation
+ Vec3::new(left_2d.x * TILE_SIZE, left_2d.y * TILE_SIZE, 0.0),
cur_z,
TILE_SIZE,
),
snap_to_grid(
transform.translation
+ Vec3::new(
(right_2d.x + forward_2d.x).signum() * TILE_SIZE,
(right_2d.y + forward_2d.y).signum() * TILE_SIZE,
0.0,
),
cur_z,
TILE_SIZE,
),
snap_to_grid(
transform.translation
+ Vec3::new(
right_2d.x * TILE_SIZE,
right_2d.y * TILE_SIZE,
0.0,
),
cur_z,
TILE_SIZE,
),
];
let sidestep = candidates.iter().copied().find(|&c| {
tilemap.is_standable(c.as_ivec3())
&& occupancy.count_at(c) <= current_count
});
if let Some(step) = sidestep {
actual_move = step;
advance_path = false;
} else {
actual_move = next_point;
advance_path = true;
let tile_weight =
get_tile_weight(&tilemap, transform.translation.as_ivec3());
let threshold = if ambulatory.walk_speed > 0. {
(ambulatory.walk_speed as i32 * tile_weight as i32 / 50) as u32
} else {
0
};
if ambulatory.step_recovery == 0 {
ambulatory.step_recovery = threshold;
}
}
} else {
let direction = (next_point - transform.translation).normalize();
transform.translation = next_point;
actual_move = next_point;
advance_path = true;
}
if direction.x > 0.0 {
transform.scale.x = PIXEL_RATIO;
} else if direction.x < 0.0 {
transform.scale.x = -PIXEL_RATIO;
let direction = (actual_move - transform.translation).normalize_or_zero();
transform.translation = actual_move;
if direction.x > 0.0 {
transform.scale.x = PIXEL_RATIO;
} else if direction.x < 0.0 {
transform.scale.x = -PIXEL_RATIO;
}
if advance_path && transform.translation.distance(next_point) < TILE_SIZE {
let ITILE: i16 = ITILE_SIZE as i16;
ambulatory.step_history[0] = ambulatory.step_history[2];
ambulatory.step_history[1] = ambulatory.step_history[3];
ambulatory.step_history[2] = (old_translation.x as i16) / ITILE;
ambulatory.step_history[3] = (old_translation.y as i16) / ITILE;
let mut dir_sum = Vec2::ZERO;
let mut n = 0u32;
let h = &ambulatory.step_history;
if h[0] != 0 || h[1] != 0 {
let d = Vec2::new((h[2] - h[0]) as f32, (h[3] - h[1]) as f32);
if d.length_squared() > 0.0 {
dir_sum += d.normalize();
n += 1;
}
}
if transform.translation.distance(next_point) < TILE_SIZE {
ambulatory.path_index += 1;
let cur_d = Vec2::new(
actual_move.x - old_translation.x,
actual_move.y - old_translation.y,
);
if cur_d.length_squared() > 0.0 {
dir_sum += cur_d.normalize();
n += 1;
}
if let Some(ref path) = ambulatory.current_path {
let start = ambulatory.path_index;
for i in start..((start + 2).min(path.len().saturating_sub(1))) {
let a = path[i];
let b = path[i + 1];
let d = Vec2::new(b.x - a.x, b.y - a.y);
if d.length_squared() > 0.0 {
dir_sum += d.normalize();
n += 1;
}
}
}
if n > 0 {
ambulatory.move_direction = (dir_sum / n as f32).normalize_or_zero();
}
ambulatory.path_index += 1;
}
} else {
ambulatory.current_path = None;
@@ -664,6 +761,15 @@ fn is_standable_tile(tilemap: &TileMap, pos: IVec3) -> bool {
tilemap.is_standable(pos)
}
#[inline]
fn snap_to_grid(raw: Vec3, preserve_z: f32, tile_size: f32) -> Vec3 {
Vec3::new(
(raw.x / tile_size).round() * tile_size,
(raw.y / tile_size).round() * tile_size,
preserve_z,
)
}
/// Sample a random standable tile on an edge of `next_chunk`, picking the one
/// whose world position is closest to the straight-line projection from
/// `current_pos` toward `goal`. Falls back to chunk centre if no standable
src/world/tiles/tilemap.rs
+5
View File
@@ -194,6 +194,11 @@ impl TileMap {
#[inline]
pub fn insert_fixture(&mut self, pos: IVec3, tile: FixtureTileData) {
let chunk_pos = world_to_chunk(pos);
if let Some(chunk) = self.chunks.get_mut(&chunk_pos) {
let (lx, ly, z) = ChunkData::world_to_local(pos);
chunk.set_fixture_tile(lx, ly, z, tile.can_stand_in(), tile.can_stand_on());
}
self.fixture_tiles.insert(pos, tile);
}