use crate::config::{CapabilityFlags, ChunkingConfig, GenerationConfig, GenerationMode};
use crate::digest::ConfigDigest;
use crate::generator::MapGenerator;
use crate::model::request::{GenerationRequest, RuntimeContext};
use crate::rng::fnv1a_64;
fn hash_room_ids(rooms: &[crate::model::room::Room]) -> u64 {
let mut data = Vec::new();
for room in rooms {
data.extend_from_slice(room.id.as_bytes());
data.extend_from_slice(format!("{:?}", room.room_type).as_bytes());
}
fnv1a_64(&data)
}
fn hash_corridor_ids(corridors: &[crate::model::room::Corridor]) -> u64 {
let mut data = Vec::new();
for corridor in corridors {
data.extend_from_slice(corridor.id.as_bytes());
data.extend_from_slice(corridor.from_room.as_bytes());
data.extend_from_slice(corridor.to_room.as_bytes());
}
fnv1a_64(&data)
}
fn hash_spawns(spawns: &[crate::model::spawn::SpawnPoint]) -> u64 {
let mut data = Vec::new();
for spawn in spawns {
data.extend_from_slice(spawn.room_id.as_bytes());
data.extend_from_slice(&spawn.grid_pos.x.to_le_bytes());
data.extend_from_slice(&spawn.grid_pos.y.to_le_bytes());
data.extend_from_slice(format!("{:?}", spawn.kind).as_bytes());
}
fnv1a_64(&data)
}
fn make_runtime_chunked_config() -> GenerationConfig {
GenerationConfig {
generation_mode: GenerationMode::RuntimeChunked,
capability_flags: CapabilityFlags {
runtime_chunked: true,
hybrid_precompute: false,
grammar_support: false,
debug_output: false,
},
chunking: ChunkingConfig {
chunk_size: 32,
enabled: true,
},
..Default::default()
}
}
fn make_hybrid_config() -> GenerationConfig {
GenerationConfig {
generation_mode: GenerationMode::HybridPrecompute,
capability_flags: CapabilityFlags {
runtime_chunked: false,
hybrid_precompute: true,
grammar_support: false,
debug_output: false,
},
chunking: ChunkingConfig {
chunk_size: 32,
enabled: true,
},
..Default::default()
}
}
const GOLDEN_SEED42_ROOM_HASH: u64 = 0xbb9c3cdf7d452a0a;
const GOLDEN_SEED42_CORRIDOR_HASH: u64 = 0x9f1b9dc978b92993;
const GOLDEN_SEED42_ITEM_HASH: u64 = 0x3ffbe579cd1dd622;
const GOLDEN_SEED42_ENEMY_HASH: u64 = 0x60fa4cbee9a988c3;
#[test]
fn test_golden_sample_seed_42() {
let generator = MapGenerator::new();
let result = generator
.generate(GenerationRequest {
seed: Some(42),
config: GenerationConfig::default(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("黄金样本生成应成功");
let room_hash = hash_room_ids(&result.rooms);
let corridor_hash = hash_corridor_ids(&result.corridors);
let item_spawn_hash = hash_spawns(&result.item_spawns);
let enemy_spawn_hash = hash_spawns(&result.enemy_spawns);
assert_eq!(
room_hash, GOLDEN_SEED42_ROOM_HASH,
"房间哈希与黄金常量不一致——算法可能已变更"
);
assert_eq!(
corridor_hash, GOLDEN_SEED42_CORRIDOR_HASH,
"走廊哈希与黄金常量不一致"
);
assert_eq!(
item_spawn_hash, GOLDEN_SEED42_ITEM_HASH,
"交互物哈希与黄金常量不一致"
);
assert_eq!(
enemy_spawn_hash, GOLDEN_SEED42_ENEMY_HASH,
"敌人哈希与黄金常量不一致"
);
let room_count = result.rooms.len();
let corridor_count = result.corridors.len();
let item_spawn_count = result.item_spawns.len();
let enemy_spawn_count = result.enemy_spawns.len();
let result2 = generator
.generate(GenerationRequest {
seed: Some(42),
config: GenerationConfig::default(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("第二次生成应成功");
let room_hash2 = hash_room_ids(&result2.rooms);
let corridor_hash2 = hash_corridor_ids(&result2.corridors);
let item_spawn_hash2 = hash_spawns(&result2.item_spawns);
let enemy_spawn_hash2 = hash_spawns(&result2.enemy_spawns);
assert_eq!(room_hash, room_hash2, "房间哈希应一致");
assert_eq!(corridor_hash, corridor_hash2, "走廊哈希应一致");
assert_eq!(item_spawn_hash, item_spawn_hash2, "交互物哈希应一致");
assert_eq!(enemy_spawn_hash, enemy_spawn_hash2, "敌人哈希应一致");
assert_eq!(result.rooms.len(), room_count, "房间数应一致");
assert_eq!(result2.corridors.len(), corridor_count, "走廊数应一致");
assert_eq!(
result2.item_spawns.len(),
item_spawn_count,
"交互物数应一致"
);
assert_eq!(
result2.enemy_spawns.len(),
enemy_spawn_count,
"敌人数应一致"
);
assert_eq!(result.metadata.seed, 42);
assert_eq!(
result.metadata.config_digest,
result2.metadata.config_digest
);
assert_eq!(
result.metadata.schema_version,
result2.metadata.schema_version
);
}
#[test]
fn test_golden_sample_seed_12345() {
let generator = MapGenerator::new();
let result = generator
.generate(GenerationRequest {
seed: Some(12345),
config: GenerationConfig::default(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("黄金样本生成应成功");
println!(
"SEED12345_ROOM_HASH=0x{:016x}",
hash_room_ids(&result.rooms)
);
println!(
"SEED12345_CORRIDOR_HASH=0x{:016x}",
hash_corridor_ids(&result.corridors)
);
println!(
"SEED12345_ITEM_HASH=0x{:016x}",
hash_spawns(&result.item_spawns)
);
println!(
"SEED12345_ENEMY_HASH=0x{:016x}",
hash_spawns(&result.enemy_spawns)
);
for i in 0..3 {
let result_n = generator
.generate(GenerationRequest {
seed: Some(12345),
config: GenerationConfig::default(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.unwrap_or_else(|_| panic!("第 {} 次生成应成功", i + 2));
assert_eq!(
hash_room_ids(&result.rooms),
hash_room_ids(&result_n.rooms),
"第 {} 次生成的房间哈希应一致",
i + 2
);
assert_eq!(
hash_corridor_ids(&result.corridors),
hash_corridor_ids(&result_n.corridors),
"第 {} 次生成的走廊哈希应一致",
i + 2
);
assert_eq!(
hash_spawns(&result.item_spawns),
hash_spawns(&result_n.item_spawns),
"第 {} 次生成的交互物哈希应一致",
i + 2
);
assert_eq!(
hash_spawns(&result.enemy_spawns),
hash_spawns(&result_n.enemy_spawns),
"第 {} 次生成的敌人哈希应一致",
i + 2
);
}
}
#[test]
fn test_golden_sample_json_roundtrip() {
let generator = MapGenerator::new();
let result = generator
.generate(GenerationRequest {
seed: Some(42),
config: GenerationConfig::default(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("生成应成功");
let json = crate::export::export_json(&result).expect("JSON 导出应成功");
let (imported, _warnings) = crate::export::import_json(&json).expect("JSON 导入应成功");
assert_eq!(imported.metadata.seed, result.metadata.seed);
assert_eq!(
imported.metadata.config_digest,
result.metadata.config_digest
);
assert_eq!(imported.rooms.len(), result.rooms.len());
assert_eq!(imported.corridors.len(), result.corridors.len());
assert_eq!(imported.item_spawns.len(), result.item_spawns.len());
assert_eq!(imported.enemy_spawns.len(), result.enemy_spawns.len());
for (original, reimported) in result.rooms.iter().zip(imported.rooms.iter()) {
assert_eq!(original.id, reimported.id);
assert_eq!(original.room_type, reimported.room_type);
}
assert_eq!(
imported.terrains.len(),
result.terrains.len(),
"地形数应一致"
);
for (i, (orig_terrain, imp_terrain)) in result
.terrains
.iter()
.zip(imported.terrains.iter())
.enumerate()
{
assert_eq!(
orig_terrain.room_id, imp_terrain.room_id,
"terrain[{i}] room_id 应一致"
);
assert_eq!(
orig_terrain.grid_size, imp_terrain.grid_size,
"terrain[{i}] grid_size 应一致"
);
assert_eq!(
orig_terrain.tiles.width, imp_terrain.tiles.width,
"terrain[{i}] tiles.width 应一致"
);
assert_eq!(
orig_terrain.tiles.height, imp_terrain.tiles.height,
"terrain[{i}] tiles.height 应一致"
);
assert_eq!(
orig_terrain.tiles.data, imp_terrain.tiles.data,
"terrain[{i}] tiles.data 应一致"
);
}
for (i, (orig, imp)) in result
.enemy_spawns
.iter()
.zip(imported.enemy_spawns.iter())
.enumerate()
{
assert_eq!(orig.id, imp.id, "enemy_spawn[{i}] id 应一致");
assert_eq!(
orig.grid_pos, imp.grid_pos,
"enemy_spawn[{i}] grid_pos 应一致"
);
}
}
#[test]
fn test_golden_seed_none_stability() {
let generator = MapGenerator::new();
let first = generator
.generate(GenerationRequest {
seed: None,
config: GenerationConfig::default(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("seed=None 生成应成功");
for i in 0..4 {
let repeat = generator
.generate(GenerationRequest {
seed: None,
config: GenerationConfig::default(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.unwrap_or_else(|_| panic!("第 {} 次 seed=None 生成应成功", i + 2));
assert_eq!(
first.rooms.len(),
repeat.rooms.len(),
"第 {} 次房间数应一致",
i + 2
);
assert_eq!(
first.corridors.len(),
repeat.corridors.len(),
"第 {} 次走廊数应一致",
i + 2
);
assert_eq!(
first.item_spawns.len(),
repeat.item_spawns.len(),
"第 {} 次交互物数应一致",
i + 2
);
assert_eq!(
first.enemy_spawns.len(),
repeat.enemy_spawns.len(),
"第 {} 次敌人数应一致",
i + 2
);
assert_eq!(
hash_room_ids(&first.rooms),
hash_room_ids(&repeat.rooms),
"第 {} 次房间哈希应一致",
i + 2
);
assert_eq!(
hash_corridor_ids(&first.corridors),
hash_corridor_ids(&repeat.corridors),
"第 {} 次走廊哈希应一致",
i + 2
);
assert_eq!(
hash_spawns(&first.item_spawns),
hash_spawns(&repeat.item_spawns),
"第 {} 次交互物哈希应一致",
i + 2
);
assert_eq!(
hash_spawns(&first.enemy_spawns),
hash_spawns(&repeat.enemy_spawns),
"第 {} 次敌人哈希应一致",
i + 2
);
assert_eq!(
first.metadata.seed,
repeat.metadata.seed,
"第 {} 次元数据种子应一致",
i + 2
);
assert_eq!(
first.metadata.config_digest,
repeat.metadata.config_digest,
"第 {} 次配置摘要应一致",
i + 2
);
}
}
#[test]
fn test_seed_none_equals_seed_from_config() {
let config = GenerationConfig::default();
let expected_seed = ConfigDigest::seed_from_config(&config).expect("默认配置派生种子不应失败");
let generator = MapGenerator::new();
let result = generator
.generate(GenerationRequest {
seed: None,
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
})
.expect("seed=None 生成应成功");
assert_eq!(
result.metadata.seed, expected_seed,
"seed=None 时结果种子应等于 ConfigDigest::seed_from_config 派生值"
);
}
#[test]
fn test_golden_runtime_chunked_seed_42() {
let generator = MapGenerator::new();
let config = make_runtime_chunked_config();
let make_request = || GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: Some(RuntimeContext {
focus_position: None,
interest_radius: None,
requested_chunks: vec![], caller_tag: None,
}),
trace_id: None,
};
let result1 = generator
.generate_chunk(make_request())
.expect("RuntimeChunked 第一次生成应成功");
let result2 = generator
.generate_chunk(make_request())
.expect("RuntimeChunked 第二次生成应成功");
assert_eq!(
result1.rooms.len(),
result2.rooms.len(),
"RuntimeChunked 房间数应一致"
);
assert_eq!(
hash_room_ids(&result1.rooms),
hash_room_ids(&result2.rooms),
"RuntimeChunked 房间哈希应一致"
);
assert_eq!(
hash_corridor_ids(&result1.corridors),
hash_corridor_ids(&result2.corridors),
"RuntimeChunked 走廊哈希应一致"
);
assert_eq!(
hash_spawns(&result1.item_spawns),
hash_spawns(&result2.item_spawns),
"RuntimeChunked 交互物哈希应一致"
);
assert_eq!(
hash_spawns(&result1.enemy_spawns),
hash_spawns(&result2.enemy_spawns),
"RuntimeChunked 敌人哈希应一致"
);
assert_eq!(result1.metadata.seed, 42);
assert_eq!(
result1.metadata.config_digest, result2.metadata.config_digest,
"RuntimeChunked 配置摘要应一致"
);
}
#[test]
fn test_golden_hybrid_seed_42() {
let generator = MapGenerator::new();
let config = make_hybrid_config();
let make_request = || GenerationRequest {
seed: Some(42),
config: config.clone(),
constraints: vec![],
runtime_context: None,
trace_id: None,
};
let topo1 = generator
.generate_topology_only(make_request())
.expect("HybridPrecompute 拓扑第一次生成应成功");
let topo2 = generator
.generate_topology_only(make_request())
.expect("HybridPrecompute 拓扑第二次生成应成功");
assert_eq!(topo1.seed, 42);
assert_eq!(topo1.seed, topo2.seed, "HybridPrecompute 种子应一致");
assert_eq!(
topo1.topology.nodes.len(),
topo2.topology.nodes.len(),
"HybridPrecompute 拓扑节点数应一致"
);
assert_eq!(
topo1.config_digest, topo2.config_digest,
"HybridPrecompute 配置摘要应一致"
);
assert_eq!(
topo1.chunks.len(),
topo2.chunks.len(),
"HybridPrecompute 分块数应一致"
);
let chunk_id = &topo1.chunks[0].id;
let detail1 = generator
.fill_chunk_details(&topo1, chunk_id)
.expect("HybridPrecompute 第一次细节填充应成功");
let detail2 = generator
.fill_chunk_details(&topo2, chunk_id)
.expect("HybridPrecompute 第二次细节填充应成功");
assert_eq!(detail1.chunk_id, detail2.chunk_id, "分块 ID 应一致");
assert_eq!(
detail1.terrains.len(),
detail2.terrains.len(),
"HybridPrecompute 地形数应一致"
);
assert_eq!(
detail1.item_spawns.len(),
detail2.item_spawns.len(),
"HybridPrecompute 交互物数应一致"
);
assert_eq!(
detail1.enemy_spawns.len(),
detail2.enemy_spawns.len(),
"HybridPrecompute 敌人数应一致"
);
assert_eq!(
hash_spawns(&detail1.item_spawns),
hash_spawns(&detail2.item_spawns),
"HybridPrecompute 交互物哈希应一致"
);
assert_eq!(
hash_spawns(&detail1.enemy_spawns),
hash_spawns(&detail2.enemy_spawns),
"HybridPrecompute 敌人哈希应一致"
);
}