use crate::config::GenerationConfig;
use crate::error::{PcgError, PcgResult};
use crate::model::request::Constraint;
use crate::rng::fnv1a_64;
use serde::{Deserialize, Deserializer, Serialize, Serializer};
fn validate_no_nan(config: &GenerationConfig) -> PcgResult<()> {
if config.terrain.obstacle_density.is_nan() {
return Err(PcgError::config_with_field(
"obstacle_density 不能为 NaN",
"terrain.obstacle_density",
));
}
if config.terrain.min_walkable_ratio.is_nan() {
return Err(PcgError::config_with_field(
"min_walkable_ratio 不能为 NaN",
"terrain.min_walkable_ratio",
));
}
if config.item_spawns.rarity_weights.iter().any(|w| w.is_nan()) {
return Err(PcgError::config_with_field(
"rarity_weights 不能包含 NaN",
"item_spawns.rarity_weights",
));
}
Ok(())
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct ConfigDigest {
hash: String,
}
impl ConfigDigest {
pub fn from_config(config: &GenerationConfig) -> PcgResult<Self> {
let (_, hash) = Self::seed_and_digest_from_config(config)?;
Ok(Self { hash })
}
pub fn seed_from_config(config: &GenerationConfig) -> PcgResult<u64> {
let (seed, _) = Self::seed_and_digest_from_config(config)?;
Ok(seed)
}
pub fn seed_and_digest_from_config(config: &GenerationConfig) -> PcgResult<(u64, String)> {
validate_no_nan(config)?;
let json = serde_json::to_string(config)
.map_err(|e| PcgError::config(format!("GenerationConfig 序列化失败: {}", e)))?;
let hash_value = fnv1a_64(json.as_bytes());
Ok((hash_value, format!("{:016x}", hash_value)))
}
pub fn from_string(hash: String) -> Self {
Self { hash }
}
pub fn as_str(&self) -> &str {
&self.hash
}
pub fn into_string(self) -> String {
self.hash
}
pub fn matches(&self, config: &GenerationConfig) -> bool {
Self::from_config(config).is_ok_and(|expected| self.hash == expected.hash)
}
}
#[derive(Debug, Clone, PartialEq, Eq, Hash)]
#[non_exhaustive]
pub struct ConstraintDigest {
hash: String,
}
impl ConstraintDigest {
pub fn from_constraints(constraints: &[Constraint]) -> PcgResult<Self> {
let json = serde_json::to_string(constraints)
.map_err(|e| PcgError::config(format!("constraints 序列化失败: {}", e)))?;
Ok(Self {
hash: format!("{:016x}", fnv1a_64(json.as_bytes())),
})
}
pub fn as_str(&self) -> &str {
&self.hash
}
pub fn into_string(self) -> String {
self.hash
}
}
impl std::fmt::Display for ConfigDigest {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}", self.hash)
}
}
impl Serialize for ConfigDigest {
fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error> {
serializer.serialize_str(&self.hash)
}
}
impl<'de> Deserialize<'de> for ConfigDigest {
fn deserialize<D: Deserializer<'de>>(deserializer: D) -> Result<Self, D::Error> {
let hash = String::deserialize(deserializer)?;
Ok(Self::from_string(hash))
}
}
impl TryFrom<&GenerationConfig> for ConfigDigest {
type Error = Box<PcgError>;
fn try_from(config: &GenerationConfig) -> Result<Self, Self::Error> {
Self::from_config(config)
}
}
impl From<String> for ConfigDigest {
fn from(hash: String) -> Self {
Self::from_string(hash)
}
}
impl From<&str> for ConfigDigest {
fn from(hash: &str) -> Self {
Self::from_string(hash.to_string())
}
}
#[cfg(test)]
mod tests {
use super::*;
use crate::config::{GenerationConfig, RangeU16};
#[test]
fn test_digest_from_config() {
let config = GenerationConfig::default();
let digest = ConfigDigest::from_config(&config).expect("默认配置应可序列化");
assert_eq!(digest.as_str().len(), 16);
assert!(digest.as_str().chars().all(|c| c.is_ascii_hexdigit()));
}
#[test]
fn test_digest_stability() {
let config = GenerationConfig::default();
let digest1 = ConfigDigest::from_config(&config).expect("默认配置应可序列化");
let digest2 = ConfigDigest::from_config(&config).expect("默认配置应可序列化");
assert_eq!(digest1, digest2);
assert_eq!(digest1.as_str(), digest2.as_str());
}
#[test]
fn test_digest_uniqueness() {
let config1 = GenerationConfig::default();
let config2 = GenerationConfig {
room_count: RangeU16 { min: 15, max: 25 },
..Default::default()
};
let digest1 = ConfigDigest::from_config(&config1).expect("配置应可序列化");
let digest2 = ConfigDigest::from_config(&config2).expect("配置应可序列化");
assert_ne!(digest1, digest2);
assert_ne!(digest1.as_str(), digest2.as_str());
}
#[test]
fn test_digest_matches() {
let config = GenerationConfig::default();
let digest = ConfigDigest::from_config(&config).expect("默认配置应可序列化");
assert!(digest.matches(&config));
let different_config = GenerationConfig {
room_count: RangeU16 { min: 15, max: 25 },
..Default::default()
};
assert!(!digest.matches(&different_config));
}
#[test]
fn test_digest_from_string() {
let hash_str = "0123456789abcdef";
let digest = ConfigDigest::from_string(hash_str.to_string());
assert_eq!(digest.as_str(), hash_str);
}
#[test]
fn test_digest_display() {
let config = GenerationConfig::default();
let digest = ConfigDigest::from_config(&config).expect("默认配置应可序列化");
let display_str = format!("{}", digest);
assert_eq!(display_str, digest.as_str());
}
#[test]
fn test_digest_conversions() {
let config = GenerationConfig::default();
let digest1 = ConfigDigest::try_from(&config).expect("默认配置应可序列化");
let digest2: ConfigDigest = digest1.as_str().to_string().into();
let digest3: ConfigDigest = digest1.as_str().into();
assert_eq!(digest1, digest2);
assert_eq!(digest2, digest3);
}
#[test]
fn test_digest_try_from_config_rejects_nan() {
let mut config = GenerationConfig::default();
config.terrain.obstacle_density = f32::NAN;
let err = ConfigDigest::try_from(&config).expect_err("NaN 配置应返回错误");
assert_eq!(err.error_code(), "PCG-CONFIG-001");
}
#[test]
fn test_constraint_digest_differs_by_constraints() {
use crate::model::request::ExclusionZoneConstraint;
let empty = ConstraintDigest::from_constraints(&[]).expect("空约束应可序列化");
let with_zone = ConstraintDigest::from_constraints(&[Constraint::ExclusionZone(
ExclusionZoneConstraint {
label: "zone".to_string(),
min: crate::model::geometry::GridPoint { x: 0, y: 0 },
max: crate::model::geometry::GridPoint { x: 5, y: 5 },
exclude_rooms: false,
exclude_spawns: true,
},
)])
.expect("约束应可序列化");
assert_eq!(
empty.as_str(),
ConstraintDigest::from_constraints(&[])
.expect("空约束应可序列化")
.as_str()
);
assert_ne!(empty.as_str(), with_zone.as_str());
}
#[test]
fn test_digest_sensitivity_to_nested_changes() {
let config1 = GenerationConfig::default();
let mut config2 = GenerationConfig::default();
config2.terrain.obstacle_density = 0.3;
let digest1 = ConfigDigest::from_config(&config1).expect("配置应可序列化");
let digest2 = ConfigDigest::from_config(&config2).expect("配置应可序列化");
assert_ne!(digest1, digest2);
}
#[test]
fn test_digest_sensitivity_to_theme_tags() {
let config1 = GenerationConfig::default();
let config2 = GenerationConfig {
theme_tags: vec!["dungeon".to_string(), "dark".to_string()],
..Default::default()
};
let digest1 = ConfigDigest::from_config(&config1).expect("配置应可序列化");
let digest2 = ConfigDigest::from_config(&config2).expect("配置应可序列化");
assert_ne!(digest1, digest2);
}
#[test]
fn test_digest_into_string() {
let config = GenerationConfig::default();
let digest = ConfigDigest::from_config(&config).expect("默认配置应可序列化");
let hash_str = digest.as_str().to_string();
let owned_str = digest.into_string();
assert_eq!(owned_str, hash_str);
}
}