Generate structure entities and add /locate structure
Structure templates now place their saved entities (StructureTemplate.placeEntities: moved, turned and mirrored with the template, finalized for jigsaw pieces, ignored for mansions and end cities), carried in the proto chunk and spawned with the chunk: villages get their villagers and animals. /locate structure (an id or a #tag) searches ring and random-spread placements like ChunkGenerator.findNearestMapStructure; seed 42 matches vanilla for villages, monuments, swamp huts, igloos, strongholds and outposts. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
@@ -1346,6 +1346,13 @@ impl ArgType {
|
||||
ArgType::ItemPredicate => Arg::Item(parse_item(reader, reg, true)?),
|
||||
ArgType::BlockState => Arg::Block(parse_block(reader, reg, false)?),
|
||||
ArgType::BlockPredicate => Arg::Block(parse_block(reader, reg, true)?),
|
||||
// ResourceOrTagKeyArgument: structures and biomes also take a #tag.
|
||||
ArgType::Resource(kind @ (Resource::Structure | Resource::Biome))
|
||||
if reader.can_read() && reader.peek() == '#' =>
|
||||
{
|
||||
reader.cursor += 1;
|
||||
Arg::Resource(format!("#{}", read_id(reader)?))
|
||||
}
|
||||
ArgType::Resource(kind) => {
|
||||
let id = read_id(reader)?;
|
||||
let values = kind.values(reg);
|
||||
|
||||
@@ -4720,8 +4720,7 @@ impl Game<'_> {
|
||||
let inner = Arc::new(VanillaTerrain::for_dimension(&self.options.resources.join("worldgen"), res.assets.registry, &res.biomes, seed, dim.id()).map_err(|e| {
|
||||
format!("{e}\nPrepare the worldgen bundle with: python3 tools/prepare_native_client.py")
|
||||
})?);
|
||||
self.end
|
||||
.set_locator((dim == Dim::Overworld).then(|| inner.clone()));
|
||||
self.end.set_locator(Some(inner.clone()));
|
||||
Streaming::new(
|
||||
Arc::new(Persistent {
|
||||
inner,
|
||||
|
||||
@@ -1835,10 +1835,82 @@ impl Game<'_> {
|
||||
let Some(Arg::Resource(s)) = ctx.get("structure").cloned() else {
|
||||
return Ok(0);
|
||||
};
|
||||
Err(CommandError::new(Text::tr(
|
||||
"commands.locate.structure.not_found",
|
||||
&[&s],
|
||||
)))
|
||||
// LocateCommand.locateStructure: an id or a #tag of structures.
|
||||
let names = match s.strip_prefix('#') {
|
||||
Some(tag) => self.structure_tag(tag),
|
||||
None => vec![s.clone()],
|
||||
};
|
||||
let from = origin.map(|v| v.floor() as i32);
|
||||
let found = self.end.locator().and_then(|t| t.locate(&names, from, 100));
|
||||
let Some((name, p)) = found else {
|
||||
return Err(CommandError::new(Text::tr(
|
||||
"commands.locate.structure.not_found",
|
||||
&[&s],
|
||||
)));
|
||||
};
|
||||
let coords = Text::translate(
|
||||
"chat.coordinates",
|
||||
&[
|
||||
Text::literal(p[0].to_string()),
|
||||
Text::literal("~"),
|
||||
Text::literal(p[2].to_string()),
|
||||
],
|
||||
);
|
||||
let link = Text::literal("[")
|
||||
.append(coords)
|
||||
.append("]")
|
||||
.with_style(&Style {
|
||||
color: Some(text::GREEN),
|
||||
suggest: Some(format!("/tp @s {} ~ {}", p[0], p[2])),
|
||||
..Style::default()
|
||||
});
|
||||
let (dx, dz) = (f64::from(p[0] - from[0]), f64::from(p[2] - from[2]));
|
||||
let distance = (dx * dx + dz * dz).sqrt().floor() as i32;
|
||||
let shown = if s.starts_with('#') {
|
||||
format!("{s} ({name})")
|
||||
} else {
|
||||
name
|
||||
};
|
||||
self.feedback(Text::translate(
|
||||
"commands.locate.structure.success",
|
||||
&[
|
||||
Text::literal(shown),
|
||||
link,
|
||||
Text::literal(distance.to_string()),
|
||||
],
|
||||
));
|
||||
Ok(distance)
|
||||
}
|
||||
/// The structures of a `worldgen/structure` tag, nested tags expanded.
|
||||
fn structure_tag(&self, tag: &str) -> Vec<String> {
|
||||
let mut out = Vec::new();
|
||||
let mut pending = vec![tag.to_owned()];
|
||||
let mut seen = std::collections::HashSet::new();
|
||||
while let Some(t) = pending.pop() {
|
||||
if !seen.insert(t.clone()) {
|
||||
continue;
|
||||
}
|
||||
let (ns, path) = t.split_once(':').unwrap_or(("minecraft", &t));
|
||||
let file = self
|
||||
.options
|
||||
.resources
|
||||
.join(format!("data/{ns}/tags/worldgen/structure/{path}.json"));
|
||||
let Ok(v) = std::fs::read(file)
|
||||
.map_err(|_| ())
|
||||
.and_then(|b| serde_json::from_slice::<serde_json::Value>(&b).map_err(|_| ()))
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
for e in v["values"].as_array().into_iter().flatten() {
|
||||
let id = e.as_str().or_else(|| e["id"].as_str()).unwrap_or_default();
|
||||
match id.strip_prefix('#') {
|
||||
Some(nested) => pending.push(nested.to_owned()),
|
||||
None if !id.is_empty() => out.push(id.to_owned()),
|
||||
None => {}
|
||||
}
|
||||
}
|
||||
}
|
||||
out
|
||||
}
|
||||
fn cmd_say(&mut self, id: &str, ctx: &Context) -> R<i32> {
|
||||
let raw = match ctx.get(if id == "me" { "action" } else { "message" }) {
|
||||
|
||||
@@ -93,6 +93,9 @@ impl EndFlash {
|
||||
}
|
||||
}
|
||||
impl EndState {
|
||||
pub(super) fn locator(&self) -> Option<Arc<VanillaTerrain>> {
|
||||
self.locator.lock().unwrap().clone()
|
||||
}
|
||||
pub(super) fn set_locator(&self, terrain: Option<Arc<VanillaTerrain>>) {
|
||||
*self.locator.lock().unwrap() = terrain;
|
||||
}
|
||||
|
||||
@@ -206,9 +206,23 @@ impl Game<'_> {
|
||||
}
|
||||
_ if self.res.mob_types.contains_key(&kind) => {
|
||||
self.next_entity += 1;
|
||||
if let Some(m) =
|
||||
// Structure entities placed with finalizeEntities.
|
||||
let mut tag = tag;
|
||||
let finalize = match &mut tag {
|
||||
Tag::Compound(c) => c.remove(&"horizon:finalize".into()).is_some(),
|
||||
_ => false,
|
||||
};
|
||||
if let Some(mut m) =
|
||||
entity_nbt::mob_from_nbt(&tag, &self.res.mob_types, self.next_entity)
|
||||
{
|
||||
if finalize {
|
||||
let facts = self.biome_facts(
|
||||
m.position.x.floor() as i32,
|
||||
m.position.y.floor() as i32,
|
||||
m.position.z.floor() as i32,
|
||||
);
|
||||
horizon_client::mobs::spawning::finalize(&mut m, &facts);
|
||||
}
|
||||
self.remember(m.id, uuid, tag);
|
||||
self.mobs.push(m);
|
||||
}
|
||||
|
||||
@@ -68,6 +68,16 @@ impl VanillaTerrain {
|
||||
loot,
|
||||
})
|
||||
}
|
||||
/// `/locate structure`: the nearest start of one of `names` within
|
||||
/// `radius` placement sectors of block `from`.
|
||||
pub fn locate(
|
||||
&self,
|
||||
names: &[String],
|
||||
from: [i32; 3],
|
||||
radius: i32,
|
||||
) -> Option<(String, [i32; 3])> {
|
||||
self.generator.worker().locate(names, from, radius)
|
||||
}
|
||||
/// Concentric ring positions of a structure set (strongholds), once known.
|
||||
pub fn ring_positions(&self, set: &str) -> Option<Vec<ChunkPos>> {
|
||||
self.generator.ring_positions(set)
|
||||
@@ -142,7 +152,7 @@ impl ChunkGenerator for VanillaTerrain {
|
||||
}
|
||||
fn finish(&self, proto: Proto) -> Chunk {
|
||||
let proto = proto.downcast::<VanillaProto>().expect("vanilla proto");
|
||||
let chunk = match *proto {
|
||||
let mut chunk = match *proto {
|
||||
VanillaProto::Ready(c) => c,
|
||||
VanillaProto::Failed(x, z) => return Chunk::empty(x, z),
|
||||
};
|
||||
@@ -190,6 +200,10 @@ impl ChunkGenerator for VanillaTerrain {
|
||||
}
|
||||
out.biomes = Arc::new(biomes);
|
||||
out.block_entities = crate::structure_blocks::block_entities(&chunk, self.loot.as_deref());
|
||||
out.entities = std::mem::take(&mut chunk.entities)
|
||||
.into_iter()
|
||||
.map(horizon_world::nbt::Tag::Compound)
|
||||
.collect();
|
||||
for s in &mut out.sections {
|
||||
Arc::make_mut(s).compact();
|
||||
}
|
||||
|
||||
@@ -500,6 +500,9 @@ pub struct ProtoChunk {
|
||||
pub block_entities: Vec<([i32; 3], crate::nbt::Compound)>,
|
||||
/// Structure starts referencing this chunk (STRUCTURE_REFERENCES).
|
||||
pub(super) structure_starts: Vec<Arc<super::structure::start::StructureStart>>,
|
||||
/// Entities placed by structures (`ProtoChunk.addEntity`), as NBT with
|
||||
/// absolute `Pos`.
|
||||
pub entities: Vec<crate::nbt::Compound>,
|
||||
}
|
||||
impl ProtoChunk {
|
||||
pub fn position(&self) -> ChunkPos {
|
||||
@@ -1021,6 +1024,7 @@ where
|
||||
decorated: false,
|
||||
block_entities: Vec::new(),
|
||||
structure_starts: references,
|
||||
entities: Vec::new(),
|
||||
})
|
||||
}
|
||||
}
|
||||
@@ -1326,6 +1330,13 @@ trait SeededPipeline: Send + Sync {
|
||||
) -> Vec<Arc<super::structure::start::StructureStart>>;
|
||||
fn unsupported_features(&self) -> Vec<(String, String)>;
|
||||
fn ring_positions(&self, set: &str) -> Option<Vec<ChunkPos>>;
|
||||
fn locate(
|
||||
&self,
|
||||
worker: &mut WorkerState,
|
||||
names: &[String],
|
||||
from: [i32; 3],
|
||||
radius: i32,
|
||||
) -> Option<(String, [i32; 3])>;
|
||||
}
|
||||
impl<R: RandomSource + 'static> SeededPipeline for Pipeline<R>
|
||||
where
|
||||
@@ -1403,6 +1414,24 @@ where
|
||||
fn ring_positions(&self, set: &str) -> Option<Vec<ChunkPos>> {
|
||||
self.structures.as_ref()?.cached_rings(set)
|
||||
}
|
||||
fn locate(
|
||||
&self,
|
||||
worker: &mut WorkerState,
|
||||
names: &[String],
|
||||
from: [i32; 3],
|
||||
radius: i32,
|
||||
) -> Option<(String, [i32; 3])> {
|
||||
self.structures.as_ref()?.locate(
|
||||
&mut StructureQueries {
|
||||
pipeline: self,
|
||||
worker,
|
||||
valid: BTreeSet::new(),
|
||||
},
|
||||
names,
|
||||
from,
|
||||
radius,
|
||||
)
|
||||
}
|
||||
}
|
||||
|
||||
/// Counters from one FEATURES pass.
|
||||
@@ -1541,6 +1570,15 @@ impl GeneratorWorker {
|
||||
self.state.timings.chunks += 1;
|
||||
result
|
||||
}
|
||||
/// `/locate structure`: the nearest start of one of `names`.
|
||||
pub fn locate(
|
||||
&mut self,
|
||||
names: &[String],
|
||||
from: [i32; 3],
|
||||
radius: i32,
|
||||
) -> Option<(String, [i32; 3])> {
|
||||
self.pipeline.locate(&mut self.state, names, from, radius)
|
||||
}
|
||||
/// STRUCTURE_STARTS: the structure starts owned by a chunk (cached).
|
||||
pub fn structure_starts(
|
||||
&mut self,
|
||||
|
||||
@@ -316,6 +316,7 @@ impl Decoration {
|
||||
}
|
||||
let mut world = World {
|
||||
block_entities,
|
||||
entities: Vec::new(),
|
||||
level_random,
|
||||
blocks: data
|
||||
.feature_resources
|
||||
@@ -418,6 +419,22 @@ impl Decoration {
|
||||
chunk.block_entities.push((pos, nbt));
|
||||
}
|
||||
}
|
||||
// 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 {
|
||||
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)
|
||||
+ 1;
|
||||
if let Some(chunk) = usize::try_from(index).ok().and_then(|i| region.get_mut(i)) {
|
||||
chunk.entities.push(nbt);
|
||||
}
|
||||
}
|
||||
for terrain in world.region.into_chunks() {
|
||||
let p = terrain.position();
|
||||
let index = (p.z.wrapping_sub(center.z) + 1) * 3 + p.x.wrapping_sub(center.x) + 1;
|
||||
@@ -437,6 +454,7 @@ impl Decoration {
|
||||
/// the FEATURES step's write radius, biome lookups through the biome zoom.
|
||||
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,
|
||||
blocks: Option<&'a BlockBehavior>,
|
||||
region: TerrainRegion<'static, GenBlockStates>,
|
||||
@@ -721,6 +739,10 @@ 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> {
|
||||
self.entities.push(nbt);
|
||||
Ok(())
|
||||
}
|
||||
fn set_block_entity(
|
||||
&mut self,
|
||||
position: [i32; 3],
|
||||
|
||||
@@ -130,6 +130,105 @@ impl StructureState {
|
||||
cache.insert((chunk.x, chunk.z), starts.clone());
|
||||
starts
|
||||
}
|
||||
/// ChunkGenerator.findNearestMapStructure: the nearest start of one of
|
||||
/// `names` from block `from` (rings: every ring chunk; random spreads:
|
||||
/// sectors in growing squares up to `radius`). Returns the structure and
|
||||
/// its locate position (the start chunk's corner at y 0).
|
||||
pub(super) fn locate(
|
||||
&self,
|
||||
context: &mut impl super::structure::start::StartContext,
|
||||
names: &[String],
|
||||
from: [i32; 3],
|
||||
radius: i32,
|
||||
) -> Option<(String, [i32; 3])> {
|
||||
let seed = context.seed();
|
||||
let rings = self
|
||||
.rings
|
||||
.get_or_init(|| {
|
||||
self.registry
|
||||
.ring_positions(&self.possible_sets, seed, &mut |q| context.noise_biome(q))
|
||||
})
|
||||
.clone();
|
||||
let wanted = |s: usize| names.iter().any(|n| *n == self.registry.structures[s].name);
|
||||
let dist = |p: [i32; 3]| {
|
||||
let (dx, dz) = (f64::from(p[0] - from[0]), f64::from(p[2] - from[2]));
|
||||
dx * dx + dz * dz
|
||||
};
|
||||
let mut best: Option<(f64, String, [i32; 3])> = None;
|
||||
let found_at = |this: &Self, context: &mut _, chunk: ChunkPos| -> Option<String> {
|
||||
this.starts_at(context, chunk)
|
||||
.iter()
|
||||
.find(|s| wanted(s.structure))
|
||||
.map(|s| s.name.clone())
|
||||
};
|
||||
for &si in &self.possible_sets {
|
||||
let set = &self.registry.sets[si];
|
||||
if !set.structures.iter().any(|(s, _)| wanted(*s)) {
|
||||
continue;
|
||||
}
|
||||
match set.spacing() {
|
||||
None => {
|
||||
// Rings: nearest by the chunk's (8, 32, 8) block.
|
||||
let Some(chunks) = rings.get(&set.name) else {
|
||||
continue;
|
||||
};
|
||||
let mut nearest: Option<(f64, ChunkPos)> = None;
|
||||
for &c in chunks {
|
||||
let d = dist([c.x * 16 + 8, 32, c.z * 16 + 8]);
|
||||
if nearest.is_none_or(|(n, _)| d < n)
|
||||
&& self
|
||||
.registry
|
||||
.is_structure_chunk(set, seed, c.x, c.z, &rings)
|
||||
{
|
||||
nearest = Some((d, c));
|
||||
}
|
||||
}
|
||||
if let Some((_, c)) = nearest
|
||||
&& let Some(name) = found_at(self, context, c)
|
||||
{
|
||||
let p = [c.x * 16, 0, c.z * 16];
|
||||
let d = dist(p);
|
||||
if best.as_ref().is_none_or(|(b, ..)| d < *b) {
|
||||
best = Some((d, name, p));
|
||||
}
|
||||
}
|
||||
}
|
||||
Some(spacing) => {
|
||||
let (cx, cz) = (from[0] >> 4, from[2] >> 4);
|
||||
'search: for r in 0..=radius {
|
||||
for dx in -r..=r {
|
||||
let x_edge = dx == -r || dx == r;
|
||||
for dz in -r..=r {
|
||||
if !(x_edge || dz == -r || dz == r) {
|
||||
continue;
|
||||
}
|
||||
let (sx, sz) = (cx + spacing * dx, cz + spacing * dz);
|
||||
let Some(c) = StructureRegistry::potential_chunk(set, seed, sx, sz)
|
||||
else {
|
||||
continue;
|
||||
};
|
||||
if !self
|
||||
.registry
|
||||
.is_structure_chunk(set, seed, c.x, c.z, &rings)
|
||||
{
|
||||
continue;
|
||||
}
|
||||
if let Some(name) = found_at(self, context, c) {
|
||||
let p = [c.x * 16, 0, c.z * 16];
|
||||
let d = dist(p);
|
||||
if best.as_ref().is_none_or(|(b, ..)| d < *b) {
|
||||
best = Some((d, name, p));
|
||||
}
|
||||
break 'search;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
best.map(|(_, n, p)| (n, p))
|
||||
}
|
||||
/// ChunkGenerator.createReferences: starts within 8 chunks whose box
|
||||
/// intersects this chunk's column.
|
||||
pub(super) fn references(
|
||||
|
||||
@@ -309,6 +309,11 @@ pub trait PlacementContext {
|
||||
fn layer_block(&mut self, _position: [i32; 3]) -> Result<LayerBlock, PlacementQueryError> {
|
||||
Err(PlacementQueryError::Unavailable)
|
||||
}
|
||||
/// Add an entity from its NBT (structure templates and pieces; `Pos` is
|
||||
/// absolute). Worlds without entity storage drop it.
|
||||
fn add_entity(&mut self, _nbt: crate::nbt::Compound) -> Result<(), PlacementQueryError> {
|
||||
Ok(())
|
||||
}
|
||||
/// Store block-entity data loaded at a just-placed block (structure
|
||||
/// templates). Worlds without block-entity storage drop it.
|
||||
fn set_block_entity(
|
||||
|
||||
@@ -484,6 +484,8 @@ fn place_element<W: FeatureWorld + PlacementContext, R: RandomSource>(
|
||||
};
|
||||
let mut settings = PlaceSettings::new(rotation);
|
||||
settings.known_shape = true;
|
||||
// SinglePoolElement.getSettings.
|
||||
settings.finalize_entities = true;
|
||||
settings.bounding_box = Some(chunk_box);
|
||||
settings.waterlogging = override_liquid.unwrap_or(waterlogging);
|
||||
if !*legacy {
|
||||
|
||||
@@ -785,6 +785,9 @@ impl TemplatePiece {
|
||||
s.mirror = self.mirror;
|
||||
s.pivot = self.pivot;
|
||||
s.waterlogging = self.waterlogging;
|
||||
// Mansions and end cities spawn their mobs from data markers.
|
||||
s.ignore_entities = self.template_name.contains("woodland_mansion/")
|
||||
|| self.template_name.contains("end_city/");
|
||||
s
|
||||
}
|
||||
/// TemplateStructurePiece.postProcess at a (possibly shifted) position;
|
||||
|
||||
@@ -317,6 +317,9 @@ pub struct PlaceSettings<'a> {
|
||||
/// StructurePlaceSettings.knownShape: skip the neighbor shape updates
|
||||
/// after placement (jigsaw pieces).
|
||||
pub known_shape: bool,
|
||||
/// StructurePlaceSettings.ignoreEntities / finalizeEntities.
|
||||
pub ignore_entities: bool,
|
||||
pub finalize_entities: bool,
|
||||
}
|
||||
impl<'a> PlaceSettings<'a> {
|
||||
pub fn new(rotation: Rotation) -> Self {
|
||||
@@ -329,6 +332,8 @@ impl<'a> PlaceSettings<'a> {
|
||||
waterlogging: true,
|
||||
random: None,
|
||||
known_shape: false,
|
||||
ignore_entities: false,
|
||||
finalize_entities: false,
|
||||
}
|
||||
}
|
||||
pub fn with_processors(mut self, list: &'a ProcessorList) -> Self {
|
||||
@@ -832,9 +837,115 @@ pub fn place_in_world<W: FeatureWorld + PlacementContext>(
|
||||
world.update_from_neighbour_shapes(pos, flags & !1 | 16)?;
|
||||
}
|
||||
}
|
||||
if !settings.ignore_entities {
|
||||
place_entities(world, template, position, settings)?;
|
||||
}
|
||||
Ok(true)
|
||||
}
|
||||
|
||||
/// StructureTemplate.placeEntities: each saved entity moved, turned and
|
||||
/// mirrored with the template, its NBT handed to the world.
|
||||
fn place_entities<W: PlacementContext>(
|
||||
world: &mut W,
|
||||
template: &StructureTemplate,
|
||||
position: [i32; 3],
|
||||
settings: &PlaceSettings<'_>,
|
||||
) -> Result<(), PlacementQueryError> {
|
||||
let (mirror, rotation, pivot) = (settings.mirror, settings.rotation, settings.pivot);
|
||||
for e in &template.entities {
|
||||
let b = StructureTemplate::transform(e.block_pos, mirror, rotation, pivot);
|
||||
let block_pos = [b[0] + position[0], b[1] + position[1], b[2] + position[2]];
|
||||
if settings
|
||||
.bounding_box
|
||||
.is_some_and(|bb| !bb.is_inside(block_pos))
|
||||
{
|
||||
continue;
|
||||
}
|
||||
let r = StructureTemplate::transform_vec(e.pos, mirror, rotation, pivot);
|
||||
let pos = [
|
||||
r[0] + f64::from(position[0]),
|
||||
r[1] + f64::from(position[1]),
|
||||
r[2] + f64::from(position[2]),
|
||||
];
|
||||
let mut nbt = e.nbt.clone();
|
||||
nbt.insert(
|
||||
"Pos".into(),
|
||||
Tag::List(pos.iter().map(|v| Tag::Double(v.to_bits())).collect()),
|
||||
);
|
||||
nbt.remove(&"UUID".into());
|
||||
if nbt.contains_key(&"block_pos".into()) {
|
||||
nbt.insert("block_pos".into(), Tag::IntArray(block_pos.to_vec()));
|
||||
}
|
||||
for (key, i) in [("TileX", 0), ("TileY", 1), ("TileZ", 2)] {
|
||||
if nbt.contains_key(&key.into()) {
|
||||
nbt.insert(key.into(), Tag::Int(block_pos[i]));
|
||||
}
|
||||
}
|
||||
// Entity.rotate + Entity.mirror on the yaw.
|
||||
let wrap = |a: f32| {
|
||||
let a = a % 360.0;
|
||||
if a >= 180.0 {
|
||||
a - 360.0
|
||||
} else if a < -180.0 {
|
||||
a + 360.0
|
||||
} else {
|
||||
a
|
||||
}
|
||||
};
|
||||
if let Some(Tag::List(rot)) = nbt.get(&"Rotation".into()).cloned()
|
||||
&& let Some(Tag::Float(bits)) = rot.first()
|
||||
{
|
||||
let yaw = wrap(f32::from_bits(*bits));
|
||||
let rotated = match rotation {
|
||||
Rotation::Clockwise180 => yaw + 180.0,
|
||||
Rotation::Counterclockwise90 => yaw + 270.0,
|
||||
Rotation::Clockwise90 => yaw + 90.0,
|
||||
Rotation::None => yaw,
|
||||
};
|
||||
let mirrored = match mirror {
|
||||
Mirror::FrontBack => -yaw,
|
||||
Mirror::LeftRight => 180.0 - yaw,
|
||||
Mirror::None => yaw,
|
||||
};
|
||||
let mut rot = rot.clone();
|
||||
rot[0] = Tag::Float((rotated + mirrored - yaw).to_bits());
|
||||
nbt.insert("Rotation".into(), Tag::List(rot));
|
||||
}
|
||||
// HangingEntity.rotate/mirror: the facing turns with the template.
|
||||
if let Some(&Tag::Byte(f)) = nbt.get(&"Facing".into()) {
|
||||
nbt.insert("Facing".into(), Tag::Byte(turn_facing(f, mirror, rotation)));
|
||||
}
|
||||
if settings.finalize_entities {
|
||||
nbt.insert("horizon:finalize".into(), Tag::Byte(1));
|
||||
}
|
||||
world.add_entity(nbt)?;
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
/// A 3D data value (2 north, 3 south, 4 west, 5 east) mirrored then rotated.
|
||||
fn turn_facing(f: i8, mirror: Mirror, rotation: Rotation) -> i8 {
|
||||
if !(2..=5).contains(&f) {
|
||||
return f;
|
||||
}
|
||||
let mirrored = match (mirror, f) {
|
||||
(Mirror::LeftRight, 2) => 3,
|
||||
(Mirror::LeftRight, 3) => 2,
|
||||
(Mirror::FrontBack, 4) => 5,
|
||||
(Mirror::FrontBack, 5) => 4,
|
||||
(_, f) => f,
|
||||
};
|
||||
// Clockwise order: north, east, south, west.
|
||||
let order = [2, 5, 3, 4];
|
||||
let i = order.iter().position(|&d| d == mirrored).unwrap_or(0);
|
||||
let steps = match rotation {
|
||||
Rotation::None => 0,
|
||||
Rotation::Clockwise90 => 1,
|
||||
Rotation::Clockwise180 => 2,
|
||||
Rotation::Counterclockwise90 => 3,
|
||||
};
|
||||
order[(i + steps) % 4]
|
||||
}
|
||||
|
||||
/// StructureTemplate.updateShapeAtEdge over the placed positions' voxel
|
||||
/// shape (DiscreteVoxelShape.forAllFaces order: X-Y rows along Z, then
|
||||
/// Z-X rows along Y, then Y-Z rows along X).
|
||||
|
||||
@@ -326,6 +326,32 @@ impl StructureRegistry {
|
||||
rings
|
||||
}
|
||||
/// RandomSpreadStructurePlacement.getPotentialStructureChunk et al.
|
||||
/// RandomSpreadStructurePlacement.getPotentialStructureChunk for the
|
||||
/// sector holding chunk (`x`, `z`); `None` for other placements.
|
||||
pub fn potential_chunk(set: &StructureSet, seed: i64, x: i32, z: i32) -> Option<ChunkPos> {
|
||||
let Placement::RandomSpread {
|
||||
spacing,
|
||||
separation,
|
||||
triangular,
|
||||
} = set.placement
|
||||
else {
|
||||
return None;
|
||||
};
|
||||
let (gx, gz) = (x.div_euclid(spacing), z.div_euclid(spacing));
|
||||
let mut random = WorldgenRandom::new(LegacyRandom::new(0));
|
||||
random.set_large_feature_with_salt(seed, gx, gz, set.salt);
|
||||
let limit = spacing - separation;
|
||||
let spread = |r: &mut WorldgenRandom<LegacyRandom>| {
|
||||
if triangular {
|
||||
(r.next_int_bound(limit).unwrap_or(0) + r.next_int_bound(limit).unwrap_or(0)) / 2
|
||||
} else {
|
||||
r.next_int_bound(limit).unwrap_or(0)
|
||||
}
|
||||
};
|
||||
let sx = spread(&mut random);
|
||||
let sz = spread(&mut random);
|
||||
Some(ChunkPos::new(gx * spacing + sx, gz * spacing + sz))
|
||||
}
|
||||
pub fn is_structure_chunk(
|
||||
&self,
|
||||
set: &StructureSet,
|
||||
@@ -386,6 +412,15 @@ impl StructureRegistry {
|
||||
}
|
||||
}
|
||||
}
|
||||
impl StructureSet {
|
||||
/// The random spread's spacing in chunks (`None` for rings).
|
||||
pub fn spacing(&self) -> Option<i32> {
|
||||
match self.placement {
|
||||
Placement::RandomSpread { spacing, .. } => Some(spacing),
|
||||
_ => None,
|
||||
}
|
||||
}
|
||||
}
|
||||
fn reduce(method: Reduction, seed: i64, salt: i32, x: i32, z: i32, probability: f32) -> bool {
|
||||
let mut random = WorldgenRandom::new(LegacyRandom::new(0));
|
||||
match method {
|
||||
|
||||
@@ -33,10 +33,18 @@ impl Palette {
|
||||
&self.blocks
|
||||
}
|
||||
}
|
||||
/// StructureTemplate.StructureEntityInfo: an entity saved with the template.
|
||||
#[derive(Clone, Debug)]
|
||||
pub struct EntityInfo {
|
||||
pub pos: [f64; 3],
|
||||
pub block_pos: [i32; 3],
|
||||
pub nbt: Compound,
|
||||
}
|
||||
#[derive(Debug)]
|
||||
pub struct StructureTemplate {
|
||||
pub size: [i32; 3],
|
||||
palettes: Vec<Palette>,
|
||||
pub entities: Vec<EntityInfo>,
|
||||
}
|
||||
|
||||
fn int_list(tag: Option<&Tag>) -> [i32; 3] {
|
||||
@@ -123,6 +131,7 @@ impl StructureTemplate {
|
||||
Self {
|
||||
size: [0; 3],
|
||||
palettes: Vec::new(),
|
||||
entities: Vec::new(),
|
||||
}
|
||||
}
|
||||
/// StructureTemplate.load. Blocks are ordered as vanilla orders them:
|
||||
@@ -199,7 +208,54 @@ impl StructureTemplate {
|
||||
_ => load(&[]),
|
||||
},
|
||||
}
|
||||
Self { size, palettes }
|
||||
let mut entities = Vec::new();
|
||||
if let Some(Tag::List(list)) = get(root, "entities") {
|
||||
for e in list {
|
||||
let Tag::Compound(e) = e else { continue };
|
||||
let Some(Tag::Compound(nbt)) = get(e, "nbt") else {
|
||||
continue;
|
||||
};
|
||||
let mut pos = [0.0; 3];
|
||||
if let Some(Tag::List(p)) = get(e, "pos") {
|
||||
for (slot, v) in pos.iter_mut().zip(p) {
|
||||
if let Tag::Double(bits) = v {
|
||||
*slot = f64::from_bits(*bits);
|
||||
}
|
||||
}
|
||||
}
|
||||
entities.push(EntityInfo {
|
||||
pos,
|
||||
block_pos: int_list(get(e, "blockPos")),
|
||||
nbt: nbt.clone(),
|
||||
});
|
||||
}
|
||||
}
|
||||
Self {
|
||||
size,
|
||||
palettes,
|
||||
entities,
|
||||
}
|
||||
}
|
||||
/// StructureTemplate.transform(Vec3, ...): entity positions.
|
||||
pub fn transform_vec(
|
||||
pos: [f64; 3],
|
||||
mirror: Mirror,
|
||||
rotation: Rotation,
|
||||
pivot: [i32; 3],
|
||||
) -> [f64; 3] {
|
||||
let [mut x, y, mut z] = pos;
|
||||
match mirror {
|
||||
Mirror::LeftRight => z = 1.0 - z,
|
||||
Mirror::FrontBack => x = 1.0 - x,
|
||||
Mirror::None => {}
|
||||
}
|
||||
let (px, pz) = (f64::from(pivot[0]), f64::from(pivot[2]));
|
||||
match rotation {
|
||||
Rotation::Counterclockwise90 => [px - pz + z, y, px + pz + 1.0 - x],
|
||||
Rotation::Clockwise90 => [px + pz + 1.0 - z, y, pz - px + x],
|
||||
Rotation::Clockwise180 => [px + px + 1.0 - x, y, pz + pz + 1.0 - z],
|
||||
Rotation::None => [x, y, z],
|
||||
}
|
||||
}
|
||||
pub fn palettes(&self) -> &[Palette] {
|
||||
&self.palettes
|
||||
|
||||
Reference in New Issue
Block a user