135 lines
4.8 KiB
Markdown
135 lines
4.8 KiB
Markdown
# Session Summary: Data-Oriented Chunks Optimization
|
|
|
|
## Date: 2026-03-19
|
|
|
|
## Completed Work
|
|
|
|
### Phase 1-3 Optimization (Implemented over multiple sessions)
|
|
1. **Bit-Packed Standability** - ChunkData with bitsets for O(1) pathfinding
|
|
2. **Reactive Connectivity** - Dirty flag system for O(d) connectivity updates
|
|
3. **Async Terrain Baking** - AsyncComputeTaskPool for terrain generation
|
|
|
|
### Recent Session Changes
|
|
|
|
1. **External Tile Registry** (`tiles.toml`)
|
|
- Hot-reloadable tile definitions without recompiling
|
|
- TileRegistry singleton for async-safe access
|
|
- Configurable weights, IDs, standability flags
|
|
|
|
2. **Pathfinding Weight System**
|
|
- Lower weight = preferred path (rock=50 best, bedrock=150 worst)
|
|
- Movement speed affected by tile weight
|
|
- `calculate_movement_cost(move_dir, tile_weight)` signature change
|
|
|
|
3. **Bug Fixes**
|
|
- Fixed infinite spawner with `Local<bool>` state guards
|
|
- Fixed `world_to_chunk` to use `CHUNK_SIZE_TILE` (128) not `CHUNK_SIZE` (8)
|
|
- Fixed spawn coordinate grid alignment
|
|
- Fixed standability logic (reverted to original)
|
|
|
|
4. **Standability Logic (Working Version)**
|
|
```rust
|
|
fn is_standable_slow(&self, pos: IVec3) -> bool {
|
|
let can_stand_in_floor = self.floor_tiles.get(&pos)
|
|
.map(|t| t.can_stand_in()).unwrap_or(false);
|
|
let can_stand_in_fixture = self.fixture_tiles.get(&pos)
|
|
.map(|t| t.can_stand_in()).unwrap_or(false);
|
|
let pos_below = IVec3::new(pos.x, pos.y, pos.z - ITILE_SIZE);
|
|
let can_stand_on_floor = self.floor_tiles.get(&pos_below)
|
|
.map(|t| t.can_stand_on()).unwrap_or(false);
|
|
let can_stand_on_fixture = self.fixture_tiles.get(&pos_below)
|
|
.map(|t| t.can_stand_on()).unwrap_or(false);
|
|
(can_stand_in_floor || can_stand_in_fixture)
|
|
&& (can_stand_on_floor || can_stand_on_fixture)
|
|
}
|
|
```
|
|
|
|
## Current Bug: Zigzag Pathfinding
|
|
|
|
### Symptom
|
|
Entities no longer walk in straight lines to their targets. Movement shows erratic zigzag behavior instead of direct paths.
|
|
|
|
### Working Hypothesis
|
|
The zigzag behavior likely stems from:
|
|
1. Path validation failing and paths being constantly regenerated
|
|
2. Weight system causing cost calculation issues
|
|
3. Movement speed modifier causing step recovery inconsistencies
|
|
4. The tile weight being applied incorrectly in movement
|
|
|
|
### What Was Working Before Recent Changes
|
|
- Straight-line pathfinding
|
|
- Entities would walk directly to targets
|
|
|
|
### What Changed That Might Cause Zigzag
|
|
- `calculate_movement_cost` now takes `tile_weight` parameter
|
|
- Movement speed now varies by tile weight
|
|
- `get_tile_weight()` retrieves weight from tilemap
|
|
|
|
### Relevant Code Locations
|
|
- `src/entities/shared_systems/pathfinding.rs`
|
|
- `calculate_movement_cost()` lines ~600
|
|
- `get_tile_weight()` lines ~440
|
|
- Movement system lines ~482
|
|
- `src/world/tiles/tilemap.rs`
|
|
- `get_astar_weight()` method
|
|
- `tiles.toml`
|
|
- Weight values: rock=50, grass=100, bedrock=150
|
|
|
|
---
|
|
|
|
# Next Agent Prompt
|
|
|
|
## Starting From Zero Context
|
|
|
|
You are investigating a zigzag pathfinding bug in a Bevy game engine project called "Dorf".
|
|
|
|
### Project Overview
|
|
- Voxel-style game with procedural terrain generation
|
|
- Pathfinding system with A* implementation
|
|
- Tile-based world with gravity for entities
|
|
- Coordinates: TILE_SIZE=16, ITILE_SIZE=16
|
|
|
|
### The Bug
|
|
After recent commits, entities exhibit zigzag movement instead of walking in straight lines to their targets.
|
|
|
|
### Investigation Steps
|
|
1. **Read the pathfinding system** (`src/entities/shared_systems/pathfinding.rs`)
|
|
- Focus on `movement()` function (line ~482)
|
|
- Focus on `calculate_movement_cost()` (line ~600)
|
|
- Focus on path validation (`validate_next_steps()`)
|
|
|
|
2. **Understand the weight system**
|
|
- How does `tile_weight` affect `calculate_movement_cost()`?
|
|
- Does varying movement costs cause zigzag paths?
|
|
|
|
3. **Check movement speed modifier**
|
|
- `threshold = walk_speed * (tile_weight / 50.0)`
|
|
- Could this cause inconsistent stepping?
|
|
|
|
4. **Compare with git history**
|
|
- Run `git log --oneline -10` to see recent commits
|
|
- `git diff HEAD~1` to see last commit changes
|
|
- Find when zigzag started by checking commits
|
|
|
|
5. **Hypothesize and test**
|
|
- Disable weight system temporarily
|
|
- Compare path cost calculations
|
|
- Verify path validation is working
|
|
|
|
### Key Files
|
|
- `src/entities/shared_systems/pathfinding.rs` - Main pathfinding logic
|
|
- `src/entities/shared_components/ambulatory.rs` - Movement state
|
|
- `src/world/tiles/tilemap.rs` - Tile lookups
|
|
- `tiles.toml` - Tile weight definitions
|
|
|
|
### Expected Behavior
|
|
Entities should walk in straight lines from start to goal when no obstacles.
|
|
|
|
### Actual Behavior
|
|
Entities zigzag/wander instead of walking straight.
|
|
|
|
### Success Criteria
|
|
- Entities walk in straight lines to targets
|
|
- Path costs are consistent
|
|
- No erratic movement behavior
|