use crate::backend::{PipelineBackend, ValidationScope};
use crate::config::NormalizedConfig;
use crate::error::PcgResult;
use crate::layout::{self, LayoutOutput};
use crate::model::request::Constraint;
use crate::model::result::GenerationResult;
use crate::model::room::{DoorAnchor, Room, RoomGraph};
use crate::model::terrain::Terrain;
use crate::rng::StableRng;
use crate::spawn::{self, SpawnOutput, SpawnOutputWithDebug};
use crate::validation::{
validate_no_overlap, validate_reachability, validate_result, validate_spawn_spacing_iter,
validate_terrain_connectivity,
};
use crate::{spawn::min_cross_type_spacing, terrain};
#[derive(Debug, Clone, Copy, Default)]
#[non_exhaustive]
pub struct TopDownBackend;
impl PipelineBackend for TopDownBackend {
fn solve_layout(
&self,
graph: &RoomGraph,
config: &NormalizedConfig,
rng: &mut StableRng,
) -> PcgResult<LayoutOutput> {
layout::solve_layout(graph, config, rng)
}
fn generate_terrains(
&self,
rooms: &[Room],
door_anchors: &[DoorAnchor],
config: &NormalizedConfig,
rng: &mut StableRng,
) -> PcgResult<Vec<Terrain>> {
terrain::generate_terrains(rooms, door_anchors, config, rng)
}
fn generate_spawns(
&self,
rooms: &[Room],
terrains: &[Terrain],
config: &NormalizedConfig,
rng: &StableRng,
) -> PcgResult<SpawnOutput> {
spawn::generate_spawns(rooms, terrains, config, rng)
}
fn generate_spawns_with_debug(
&self,
rooms: &[Room],
terrains: &[Terrain],
config: &NormalizedConfig,
rng: &StableRng,
) -> PcgResult<SpawnOutputWithDebug> {
spawn::generate_spawns_with_debug(rooms, terrains, config, rng)
}
fn validate(
&self,
result: &GenerationResult,
config: &NormalizedConfig,
constraints: &[Constraint],
scope: ValidationScope,
) -> PcgResult<()> {
let min_spacing = i32::from(min_cross_type_spacing(&config.config));
let spawns = || result.item_spawns.iter().chain(result.enemy_spawns.iter());
match scope {
ValidationScope::FullFloor => {
validate_result(result)?;
validate_reachability(&result.topology)?;
validate_no_overlap(&result.rooms)?;
validate_terrain_connectivity(&result.terrains)?;
validate_spawn_spacing_iter(spawns(), constraints, Some(min_spacing))?;
}
ValidationScope::Chunk => {
validate_no_overlap(&result.rooms)?;
validate_terrain_connectivity(&result.terrains)?;
validate_spawn_spacing_iter(spawns(), constraints, Some(min_spacing))?;
}
}
Ok(())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::GenerationConfig;
use crate::generator::MapGenerator;
use crate::model::request::GenerationRequest;
fn valid_result_and_config() -> (GenerationResult, NormalizedConfig) {
let config = GenerationConfig::default();
let normalized = config.normalize().expect("默认配置应归一化");
let result = MapGenerator::new()
.generate(GenerationRequest {
seed: Some(42),
config,
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("默认配置生成应成功并通过硬校验");
(result, normalized)
}
#[test]
fn test_validate_fullfloor_passes_for_valid_result() {
let (result, normalized) = valid_result_and_config();
assert!(TopDownBackend
.validate(&result, &normalized, &[], ValidationScope::FullFloor)
.is_ok());
}
#[test]
fn test_validate_detects_overlap() {
let (mut result, normalized) = valid_result_and_config();
let first_bounds = result.rooms[0].bounds;
result.rooms[1].bounds = first_bounds;
let err = TopDownBackend
.validate(&result, &normalized, &[], ValidationScope::FullFloor)
.unwrap_err();
assert_eq!(err.error_code(), "PCG-LAYOUT-001");
}
#[test]
fn test_chunk_scope_skips_whole_graph_structural_checks() {
let (mut result, normalized) = valid_result_and_config();
result.rooms.pop();
assert!(TopDownBackend
.validate(&result, &normalized, &[], ValidationScope::FullFloor)
.is_err());
assert!(TopDownBackend
.validate(&result, &normalized, &[], ValidationScope::Chunk)
.is_ok());
}
}