use crate::config::TerrainConfig;
use crate::error::PcgResult;
use crate::model::geometry::GridSize;
use crate::model::room::{DoorAnchor, Room};
use crate::model::terrain::{ConnectivitySummary, Grid2D, Terrain, TileKind};
use crate::rng::StableRng;
use super::carve::{extract_room_bounds, init_room_grid};
use super::strategy::TerrainStrategy;
#[non_exhaustive]
pub struct OpenArenaStrategy;
impl TerrainStrategy for OpenArenaStrategy {
fn name(&self) -> &str {
"open_arena"
}
fn generate(
&self,
room: &Room,
anchors: &[DoorAnchor],
config: &TerrainConfig,
rng: &mut StableRng,
) -> PcgResult<Terrain> {
let (bounds, width, height) = extract_room_bounds(room)?;
let mut tiles = init_room_grid(width, height)?;
let doorway_locals = super::carve::mark_doorways(&mut tiles, anchors, &room.id, bounds.min);
let edge_margin = 2i32;
let obstacle_budget =
((width * height) as f32 * config.obstacle_density * 0.3).round() as usize;
let mut placed = 0usize;
let max_attempts = obstacle_budget * 10;
let mut attempts = 0usize;
let placeable = width > 2 && height > 2;
while placeable && placed < obstacle_budget && attempts < max_attempts {
attempts += 1;
let x = rng.random_range(1, width as i32 - 1);
let y = rng.random_range(1, height as i32 - 1);
let dist_to_left = x;
let dist_to_right = width as i32 - 1 - x;
let dist_to_top = y;
let dist_to_bottom = height as i32 - 1 - y;
let min_dist = dist_to_left
.min(dist_to_right)
.min(dist_to_top)
.min(dist_to_bottom);
if min_dist >= 1
&& min_dist <= edge_margin
&& tiles.get(x, y).copied() == Some(TileKind::Floor)
{
tiles.set(x, y, TileKind::Obstacle);
placed += 1;
}
}
ensure_doorway_connectivity(&mut tiles, &doorway_locals);
Ok(Terrain {
room_id: room.id.clone(),
grid_size: GridSize { width, height },
tiles,
reserved_zones: Vec::new(),
connectivity_summary: ConnectivitySummary {
all_doors_connected: false,
walkable_tile_count: 0,
total_tile_count: 0,
connected_region_count: 0,
},
})
}
}
fn ensure_doorway_connectivity(
tiles: &mut Grid2D<TileKind>,
doorways: &[crate::model::geometry::GridPoint],
) {
use std::collections::VecDeque;
if doorways.len() < 2 {
return;
}
let w = tiles.width;
let h = tiles.height;
let size = (w * h) as usize;
let start = doorways[0];
let mut visited = vec![false; size];
let mut queue = VecDeque::new();
queue.push_back(start);
visited[(start.y as u32 * w + start.x as u32) as usize] = true;
while let Some(current) = queue.pop_front() {
for (dx, dy) in &[(1, 0), (-1, 0), (0, 1), (0, -1)] {
let nx = current.x + dx;
let ny = current.y + dy;
if nx < 0 || ny < 0 || nx >= w as i32 || ny >= h as i32 {
continue;
}
let ni = (ny as u32 * w + nx as u32) as usize;
if visited[ni] {
continue;
}
if let Some(tile) = tiles.get(nx, ny).copied() {
if super::grid::is_walkable(tile) {
visited[ni] = true;
queue.push_back(crate::model::geometry::GridPoint { x: nx, y: ny });
}
}
}
}
let all_reachable = doorways
.iter()
.all(|d| visited[(d.y as u32 * w + d.x as u32) as usize]);
if all_reachable {
return;
}
let cx = tiles.width as i32 / 2;
let cy = tiles.height as i32 / 2;
for x in 1..tiles.width as i32 - 1 {
for dy in -1..=1i32 {
let y = cy + dy;
if y > 0
&& y < tiles.height as i32 - 1
&& tiles.get(x, y).copied() == Some(TileKind::Obstacle)
{
tiles.set(x, y, TileKind::Floor);
}
}
}
for y in 1..tiles.height as i32 - 1 {
for dx in -1..=1i32 {
let x = cx + dx;
if x > 0
&& x < tiles.width as i32 - 1
&& tiles.get(x, y).copied() == Some(TileKind::Obstacle)
{
tiles.set(x, y, TileKind::Floor);
}
}
}
}