# 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