use std::collections::HashSet;
use std::time::Instant;
use crate::backend::{select_backend, PipelineBackend, ValidationScope};
use crate::config::NormalizedConfig;
use crate::constraint;
use crate::digest::ConfigDigest;
use crate::error::{PcgError, PcgResult};
use crate::export::CURRENT_SCHEMA_VERSION;
use crate::layout::LayoutOutput;
use crate::model::chunk::Chunk;
use crate::model::request::{ChunkId, GenerationRequest};
use crate::model::result::{GenerationResult, ResultMetadata};
use crate::model::room::{Corridor, DoorAnchor, Room, RoomGraph};
use crate::model::spawn::SpawnPoint;
use crate::model::terrain::Terrain;
use crate::rng::StableRng;
use crate::terrain::strategy::TerrainStrategyKind;
use crate::ue;
use crate::validation::{
validate_no_overlap, validate_request, validate_spawn_spacing_iter,
validate_terrain_connectivity,
};
use crate::{terrain, topology};
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct TopologyResult {
pub seed: u64,
pub config_digest: String,
pub(crate) normalized: NormalizedConfig,
pub topology: RoomGraph,
pub layout: LayoutOutput,
pub chunks: Vec<Chunk>,
pub constraints: Vec<crate::model::request::Constraint>,
pub trace_id: Option<String>,
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct ChunkDetailResult {
pub chunk_id: ChunkId,
pub terrains: Vec<Terrain>,
pub item_spawns: Vec<SpawnPoint>,
pub enemy_spawns: Vec<SpawnPoint>,
pub partial: bool,
}
pub fn generate_topology_only(request: GenerationRequest) -> PcgResult<TopologyResult> {
let normalized = validate_request(&request)?;
let (seed, config_digest) = match request.seed {
Some(s) => (
s,
ConfigDigest::from_config(&normalized.config)?.into_string(),
),
None => ConfigDigest::seed_and_digest_from_config(&normalized.config)?,
};
let root_rng = StableRng::from_seed(seed);
constraint::validate_constraints(&request.constraints)?;
let backend = select_backend(&normalized);
let mut topology_rng = root_rng.derive("topology");
let mut graph = topology::generate_topology(&normalized, &mut topology_rng)?;
constraint::apply_room_constraints(&mut graph.nodes, &request.constraints);
let mut layout_rng = root_rng.derive("layout");
let layout_output = backend.solve_layout(&graph, &normalized, &mut layout_rng)?;
validate_no_overlap(&layout_output.rooms)?;
let chunks = ue::streaming::build_chunks(&layout_output.rooms, &normalized)?;
Ok(TopologyResult {
seed,
config_digest,
normalized,
topology: graph,
layout: layout_output,
chunks,
constraints: request.constraints,
trace_id: request.trace_id,
})
}
pub fn fill_chunk_details(
topology_result: &TopologyResult,
chunk_id: &str,
) -> PcgResult<ChunkDetailResult> {
let chunk = topology_result
.chunks
.iter()
.find(|c| c.id == chunk_id)
.ok_or_else(|| {
PcgError::config_with_field(format!("分块 '{}' 不存在", chunk_id), "chunk_id")
})?;
let room_id_set: HashSet<&str> = chunk.room_ids.iter().map(|s| s.as_str()).collect();
let chunk_rooms: Vec<&Room> = topology_result
.layout
.rooms
.iter()
.filter(|room| room_id_set.contains(room.id.as_str()))
.collect();
let chunk_anchors: Vec<DoorAnchor> = topology_result
.layout
.door_anchors
.iter()
.filter(|anchor| room_id_set.contains(anchor.room_id.as_str()))
.cloned()
.collect();
let normalized = &topology_result.normalized;
let seed = topology_result.seed;
let root_rng = StableRng::from_seed(seed);
let start_time = Instant::now();
let time_budget_ms = normalized.time_budget_ms;
let iteration_budget = normalized.iteration_budget;
let mut terrains = Vec::new();
let mut item_spawns = Vec::new();
let mut enemy_spawns = Vec::new();
let mut partial = false;
for (idx, room) in chunk_rooms.iter().enumerate() {
if let Some(budget_ms) = time_budget_ms {
if start_time.elapsed().as_millis() as u64 >= budget_ms {
partial = true;
break;
}
}
if let Some(budget) = iteration_budget {
if idx as u32 >= budget {
partial = true;
break;
}
}
let mut terrain_rng = root_rng.derive(&format!("terrain:chunk:{}:{}", chunk_id, room.id));
let terrain_config = &normalized.config.terrain;
let terrain_result = terrain::select_strategy(room).generate(
room,
&chunk_anchors,
terrain_config,
&mut terrain_rng,
);
match terrain_result {
Ok(mut t) => {
terrain::repair_terrain_connectivity(&mut t);
let mut item_rng =
root_rng.derive(&format!("items:chunk:{}:{}", chunk_id, room.id));
let mut enemy_rng =
root_rng.derive(&format!("enemies:chunk:{}:{}", chunk_id, room.id));
let room_items = crate::spawn::items::generate_item_spawns_for_room(
room,
&t,
normalized,
&mut item_rng,
);
let occupied = crate::spawn::occupied_local_points(room, &room_items);
let cross_spacing = crate::spawn::min_cross_type_spacing(&normalized.config);
let room_enemies = crate::spawn::enemies::generate_enemy_spawns_for_room_excluding(
room,
&t,
normalized,
&occupied,
cross_spacing,
&mut enemy_rng,
);
let (filtered_items, filtered_enemies) = constraint::apply_spawn_constraints(
room_items,
room_enemies,
&topology_result.constraints,
);
item_spawns.extend(filtered_items);
enemy_spawns.extend(filtered_enemies);
terrains.push(t);
}
Err(primary_err) => {
let mut fallback_rng =
root_rng.derive(&format!("terrain:fallback:{}:{}", chunk_id, room.id));
let mut t = TerrainStrategyKind::DefaultCarve
.generate(room, &chunk_anchors, terrain_config, &mut fallback_rng)
.map_err(|_| primary_err)?;
terrain::repair_terrain_connectivity(&mut t);
terrains.push(t);
}
}
}
validate_terrain_connectivity(&terrains)?;
let min_spacing = i32::from(crate::spawn::min_cross_type_spacing(&normalized.config));
validate_spawn_spacing_iter(
item_spawns.iter().chain(enemy_spawns.iter()),
&topology_result.constraints,
Some(min_spacing),
)?;
Ok(ChunkDetailResult {
chunk_id: chunk_id.to_string(),
terrains,
item_spawns,
enemy_spawns,
partial,
})
}
pub fn generate_chunk(request: GenerationRequest) -> PcgResult<GenerationResult> {
let normalized = validate_request(&request)?;
let (seed, config_digest) = match request.seed {
Some(s) => (
s,
ConfigDigest::from_config(&normalized.config)?.into_string(),
),
None => ConfigDigest::seed_and_digest_from_config(&normalized.config)?,
};
let root_rng = StableRng::from_seed(seed);
let requested_chunks: Vec<ChunkId> = request
.runtime_context
.as_ref()
.map(|ctx| ctx.requested_chunks.clone())
.unwrap_or_default();
constraint::validate_constraints(&request.constraints)?;
let backend = select_backend(&normalized);
let mut topology_rng = root_rng.derive("topology");
let mut graph = topology::generate_topology(&normalized, &mut topology_rng)?;
constraint::apply_room_constraints(&mut graph.nodes, &request.constraints);
let mut layout_rng = root_rng.derive("layout");
let layout_output = backend.solve_layout(&graph, &normalized, &mut layout_rng)?;
let all_chunks = ue::streaming::build_chunks(&layout_output.rooms, &normalized)?;
let target_chunks: Vec<&Chunk> = if requested_chunks.is_empty() {
all_chunks.iter().collect()
} else {
all_chunks
.iter()
.filter(|c| requested_chunks.contains(&c.id))
.collect()
};
let target_room_ids: std::collections::HashSet<String> = target_chunks
.iter()
.flat_map(|c| c.room_ids.iter().cloned())
.collect();
let target_rooms: Vec<&Room> = layout_output
.rooms
.iter()
.filter(|room| target_room_ids.contains(&room.id))
.collect();
let target_anchors: Vec<DoorAnchor> = layout_output
.door_anchors
.iter()
.filter(|anchor| target_room_ids.contains(&anchor.room_id))
.cloned()
.collect();
let target_corridors: Vec<Corridor> = layout_output
.corridors
.iter()
.filter(|corridor| {
target_room_ids.contains(&corridor.from_room)
|| target_room_ids.contains(&corridor.to_room)
})
.cloned()
.collect();
let start_time = Instant::now();
let time_budget_ms = normalized.time_budget_ms;
let iteration_budget = normalized.iteration_budget;
let mut terrains = Vec::new();
let mut item_spawns = Vec::new();
let mut enemy_spawns = Vec::new();
for (idx, room) in target_rooms.iter().enumerate() {
if let Some(budget_ms) = time_budget_ms {
if start_time.elapsed().as_millis() as u64 >= budget_ms {
return Err(PcgError::budget_exhausted(
"超出时间预算,分块生成中止",
"time",
));
}
}
if let Some(budget) = iteration_budget {
if idx as u32 >= budget {
return Err(PcgError::budget_exhausted(
"超出迭代预算,分块生成中止",
"iteration",
));
}
}
let mut terrain_rng = root_rng.derive(&format!("terrain:{}", room.id));
let terrain_config = &normalized.config.terrain;
let terrain_result = terrain::select_strategy(room).generate(
room,
&target_anchors,
terrain_config,
&mut terrain_rng,
);
match terrain_result {
Ok(mut t) => {
terrain::repair_terrain_connectivity(&mut t);
let mut item_rng = root_rng.derive(&format!("items:{}", room.id));
let mut enemy_rng = root_rng.derive(&format!("enemies:{}", room.id));
let room_items = crate::spawn::items::generate_item_spawns_for_room(
room,
&t,
&normalized,
&mut item_rng,
);
let occupied = crate::spawn::occupied_local_points(room, &room_items);
let cross_spacing = crate::spawn::min_cross_type_spacing(&normalized.config);
let room_enemies = crate::spawn::enemies::generate_enemy_spawns_for_room_excluding(
room,
&t,
&normalized,
&occupied,
cross_spacing,
&mut enemy_rng,
);
let (filtered_items, filtered_enemies) = constraint::apply_spawn_constraints(
room_items,
room_enemies,
&request.constraints,
);
item_spawns.extend(filtered_items);
enemy_spawns.extend(filtered_enemies);
terrains.push(t);
}
Err(primary_err) => {
let mut fallback_rng = root_rng.derive(&format!("terrain:fallback:{}", room.id));
let mut t = TerrainStrategyKind::DefaultCarve
.generate(room, &target_anchors, terrain_config, &mut fallback_rng)
.map_err(|_| primary_err)?;
terrain::repair_terrain_connectivity(&mut t);
terrains.push(t);
}
}
}
let result = GenerationResult {
metadata: ResultMetadata {
seed,
config_digest,
schema_version: CURRENT_SCHEMA_VERSION.to_string(),
algorithm_version: env!("CARGO_PKG_VERSION").to_string(),
target_engine_version: None,
trace_id: request.trace_id,
},
topology: graph,
rooms: target_rooms.into_iter().cloned().collect(),
door_anchors: target_anchors,
corridors: target_corridors,
terrains,
item_spawns,
enemy_spawns,
chunks: all_chunks,
debug: None,
};
backend.validate(
&result,
&normalized,
&request.constraints,
ValidationScope::Chunk,
)?;
Ok(result)
}
#[cfg(test)]
#[path = "chunked_tests.rs"]
mod tests;