use proptest::prelude::*;
use crate::config::{
CapabilityFlags, ChunkingConfig, ConnectionStrategy, CorridorConfig, EnemySpawnConfig,
GenerationConfig, GenerationMode, ItemSpawnConfig, RangeU16, RoomSizeConfig, TerrainConfig,
};
use crate::generator::MapGenerator;
use crate::model::request::{
AnchorConstraint, Constraint, ExclusionZoneConstraint, GenerationRequest, RuntimeContext,
};
use crate::model::room::RoomType;
use crate::model::spawn::SpawnPoint;
use crate::validation::{
validate_no_overlap, validate_reachability, validate_spawn_spacing,
validate_terrain_connectivity,
};
fn arb_generation_config() -> impl Strategy<Value = GenerationConfig> {
(2u16..=50u16)
.prop_flat_map(|room_count| {
let max_path = room_count.min(8);
let path_len = 2u16..=max_path;
let branch = 0u16..=3u16;
let dead_end = 0u16..=2u16;
(Just(room_count), path_len, branch, dead_end)
})
.prop_map(
|(room_count, path_len, branch_max, dead_end_max)| GenerationConfig {
room_count: RangeU16 {
min: room_count,
max: room_count,
},
critical_path_length: RangeU16 {
min: path_len,
max: path_len,
},
branch_count: RangeU16 {
min: 0,
max: branch_max,
},
dead_end_count: RangeU16 {
min: 0,
max: dead_end_max,
},
room_size: RoomSizeConfig {
min_width: 8,
max_width: 12,
min_height: 8,
max_height: 12,
},
corridor: CorridorConfig {
width: 2,
max_turns: 3,
connection_strategy: ConnectionStrategy::Orthogonal,
},
terrain: TerrainConfig {
obstacle_density: 0.15,
min_walkable_ratio: 0.6,
},
item_spawns: ItemSpawnConfig {
count_per_room: RangeU16 { min: 1, max: 2 },
min_spacing: 2,
rarity_weights: vec![0.6, 0.3, 0.1],
},
enemy_spawns: EnemySpawnConfig {
count_per_room: RangeU16 { min: 1, max: 3 },
min_spacing: 3,
min_distance_from_entrance: 4,
base_difficulty_budget: 100,
},
chunking: ChunkingConfig {
chunk_size: 32,
enabled: false,
},
theme_tags: vec!["default".to_string()],
generation_mode: GenerationMode::OfflineFullFloor,
capability_flags: CapabilityFlags::default(),
},
)
}
fn arb_generation_mode() -> impl Strategy<Value = GenerationMode> {
prop_oneof![
6 => Just(GenerationMode::OfflineFullFloor),
2 => Just(GenerationMode::RuntimeChunked),
2 => Just(GenerationMode::HybridPrecompute),
]
}
fn arb_test_input() -> impl Strategy<Value = (GenerationConfig, Option<RuntimeContext>)> {
(arb_generation_config(), arb_generation_mode()).prop_map(|(mut config, mode)| {
config.generation_mode = mode;
config.capability_flags = match mode {
GenerationMode::OfflineFullFloor => CapabilityFlags::default(),
GenerationMode::RuntimeChunked => CapabilityFlags {
runtime_chunked: true,
..CapabilityFlags::default()
},
GenerationMode::HybridPrecompute => CapabilityFlags {
hybrid_precompute: true,
..CapabilityFlags::default()
},
};
if matches!(
mode,
GenerationMode::RuntimeChunked | GenerationMode::HybridPrecompute
) {
config.chunking.enabled = true;
}
let runtime_ctx = match mode {
GenerationMode::RuntimeChunked => Some(RuntimeContext {
focus_position: None,
interest_radius: None,
requested_chunks: vec![],
caller_tag: Some("proptest".to_string()),
}),
_ => None,
};
(config, runtime_ctx)
})
}
fn arb_seed() -> impl Strategy<Value = u64> {
any::<u64>()
}
fn generate_hybrid_full(
seed: u64,
config: GenerationConfig,
constraints: Vec<crate::model::request::Constraint>,
trace_id: Option<String>,
) -> crate::error::PcgResult<crate::model::result::GenerationResult> {
let generator = MapGenerator::new();
let topo_req = GenerationRequest {
seed: Some(seed),
config,
constraints,
runtime_context: None,
trace_id,
};
let topo_result = generator.generate_topology_only(topo_req)?;
let mut all_terrains = Vec::new();
let mut all_item_spawns = Vec::new();
let mut all_enemy_spawns = Vec::new();
for chunk in &topo_result.chunks {
let detail = generator.fill_chunk_details(&topo_result, &chunk.id)?;
all_terrains.extend(detail.terrains);
all_item_spawns.extend(detail.item_spawns);
all_enemy_spawns.extend(detail.enemy_spawns);
}
use crate::export::CURRENT_SCHEMA_VERSION;
Ok(crate::model::result::GenerationResult {
metadata: crate::model::result::ResultMetadata {
seed: topo_result.seed,
config_digest: topo_result.config_digest,
schema_version: CURRENT_SCHEMA_VERSION.to_string(),
algorithm_version: env!("CARGO_PKG_VERSION").to_string(),
target_engine_version: None,
trace_id: topo_result.trace_id,
},
topology: topo_result.topology,
rooms: topo_result.layout.rooms,
door_anchors: topo_result.layout.door_anchors,
corridors: topo_result.layout.corridors,
terrains: all_terrains,
item_spawns: all_item_spawns,
enemy_spawns: all_enemy_spawns,
chunks: topo_result.chunks,
debug: None,
})
}
fn generate_by_mode(
seed: u64,
config: GenerationConfig,
runtime_ctx: Option<RuntimeContext>,
constraints: Vec<crate::model::request::Constraint>,
trace_id: Option<String>,
) -> crate::error::PcgResult<crate::model::result::GenerationResult> {
match config.generation_mode {
GenerationMode::HybridPrecompute => {
generate_hybrid_full(seed, config, constraints, trace_id)
}
_ => {
let generator = MapGenerator::new();
generator.generate(GenerationRequest {
seed: Some(seed),
config,
constraints,
runtime_context: runtime_ctx,
trace_id,
})
}
}
}
proptest! {
#![proptest_config({
let cases = std::env::var("PROPTEST_CASES")
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(50u32);
ProptestConfig::with_cases(cases)
})]
#[test]
fn prop_deterministic_generation(
seed in arb_seed(),
(config, runtime_ctx) in arb_test_input(),
) {
let result1 = generate_by_mode(
seed, config.clone(), runtime_ctx.clone(), vec![], None,
);
let result2 = generate_by_mode(
seed, config.clone(), runtime_ctx.clone(), vec![], None,
);
let r1 = result1.expect("第一次生成应成功");
let r2 = result2.expect("第二次生成应成功");
prop_assert_eq!(&r1.metadata.seed, &r2.metadata.seed);
prop_assert_eq!(&r1.metadata.config_digest, &r2.metadata.config_digest);
prop_assert_eq!(r1.topology.nodes.len(), r2.topology.nodes.len());
prop_assert_eq!(r1.topology.edges.len(), r2.topology.edges.len());
prop_assert_eq!(&r1.topology.critical_path, &r2.topology.critical_path);
let ids1: Vec<&str> = r1.rooms.iter().map(|r| r.id.as_str()).collect();
let ids2: Vec<&str> = r2.rooms.iter().map(|r| r.id.as_str()).collect();
prop_assert_eq!(&ids1, &ids2);
prop_assert_eq!(r1.corridors.len(), r2.corridors.len());
prop_assert_eq!(r1.item_spawns.len(), r2.item_spawns.len());
prop_assert_eq!(r1.enemy_spawns.len(), r2.enemy_spawns.len());
let json1 = serde_json::to_string(&r1).expect("序列化应成功");
let json2 = serde_json::to_string(&r2).expect("序列化应成功");
prop_assert_eq!(&json1, &json2, "相同 seed+config 的两次生成结果 JSON 应完全一致");
}
}
proptest! {
#![proptest_config({
let cases = std::env::var("PROPTEST_CASES")
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(50u32);
ProptestConfig::with_cases(cases)
})]
#[test]
fn prop_topology_reachability(
seed in arb_seed(),
(config, runtime_ctx) in arb_test_input(),
) {
let result = generate_by_mode(
seed, config, runtime_ctx, vec![], None,
).expect("生成应成功");
let reachability_result = validate_reachability(&result.topology);
prop_assert!(
reachability_result.is_ok(),
"所有房间应从 Start 可达: {:?}",
reachability_result.err()
);
}
}
proptest! {
#![proptest_config({
let cases = std::env::var("PROPTEST_CASES")
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(50u32);
ProptestConfig::with_cases(cases)
})]
#[test]
fn prop_no_room_overlap(
seed in arb_seed(),
(config, runtime_ctx) in arb_test_input(),
) {
let result = generate_by_mode(
seed, config, runtime_ctx, vec![], None,
).expect("生成应成功");
let overlap_result = validate_no_overlap(&result.rooms);
prop_assert!(
overlap_result.is_ok(),
"房间边界不应重叠: {:?}",
overlap_result.err()
);
}
}
proptest! {
#![proptest_config({
let cases = std::env::var("PROPTEST_CASES")
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(50u32);
ProptestConfig::with_cases(cases)
})]
#[test]
fn prop_terrain_connectivity(
seed in arb_seed(),
(config, runtime_ctx) in arb_test_input(),
) {
let result = generate_by_mode(
seed, config, runtime_ctx, vec![], None,
).expect("生成应成功");
let connectivity_result = validate_terrain_connectivity(&result.terrains);
prop_assert!(
connectivity_result.is_ok(),
"所有房间地形应从入口到出口连通: {:?}",
connectivity_result.err()
);
}
}
proptest! {
#![proptest_config({
let cases = std::env::var("PROPTEST_CASES")
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(50u32);
ProptestConfig::with_cases(cases)
})]
#[test]
fn prop_spawn_spacing(
seed in arb_seed(),
(config, runtime_ctx) in arb_test_input(),
) {
let result = generate_by_mode(
seed, config.clone(), runtime_ctx, vec![], None,
).expect("生成应成功");
let all_spawns: Vec<SpawnPoint> = result
.item_spawns
.iter()
.chain(result.enemy_spawns.iter())
.cloned()
.collect();
let min_spacing = config.item_spawns.min_spacing.min(config.enemy_spawns.min_spacing) as i32;
let spacing_result = validate_spawn_spacing(&all_spawns, &[], Some(min_spacing));
prop_assert!(
spacing_result.is_ok(),
"所有点位应满足最小间距 {}: {:?}",
min_spacing,
spacing_result.err()
);
}
}
proptest! {
#![proptest_config({
let cases = std::env::var("PROPTEST_CASES")
.ok()
.and_then(|v| v.parse().ok())
.unwrap_or(50u32);
ProptestConfig::with_cases(cases)
})]
#[test]
fn prop_constraints_satisfied(
seed in arb_seed(),
(config, runtime_ctx) in arb_test_input(),
zone_x in 0i32..50i32,
zone_y in 0i32..50i32,
) {
let exclusion_zone = Constraint::ExclusionZone(ExclusionZoneConstraint {
label: "test-exclusion".to_string(),
min: crate::model::geometry::GridPoint { x: zone_x, y: zone_y },
max: crate::model::geometry::GridPoint { x: zone_x + 10, y: zone_y + 10 },
exclude_rooms: false,
exclude_spawns: true,
});
let anchor = Constraint::Anchor(AnchorConstraint {
label: "test-anchor".to_string(),
room_id: None,
room_type: Some(RoomType::Treasure),
target_grid_pos: None,
});
let constraints = vec![exclusion_zone.clone(), anchor];
let result = generate_by_mode(
seed, config, runtime_ctx, constraints.clone(), None,
).expect("带约束的生成应成功");
let all_spawns: Vec<SpawnPoint> = result
.item_spawns
.iter()
.chain(result.enemy_spawns.iter())
.cloned()
.collect();
if let Constraint::ExclusionZone(ref zone) = constraints[0] {
for spawn in &all_spawns {
let in_zone = spawn.grid_pos.x >= zone.min.x
&& spawn.grid_pos.x < zone.max.x
&& spawn.grid_pos.y >= zone.min.y
&& spawn.grid_pos.y < zone.max.y;
prop_assert!(
!in_zone,
"点位 {} 在坐标 ({},{}) 不应在排除区 [{},{})x[{},{}) 内",
spawn.id,
spawn.grid_pos.x,
spawn.grid_pos.y,
zone.min.x,
zone.max.x,
zone.min.y,
zone.max.y,
);
}
}
let branch_rooms: Vec<&crate::model::room::Room> = result.rooms.iter()
.filter(|r| r.branch_id.is_some())
.collect();
if !branch_rooms.is_empty() {
let has_treasure = result.rooms.iter().any(|r| r.room_type == RoomType::Treasure);
prop_assert!(
has_treasure,
"存在分支房间时,锚点约束指定 Treasure 类型应被满足"
);
}
}
}