use crate::error::{PcgError, PcgResult};
use crate::model::geometry::CardinalDir;
use crate::model::room::RoomType;
use crate::rng::StableRng;
#[derive(Debug, Clone)]
#[non_exhaustive]
pub struct GrammarRule {
pub name: String,
pub base_weight: f64,
}
#[derive(Debug, Clone, Default)]
#[non_exhaustive]
pub struct GrammarContext {
pub facing: Option<CardinalDir>,
pub theme_tags: Vec<String>,
pub corridor_length: Option<u16>,
pub room_type: Option<RoomType>,
}
#[non_exhaustive]
pub struct WeightedRuleSelector;
impl Default for WeightedRuleSelector {
fn default() -> Self {
Self
}
}
impl WeightedRuleSelector {
pub fn select(
&self,
rules: &[GrammarRule],
context: &GrammarContext,
rng: &mut StableRng,
) -> PcgResult<usize> {
if rules.is_empty() {
return Err(PcgError::capability_unavailable(
"Grammar 规则列表为空,无法进行选择",
"grammar",
));
}
let adjusted_weights: Vec<f64> = rules
.iter()
.map(|rule| self.compute_adjusted_weight(rule, context))
.collect();
let total_weight: f64 = adjusted_weights.iter().sum();
if !total_weight.is_finite() || total_weight <= 0.0 {
if rules.iter().any(|r| r.base_weight.is_nan()) {
return Err(PcgError::capability_unavailable(
"Grammar 规则中存在 NaN base_weight,无法进行选择",
"grammar",
));
}
return Err(PcgError::capability_unavailable(
"所有 Grammar 规则的调整后权重为零",
"grammar",
));
}
let mut random_value = rng.gen_f64() * total_weight;
for (i, &weight) in adjusted_weights.iter().enumerate() {
random_value -= weight;
if random_value <= 0.0 {
return Ok(i);
}
}
Ok(rules.len() - 1)
}
fn compute_adjusted_weight(&self, rule: &GrammarRule, context: &GrammarContext) -> f64 {
let mut weight = rule.base_weight;
if !weight.is_finite() || weight <= 0.0 {
return 0.0;
}
let rule_name_lower = rule.name.to_lowercase();
if let Some(facing) = &context.facing {
let facing_keyword = facing_to_keyword(facing);
if rule_name_lower.contains(facing_keyword) {
weight *= 2.0;
}
}
for tag in &context.theme_tags {
if rule_name_lower.contains(&tag.to_lowercase()) {
weight *= 1.5;
break; }
}
if let Some(length) = context.corridor_length {
let length_matches = (length > 10 && rule_name_lower.contains("long"))
|| (length <= 5 && rule_name_lower.contains("short"));
if length_matches {
weight *= 1.8;
}
}
if let Some(room_type) = &context.room_type {
let type_keyword = room_type_to_keyword(room_type);
if rule_name_lower.contains(type_keyword) {
weight *= 1.5;
}
}
weight
}
}
fn facing_to_keyword(facing: &CardinalDir) -> &'static str {
match facing {
CardinalDir::North => "north",
CardinalDir::South => "south",
CardinalDir::East => "east",
CardinalDir::West => "west",
}
}
fn room_type_to_keyword(room_type: &RoomType) -> &'static str {
match room_type {
RoomType::Start => "start",
RoomType::Combat => "combat",
RoomType::Treasure => "treasure",
RoomType::Shop => "shop",
RoomType::Elite => "elite",
RoomType::Puzzle => "puzzle",
RoomType::Safe => "safe",
RoomType::Boss => "boss",
RoomType::Event => "event",
RoomType::Secret => "secret",
}
}
#[cfg(test)]
mod __tests__ {
use super::*;
#[test]
fn test_select_single_rule() {
let rules = vec![GrammarRule {
name: "default_room".to_string(),
base_weight: 1.0,
}];
let context = GrammarContext::default();
let mut rng = StableRng::from_seed(42);
let selector = WeightedRuleSelector;
let result = selector.select(&rules, &context, &mut rng);
assert_eq!(result.unwrap(), 0);
}
#[test]
fn test_select_deterministic() {
let rules = vec![
GrammarRule {
name: "rule_a".to_string(),
base_weight: 1.0,
},
GrammarRule {
name: "rule_b".to_string(),
base_weight: 1.0,
},
GrammarRule {
name: "rule_c".to_string(),
base_weight: 1.0,
},
];
let context = GrammarContext::default();
let mut rng1 = StableRng::from_seed(12345);
let mut rng2 = StableRng::from_seed(12345);
let selector = WeightedRuleSelector;
let result1 = selector.select(&rules, &context, &mut rng1).unwrap();
let result2 = selector.select(&rules, &context, &mut rng2).unwrap();
assert_eq!(result1, result2);
}
#[test]
fn test_facing_weight_boost() {
let rules = vec![
GrammarRule {
name: "corridor_north".to_string(),
base_weight: 1.0,
},
GrammarRule {
name: "corridor_south".to_string(),
base_weight: 1.0,
},
];
let context = GrammarContext {
facing: Some(CardinalDir::North),
..Default::default()
};
let selector = WeightedRuleSelector;
let mut north_count = 0;
let mut rng = StableRng::from_seed(42);
for _ in 0..1000 {
let idx = selector.select(&rules, &context, &mut rng).unwrap();
if idx == 0 {
north_count += 1;
}
}
let ratio = north_count as f64 / 1000.0;
assert!(
ratio > 0.55,
"朝向匹配规则应被更频繁选中,实际比例: {ratio}"
);
}
#[test]
fn test_theme_weight_boost() {
let rules = vec![
GrammarRule {
name: "room_dungeon_dark".to_string(),
base_weight: 1.0,
},
GrammarRule {
name: "room_forest_light".to_string(),
base_weight: 1.0,
},
];
let context = GrammarContext {
theme_tags: vec!["dungeon".to_string()],
..Default::default()
};
let selector = WeightedRuleSelector;
let mut dungeon_count = 0;
let mut rng = StableRng::from_seed(42);
for _ in 0..1000 {
let idx = selector.select(&rules, &context, &mut rng).unwrap();
if idx == 0 {
dungeon_count += 1;
}
}
let ratio = dungeon_count as f64 / 1000.0;
assert!(
ratio > 0.50,
"主题匹配规则应被更频繁选中,实际比例: {ratio}"
);
}
#[test]
fn test_corridor_length_weight_boost() {
let rules = vec![
GrammarRule {
name: "corridor_long_variant".to_string(),
base_weight: 1.0,
},
GrammarRule {
name: "corridor_short_variant".to_string(),
base_weight: 1.0,
},
];
let long_context = GrammarContext {
corridor_length: Some(15),
..Default::default()
};
let selector = WeightedRuleSelector;
let mut long_count = 0;
let mut rng = StableRng::from_seed(42);
for _ in 0..1000 {
let idx = selector.select(&rules, &long_context, &mut rng).unwrap();
if idx == 0 {
long_count += 1;
}
}
let ratio = long_count as f64 / 1000.0;
assert!(ratio > 0.55, "长走廊应偏好 long 规则,实际比例: {ratio}");
}
#[test]
fn test_room_type_weight_boost() {
let rules = vec![
GrammarRule {
name: "module_boss_arena".to_string(),
base_weight: 1.0,
},
GrammarRule {
name: "module_combat_basic".to_string(),
base_weight: 1.0,
},
];
let context = GrammarContext {
room_type: Some(RoomType::Boss),
..Default::default()
};
let selector = WeightedRuleSelector;
let mut boss_count = 0;
let mut rng = StableRng::from_seed(42);
for _ in 0..1000 {
let idx = selector.select(&rules, &context, &mut rng).unwrap();
if idx == 0 {
boss_count += 1;
}
}
let ratio = boss_count as f64 / 1000.0;
assert!(
ratio > 0.50,
"房间类型匹配规则应被更频繁选中,实际比例: {ratio}"
);
}
#[test]
fn test_empty_rules_returns_error() {
let rules: Vec<GrammarRule> = vec![];
let context = GrammarContext::default();
let mut rng = StableRng::from_seed(42);
let selector = WeightedRuleSelector;
let result = selector.select(&rules, &context, &mut rng);
assert!(result.is_err());
}
#[test]
fn test_zero_weight_rules_returns_error() {
let rules = vec![
GrammarRule {
name: "rule_a".to_string(),
base_weight: 0.0,
},
GrammarRule {
name: "rule_b".to_string(),
base_weight: 0.0,
},
];
let context = GrammarContext::default();
let mut rng = StableRng::from_seed(42);
let selector = WeightedRuleSelector;
let result = selector.select(&rules, &context, &mut rng);
assert!(result.is_err());
}
#[test]
fn test_combined_context_boost() {
let rules = vec![
GrammarRule {
name: "corridor_north_long_dungeon".to_string(),
base_weight: 1.0,
},
GrammarRule {
name: "corridor_south_short_forest".to_string(),
base_weight: 1.0,
},
];
let context = GrammarContext {
facing: Some(CardinalDir::North),
theme_tags: vec!["dungeon".to_string()],
corridor_length: Some(15),
room_type: None,
};
let selector = WeightedRuleSelector;
let mut first_count = 0;
let mut rng = StableRng::from_seed(42);
for _ in 0..1000 {
let idx = selector.select(&rules, &context, &mut rng).unwrap();
if idx == 0 {
first_count += 1;
}
}
let ratio = first_count as f64 / 1000.0;
assert!(
ratio > 0.75,
"多因素叠加规则应被高频选中,实际比例: {ratio}"
);
}
#[test]
fn test_invalid_grammar_rule_returns_capability_error() {
let rules: Vec<GrammarRule> = vec![];
let context = GrammarContext::default();
let mut rng = StableRng::from_seed(42);
let selector = WeightedRuleSelector;
let result = selector.select(&rules, &context, &mut rng);
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.error_code(), "PCG-CAPABILITY-001");
if let PcgError::CapabilityUnavailable { capability, .. } = err.as_ref() {
assert_eq!(capability, "grammar");
} else {
panic!("应返回 CapabilityUnavailable 错误");
}
}
#[test]
fn test_invalid_module_reference_returns_capability_error() {
let rules = vec![
GrammarRule {
name: "invalid_module".to_string(),
base_weight: 0.0,
},
GrammarRule {
name: "broken_ref".to_string(),
base_weight: -1.0,
},
];
let context = GrammarContext::default();
let mut rng = StableRng::from_seed(42);
let selector = WeightedRuleSelector;
let result = selector.select(&rules, &context, &mut rng);
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.error_code(), "PCG-CAPABILITY-001");
}
#[test]
fn test_select_nan_weight_returns_err() {
let rules = vec![
GrammarRule {
name: "rule_nan_a".to_string(),
base_weight: f64::NAN,
},
GrammarRule {
name: "rule_nan_b".to_string(),
base_weight: f64::NAN,
},
];
let context = GrammarContext::default();
let mut rng = StableRng::from_seed(42);
let selector = WeightedRuleSelector;
let result = selector.select(&rules, &context, &mut rng);
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.error_code(), "PCG-CAPABILITY-001");
if let PcgError::CapabilityUnavailable { capability, .. } = err.as_ref() {
assert_eq!(capability, "grammar");
} else {
panic!("应返回 CapabilityUnavailable 错误");
}
}
#[test]
fn test_select_negative_weight_returns_err() {
let rules = vec![
GrammarRule {
name: "rule_neg_a".to_string(),
base_weight: -1.0,
},
GrammarRule {
name: "rule_neg_b".to_string(),
base_weight: -5.0,
},
];
let context = GrammarContext::default();
let mut rng = StableRng::from_seed(42);
let selector = WeightedRuleSelector;
let result = selector.select(&rules, &context, &mut rng);
assert!(result.is_err());
let err = result.unwrap_err();
assert_eq!(err.error_code(), "PCG-CAPABILITY-001");
}
#[test]
fn test_select_deterministic_with_fixed_seed() {
let rules = vec![
GrammarRule {
name: "corridor_north".to_string(),
base_weight: 2.0,
},
GrammarRule {
name: "corridor_south".to_string(),
base_weight: 3.0,
},
GrammarRule {
name: "corridor_east".to_string(),
base_weight: 1.5,
},
];
let context = GrammarContext {
facing: Some(CardinalDir::North),
corridor_length: Some(8),
..Default::default()
};
let selector = WeightedRuleSelector;
let mut rng1 = StableRng::from_seed(99999);
let results1: Vec<usize> = (0..5)
.map(|_| selector.select(&rules, &context, &mut rng1).unwrap())
.collect();
let mut rng2 = StableRng::from_seed(99999);
let results2: Vec<usize> = (0..5)
.map(|_| selector.select(&rules, &context, &mut rng2).unwrap())
.collect();
assert_eq!(results1, results2, "相同 seed 的多次选择序列应完全一致");
}
}