use crate::config::TerrainConfig;
use crate::error::PcgResult;
use crate::model::room::{DoorAnchor, Room, RoomType};
use crate::model::terrain::Terrain;
use crate::rng::StableRng;
use super::default_strategy::DefaultCarveStrategy;
use super::maze::MazeStrategy;
use super::open_arena::OpenArenaStrategy;
use super::organic::OrganicStrategy;
use super::pillar::PillarStrategy;
use super::strategy::{TerrainStrategy, TerrainStrategyKind};
pub fn select_strategy(room: &Room) -> TerrainStrategyKind {
if room.room_type == RoomType::Boss {
return TerrainStrategyKind::OpenArena;
}
if matches!(room.room_type, RoomType::Combat | RoomType::Elite) && has_theme_tag(room, "pillar")
{
return TerrainStrategyKind::Pillar;
}
if room.room_type == RoomType::Puzzle && has_theme_tag(room, "maze") {
return TerrainStrategyKind::Maze;
}
if has_theme_tag(room, "organic") || has_theme_tag(room, "cave") {
return TerrainStrategyKind::Organic;
}
TerrainStrategyKind::DefaultCarve
}
impl TerrainStrategyKind {
pub fn name(&self) -> &str {
match self {
Self::DefaultCarve => "default_carve",
Self::OpenArena => "open_arena",
Self::Maze => "maze",
Self::Organic => "organic",
Self::Pillar => "pillar",
}
}
pub fn generate(
&self,
room: &Room,
anchors: &[DoorAnchor],
config: &TerrainConfig,
rng: &mut StableRng,
) -> PcgResult<Terrain> {
match self {
Self::DefaultCarve => DefaultCarveStrategy.generate(room, anchors, config, rng),
Self::OpenArena => OpenArenaStrategy.generate(room, anchors, config, rng),
Self::Maze => MazeStrategy.generate(room, anchors, config, rng),
Self::Organic => OrganicStrategy.generate(room, anchors, config, rng),
Self::Pillar => PillarStrategy.generate(room, anchors, config, rng),
}
}
}
fn has_theme_tag(room: &Room, tag: &str) -> bool {
room.theme_tags.iter().any(|t| t == tag)
}
#[cfg(test)]
mod __tests__ {
use super::*;
use crate::model::room::Room;
fn make_test_room(room_type: RoomType, tags: Vec<&str>) -> Room {
Room {
id: "test-room".to_string(),
room_type,
depth_from_start: 1,
branch_id: None,
difficulty: 1,
theme_tags: tags.into_iter().map(|s| s.to_string()).collect(),
bounds: None,
template_ref: None,
grammar_token: None,
}
}
#[test]
fn test_boss_room_selects_open_arena() {
let room = make_test_room(RoomType::Boss, vec![]);
let strategy = select_strategy(&room);
assert_eq!(strategy.name(), "open_arena");
}
#[test]
fn test_combat_with_pillar_tag_selects_pillar() {
let room = make_test_room(RoomType::Combat, vec!["pillar"]);
let strategy = select_strategy(&room);
assert_eq!(strategy.name(), "pillar");
}
#[test]
fn test_elite_with_pillar_tag_selects_pillar() {
let room = make_test_room(RoomType::Elite, vec!["pillar"]);
let strategy = select_strategy(&room);
assert_eq!(strategy.name(), "pillar");
}
#[test]
fn test_puzzle_with_maze_tag_selects_maze() {
let room = make_test_room(RoomType::Puzzle, vec!["maze"]);
let strategy = select_strategy(&room);
assert_eq!(strategy.name(), "maze");
}
#[test]
fn test_room_with_organic_tag_selects_organic() {
let room = make_test_room(RoomType::Combat, vec!["organic"]);
let strategy = select_strategy(&room);
assert_eq!(strategy.name(), "organic");
}
#[test]
fn test_room_with_cave_tag_selects_organic() {
let room = make_test_room(RoomType::Treasure, vec!["cave"]);
let strategy = select_strategy(&room);
assert_eq!(strategy.name(), "organic");
}
#[test]
fn test_default_strategy_for_plain_combat() {
let room = make_test_room(RoomType::Combat, vec![]);
let strategy = select_strategy(&room);
assert_eq!(strategy.name(), "default_carve");
}
#[test]
fn test_default_strategy_for_shop() {
let room = make_test_room(RoomType::Shop, vec![]);
let strategy = select_strategy(&room);
assert_eq!(strategy.name(), "default_carve");
}
#[test]
fn test_boss_overrides_organic_tag() {
let room = make_test_room(RoomType::Boss, vec!["organic"]);
let strategy = select_strategy(&room);
assert_eq!(strategy.name(), "open_arena");
}
#[test]
fn test_pillar_overrides_organic_tag() {
let room = make_test_room(RoomType::Combat, vec!["pillar", "organic"]);
let strategy = select_strategy(&room);
assert_eq!(strategy.name(), "pillar");
}
}