use crate::config::TerrainConfig;
use crate::model::geometry::{CardinalDir, GridPoint, RoomBounds};
use crate::model::room::{DoorAnchor, Room, RoomType};
use crate::model::terrain::TileKind;
use crate::rng::StableRng;
use crate::terrain::grid::is_walkable;
use crate::terrain::strategy::TerrainStrategy;
use crate::terrain::{
DefaultCarveStrategy, MazeStrategy, OpenArenaStrategy, OrganicStrategy, PillarStrategy,
};
fn make_test_room_with_bounds(
room_type: RoomType,
width: u32,
height: u32,
tags: Vec<&str>,
) -> Room {
Room {
id: "test-room-1".to_string(),
room_type,
depth_from_start: 1,
branch_id: None,
difficulty: 1,
theme_tags: tags.into_iter().map(|s| s.to_string()).collect(),
bounds: Some(RoomBounds {
min: GridPoint { x: 0, y: 0 },
max: GridPoint {
x: width as i32,
y: height as i32,
},
}),
template_ref: None,
grammar_token: None,
}
}
fn make_test_anchors(room_id: &str, width: u32, height: u32) -> Vec<DoorAnchor> {
let mut anchors = Vec::new();
anchors.push(DoorAnchor {
id: "anchor-north".to_string(),
room_id: room_id.to_string(),
edge_id: "edge-1".to_string(),
grid_pos: GridPoint {
x: width as i32 / 2,
y: 0,
},
facing: CardinalDir::North,
width_tiles: 1,
socket_tag: None,
});
anchors.push(DoorAnchor {
id: "anchor-south".to_string(),
room_id: room_id.to_string(),
edge_id: "edge-2".to_string(),
grid_pos: GridPoint {
x: width as i32 / 2,
y: height as i32 - 1,
},
facing: CardinalDir::South,
width_tiles: 1,
socket_tag: None,
});
if height > 4 {
anchors.push(DoorAnchor {
id: "anchor-west".to_string(),
room_id: room_id.to_string(),
edge_id: "edge-3".to_string(),
grid_pos: GridPoint {
x: 0,
y: height as i32 / 2,
},
facing: CardinalDir::West,
width_tiles: 1,
socket_tag: None,
});
}
if width > 4 {
anchors.push(DoorAnchor {
id: "anchor-east".to_string(),
room_id: room_id.to_string(),
edge_id: "edge-4".to_string(),
grid_pos: GridPoint {
x: width as i32 - 1,
y: height as i32 / 2,
},
facing: CardinalDir::East,
width_tiles: 1,
socket_tag: None,
});
}
anchors
}
fn default_terrain_config() -> TerrainConfig {
TerrainConfig {
obstacle_density: 0.2,
min_walkable_ratio: 0.5,
}
}
fn assert_doorway_connectivity(terrain: &crate::model::terrain::Terrain, strategy_name: &str) {
use std::collections::VecDeque;
let w = terrain.grid_size.width;
let h = terrain.grid_size.height;
let mut doorways = Vec::new();
for y in 0..h as i32 {
for x in 0..w as i32 {
if terrain.tiles.get(x, y).copied() == Some(TileKind::Doorway) {
doorways.push(GridPoint { x, y });
}
}
}
if doorways.len() < 2 {
return;
}
let size = (w * h) as usize;
let start = doorways[0];
let mut visited = vec![false; size];
let mut queue = VecDeque::new();
queue.push_back(start);
visited[(start.y as u32 * w + start.x as u32) as usize] = true;
while let Some(current) = queue.pop_front() {
for (dx, dy) in &[(1, 0), (-1, 0), (0, 1), (0, -1)] {
let nx = current.x + dx;
let ny = current.y + dy;
if nx < 0 || ny < 0 || nx >= w as i32 || ny >= h as i32 {
continue;
}
let ni = (ny as u32 * w + nx as u32) as usize;
if visited[ni] {
continue;
}
if let Some(tile) = terrain.tiles.get(nx, ny).copied() {
if is_walkable(tile) {
visited[ni] = true;
queue.push_back(GridPoint { x: nx, y: ny });
}
}
}
}
for (i, doorway) in doorways.iter().enumerate() {
assert!(
visited[(doorway.y as u32 * w + doorway.x as u32) as usize],
"[{}] 门口 {} (位置 {:?}) 不可达,从门口 0 ({:?}) 出发无法到达",
strategy_name,
i,
doorway,
start
);
}
}
fn assert_walkable_area(
terrain: &crate::model::terrain::Terrain,
min_ratio: f32,
strategy_name: &str,
) {
let total = terrain.grid_size.width * terrain.grid_size.height;
let walkable = count_walkable_tiles(terrain);
let ratio = walkable as f32 / total as f32;
assert!(
ratio >= min_ratio,
"[{}] 可通行面积比例 {:.3} 低于最小要求 {:.3}(可通行: {}, 总计: {})",
strategy_name,
ratio,
min_ratio,
walkable,
total
);
}
fn count_walkable_tiles(terrain: &crate::model::terrain::Terrain) -> u32 {
let mut count = 0u32;
for y in 0..terrain.grid_size.height as i32 {
for x in 0..terrain.grid_size.width as i32 {
if let Some(tile) = terrain.tiles.get(x, y).copied() {
if is_walkable(tile) {
count += 1;
}
}
}
}
count
}
fn assert_border_integrity(terrain: &crate::model::terrain::Terrain, strategy_name: &str) {
let w = terrain.grid_size.width as i32;
let h = terrain.grid_size.height as i32;
for y in 0..h {
for x in 0..w {
if x == 0 || y == 0 || x == w - 1 || y == h - 1 {
let tile = terrain.tiles.get(x, y).copied().unwrap();
assert!(
tile == TileKind::Wall || tile == TileKind::Doorway,
"[{}] 边框位置 ({}, {}) 应为 Wall 或 Doorway,实际为 {:?}",
strategy_name,
x,
y,
tile
);
}
}
}
}
fn assert_doorways_marked(
terrain: &crate::model::terrain::Terrain,
anchors: &[DoorAnchor],
room_id: &str,
origin: GridPoint,
strategy_name: &str,
) {
for anchor in anchors.iter().filter(|a| a.room_id == room_id) {
let local = GridPoint {
x: anchor.grid_pos.x - origin.x,
y: anchor.grid_pos.y - origin.y,
};
let tile = terrain.tiles.get(local.x, local.y).copied();
assert_eq!(
tile,
Some(TileKind::Doorway),
"[{}] 锚点 {} 在局部坐标 ({}, {}) 应为 Doorway,实际为 {:?}",
strategy_name,
anchor.id,
local.x,
local.y,
tile
);
}
}
#[test]
fn test_open_arena_connectivity() {
let room = make_test_room_with_bounds(RoomType::Boss, 16, 16, vec![]);
let anchors = make_test_anchors(&room.id, 16, 16);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(42);
let terrain = OpenArenaStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("OpenArenaStrategy 生成失败");
assert_doorway_connectivity(&terrain, "open_arena");
}
#[test]
fn test_open_arena_walkable_area() {
let room = make_test_room_with_bounds(RoomType::Boss, 16, 16, vec![]);
let anchors = make_test_anchors(&room.id, 16, 16);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(42);
let terrain = OpenArenaStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("OpenArenaStrategy 生成失败");
assert_walkable_area(&terrain, 0.5, "open_arena");
}
#[test]
fn test_open_arena_border_integrity() {
let room = make_test_room_with_bounds(RoomType::Boss, 12, 12, vec![]);
let anchors = make_test_anchors(&room.id, 12, 12);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(100);
let terrain = OpenArenaStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("OpenArenaStrategy 生成失败");
assert_border_integrity(&terrain, "open_arena");
}
#[test]
fn test_open_arena_doorways_marked() {
let room = make_test_room_with_bounds(RoomType::Boss, 14, 14, vec![]);
let anchors = make_test_anchors(&room.id, 14, 14);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(77);
let terrain = OpenArenaStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("OpenArenaStrategy 生成失败");
assert_doorways_marked(
&terrain,
&anchors,
&room.id,
GridPoint { x: 0, y: 0 },
"open_arena",
);
}
#[test]
fn test_open_arena_tiny_room_does_not_panic() {
let room = make_test_room_with_bounds(RoomType::Boss, 2, 8, vec![]);
let anchors = make_test_anchors(&room.id, 2, 8);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(7);
let terrain = OpenArenaStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("过小房间不应 panic,应产出退化地形");
assert_eq!(terrain.grid_size.width, 2);
}
#[test]
fn test_pillar_connectivity() {
let room = make_test_room_with_bounds(RoomType::Combat, 14, 14, vec!["pillar"]);
let anchors = make_test_anchors(&room.id, 14, 14);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(123);
let terrain = PillarStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("PillarStrategy 生成失败");
assert_doorway_connectivity(&terrain, "pillar");
}
#[test]
fn test_pillar_walkable_area() {
let room = make_test_room_with_bounds(RoomType::Combat, 14, 14, vec!["pillar"]);
let anchors = make_test_anchors(&room.id, 14, 14);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(123);
let terrain = PillarStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("PillarStrategy 生成失败");
assert_walkable_area(&terrain, 0.5, "pillar");
}
#[test]
fn test_pillar_border_integrity() {
let room = make_test_room_with_bounds(RoomType::Combat, 12, 10, vec!["pillar"]);
let anchors = make_test_anchors(&room.id, 12, 10);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(200);
let terrain = PillarStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("PillarStrategy 生成失败");
assert_border_integrity(&terrain, "pillar");
}
#[test]
fn test_pillar_doorways_marked() {
let room = make_test_room_with_bounds(RoomType::Combat, 14, 14, vec!["pillar"]);
let anchors = make_test_anchors(&room.id, 14, 14);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(55);
let terrain = PillarStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("PillarStrategy 生成失败");
assert_doorways_marked(
&terrain,
&anchors,
&room.id,
GridPoint { x: 0, y: 0 },
"pillar",
);
}
#[test]
fn test_maze_connectivity() {
let room = make_test_room_with_bounds(RoomType::Puzzle, 15, 15, vec!["maze"]);
let anchors = make_test_anchors(&room.id, 15, 15);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(999);
let terrain = MazeStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("MazeStrategy 生成失败");
assert_doorway_connectivity(&terrain, "maze");
}
#[test]
fn test_maze_walkable_area() {
let room = make_test_room_with_bounds(RoomType::Puzzle, 15, 15, vec!["maze"]);
let anchors = make_test_anchors(&room.id, 15, 15);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(999);
let terrain = MazeStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("MazeStrategy 生成失败");
assert_walkable_area(&terrain, 0.2, "maze");
}
#[test]
fn test_maze_border_integrity() {
let room = make_test_room_with_bounds(RoomType::Puzzle, 13, 13, vec!["maze"]);
let anchors = make_test_anchors(&room.id, 13, 13);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(300);
let terrain = MazeStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("MazeStrategy 生成失败");
assert_border_integrity(&terrain, "maze");
}
#[test]
fn test_maze_border_integrity_odd_center() {
for (w, h) in [(10u32, 10u32), (14, 14), (15, 15), (18, 18)] {
for seed in [42u64, 88, 300, 999, 12345] {
let room = make_test_room_with_bounds(RoomType::Puzzle, w, h, vec!["maze"]);
let anchors = make_test_anchors(&room.id, w, h);
let mut rng = StableRng::from_seed(seed);
let terrain = MazeStrategy
.generate(&room, &anchors, &default_terrain_config(), &mut rng)
.expect("MazeStrategy 生成失败");
assert_border_integrity(&terrain, &format!("maze({}x{},seed={})", w, h, seed));
}
}
}
#[test]
fn test_maze_doorways_marked() {
let room = make_test_room_with_bounds(RoomType::Puzzle, 15, 15, vec!["maze"]);
let anchors = make_test_anchors(&room.id, 15, 15);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(88);
let terrain = MazeStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("MazeStrategy 生成失败");
assert_doorways_marked(
&terrain,
&anchors,
&room.id,
GridPoint { x: 0, y: 0 },
"maze",
);
}
#[test]
fn test_organic_connectivity() {
let room = make_test_room_with_bounds(RoomType::Combat, 14, 14, vec!["organic"]);
let anchors = make_test_anchors(&room.id, 14, 14);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(500);
let terrain = OrganicStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("OrganicStrategy 生成失败");
assert_doorway_connectivity(&terrain, "organic");
}
#[test]
fn test_organic_walkable_area() {
let room = make_test_room_with_bounds(RoomType::Combat, 14, 14, vec!["organic"]);
let anchors = make_test_anchors(&room.id, 14, 14);
let config = TerrainConfig {
obstacle_density: 0.2,
min_walkable_ratio: 0.4,
};
let mut rng = StableRng::from_seed(500);
let terrain = OrganicStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("OrganicStrategy 生成失败");
assert_walkable_area(&terrain, 0.2, "organic");
}
#[test]
fn test_organic_border_integrity() {
let room = make_test_room_with_bounds(RoomType::Combat, 12, 12, vec!["organic"]);
let anchors = make_test_anchors(&room.id, 12, 12);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(600);
let terrain = OrganicStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("OrganicStrategy 生成失败");
assert_border_integrity(&terrain, "organic");
}
#[test]
fn test_organic_doorways_marked() {
let room = make_test_room_with_bounds(RoomType::Combat, 14, 14, vec!["organic"]);
let anchors = make_test_anchors(&room.id, 14, 14);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(700);
let terrain = OrganicStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("OrganicStrategy 生成失败");
assert_doorways_marked(
&terrain,
&anchors,
&room.id,
GridPoint { x: 0, y: 0 },
"organic",
);
}
#[test]
fn test_default_carve_connectivity() {
let room = make_test_room_with_bounds(RoomType::Combat, 12, 12, vec![]);
let anchors = make_test_anchors(&room.id, 12, 12);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(42);
let terrain = DefaultCarveStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("DefaultCarveStrategy 生成失败");
assert_doorway_connectivity(&terrain, "default_carve");
}
#[test]
fn test_default_carve_walkable_area() {
let room = make_test_room_with_bounds(RoomType::Combat, 12, 12, vec![]);
let anchors = make_test_anchors(&room.id, 12, 12);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(42);
let terrain = DefaultCarveStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("DefaultCarveStrategy 生成失败");
assert_walkable_area(&terrain, 0.5, "default_carve");
}
#[test]
fn test_default_carve_border_integrity() {
let room = make_test_room_with_bounds(RoomType::Event, 10, 10, vec![]);
let anchors = make_test_anchors(&room.id, 10, 10);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(150);
let terrain = DefaultCarveStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("DefaultCarveStrategy 生成失败");
assert_border_integrity(&terrain, "default_carve");
}
#[test]
fn test_default_carve_doorways_marked() {
let room = make_test_room_with_bounds(RoomType::Combat, 12, 12, vec![]);
let anchors = make_test_anchors(&room.id, 12, 12);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(42);
let terrain = DefaultCarveStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("DefaultCarveStrategy 生成失败");
assert_doorways_marked(
&terrain,
&anchors,
&room.id,
GridPoint { x: 0, y: 0 },
"default_carve",
);
}
#[test]
fn test_all_strategies_multiple_seeds() {
let seeds = [1, 42, 100, 256, 999, 12345, 65535];
for seed in seeds {
let room = make_test_room_with_bounds(RoomType::Boss, 14, 14, vec![]);
let anchors = make_test_anchors(&room.id, 14, 14);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(seed);
let terrain = OpenArenaStrategy
.generate(&room, &anchors, &config, &mut rng)
.unwrap_or_else(|_| panic!("OpenArena seed={} 生成失败", seed));
assert_doorway_connectivity(&terrain, &format!("open_arena(seed={})", seed));
let room = make_test_room_with_bounds(RoomType::Combat, 16, 16, vec!["pillar"]);
let anchors = make_test_anchors(&room.id, 16, 16);
let mut rng = StableRng::from_seed(seed);
let terrain = PillarStrategy
.generate(&room, &anchors, &config, &mut rng)
.unwrap_or_else(|_| panic!("Pillar seed={} 生成失败", seed));
assert_doorway_connectivity(&terrain, &format!("pillar(seed={})", seed));
let room = make_test_room_with_bounds(RoomType::Puzzle, 13, 13, vec!["maze"]);
let anchors = make_test_anchors(&room.id, 13, 13);
let mut rng = StableRng::from_seed(seed);
let terrain = MazeStrategy
.generate(&room, &anchors, &config, &mut rng)
.unwrap_or_else(|_| panic!("Maze seed={} 生成失败", seed));
assert_doorway_connectivity(&terrain, &format!("maze(seed={})", seed));
let room = make_test_room_with_bounds(RoomType::Combat, 12, 12, vec!["organic"]);
let anchors = make_test_anchors(&room.id, 12, 12);
let mut rng = StableRng::from_seed(seed);
let terrain = OrganicStrategy
.generate(&room, &anchors, &config, &mut rng)
.unwrap_or_else(|_| panic!("Organic seed={} 生成失败", seed));
assert_doorway_connectivity(&terrain, &format!("organic(seed={})", seed));
let room = make_test_room_with_bounds(RoomType::Combat, 10, 10, vec![]);
let anchors = make_test_anchors(&room.id, 10, 10);
let mut rng = StableRng::from_seed(seed);
let terrain = DefaultCarveStrategy
.generate(&room, &anchors, &config, &mut rng)
.unwrap_or_else(|_| panic!("DefaultCarve seed={} 生成失败", seed));
assert_doorway_connectivity(&terrain, &format!("default_carve(seed={})", seed));
}
}
#[test]
fn test_connectivity_summary_consistency() {
let room = make_test_room_with_bounds(RoomType::Boss, 16, 16, vec![]);
let anchors = make_test_anchors(&room.id, 16, 16);
let config = default_terrain_config();
let mut rng = StableRng::from_seed(42);
let terrain = OpenArenaStrategy
.generate(&room, &anchors, &config, &mut rng)
.expect("生成失败");
assert_doorway_connectivity(&terrain, "connectivity_summary_check");
let actual_walkable = count_walkable_tiles(&terrain);
assert!(
actual_walkable > 0,
"手动统计的可通行瓦片应大于 0,实际为 {}",
actual_walkable
);
}