feat(simulation): add tile-type layer, content loader, and chunk streaming

Spatial chain for Sprint 23 (#576, #577, #578): - TileKind enum (Floor/Wall/Void/Restricted) on WalkabilityMap with set_tile_kind/tile_kind API, backward-compatible with existing is_walkable/set_walkable - Location YAML tile format: tiles as string arrays (F/W/V/R chars), load_location_tiles() stamps tile data onto WalkabilityMap from ContentStore on production startup - Chunk streaming system: ChunkLoadRadius + ChunkStreamingCadence resources, loads/unloads chunks around player position on cadence. v0.1 radius covers full district (no streaming stutter) Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>
2026-03-03 19:11:42 +01:00
parent b6c255c8cb
commit 7fbfc5ae65
6 changed files with 845 additions and 7 deletions
@@ -327,6 +327,117 @@ fn walk_yaml_files(dir: &Path, callback: &mut impl FnMut(&Path)) {
 }

 /// Check if a YAML file contains only comments and whitespace (stub file).
+// ---------------------------------------------------------------------------
+// Tile loading (#577)
+// ---------------------------------------------------------------------------
+
+use crate::simulation::movement::{TileKind, TilePosition, WalkabilityMap};
+
+/// Parse a tile character into a TileKind.
+/// Returns `None` for unrecognized characters.
+fn parse_tile_char(ch: char) -> Option<TileKind> {
+    match ch {
+        'F' => Some(TileKind::Floor),
+        'W' => Some(TileKind::Wall),
+        'V' => Some(TileKind::Void),
+        'R' => Some(TileKind::Restricted),
+        _ => None,
+    }
+}
+
+/// Load tile data from all locations in a ContentStore into a WalkabilityMap.
+///
+/// For each location that has both `tile_bounds` and `tiles`, parses the tile
+/// rows and calls `set_walkable` + `set_tile_kind` on the WalkabilityMap.
+///
+/// Logs warnings for:
+/// - Row count mismatch vs tile_bounds height
+/// - Column count mismatch vs tile_bounds width
+/// - Unrecognized tile characters
+///
+/// Returns the number of locations that had tile data applied.
+pub fn load_location_tiles(store: &ContentStore, walkability: &mut WalkabilityMap) -> u32 {
+    let mut locations_loaded = 0u32;
+
+    for (_district_id, district) in &store.districts {
+        for location in &district.locations {
+            if apply_location_tiles(location, walkability) {
+                locations_loaded += 1;
+            }
+        }
+    }
+
+    locations_loaded
+}
+
+/// Apply tile data from a single Location to the WalkabilityMap.
+/// Returns true if tiles were applied, false if skipped.
+fn apply_location_tiles(location: &Location, walkability: &mut WalkabilityMap) -> bool {
+    let (Some(bounds), Some(tiles)) = (&location.tile_bounds, &location.tiles) else {
+        return false;
+    };
+
+    let expected_height = (bounds.y_max - bounds.y_min + 1) as usize;
+    let expected_width = (bounds.x_max - bounds.x_min + 1) as usize;
+
+    if tiles.len() != expected_height {
+        tracing::warn!(
+            "Location '{}': tile row count {} != expected height {} (from tile_bounds)",
+            location.canonical_id,
+            tiles.len(),
+            expected_height,
+        );
+    }
+
+    for (row_idx, row) in tiles.iter().enumerate() {
+        let y = bounds.y_min + row_idx as i32;
+
+        if row.len() != expected_width {
+            tracing::warn!(
+                "Location '{}' row {}: length {} != expected width {}",
+                location.canonical_id,
+                row_idx,
+                row.len(),
+                expected_width,
+            );
+        }
+
+        for (col_idx, ch) in row.chars().enumerate() {
+            let x = bounds.x_min + col_idx as i32;
+            let pos = TilePosition::new(x, y, bounds.z);
+
+            match parse_tile_char(ch) {
+                Some(kind) => {
+                    let walkable = matches!(kind, TileKind::Floor);
+                    walkability.set_walkable(&pos, walkable);
+                    walkability.set_tile_kind(&pos, kind);
+                }
+                None => {
+                    tracing::warn!(
+                        "Location '{}' row {} col {}: unrecognized tile char '{}'",
+                        location.canonical_id,
+                        row_idx,
+                        col_idx,
+                        ch,
+                    );
+                }
+            }
+        }
+    }
+
+    tracing::info!(
+        "Loaded tiles for location '{}': {}x{} at ({},{}) z={}",
+        location.canonical_id,
+        expected_width,
+        expected_height,
+        bounds.x_min,
+        bounds.y_min,
+        bounds.z,
+    );
+
+    true
+}
+
 fn is_comment_only_file(path: &Path) -> bool {
    let Ok(text) = std::fs::read_to_string(path) else {
        return false;
@@ -618,4 +729,193 @@ pools:
            }
        }
    }
