use crate::config::GenerationConfig;
use crate::generator::MapGenerator;
use crate::model::request::GenerationRequest;
#[test]
fn test_debug_toggle_rooms_identical() {
let config = GenerationConfig::default();
let generator_off = MapGenerator::new();
let result_off = generator_off
.generate(GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("关闭调试生成应成功");
let mut generator_on = MapGenerator::new();
generator_on.set_debug(true);
let result_on = generator_on
.generate(GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("开启调试生成应成功");
assert_eq!(
result_off.rooms.len(),
result_on.rooms.len(),
"调试开关不应影响房间数量"
);
for (room_off, room_on) in result_off.rooms.iter().zip(result_on.rooms.iter()) {
assert_eq!(room_off.id, room_on.id, "房间 ID 应一致");
assert_eq!(room_off.room_type, room_on.room_type, "房间类型应一致");
assert_eq!(room_off.bounds, room_on.bounds, "房间边界应一致");
assert_eq!(
room_off.depth_from_start, room_on.depth_from_start,
"房间深度应一致"
);
assert_eq!(room_off.difficulty, room_on.difficulty, "房间难度应一致");
}
}
#[test]
fn test_debug_toggle_corridors_identical() {
let config = GenerationConfig::default();
let generator_off = MapGenerator::new();
let result_off = generator_off
.generate(GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("关闭调试生成应成功");
let mut generator_on = MapGenerator::new();
generator_on.set_debug(true);
let result_on = generator_on
.generate(GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("开启调试生成应成功");
assert_eq!(
result_off.corridors.len(),
result_on.corridors.len(),
"调试开关不应影响走廊数量"
);
for (corr_off, corr_on) in result_off.corridors.iter().zip(result_on.corridors.iter()) {
assert_eq!(corr_off.id, corr_on.id, "走廊 ID 应一致");
assert_eq!(corr_off.from_room, corr_on.from_room, "走廊起点应一致");
assert_eq!(corr_off.to_room, corr_on.to_room, "走廊终点应一致");
assert_eq!(corr_off.width_tiles, corr_on.width_tiles, "走廊宽度应一致");
}
}
#[test]
fn test_debug_toggle_spawns_identical() {
let config = GenerationConfig::default();
let generator_off = MapGenerator::new();
let result_off = generator_off
.generate(GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("关闭调试生成应成功");
let mut generator_on = MapGenerator::new();
generator_on.set_debug(true);
let result_on = generator_on
.generate(GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("开启调试生成应成功");
assert_eq!(
result_off.item_spawns.len(),
result_on.item_spawns.len(),
"调试开关不应影响交互物数量"
);
assert_eq!(
result_off.enemy_spawns.len(),
result_on.enemy_spawns.len(),
"调试开关不应影响敌人数量"
);
for (spawn_off, spawn_on) in result_off
.item_spawns
.iter()
.zip(result_on.item_spawns.iter())
{
assert_eq!(spawn_off.room_id, spawn_on.room_id, "交互物房间 ID 应一致");
assert_eq!(
spawn_off.grid_pos, spawn_on.grid_pos,
"交互物网格位置应一致"
);
assert_eq!(spawn_off.kind, spawn_on.kind, "交互物类型应一致");
}
for (spawn_off, spawn_on) in result_off
.enemy_spawns
.iter()
.zip(result_on.enemy_spawns.iter())
{
assert_eq!(spawn_off.room_id, spawn_on.room_id, "敌人房间 ID 应一致");
assert_eq!(spawn_off.grid_pos, spawn_on.grid_pos, "敌人网格位置应一致");
assert_eq!(spawn_off.kind, spawn_on.kind, "敌人类型应一致");
}
}
#[test]
fn test_debug_toggle_topology_identical() {
let config = GenerationConfig::default();
let generator_off = MapGenerator::new();
let result_off = generator_off
.generate(GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("关闭调试生成应成功");
let mut generator_on = MapGenerator::new();
generator_on.set_debug(true);
let result_on = generator_on
.generate(GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("开启调试生成应成功");
assert_eq!(
result_off.topology.nodes.len(),
result_on.topology.nodes.len(),
"拓扑节点数应一致"
);
assert_eq!(
result_off.topology.critical_path, result_on.topology.critical_path,
"关键路径应一致"
);
assert_eq!(
result_off.topology.edges.len(),
result_on.topology.edges.len(),
"拓扑边数应一致"
);
for (edge_off, edge_on) in result_off
.topology
.edges
.iter()
.zip(result_on.topology.edges.iter())
{
assert_eq!(edge_off.id, edge_on.id, "边 ID 应一致");
assert_eq!(edge_off.from_room, edge_on.from_room, "边起点应一致");
assert_eq!(edge_off.to_room, edge_on.to_room, "边终点应一致");
}
}
#[test]
fn test_debug_toggle_different_seed() {
let config = GenerationConfig::default();
let generator_off = MapGenerator::new();
let result_off = generator_off
.generate(GenerationRequest {
seed: Some(99),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("关闭调试生成应成功");
let mut generator_on = MapGenerator::new();
generator_on.set_debug(true);
let result_on = generator_on
.generate(GenerationRequest {
seed: Some(99),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("开启调试生成应成功");
assert_eq!(result_off.rooms.len(), result_on.rooms.len());
assert_eq!(result_off.corridors.len(), result_on.corridors.len());
assert_eq!(result_off.item_spawns.len(), result_on.item_spawns.len());
assert_eq!(result_off.enemy_spawns.len(), result_on.enemy_spawns.len());
assert!(result_off.debug.is_none(), "关闭调试不应有调试输出");
assert!(result_on.debug.is_some(), "开启调试应有调试输出");
}
#[test]
fn test_debug_toggle_terrains_identical() {
let config = GenerationConfig::default();
let generator_off = MapGenerator::new();
let result_off = generator_off
.generate(GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("关闭调试生成应成功");
let mut generator_on = MapGenerator::new();
generator_on.set_debug(true);
let result_on = generator_on
.generate(GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("开启调试生成应成功");
assert_eq!(
result_off.terrains.len(),
result_on.terrains.len(),
"调试开关不应影响地形数量"
);
for (idx, (terrain_off, terrain_on)) in result_off
.terrains
.iter()
.zip(result_on.terrains.iter())
.enumerate()
{
assert_eq!(
terrain_off.room_id, terrain_on.room_id,
"地形[{}] room_id 应一致",
idx
);
assert_eq!(
terrain_off.grid_size, terrain_on.grid_size,
"地形[{}] grid_size 应一致(房间 {})",
idx, terrain_off.room_id
);
assert_eq!(
terrain_off.tiles.data.len(),
terrain_on.tiles.data.len(),
"地形[{}] tiles.data 长度应一致(房间 {})",
idx,
terrain_off.room_id
);
for (tile_idx, (tile_off, tile_on)) in terrain_off
.tiles
.data
.iter()
.zip(terrain_on.tiles.data.iter())
.enumerate()
{
assert_eq!(
tile_off, tile_on,
"地形[{}] tile[{}] 应一致(房间 {})",
idx, tile_idx, terrain_off.room_id
);
}
let cs_off = &terrain_off.connectivity_summary;
let cs_on = &terrain_on.connectivity_summary;
assert_eq!(
cs_off.all_doors_connected, cs_on.all_doors_connected,
"地形[{}] all_doors_connected 应一致(房间 {})",
idx, terrain_off.room_id
);
assert_eq!(
cs_off.walkable_tile_count, cs_on.walkable_tile_count,
"地形[{}] walkable_tile_count 应一致(房间 {})",
idx, terrain_off.room_id
);
assert_eq!(
cs_off.total_tile_count, cs_on.total_tile_count,
"地形[{}] total_tile_count 应一致(房间 {})",
idx, terrain_off.room_id
);
assert_eq!(
cs_off.connected_region_count, cs_on.connected_region_count,
"地形[{}] connected_region_count 应一致(房间 {})",
idx, terrain_off.room_id
);
}
}