Merge pull request #2437 from RoyalPixelsDE/fix/structure-mob-finalize
🤖 Agent: Gate check by Ludovic's AI agent (Claude). Checked against 26.3: `StructureTemplate.placeEntities` and the pieces' markers call `finalizeSpawn(level, difficulty, STRUCTURE, null)` inside the `WorldGenRegion` with its random, and the save keys now follow `addAdditionalSaveData`. Your rebased head is the reviewed change plus the comment cleanup, on current main. Gate: this wave's 50 PRs merged on main in one tree (union 9033a9c3b): fmt and clippy `-D warnings` clean, the horizon-client (1136 lib plus the integration tests), horizon-client-core (37), horizon-world (165) and horizon-protocol (100) tests pass, the fast build links, and the 140 harnesses `parity.py` picks for the tree's changed files pass on playhorizon (remote_fireworks, a known load flake there, passed on a rerun on a quiet Mac mini). `lan_e2e.py` passes 14 checks with the host on its server thread and in-frame (chest, xp, damage, kills, projectiles, mobs, drops, body, stopsound, digging, instant_digging, books, knockback, barter); `hurt` fails on main too when run after `damage` (check-order dependency, not this wave). Thanks @FusselTV!
This commit is contained in:
@@ -180,7 +180,6 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
("Silent", m.silent),
|
||||
("NoGravity", m.no_gravity),
|
||||
("Glowing", m.glowing),
|
||||
("Invulnerable", m.invulnerable_flag),
|
||||
] {
|
||||
if on {
|
||||
map.insert(key.into(), Tag::Byte(1));
|
||||
@@ -188,6 +187,26 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
map.remove(&horizon_world::nbt::JavaString::from(key));
|
||||
}
|
||||
}
|
||||
map.insert(
|
||||
"Invulnerable".into(),
|
||||
Tag::Byte(i8::from(m.invulnerable_flag)),
|
||||
);
|
||||
map.insert(
|
||||
"LeftHanded".into(),
|
||||
Tag::Byte(i8::from(m.extra.left_handed)),
|
||||
);
|
||||
// Keys of older formats that structure templates still carry.
|
||||
for key in [
|
||||
"HandItems",
|
||||
"ArmorItems",
|
||||
"HandDropChances",
|
||||
"ArmorDropChances",
|
||||
"Dimension",
|
||||
"HurtByTimestamp",
|
||||
"Leashed",
|
||||
] {
|
||||
map.remove(&horizon_world::nbt::JavaString::from(key));
|
||||
}
|
||||
if m.ticks_frozen > 0 {
|
||||
map.insert("TicksFrozen".into(), Tag::Int(m.ticks_frozen));
|
||||
} else {
|
||||
@@ -197,7 +216,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
("AbsorptionAmount", Tag::Float(0)),
|
||||
("FallFlying", Tag::Byte(0)),
|
||||
("CanPickUpLoot", Tag::Byte(i8::from(m.can_pick_up_loot()))),
|
||||
("LeftHanded", Tag::Byte(0)),
|
||||
("current_impulse_context_reset_grace_time", Tag::Int(0)),
|
||||
(
|
||||
"Brain",
|
||||
Tag::compound([("memories", Tag::Compound(Compound::new()))]),
|
||||
@@ -209,7 +228,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
// Only breedable animals have an age; a loaded creature that was saved without
|
||||
// one (a frog) stays without.
|
||||
let aged = raw.is_none_or(|r| r.get("Age").is_some());
|
||||
if m.kind.category == "creature" && aged {
|
||||
if (m.kind.category == "creature" || m.species() == crate::mobs::Species::Hoglin) && aged {
|
||||
map.insert("Age".into(), Tag::Int(m.extra.age));
|
||||
map.insert("AgeLocked".into(), Tag::Byte(i8::from(m.extra.age_locked)));
|
||||
map.insert("ForcedAge".into(), Tag::Int(m.extra.forced_age));
|
||||
@@ -260,6 +279,10 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
.or_insert_with(|| string("minecraft:classic"));
|
||||
}
|
||||
"minecraft:piglin" | "minecraft:piglin_brute" | "minecraft:hoglin" => {
|
||||
// Only Piglin.addAdditionalSaveData writes CannotHunt.
|
||||
if id == "minecraft:piglin_brute" {
|
||||
map.remove(&"CannotHunt".into());
|
||||
}
|
||||
map.insert(
|
||||
"IsImmuneToZombification".into(),
|
||||
Tag::Byte(i8::from(m.extra.flag2)),
|
||||
@@ -498,8 +521,7 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
)])
|
||||
});
|
||||
}
|
||||
"minecraft:zombie" => {
|
||||
map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
|
||||
"minecraft:zombie" | "minecraft:husk" | "minecraft:drowned" => {
|
||||
for (key, value) in [
|
||||
("DrownedConversionTime", Tag::Int(-1)),
|
||||
("InWaterTime", Tag::Int(-1)),
|
||||
@@ -532,6 +554,21 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
Tag::Byte(i8::from(m.extra.can_break_doors)),
|
||||
);
|
||||
}
|
||||
if matches!(
|
||||
id,
|
||||
"minecraft:zombie"
|
||||
| "minecraft:husk"
|
||||
| "minecraft:drowned"
|
||||
| "minecraft:zombie_villager"
|
||||
| "minecraft:zombified_piglin"
|
||||
| "minecraft:piglin"
|
||||
| "minecraft:zoglin"
|
||||
) {
|
||||
map.insert("IsBaby".into(), Tag::Byte(i8::from(m.is_baby())));
|
||||
}
|
||||
if let Some(a) = m.extra.attributes.as_deref() {
|
||||
put_attributes(map, m, a);
|
||||
}
|
||||
crate::mobs::raider::write_nbt(m, map);
|
||||
crate::mobs::riders::write_nbt(m, map);
|
||||
// LivingEntity equipment: what the mob holds now.
|
||||
@@ -614,6 +651,89 @@ pub fn mob_to_nbt(m: &Mob, uuid: [i32; 4], raw: Option<&Tag>) -> Tag {
|
||||
}
|
||||
tag
|
||||
}
|
||||
/// `AttributeMap.pack` for the attributes with a base or permanent modifier
|
||||
/// finalizeSpawn set, over the saved list.
|
||||
fn put_attributes(map: &mut Compound, m: &Mob, a: &crate::mobs::finalize::Attributes) {
|
||||
use crate::mobs::finalize::{self, Attr, Op};
|
||||
let mut list = match map.get(&"attributes".into()) {
|
||||
Some(Tag::List(l)) => l.clone(),
|
||||
_ => Vec::new(),
|
||||
};
|
||||
for attr in Attr::ALL {
|
||||
let modifiers: Vec<Tag> = a
|
||||
.modifiers
|
||||
.iter()
|
||||
.filter(|x| x.attr == attr)
|
||||
.map(|x| {
|
||||
let op = match x.op {
|
||||
Op::AddValue => "add_value",
|
||||
Op::AddMultipliedBase => "add_multiplied_base",
|
||||
Op::AddMultipliedTotal => "add_multiplied_total",
|
||||
};
|
||||
Tag::compound([
|
||||
("id", string(x.id)),
|
||||
("amount", Tag::Double(x.amount.to_bits())),
|
||||
("operation", string(op)),
|
||||
])
|
||||
})
|
||||
.collect();
|
||||
if modifiers.is_empty() && !a.bases.iter().any(|(b, _)| *b == attr) {
|
||||
continue;
|
||||
}
|
||||
let id = format!("minecraft:{}", attr.name());
|
||||
let mut entry = vec![
|
||||
("id", string(&id)),
|
||||
("base", Tag::Double(finalize::base_value(m, attr).to_bits())),
|
||||
];
|
||||
if !modifiers.is_empty() {
|
||||
entry.push(("modifiers", Tag::List(modifiers)));
|
||||
}
|
||||
let entry = Tag::compound(entry);
|
||||
match list
|
||||
.iter_mut()
|
||||
.find(|t| text(t.get("id")).as_deref() == Some(id.as_str()))
|
||||
{
|
||||
Some(t) => *t = entry,
|
||||
None => list.push(entry),
|
||||
}
|
||||
}
|
||||
map.insert("attributes".into(), Tag::List(list));
|
||||
}
|
||||
/// `Brain.Packed`: the memories finalizeSpawn set, over the saved ones.
|
||||
pub fn put_brain(map: &mut Compound, m: &Mob, dimension: &str) {
|
||||
if m.extra.memories.is_empty() {
|
||||
return;
|
||||
}
|
||||
let mut memories = match map.get(&"Brain".into()).and_then(|b| b.get("memories")) {
|
||||
Some(Tag::Compound(c)) => c.clone(),
|
||||
_ => Compound::new(),
|
||||
};
|
||||
for &(name, value, ttl) in &m.extra.memories {
|
||||
let value = match name {
|
||||
"hunted_recently" => Tag::Byte(value as i8),
|
||||
"home" => match m.extra.home {
|
||||
Some(p) => Tag::compound([
|
||||
("dimension", string(dimension)),
|
||||
("pos", Tag::IntArray(p.to_vec())),
|
||||
]),
|
||||
None => continue,
|
||||
},
|
||||
_ => Tag::Int(value as i32),
|
||||
};
|
||||
let mut memory = vec![("value", value)];
|
||||
if ttl != i64::MAX {
|
||||
memory.push(("ttl", Tag::Long(ttl)));
|
||||
}
|
||||
memories.insert(
|
||||
format!("minecraft:{name}").as_str().into(),
|
||||
Tag::compound(memory),
|
||||
);
|
||||
}
|
||||
map.insert(
|
||||
"Brain".into(),
|
||||
Tag::compound([("memories", Tag::Compound(memories))]),
|
||||
);
|
||||
}
|
||||
/// `CustomName`: a text component saved as a string or a `{text: ..}` compound.
|
||||
fn custom_name(tag: &Tag) -> Option<String> {
|
||||
match tag.get("CustomName")? {
|
||||
@@ -633,6 +753,22 @@ pub fn name_text(tag: &Tag) -> Text {
|
||||
t => crate::scoreboard::comp_text(&crate::scoreboard::tag_to_json(t)),
|
||||
}
|
||||
}
|
||||
/// Mob.finalizeSpawn's follow range bonus in the saved attributes.
|
||||
pub(crate) fn spawn_bonus(tag: &Tag) -> Option<f64> {
|
||||
let Some(Tag::List(attrs)) = tag.get("attributes") else {
|
||||
return None;
|
||||
};
|
||||
let range = attrs
|
||||
.iter()
|
||||
.find(|a| text(a.get("id")).as_deref() == Some("minecraft:follow_range"))?;
|
||||
let Some(Tag::List(modifiers)) = range.get("modifiers") else {
|
||||
return None;
|
||||
};
|
||||
let bonus = modifiers
|
||||
.iter()
|
||||
.find(|x| text(x.get("id")).as_deref() == Some("minecraft:random_spawn_bonus"))?;
|
||||
float(bonus.get("amount"))
|
||||
}
|
||||
pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -> Option<Mob> {
|
||||
let kind = types.get(&self::kind(tag)?)?.clone();
|
||||
let position = position(tag)?;
|
||||
@@ -658,6 +794,11 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
|
||||
}
|
||||
}
|
||||
}
|
||||
if let Some(bonus) = spawn_bonus(tag) {
|
||||
use crate::mobs::finalize::{Attr, Op, add_modifier};
|
||||
let id = "minecraft:random_spawn_bonus";
|
||||
add_modifier(&mut m, Attr::FollowRange, id, bonus, Op::AddMultipliedBase);
|
||||
}
|
||||
m.health = float(tag.get("Health")).map_or(m.attrs.max_health, |h| h as f32);
|
||||
m.hurt_time = number(tag.get("HurtTime")).unwrap_or(0) as i32;
|
||||
// What it holds (equipment.mainhand / offhand), when saved.
|
||||
@@ -699,7 +840,8 @@ pub fn mob_from_nbt(tag: &Tag, types: &HashMap<String, Arc<MobType>>, id: u32) -
|
||||
m.extra.pick_up_loot = flag(tag, "CanPickUpLoot");
|
||||
m.custom_name = custom_name(tag);
|
||||
m.custom_name_text = tag.get("CustomName").map(name_text);
|
||||
if m.kind.category == "creature" {
|
||||
m.extra.left_handed = flag(tag, "LeftHanded");
|
||||
if m.kind.category == "creature" || m.species() == crate::mobs::Species::Hoglin {
|
||||
m.extra.age = number(tag.get("Age")).unwrap_or(0) as i32;
|
||||
m.extra.forced_age = number(tag.get("ForcedAge")).unwrap_or(0) as i32;
|
||||
m.extra.age_locked = flag(tag, "AgeLocked");
|
||||
|
||||
@@ -4740,6 +4740,7 @@ impl Game<'_> {
|
||||
/// What the tick runs after the local player's own update: effects, the
|
||||
/// world's entities and blocks, and the network hub.
|
||||
fn tick_world(&mut self, running: bool) -> Result<()> {
|
||||
self.share_spawn_conditions();
|
||||
self.update_chunk_tickets();
|
||||
horizon_client::spans::time("tick_effects", || self.tick_effects(running));
|
||||
// Player.tick's ItemCooldowns.tick for the window's player (a
|
||||
@@ -8175,6 +8176,7 @@ impl Game<'_> {
|
||||
);
|
||||
self.session_lock = Some(session_lock);
|
||||
self.end.set_locator(locator);
|
||||
self.share_spawn_conditions();
|
||||
self.score = Default::default();
|
||||
self.fns = Default::default();
|
||||
self.bosses = Default::default();
|
||||
@@ -8313,6 +8315,7 @@ impl Game<'_> {
|
||||
seed,
|
||||
)?;
|
||||
self.end.set_locator(locator);
|
||||
self.share_spawn_conditions();
|
||||
Ok((streaming, save))
|
||||
}
|
||||
/// Change dimension through a portal (Entity.changeDimension with
|
||||
|
||||
@@ -430,6 +430,12 @@ impl Game<'_> {
|
||||
),
|
||||
}
|
||||
}
|
||||
/// What the generator finalizes this level's structure mobs with.
|
||||
pub(super) fn share_spawn_conditions(&self) {
|
||||
if let Some(terrain) = self.end.locator() {
|
||||
terrain.set_spawn_conditions(self.difficulty_id() as u8, self.world.day_time);
|
||||
}
|
||||
}
|
||||
/// `ServerLevel.getCurrentDifficultyAt`.
|
||||
pub(super) fn local_difficulty(&self, at: [f64; 3]) -> spawning::LocalDifficulty {
|
||||
use horizon_world::food::Difficulty;
|
||||
|
||||
@@ -192,6 +192,7 @@ impl Game<'_> {
|
||||
let mut locator = self.end.locator();
|
||||
swap(&mut locator, &mut p.locator);
|
||||
self.end.set_locator(locator);
|
||||
self.share_spawn_conditions();
|
||||
swap(&mut self.save, &mut p.save);
|
||||
swap(&mut self.block_ticks, &mut p.block_ticks);
|
||||
swap(&mut self.tick_chunks, &mut p.tick_chunks);
|
||||
|
||||
@@ -357,7 +357,8 @@ impl Game<'_> {
|
||||
pub(super) fn load_mob(&mut self, tag: Tag, mount: Option<u32>) -> Option<u32> {
|
||||
self.next_entity += 1;
|
||||
let uuid = entity_nbt::uuid(&tag);
|
||||
// Structure entities placed with finalizeEntities.
|
||||
// Structure mobs that generation left to finish: saves from before
|
||||
// they were finalized at placement, or a placement that could not.
|
||||
let mut tag = tag;
|
||||
let mut finalize = false;
|
||||
if let Tag::Compound(c) = &mut tag {
|
||||
@@ -449,7 +450,8 @@ impl Game<'_> {
|
||||
}
|
||||
}
|
||||
/// An entity of a type Horizon does not simulate, kept as its compound.
|
||||
fn load_other(&mut self, tag: Tag, kind: &str) -> Option<u32> {
|
||||
fn load_other(&mut self, mut tag: Tag, kind: &str) -> Option<u32> {
|
||||
strip_finalize(&mut tag);
|
||||
let position = entity_nbt::position(&tag)?;
|
||||
let rotation = match tag.get("Rotation") {
|
||||
Some(Tag::List(l)) => {
|
||||
@@ -1014,3 +1016,9 @@ impl Game<'_> {
|
||||
self.save.save_entities(chunks)
|
||||
}
|
||||
}
|
||||
/// Only a mob is finalized; another entity drops the request.
|
||||
fn strip_finalize(tag: &mut Tag) {
|
||||
if let Tag::Compound(c) = tag {
|
||||
c.remove(&"horizon:finalize".into());
|
||||
}
|
||||
}
|
||||
|
||||
@@ -235,7 +235,7 @@ impl Game<'_> {
|
||||
}
|
||||
out
|
||||
}
|
||||
fn difficulty_id(&self) -> i32 {
|
||||
pub(super) fn difficulty_id(&self) -> i32 {
|
||||
use horizon_world::food::Difficulty;
|
||||
match self.world.health_rules.difficulty {
|
||||
Difficulty::Peaceful => 0,
|
||||
|
||||
@@ -24,7 +24,9 @@ use horizon_world::{
|
||||
};
|
||||
use std::{path::Path, sync::Arc};
|
||||
mod lod;
|
||||
mod structure_mobs;
|
||||
use lod::VanillaLodSampler;
|
||||
use structure_mobs::StructureMobFinalizer;
|
||||
|
||||
pub struct VanillaTerrain {
|
||||
generator: OverworldGenerator,
|
||||
@@ -32,6 +34,7 @@ pub struct VanillaTerrain {
|
||||
biome_map: Vec<u16>,
|
||||
/// Loot tables for generated containers.
|
||||
loot: Option<Arc<horizon_world::loot::LootData>>,
|
||||
structure_mobs: Arc<StructureMobFinalizer>,
|
||||
/// A worker for structure queries from the game thread.
|
||||
query: std::sync::Mutex<Option<GeneratorWorker>>,
|
||||
/// Block state id -> block index, the game's block tick type: worldgen
|
||||
@@ -138,6 +141,10 @@ impl VanillaTerrain {
|
||||
generator,
|
||||
biome_map,
|
||||
loot,
|
||||
structure_mobs: Arc::new(StructureMobFinalizer::new(
|
||||
dir.parent().unwrap_or(dir).to_owned(),
|
||||
dimension,
|
||||
)),
|
||||
query: std::sync::Mutex::new(None),
|
||||
tick_blocks,
|
||||
tick_states,
|
||||
@@ -147,6 +154,11 @@ impl VanillaTerrain {
|
||||
created: std::time::Instant::now(),
|
||||
})
|
||||
}
|
||||
/// The difficulty (0 peaceful to 3 hard) and overworld clock structure
|
||||
/// mobs are finalized with.
|
||||
pub fn set_spawn_conditions(&self, difficulty: u8, day_time: i64) {
|
||||
self.structure_mobs.set_conditions(difficulty, day_time);
|
||||
}
|
||||
/// A proto chunk's blocks, biomes, scheduled ticks and post-processing
|
||||
/// marks as a column.
|
||||
fn column(&self, chunk: &ProtoChunk) -> Chunk {
|
||||
@@ -362,7 +374,9 @@ pub fn shared_data(
|
||||
impl ChunkGenerator for VanillaTerrain {
|
||||
type Worker = GeneratorWorker;
|
||||
fn worker(&self) -> GeneratorWorker {
|
||||
self.generator.worker()
|
||||
let mut worker = self.generator.worker();
|
||||
worker.set_structure_mobs(self.structure_mobs.clone());
|
||||
worker
|
||||
}
|
||||
fn lod_sampler(self: Arc<Self>) -> Box<dyn LodSampler> {
|
||||
Box::new(VanillaLodSampler::new(self))
|
||||
|
||||
@@ -0,0 +1,446 @@
|
||||
//! `Mob.finalizeSpawn(level, level.getCurrentDifficultyAt(pos), STRUCTURE, null)`
|
||||
//! of the mobs structures place (StructureTemplate.placeEntities with
|
||||
//! finalizeEntities, ocean ruin drowned, mansion illagers, witch huts,
|
||||
//! monuments), run as decoration places them, with the WorldGenRegion's random.
|
||||
use crate::{
|
||||
enchant::Enchantments,
|
||||
entity_nbt,
|
||||
items::Items,
|
||||
mobs::{
|
||||
Mob, MobType, MobTypes,
|
||||
finalize::{self, Ctx, FinalizeLevel, Reason, SpawnData, SpawnRegistries},
|
||||
spawning::{LocalDifficulty, MOON_BRIGHTNESS},
|
||||
},
|
||||
};
|
||||
use chrono::Datelike;
|
||||
use horizon_core::{
|
||||
geometry::{Aabb, Vec3},
|
||||
random::{LegacyRandom, RandomSource, XoroshiroRandom},
|
||||
};
|
||||
use horizon_world::{
|
||||
nbt::{Compound, Tag},
|
||||
worldgen::{generator::StructureMobs, structure::legacy::PieceRandom},
|
||||
};
|
||||
use std::{
|
||||
collections::{HashMap, HashSet},
|
||||
path::PathBuf,
|
||||
sync::{
|
||||
Arc, OnceLock,
|
||||
atomic::{AtomicI64, AtomicU8, Ordering},
|
||||
},
|
||||
};
|
||||
|
||||
struct Data {
|
||||
types: HashMap<String, Arc<MobType>>,
|
||||
biome_tags: HashMap<String, HashSet<String>>,
|
||||
registries: SpawnRegistries,
|
||||
enchantments: Enchantments,
|
||||
items: Items,
|
||||
camel_husk: (f32, f32),
|
||||
}
|
||||
fn load(root: &std::path::Path) -> Option<Data> {
|
||||
let types = MobTypes::load(root).ok()?.types;
|
||||
let camel = types.get("minecraft:camel_husk")?;
|
||||
let camel_husk = (camel.width as f32, camel.height as f32);
|
||||
Some(Data {
|
||||
types: types.into_iter().map(|(k, t)| (k, Arc::new(t))).collect(),
|
||||
biome_tags: crate::items::load_tags(root, "worldgen/biome").unwrap_or_default(),
|
||||
registries: SpawnRegistries::load(root),
|
||||
enchantments: Enchantments::load(root),
|
||||
items: Items::tags_only(root).ok()?,
|
||||
camel_husk,
|
||||
})
|
||||
}
|
||||
|
||||
pub struct StructureMobFinalizer {
|
||||
root: PathBuf,
|
||||
dimension: String,
|
||||
data: OnceLock<Option<Data>>,
|
||||
/// The level's difficulty (0 peaceful to 3 hard) and overworld clock.
|
||||
difficulty: AtomicU8,
|
||||
day_time: AtomicI64,
|
||||
}
|
||||
impl StructureMobFinalizer {
|
||||
pub fn new(root: PathBuf, dimension: &str) -> Self {
|
||||
Self {
|
||||
root,
|
||||
dimension: dimension.to_owned(),
|
||||
data: OnceLock::new(),
|
||||
difficulty: AtomicU8::new(2),
|
||||
day_time: AtomicI64::new(0),
|
||||
}
|
||||
}
|
||||
pub fn set_conditions(&self, difficulty: u8, day_time: i64) {
|
||||
self.difficulty.store(difficulty, Ordering::Relaxed);
|
||||
self.day_time.store(day_time, Ordering::Relaxed);
|
||||
}
|
||||
}
|
||||
|
||||
struct Level<'a> {
|
||||
data: &'a Data,
|
||||
biome: &'a str,
|
||||
structures: &'a [String],
|
||||
difficulty: u8,
|
||||
day_time: i64,
|
||||
next_id: u32,
|
||||
}
|
||||
impl FinalizeLevel for Level<'_> {
|
||||
fn biome(&self, _: [i32; 3]) -> String {
|
||||
self.biome.to_owned()
|
||||
}
|
||||
fn biome_tag(&self, tag: &str, _: [i32; 3]) -> bool {
|
||||
self.data
|
||||
.biome_tags
|
||||
.get(tag)
|
||||
.is_some_and(|b| b.contains(self.biome))
|
||||
}
|
||||
fn structures_with_piece_at(&self, _: [i32; 3]) -> Vec<String> {
|
||||
self.structures.to_vec()
|
||||
}
|
||||
fn moon_phase(&self, _: [i32; 3]) -> usize {
|
||||
self.day_time.div_euclid(24000).rem_euclid(8) as usize
|
||||
}
|
||||
fn spawning_monsters(&self) -> bool {
|
||||
self.difficulty != 0
|
||||
}
|
||||
// No block collision: only a husk's camel asks, and no structure places husks.
|
||||
fn no_collision(&self, _: Aabb) -> bool {
|
||||
true
|
||||
}
|
||||
// WorldGenRegion holds no entities.
|
||||
fn free_chicken(&self, _: Aabb) -> Option<u32> {
|
||||
None
|
||||
}
|
||||
fn ride_chicken(&mut self, _: u32, _: u32) {}
|
||||
fn game_time(&self) -> i64 {
|
||||
self.day_time
|
||||
}
|
||||
fn halloween(&self) -> bool {
|
||||
let today = chrono::Local::now();
|
||||
(today.month(), today.day()) == (10, 31)
|
||||
}
|
||||
fn create(&mut self, kind: &str, _: Reason) -> Option<Mob> {
|
||||
if self.difficulty == 0 && !finalize::allowed_in_peaceful(kind) {
|
||||
return None;
|
||||
}
|
||||
let t = self.data.types.get(kind)?.clone();
|
||||
self.next_id += 1;
|
||||
Some(Mob::new(self.next_id, t, Vec3::ZERO, 0.0))
|
||||
}
|
||||
}
|
||||
|
||||
fn run<R: RandomSource>(
|
||||
level: &mut Level<'_>,
|
||||
random: &mut R,
|
||||
difficulty: LocalDifficulty,
|
||||
data: &SpawnData<'_>,
|
||||
m: &mut Mob,
|
||||
) -> Vec<Mob> {
|
||||
let mut cx = Ctx {
|
||||
level,
|
||||
random,
|
||||
difficulty,
|
||||
data,
|
||||
created: Vec::new(),
|
||||
};
|
||||
cx.finalize(m, Reason::Structure, None);
|
||||
cx.created
|
||||
}
|
||||
|
||||
/// The saved compound of mob `i` with the mobs riding it under `Passengers`.
|
||||
fn tree(mobs: &[(Mob, Option<Tag>)], i: usize, dimension: &str) -> Compound {
|
||||
let (m, raw) = &mobs[i];
|
||||
let Tag::Compound(mut c) = entity_nbt::mob_to_nbt(m, [0; 4], raw.as_ref()) else {
|
||||
return Compound::new();
|
||||
};
|
||||
c.remove(&"UUID".into());
|
||||
entity_nbt::put_brain(&mut c, m, dimension);
|
||||
let riders: Vec<Tag> = (0..mobs.len())
|
||||
.filter(|&j| mobs[j].0.extra.mount == Some(m.id))
|
||||
.map(|j| Tag::Compound(tree(mobs, j, dimension)))
|
||||
.collect();
|
||||
if !riders.is_empty() {
|
||||
c.insert("Passengers".into(), Tag::List(riders));
|
||||
}
|
||||
c
|
||||
}
|
||||
|
||||
impl StructureMobs for StructureMobFinalizer {
|
||||
fn finalize(
|
||||
&self,
|
||||
nbt: &mut Compound,
|
||||
biome: &str,
|
||||
structures: &[String],
|
||||
random: &mut dyn PieceRandom,
|
||||
) -> bool {
|
||||
let Some(data) = self.data.get_or_init(|| {
|
||||
let data = load(&self.root);
|
||||
if data.is_none() {
|
||||
log::error!("Horizon: no mob data, structure mobs are finalized when loaded");
|
||||
}
|
||||
data
|
||||
}) else {
|
||||
return false;
|
||||
};
|
||||
let mut raw = Tag::Compound(nbt.clone());
|
||||
if let Tag::Compound(c) = &mut raw {
|
||||
c.remove(&"horizon:finalize".into());
|
||||
}
|
||||
let Some(mut m) = entity_nbt::mob_from_nbt(&raw, &data.types, 1) else {
|
||||
// Not a mob: vanilla finalizes only Mob instances.
|
||||
return true;
|
||||
};
|
||||
let base = self.difficulty.load(Ordering::Relaxed);
|
||||
let day_time = self.day_time.load(Ordering::Relaxed);
|
||||
let mut level = Level {
|
||||
data,
|
||||
biome,
|
||||
structures,
|
||||
difficulty: base,
|
||||
day_time,
|
||||
next_id: 1,
|
||||
};
|
||||
let moon = MOON_BRIGHTNESS[level.moon_phase([0; 3])];
|
||||
// WorldGenRegion.getCurrentDifficultyAt: no inhabited time.
|
||||
let difficulty = LocalDifficulty::new(base, day_time, 0, moon);
|
||||
let spawn = SpawnData {
|
||||
registries: &data.registries,
|
||||
enchantments: &data.enchantments,
|
||||
items: &data.items,
|
||||
camel_husk_size: data.camel_husk,
|
||||
};
|
||||
let any = random.as_any();
|
||||
let created = if let Some(r) = any.downcast_mut::<LegacyRandom>() {
|
||||
run(&mut level, r, difficulty, &spawn, &mut m)
|
||||
} else if let Some(r) = any.downcast_mut::<XoroshiroRandom>() {
|
||||
run(&mut level, r, difficulty, &spawn, &mut m)
|
||||
} else {
|
||||
log::error!("Horizon: unknown region random, structure mobs are finalized when loaded");
|
||||
return false;
|
||||
};
|
||||
let mut mobs = vec![(m, Some(raw))];
|
||||
mobs.extend(created.into_iter().map(|c| (c, None)));
|
||||
let root = mobs
|
||||
.iter()
|
||||
.position(|(m, _)| m.extra.mount.is_none())
|
||||
.unwrap_or(0);
|
||||
*nbt = tree(&mobs, root, &self.dimension);
|
||||
true
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests {
|
||||
use super::*;
|
||||
|
||||
/// The bastion's crossbow piglin keeps its crossbow (STRUCTURE skips
|
||||
/// createSpawnWeapon) and saves what Piglin.addAdditionalSaveData writes.
|
||||
#[test]
|
||||
fn bastion_crossbow_piglin_finalizes_as_structure() {
|
||||
let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
|
||||
return;
|
||||
};
|
||||
let file = root.join("worldgen/structure/minecraft/bastion/mobs/crossbow_piglin.nbt");
|
||||
let mut bytes = Vec::new();
|
||||
std::io::Read::read_to_end(
|
||||
&mut flate2::read::GzDecoder::new(std::fs::File::open(file).unwrap()),
|
||||
&mut bytes,
|
||||
)
|
||||
.unwrap();
|
||||
let limits = horizon_world::nbt::Limits::templates();
|
||||
let template = horizon_world::nbt::read_named(&bytes, limits)
|
||||
.unwrap()
|
||||
.0
|
||||
.tag;
|
||||
let Some(Tag::List(entities)) = template.get("entities") else {
|
||||
panic!("no entities");
|
||||
};
|
||||
let Some(Tag::Compound(mut nbt)) = entities[0].get("nbt").cloned() else {
|
||||
panic!("no nbt");
|
||||
};
|
||||
nbt.remove(&"UUID".into());
|
||||
let hook = StructureMobFinalizer::new(root, "minecraft:the_nether");
|
||||
let mut random = LegacyRandom::new(12345);
|
||||
hook.finalize(&mut nbt, "minecraft:nether_wastes", &[], &mut random);
|
||||
let keys: Vec<String> = {
|
||||
let mut k: Vec<String> = nbt.keys().map(|k| k.to_string_lossy()).collect();
|
||||
k.sort();
|
||||
k
|
||||
};
|
||||
assert_eq!(
|
||||
keys,
|
||||
[
|
||||
"AbsorptionAmount",
|
||||
"Air",
|
||||
"Brain",
|
||||
"CanPickUpLoot",
|
||||
"CannotHunt",
|
||||
"DeathTime",
|
||||
"FallFlying",
|
||||
"Fire",
|
||||
"Health",
|
||||
"HurtTime",
|
||||
"Inventory",
|
||||
"Invulnerable",
|
||||
"IsBaby",
|
||||
"IsImmuneToZombification",
|
||||
"LeftHanded",
|
||||
"Motion",
|
||||
"OnGround",
|
||||
"PersistenceRequired",
|
||||
"PortalCooldown",
|
||||
"Pos",
|
||||
"Rotation",
|
||||
"TimeInOverworld",
|
||||
"attributes",
|
||||
"current_impulse_context_reset_grace_time",
|
||||
"equipment",
|
||||
"fall_distance",
|
||||
"id",
|
||||
]
|
||||
);
|
||||
let tag = Tag::Compound(nbt);
|
||||
let held = tag.get("equipment").and_then(|e| e.get("mainhand"));
|
||||
assert!(
|
||||
matches!(held.and_then(|h| h.get("id")), Some(Tag::String(s)) if s.to_string_lossy() == "minecraft:crossbow")
|
||||
);
|
||||
let hunted = tag
|
||||
.get("Brain")
|
||||
.and_then(|b| b.get("memories"))
|
||||
.and_then(|m| m.get("minecraft:hunted_recently"));
|
||||
assert!(matches!(
|
||||
hunted.and_then(|h| h.get("ttl")),
|
||||
Some(Tag::Long(600..=2400))
|
||||
));
|
||||
let Some(Tag::List(attributes)) = tag.get("attributes") else {
|
||||
panic!("no attributes");
|
||||
};
|
||||
assert!(attributes.iter().any(|a| {
|
||||
matches!(a.get("id"), Some(Tag::String(s)) if s.to_string_lossy() == "minecraft:follow_range")
|
||||
&& matches!(a.get("modifiers"), Some(Tag::List(m)) if m.len() == 1)
|
||||
}));
|
||||
}
|
||||
|
||||
fn id(t: Option<&Tag>) -> String {
|
||||
match t.and_then(|t| t.get("id")) {
|
||||
Some(Tag::String(s)) => s.to_string_lossy().trim_start_matches("minecraft:").into(),
|
||||
_ => "-".into(),
|
||||
}
|
||||
}
|
||||
/// What a vanilla world saves of a structure mob that finalizeSpawn decides.
|
||||
fn describe(mob: &Tag) -> String {
|
||||
let eq = mob.get("equipment");
|
||||
let gear: Vec<String> = ["mainhand", "head", "chest", "legs", "feet"]
|
||||
.iter()
|
||||
.map(|slot| id(eq.and_then(|e| e.get(slot))))
|
||||
.collect();
|
||||
let ttl = match mob
|
||||
.get("Brain")
|
||||
.and_then(|b| b.get("memories"))
|
||||
.and_then(|m| m.get("minecraft:hunted_recently"))
|
||||
.and_then(|h| h.get("ttl"))
|
||||
{
|
||||
Some(Tag::Long(t)) => t.to_string(),
|
||||
_ => "-".into(),
|
||||
};
|
||||
let bonus = crate::entity_nbt::spawn_bonus(mob).unwrap_or(f64::NAN);
|
||||
let flag = |k: &str| matches!(mob.get(k), Some(Tag::Byte(1)));
|
||||
let riders = match mob.get("Passengers") {
|
||||
Some(Tag::List(p)) => format!(
|
||||
" [{}]",
|
||||
p.iter().map(describe).collect::<Vec<_>>().join("; ")
|
||||
),
|
||||
_ => String::new(),
|
||||
};
|
||||
format!(
|
||||
"{} {} ttl={ttl} bonus={bonus:.6} left={} baby={}{riders}",
|
||||
id(Some(mob)),
|
||||
gear.join(","),
|
||||
flag("LeftHanded"),
|
||||
flag("IsBaby") || matches!(mob.get("Age"), Some(Tag::Int(a)) if *a < 0),
|
||||
)
|
||||
}
|
||||
/// The described entities of chunk (x, z) after decorating the 3x3 around it.
|
||||
fn chunk_mobs(
|
||||
root: &std::path::Path,
|
||||
seed: i64,
|
||||
dimension: &str,
|
||||
x: i32,
|
||||
z: i32,
|
||||
) -> Vec<String> {
|
||||
use crate::streaming::{ChunkGenerator, Proto};
|
||||
let assets = crate::assets::Assets::load(root).unwrap();
|
||||
let biomes = crate::biome::Biomes::load(root).unwrap();
|
||||
let terrain = super::super::VanillaTerrain::for_dimension(
|
||||
&root.join("worldgen"),
|
||||
assets.registry,
|
||||
&biomes,
|
||||
seed,
|
||||
dimension,
|
||||
)
|
||||
.unwrap();
|
||||
let mut worker = terrain.worker();
|
||||
let mut region: [Proto; 9] = std::array::from_fn(|i| {
|
||||
terrain.proto(&mut worker, x + i as i32 % 3 - 1, z + i as i32 / 3 - 1)
|
||||
});
|
||||
terrain.decorate(&mut worker, &mut region);
|
||||
let center = std::mem::replace(&mut region[4], Box::new(()));
|
||||
let mut got: Vec<String> = terrain
|
||||
.finish(center)
|
||||
.entities
|
||||
.iter()
|
||||
.map(describe)
|
||||
.collect();
|
||||
got.sort();
|
||||
got
|
||||
}
|
||||
/// Seed 12345's bastion at chunk (-21, 8): the mobs of chunk (-23, 8) as two
|
||||
/// vanilla 26.3 runs saved them (weapons and armour, hunting memory, follow
|
||||
/// range bonus, handedness), from the region random of that chunk. The
|
||||
/// memories are as placed: vanilla saved them 13 brain ticks later.
|
||||
#[test]
|
||||
fn bastion_chunk_mobs_match_vanilla() {
|
||||
let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
|
||||
return;
|
||||
};
|
||||
let got = chunk_mobs(&root, 12345, "minecraft:the_nether", -23, 8);
|
||||
let mut expected = [
|
||||
"piglin golden_sword,-,golden_chestplate,-,- ttl=1760 bonus=0.013784",
|
||||
"piglin crossbow,-,-,-,- ttl=806 bonus=-0.011458",
|
||||
"piglin golden_sword,-,-,-,- ttl=1315 bonus=-0.084585",
|
||||
"piglin golden_sword,-,-,-,- ttl=1489 bonus=-0.038292",
|
||||
"piglin_brute golden_axe,-,-,-,- ttl=- bonus=-0.020574",
|
||||
"piglin crossbow,-,-,-,- ttl=1620 bonus=-0.079135",
|
||||
"hoglin -,-,-,-,- ttl=- bonus=-0.012052",
|
||||
"piglin golden_sword,-,-,-,- ttl=783 bonus=-0.077071",
|
||||
"piglin crossbow,-,-,golden_leggings,- ttl=1431 bonus=0.007058",
|
||||
]
|
||||
.map(|e| format!("{e} left=false baby=false"));
|
||||
expected.sort();
|
||||
assert_eq!(got, expected);
|
||||
}
|
||||
|
||||
/// Seed 12345's ocean ruin at (53, 39, 424): Drowned.finalizeSpawn mounts the
|
||||
/// trident drowned on a zombie nautilus, as vanilla saved chunk (3, 26).
|
||||
#[test]
|
||||
fn ocean_ruin_drowned_match_vanilla() {
|
||||
let Some(root) = std::env::var_os("HORIZON_TEST_RESOURCES").map(PathBuf::from) else {
|
||||
return;
|
||||
};
|
||||
let got = chunk_mobs(&root, 12345, "minecraft:overworld", 3, 26);
|
||||
let d = |gear: &str, bonus: &str| {
|
||||
format!("drowned {gear},-,-,-,- ttl=- bonus={bonus} left=false baby=false")
|
||||
};
|
||||
let mut expected = vec![
|
||||
d("-", "0.001996"),
|
||||
format!(
|
||||
"zombie_nautilus -,-,-,-,- ttl=- bonus=-0.044983 left=false baby=false [{}]",
|
||||
d("trident", "-0.045604")
|
||||
),
|
||||
d("fishing_rod", "-0.059079"),
|
||||
d("-", "0.021658"),
|
||||
];
|
||||
expected.sort();
|
||||
assert_eq!(got, expected);
|
||||
}
|
||||
}
|
||||
@@ -1648,6 +1648,22 @@ pub(super) struct WorkerState {
|
||||
heights: HashMap<(i32, i32, u8), i32>,
|
||||
/// Decorate with structure pieces only (for structure parity checks).
|
||||
pub(super) structures_only: bool,
|
||||
pub(super) structure_mobs: Option<Arc<dyn StructureMobs>>,
|
||||
}
|
||||
/// `Mob.finalizeSpawn(level, difficulty, STRUCTURE, null)` of the entities a
|
||||
/// structure places with finalizeEntities, run by the game, which owns mobs.
|
||||
pub trait StructureMobs: Send + Sync {
|
||||
/// Finalizes the entity in `nbt` if it is a mob, drawing from the
|
||||
/// region's random. `biome` is the biome at its block, `structures` the
|
||||
/// structures with a piece there. False when it could not: the entity
|
||||
/// keeps its `horizon:finalize` for the game to finish on load.
|
||||
fn finalize(
|
||||
&self,
|
||||
nbt: &mut crate::nbt::Compound,
|
||||
biome: &str,
|
||||
structures: &[String],
|
||||
random: &mut dyn super::structure::legacy::PieceRandom,
|
||||
) -> bool;
|
||||
}
|
||||
|
||||
trait SeededPipeline: Send + Sync {
|
||||
@@ -2464,6 +2480,7 @@ impl OverworldGenerator {
|
||||
carver_biomes: HashMap::new(),
|
||||
timings: StageTimings::default(),
|
||||
structures_only: false,
|
||||
structure_mobs: None,
|
||||
heights: HashMap::new(),
|
||||
},
|
||||
}
|
||||
@@ -2590,6 +2607,9 @@ impl GeneratorWorker {
|
||||
pub fn set_structures_only(&mut self, only: bool) {
|
||||
self.state.structures_only = only;
|
||||
}
|
||||
pub fn set_structure_mobs(&mut self, mobs: Arc<dyn StructureMobs>) {
|
||||
self.state.structure_mobs = Some(mobs);
|
||||
}
|
||||
}
|
||||
|
||||
#[cfg(test)]
|
||||
|
||||
@@ -310,6 +310,7 @@ impl Decoration {
|
||||
Err(e) => return Err(resource(e.to_string())),
|
||||
};
|
||||
let structures_only = worker.structures_only;
|
||||
let references = region[4].structure_starts.clone();
|
||||
let mut block_entities = Vec::new();
|
||||
for chunk in region.iter_mut() {
|
||||
block_entities.append(&mut chunk.block_entities);
|
||||
@@ -318,6 +319,9 @@ impl Decoration {
|
||||
block_entities,
|
||||
entities: Vec::new(),
|
||||
level_random,
|
||||
structure_mobs: worker.structure_mobs.clone(),
|
||||
starts: references.clone(),
|
||||
biome_names: data.biome_names(),
|
||||
blocks: data
|
||||
.feature_resources
|
||||
.as_ref()
|
||||
@@ -334,7 +338,6 @@ impl Decoration {
|
||||
};
|
||||
let mut stats = DecorateStats::default();
|
||||
let blocks = self.blocks;
|
||||
let references = region[4].structure_starts.clone();
|
||||
// ChunkGenerator.getWritableArea: the chunk's minimum Y + 1 to its maximum Y.
|
||||
let chunk_box = BoundingBox::new(
|
||||
[center.x * 16, min_y + 1, center.z * 16],
|
||||
@@ -419,15 +422,11 @@ impl Decoration {
|
||||
}
|
||||
// WorldGenRegion.addFreshEntity: into the chunk holding the position.
|
||||
for nbt in std::mem::take(&mut world.entities) {
|
||||
let Some(crate::nbt::Tag::List(p)) = nbt.get(&"Pos".into()) else {
|
||||
let Some(at) = block_of(&nbt) else {
|
||||
continue;
|
||||
};
|
||||
let coord = |i: usize| match p.get(i) {
|
||||
Some(crate::nbt::Tag::Double(b)) => f64::from_bits(*b).floor() as i32,
|
||||
_ => 0,
|
||||
};
|
||||
let index = ((coord(2) >> 4).wrapping_sub(center.z) + 1) * 3
|
||||
+ (coord(0) >> 4).wrapping_sub(center.x)
|
||||
let index = ((at[2] >> 4).wrapping_sub(center.z) + 1) * 3
|
||||
+ (at[0] >> 4).wrapping_sub(center.x)
|
||||
+ 1;
|
||||
if let Some(chunk) = usize::try_from(index).ok().and_then(|i| region.get_mut(i)) {
|
||||
chunk.entities.push(nbt);
|
||||
@@ -454,6 +453,9 @@ struct World<'a> {
|
||||
block_entities: Vec<([i32; 3], crate::nbt::Compound)>,
|
||||
entities: Vec<crate::nbt::Compound>,
|
||||
level_random: &'a mut dyn super::structure::legacy::PieceRandom,
|
||||
structure_mobs: Option<Arc<dyn super::generator::StructureMobs>>,
|
||||
starts: Vec<Arc<super::structure::start::StructureStart>>,
|
||||
biome_names: &'a [Arc<str>],
|
||||
blocks: Option<&'a BlockBehavior>,
|
||||
region: TerrainRegion<'static, GenBlockStates>,
|
||||
biomes: BiomeRegion<BiomeId>,
|
||||
@@ -847,7 +849,27 @@ impl PlacementContext for World<'_> {
|
||||
(0..ny).all(|y| (0..nz).all(|z| shape.is_full(x as i32, y as i32, z as i32)))
|
||||
}))
|
||||
}
|
||||
fn add_entity(&mut self, nbt: crate::nbt::Compound) -> Result<(), PlacementQueryError> {
|
||||
fn add_entity(&mut self, mut nbt: crate::nbt::Compound) -> Result<(), PlacementQueryError> {
|
||||
if let Some(mobs) = self.structure_mobs.clone()
|
||||
&& nbt.contains_key(&"horizon:finalize".into())
|
||||
{
|
||||
let at = block_of(&nbt).unwrap_or([0; 3]);
|
||||
let biome = self
|
||||
.biome_identity(at)
|
||||
.ok()
|
||||
.and_then(|b| self.biome_names.get(b.0 as usize))
|
||||
.map_or("", |n| &**n)
|
||||
.to_owned();
|
||||
let structures: Vec<String> = self
|
||||
.starts
|
||||
.iter()
|
||||
.filter(|s| s.pieces.iter().any(|p| p.bounding_box().is_inside(at)))
|
||||
.map(|s| s.name.clone())
|
||||
.collect();
|
||||
if mobs.finalize(&mut nbt, &biome, &structures, self.level_random) {
|
||||
nbt.remove(&"horizon:finalize".into());
|
||||
}
|
||||
}
|
||||
self.entities.push(nbt);
|
||||
Ok(())
|
||||
}
|
||||
@@ -1167,3 +1189,14 @@ impl PlacementContext for World<'_> {
|
||||
Ok(Some(false))
|
||||
}
|
||||
}
|
||||
|
||||
/// The block an entity's `Pos` is in.
|
||||
fn block_of(nbt: &crate::nbt::Compound) -> Option<[i32; 3]> {
|
||||
let Some(crate::nbt::Tag::List(p)) = nbt.get(&"Pos".into()) else {
|
||||
return None;
|
||||
};
|
||||
Some(std::array::from_fn(|i| match p.get(i) {
|
||||
Some(crate::nbt::Tag::Double(b)) => f64::from_bits(*b).floor() as i32,
|
||||
_ => 0,
|
||||
}))
|
||||
}
|
||||
|
||||
@@ -31,14 +31,19 @@ pub type Markers = Vec<(String, [i32; 3])>;
|
||||
pub trait PieceRandom: ProcessorRandom {
|
||||
fn boolean(&mut self) -> bool;
|
||||
fn double(&mut self) -> f64;
|
||||
/// The concrete random, for callers that need all of `RandomSource`.
|
||||
fn as_any(&mut self) -> &mut dyn std::any::Any;
|
||||
}
|
||||
impl<R: RandomSource> PieceRandom for R {
|
||||
impl<R: RandomSource + 'static> PieceRandom for R {
|
||||
fn boolean(&mut self) -> bool {
|
||||
self.next_boolean()
|
||||
}
|
||||
fn double(&mut self) -> f64 {
|
||||
self.next_double()
|
||||
}
|
||||
fn as_any(&mut self) -> &mut dyn std::any::Any {
|
||||
self
|
||||
}
|
||||
}
|
||||
|
||||
/// Object-safe world access for piece post-processing.
|
||||
|
||||
Reference in New Issue
Block a user