+
+    // -----------------------------------------------------------------------
+    // Tile loading tests (#577)
+    // -----------------------------------------------------------------------
+
+    fn make_location_with_tiles(tiles: Vec<&str>) -> Location {
+        Location {
+            canonical_id: "test-loc".to_string(),
+            display_name: "Test Location".to_string(),
+            description: None,
+            tile_bounds: Some(TileBounds {
+                x_min: 0,
+                y_min: 0,
+                x_max: tiles.first().map_or(0, |r| r.len() as i32 - 1),
+                y_max: tiles.len() as i32 - 1,
+                z: 0,
+            }),
+            tiles: Some(tiles.iter().map(|s| s.to_string()).collect()),
+            sightlines: None,
+            ambient_sound: None,
+            social_site: None,
+        }
+    }
+
+    #[test]
+    fn parse_tile_char_all_kinds() {
+        assert_eq!(parse_tile_char('F'), Some(TileKind::Floor));
+        assert_eq!(parse_tile_char('W'), Some(TileKind::Wall));
+        assert_eq!(parse_tile_char('V'), Some(TileKind::Void));
+        assert_eq!(parse_tile_char('R'), Some(TileKind::Restricted));
+        assert_eq!(parse_tile_char('X'), None);
+        assert_eq!(parse_tile_char(' '), None);
+    }
+
+    #[test]
+    fn apply_location_tiles_stamps_walkability() {
+        let loc = make_location_with_tiles(vec![
+            "FWF",
+            "FFF",
+            "WFW",
+        ]);
+        let mut map = WalkabilityMap::new(4, 4, 1);
+
+        let applied = apply_location_tiles(&loc, &mut map);
+        assert!(applied);
+
+        // Row 0: F W F
+        assert!(map.can_move_to(&TilePosition::new(0, 0, 0)));
+        assert!(!map.can_move_to(&TilePosition::new(1, 0, 0)));
+        assert!(map.can_move_to(&TilePosition::new(2, 0, 0)));
+
+        // Row 1: F F F
+        assert!(map.can_move_to(&TilePosition::new(0, 1, 0)));
+        assert!(map.can_move_to(&TilePosition::new(1, 1, 0)));
+        assert!(map.can_move_to(&TilePosition::new(2, 1, 0)));
+
+        // Row 2: W F W
+        assert!(!map.can_move_to(&TilePosition::new(0, 2, 0)));
+        assert!(map.can_move_to(&TilePosition::new(1, 2, 0)));
+        assert!(!map.can_move_to(&TilePosition::new(2, 2, 0)));
+    }
+
+    #[test]
+    fn apply_location_tiles_stamps_tile_kind() {
+        let loc = make_location_with_tiles(vec![
+            "FWVR",
+        ]);
+        let mut map = WalkabilityMap::new(4, 1, 1);
+
+        apply_location_tiles(&loc, &mut map);
+
+        assert_eq!(map.tile_kind(&TilePosition::new(0, 0, 0)), TileKind::Floor);
+        assert_eq!(map.tile_kind(&TilePosition::new(1, 0, 0)), TileKind::Wall);
+        assert_eq!(map.tile_kind(&TilePosition::new(2, 0, 0)), TileKind::Void);
+        assert_eq!(map.tile_kind(&TilePosition::new(3, 0, 0)), TileKind::Restricted);
+    }
+
+    #[test]
+    fn apply_location_tiles_with_offset() {
+        let loc = Location {
+            canonical_id: "offset-loc".to_string(),
+            display_name: "Offset".to_string(),
+            description: None,
+            tile_bounds: Some(TileBounds {
+                x_min: 10,
+                y_min: 20,
+                x_max: 12,
+                y_max: 21,
+                z: 0,
+            }),
+            tiles: Some(vec!["FWF".to_string(), "WFW".to_string()]),
+            sightlines: None,
+            ambient_sound: None,
+            social_site: None,
+        };
+        let mut map = WalkabilityMap::new(32, 32, 1);
+
+        apply_location_tiles(&loc, &mut map);
+
+        // (10,20) = F, (11,20) = W, (12,20) = F
+        assert!(map.can_move_to(&TilePosition::new(10, 20, 0)));
+        assert!(!map.can_move_to(&TilePosition::new(11, 20, 0)));
+        assert!(map.can_move_to(&TilePosition::new(12, 20, 0)));
+
+        // (10,21) = W, (11,21) = F, (12,21) = W
+        assert!(!map.can_move_to(&TilePosition::new(10, 21, 0)));
+        assert!(map.can_move_to(&TilePosition::new(11, 21, 0)));
+        assert!(!map.can_move_to(&TilePosition::new(12, 21, 0)));
+    }
+
+    #[test]
+    fn apply_location_tiles_skips_without_tiles() {
+        let loc = Location {
+            canonical_id: "no-tiles".to_string(),
+            display_name: "No Tiles".to_string(),
+            description: None,
+            tile_bounds: Some(TileBounds {
+                x_min: 0, y_min: 0, x_max: 4, y_max: 4, z: 0,
+            }),
+            tiles: None,
+            sightlines: None,
+            ambient_sound: None,
+            social_site: None,
+        };
+        let mut map = WalkabilityMap::new(5, 5, 1);
+        assert!(!apply_location_tiles(&loc, &mut map));
+    }
+
+    #[test]
+    fn apply_location_tiles_skips_without_bounds() {
+        let loc = Location {
+            canonical_id: "no-bounds".to_string(),
+            display_name: "No Bounds".to_string(),
+            description: None,
+            tile_bounds: None,
+            tiles: Some(vec!["FFF".to_string()]),
+            sightlines: None,
+            ambient_sound: None,
+            social_site: None,
+        };
+        let mut map = WalkabilityMap::new(5, 5, 1);
+        assert!(!apply_location_tiles(&loc, &mut map));
+    }
+
+    #[test]
+    fn load_location_tiles_from_store() {
+        let mut store = ContentStore::default();
+        let mut district = DistrictContent::default();
+        district.locations.push(make_location_with_tiles(vec![
+            "FW",
+            "WF",
+        ]));
+        store.districts.insert("test".to_string(), district);
+
+        let mut map = WalkabilityMap::new(4, 4, 1);
+        let count = load_location_tiles(&store, &mut map);
+
+        assert_eq!(count, 1);
+        assert!(map.can_move_to(&TilePosition::new(0, 0, 0)));
+        assert!(!map.can_move_to(&TilePosition::new(1, 0, 0)));
+        assert!(!map.can_move_to(&TilePosition::new(0, 1, 0)));
+        assert!(map.can_move_to(&TilePosition::new(1, 1, 0)));
+    }
+
+    #[test]
+    fn location_yaml_with_tiles_deserializes() {
+        let yaml = r#"
+canonical_id: test-room
+display_name: "Test Room"
+tile_bounds:
+  x_min: 5
+  y_min: 10
+  x_max: 9
+  y_max: 12
+  z: 0
+tiles:
+  - "FFFFF"
+  - "FWWWF"
+  - "FFFFF"
+"#;
+        let loc: Location = serde_yaml::from_str(yaml).expect("location with tiles should parse");
+        assert_eq!(loc.canonical_id, "test-room");
+        assert!(loc.tiles.is_some());
+        let tiles = loc.tiles.unwrap();
+        assert_eq!(tiles.len(), 3);
+        assert_eq!(tiles[0], "FFFFF");
+        assert_eq!(tiles[1], "FWWWF");
+        assert_eq!(tiles[2], "FFFFF");
+    }
 }
