pub(crate) mod budget;
pub(crate) mod enemies;
pub(crate) mod items;
pub(crate) mod sampling;
use std::collections::HashMap;
use crate::config::NormalizedConfig;
use crate::debug::{RejectionReason, SpawnDebugInfo};
use crate::error::PcgResult;
use crate::model::geometry::GridPoint;
use crate::model::room::Room;
use crate::model::spawn::SpawnPoint;
use crate::model::terrain::Terrain;
use crate::rng::StableRng;
#[derive(Debug, Clone)]
#[non_exhaustive]
pub(crate) struct SpawnOutput {
pub(crate) item_spawns: Vec<SpawnPoint>,
pub(crate) enemy_spawns: Vec<SpawnPoint>,
}
pub(crate) fn min_cross_type_spacing(config: &crate::config::GenerationConfig) -> u16 {
config
.item_spawns
.min_spacing
.min(config.enemy_spawns.min_spacing)
}
pub(crate) fn occupied_local_points(room: &Room, spawns: &[SpawnPoint]) -> Vec<GridPoint> {
let Some(bounds) = room.bounds else {
return Vec::new();
};
spawns
.iter()
.map(|s| GridPoint {
x: s.grid_pos.x - bounds.min.x,
y: s.grid_pos.y - bounds.min.y,
})
.collect()
}
#[derive(Debug, Clone)]
#[non_exhaustive]
pub(crate) struct SpawnOutputWithDebug {
pub(crate) output: SpawnOutput,
pub(crate) debug_info: SpawnDebugInfo,
}
pub(crate) fn generate_spawns(
rooms: &[Room],
terrains: &[Terrain],
config: &NormalizedConfig,
rng: &StableRng,
) -> PcgResult<SpawnOutput> {
let mut item_spawns = Vec::new();
let mut enemy_spawns = Vec::new();
let cross_spacing = min_cross_type_spacing(&config.config);
let terrain_map: HashMap<&str, &Terrain> =
terrains.iter().map(|t| (t.room_id.as_str(), t)).collect();
for room in rooms {
let Some(terrain) = terrain_map.get(room.id.as_str()) else {
continue;
};
let mut item_rng = rng.derive(&format!("items:{}", room.id));
let mut enemy_rng = rng.derive(&format!("enemies:{}", room.id));
let room_items = items::generate_item_spawns_for_room(room, terrain, config, &mut item_rng);
let occupied = occupied_local_points(room, &room_items);
let room_enemies = enemies::generate_enemy_spawns_for_room_excluding(
room,
terrain,
config,
&occupied,
cross_spacing,
&mut enemy_rng,
);
item_spawns.extend(room_items);
enemy_spawns.extend(room_enemies);
}
Ok(SpawnOutput {
item_spawns,
enemy_spawns,
})
}
pub(crate) fn generate_spawns_with_debug(
rooms: &[Room],
terrains: &[Terrain],
config: &NormalizedConfig,
rng: &StableRng,
) -> PcgResult<SpawnOutputWithDebug> {
let mut item_spawns = Vec::new();
let mut enemy_spawns = Vec::new();
let mut total_candidates = 0usize;
let mut total_rejections = Vec::<RejectionReason>::new();
let mut total_accepted = 0usize;
let cross_spacing = min_cross_type_spacing(&config.config);
let terrain_map: HashMap<&str, &Terrain> =
terrains.iter().map(|t| (t.room_id.as_str(), t)).collect();
for room in rooms {
let Some(terrain) = terrain_map.get(room.id.as_str()) else {
continue;
};
let mut item_rng = rng.derive(&format!("items:{}", room.id));
let mut enemy_rng = rng.derive(&format!("enemies:{}", room.id));
let item_result =
items::generate_item_spawns_for_room_tracked(room, terrain, config, &mut item_rng);
total_candidates += item_result.candidate_count;
total_rejections.extend(item_result.rejections);
total_accepted += item_result.spawns.len();
let occupied = occupied_local_points(room, &item_result.spawns);
item_spawns.extend(item_result.spawns);
let enemy_result = enemies::generate_enemy_spawns_for_room_tracked_excluding(
room,
terrain,
config,
&occupied,
cross_spacing,
&mut enemy_rng,
);
total_candidates += enemy_result.candidate_count;
total_rejections.extend(enemy_result.rejections);
total_accepted += enemy_result.spawns.len();
enemy_spawns.extend(enemy_result.spawns);
}
let rejected_count = total_rejections.len();
Ok(SpawnOutputWithDebug {
output: SpawnOutput {
item_spawns,
enemy_spawns,
},
debug_info: SpawnDebugInfo {
candidate_count: total_candidates,
rejected_count,
rejection_reasons: total_rejections,
accepted_count: total_accepted,
},
})
}