@@ -79,6 +79,15 @@ fn load_and_spawn_content(world: &mut World) {
            let result = spawn::spawn_content(world, &store);
            tracing::info!("Content loaded and spawned: {} NPCs", result.npcs_spawned);

+            // Stamp location tile data onto WalkabilityMap (#577)
+            if world.contains_resource::<crate::simulation::movement::WalkabilityMap>() {
+                let mut walkability = world.resource_mut::<crate::simulation::movement::WalkabilityMap>();
+                let tiles_loaded = loader::load_location_tiles(&store, &mut walkability);
+                if tiles_loaded > 0 {
+                    tracing::info!("Loaded tile data for {} locations", tiles_loaded);
+                }
+            }
+
            // Build line pool index
            let index = line_pool::LinePoolIndex::build(&store);
            tracing::info!(
@@ -394,6 +394,20 @@ pub struct Location {
    pub description: Option<String>,
    #[serde(default)]
    pub tile_bounds: Option<TileBounds>,
+    /// Tile layout for this location (#577).
+    ///
+    /// Array of strings, one row per string, left-to-right = +x, top-to-bottom = +y.
+    /// Each character maps to a server-side TileKind:
+    ///   `F` = Floor  (walkable, open space)
+    ///   `W` = Wall   (solid obstacle, blocks movement and LOS)
+    ///   `V` = Void   (out-of-bounds / unloaded)
+    ///   `R` = Restricted (blocked but traversable by specific entities)
+    ///
+    /// Row 0 is placed at `tile_bounds.y_min`, column 0 at `tile_bounds.x_min`.
+    /// Requires `tile_bounds` to be set. Row count must equal
+    /// `y_max - y_min + 1`, and each row length must equal `x_max - x_min + 1`.
+    #[serde(default)]
+    pub tiles: Option<Vec<String>>,
    #[serde(default)]
    pub sightlines: Option<Sightlines>,
    #[serde(default)]