From dfda7acef23ac414e30e007fec335b0acb507f64 Mon Sep 17 00:00:00 2001 From: Ludovic Marie <136255825+ludovic111@users.noreply.github.com> Date: Wed, 7 Oct 2026 23:45:55 +0200 Subject: [PATCH] Port end spike feature with seed-derived spike layout minecraft:end_spike reproduces SpikeCacheLoader (seed-keyed shuffled sizes), obsidian columns, iron-bar cages, the crystal's yaw draw, bedrock and fire; the crystal entity is handed to a new spawn_end_crystal world hook. Co-Authored-By: Claude Opus 5.5 (1M context) --- crates/horizon-world/src/worldgen.rs | 1 + .../horizon-world/src/worldgen/end_spike.rs | 204 ++++++++++++++++++ .../src/worldgen/feature_graph.rs | 7 + .../src/worldgen/placement/context.rs | 10 + 4 files changed, 222 insertions(+) create mode 100644 crates/horizon-world/src/worldgen/end_spike.rs diff --git a/crates/horizon-world/src/worldgen.rs b/crates/horizon-world/src/worldgen.rs index 12d870d1f..8fa6ec0ac 100644 --- a/crates/horizon-world/src/worldgen.rs +++ b/crates/horizon-world/src/worldgen.rs @@ -29,6 +29,7 @@ pub mod disk; pub mod dripstone; pub mod end_gateway; pub mod end_podium; +pub mod end_spike; pub mod feature; pub mod feature_catalog; pub mod feature_graph; diff --git a/crates/horizon-world/src/worldgen/end_spike.rs b/crates/horizon-world/src/worldgen/end_spike.rs new file mode 100644 index 000000000..3be8e0f24 --- /dev/null +++ b/crates/horizon-world/src/worldgen/end_spike.rs @@ -0,0 +1,204 @@ +//! `minecraft:end_spike`: the obsidian pillars around the main End island. +use super::{ + DecodeError, Object, integer, optional, + block_feature::FeatureBlockBindings, + feature::FeatureWorld, + feature_graph::FeatureExecutionError, + placement::{PlacementContext, PlacementQueryError}, + required, + tree::{TreeResult, kind, write}, + tree_blocks::{self as tb, TreeBlocks}, +}; +use crate::registry::BlockStateId; +use horizon_core::random::{LegacyRandom, RandomSource}; +use std::sync::Arc; + +fn query(error: PlacementQueryError) -> FeatureExecutionError { + FeatureExecutionError::Query(error) +} + +#[derive(Clone, Copy, Debug, PartialEq, Eq)] +pub struct EndSpike { + pub center_x: i32, + pub center_z: i32, + pub radius: i32, + pub height: i32, + pub guarded: bool, +} +/// EndSpikeFeature.getSpikesForLevel (SpikeCacheLoader), from the world seed. +pub fn spikes_for_seed(seed: i64) -> Vec { + let key = LegacyRandom::new(seed).next_long() & 65535; + let mut random = LegacyRandom::new(key); + let mut sizes: Vec = (0..10).collect(); + tb::shuffle(&mut sizes, &mut random).expect("positive shuffle bounds"); + (0..10) + .map(|i| { + let angle = 2.0 * (-std::f64::consts::PI + (std::f64::consts::PI / 10.0) * f64::from(i)); + let size = sizes[i as usize]; + EndSpike { + center_x: (42.0 * angle.cos()).floor() as i32, + center_z: (42.0 * angle.sin()).floor() as i32, + radius: 2 + size / 3, + height: 76 + size * 3, + guarded: size == 1 || size == 2, + } + }) + .collect() +} + +#[derive(Clone, Debug)] +pub struct EndSpikeFeature { + spikes: Vec, + crystal_invulnerable: bool, + beam_target: Option<[i32; 3]>, + obsidian: BlockStateId, + air: BlockStateId, + iron_bars: BlockStateId, + bedrock: BlockStateId, + fire: BlockStateId, + blocks: Arc, +} +impl EndSpikeFeature { + pub(crate) fn decode(json: &str, bindings: &FeatureBlockBindings<'_>) -> Result { + let object: Object = serde_json::from_str(json)?; + if kind(&object)? != "minecraft:end_spike" { + return Err(DecodeError::Field("end spike type")); + } + let raw: Vec = serde_json::from_str(required(&object, "spikes")?.get())?; + let int = |o: &Object, name: &str| -> Result { + optional(o, name).map(integer).transpose().map(|v| v.unwrap_or(0)) + }; + let spikes = raw + .iter() + .map(|o| { + Ok(EndSpike { + center_x: int(o, "centerX")?, + center_z: int(o, "centerZ")?, + radius: int(o, "radius")?, + height: int(o, "height")?, + guarded: optional(o, "guarded") + .map(|v| serde_json::from_str::(v.get())) + .transpose()? + .unwrap_or(false), + }) + }) + .collect::>()?; + let beam_target = optional(&object, "crystal_beam_target") + .map(|raw| -> Result<[i32; 3], DecodeError> { + let v: Vec> = serde_json::from_str(raw.get())?; + if v.len() != 3 { + return Err(DecodeError::Field("beam target")); + } + Ok([integer(&v[0])?, integer(&v[1])?, integer(&v[2])?]) + }) + .transpose()?; + let registry = bindings.registry(); + let default = |name: &str| { + registry + .default_state(name) + .ok_or_else(|| DecodeError::Registry(format!("missing spike block {name}"))) + }; + Ok(Self { + spikes, + crystal_invulnerable: optional(&object, "crystal_invulnerable") + .map(|v| serde_json::from_str::(v.get())) + .transpose()? + .unwrap_or(false), + beam_target, + obsidian: default("minecraft:obsidian")?, + air: default("minecraft:air")?, + iron_bars: default("minecraft:iron_bars")?, + bedrock: default("minecraft:bedrock")?, + fire: default("minecraft:fire")?, + blocks: bindings.tree_blocks()?, + }) + } + pub(crate) fn place( + &self, + world: &mut W, + random: &mut R, + origin: [i32; 3], + ) -> TreeResult { + let spikes = if self.spikes.is_empty() { + spikes_for_seed(world.world_seed().map_err(query)?) + } else { + self.spikes.clone() + }; + for spike in spikes { + if origin[0] >> 4 == spike.center_x >> 4 && origin[2] >> 4 == spike.center_z >> 4 { + self.place_spike(world, random, spike)?; + } + } + Ok(true) + } + fn bars(&self, north: bool, south: bool, west: bool, east: bool) -> TreeResult { + let mut state = self.iron_bars; + for (name, value) in [("north", north), ("south", south), ("west", west), ("east", east)] { + state = self + .blocks + .with(state, name, if value { "true" } else { "false" }) + .ok_or(FeatureExecutionError::InvalidState)?; + } + Ok(state) + } + fn place_spike( + &self, + world: &mut W, + random: &mut R, + spike: EndSpike, + ) -> TreeResult<(), W::Error> { + let r = spike.radius; + let min_y = world.min_y().map_err(query)?; + let (cx, cz) = (spike.center_x, spike.center_z); + for z in cz - r..=cz + r { + for y in min_y..=spike.height + 10 { + for x in cx - r..=cx + r { + let dx = f64::from(x) - f64::from(cx); + let dz = f64::from(z) - f64::from(cz); + let p = [x, y, z]; + if dx * dx + dz * dz <= f64::from(r * r + 1) && y < spike.height { + write(world, p, self.obsidian, 3)?; + } else if y > 65 { + write(world, p, self.air, 3)?; + } + } + } + } + if spike.guarded { + for dx in -2i32..=2 { + for dz in -2i32..=2 { + for dy in 0..=3 { + let x_side = dx.abs() == 2; + let z_side = dz.abs() == 2; + let top = dy == 3; + if x_side || z_side || top { + let x_edge = dx == -2 || dx == 2 || top; + let z_edge = dz == -2 || dz == 2 || top; + let state = self.bars( + x_edge && dz != -2, + x_edge && dz != 2, + z_edge && dx != -2, + z_edge && dx != 2, + )?; + write(world, [cx + dx, spike.height + dy, cz + dz], state, 3)?; + } + } + } + } + } + let yaw = random.next_float() * 360.0; + world + .spawn_end_crystal( + [f64::from(cx) + 0.5, f64::from(spike.height + 1), f64::from(cz) + 0.5], + yaw, + self.beam_target, + self.crystal_invulnerable, + ) + .map_err(query)?; + let crystal = [cx, spike.height + 1, cz]; + write(world, tb::offset(crystal, 0, -1, 0), self.bedrock, 3)?; + // FireBlock.getState above sturdy bedrock is the plain fire default. + write(world, crystal, self.fire, 3)?; + Ok(()) + } +} diff --git a/crates/horizon-world/src/worldgen/feature_graph.rs b/crates/horizon-world/src/worldgen/feature_graph.rs index 41173eff9..b03beef80 100644 --- a/crates/horizon-world/src/worldgen/feature_graph.rs +++ b/crates/horizon-world/src/worldgen/feature_graph.rs @@ -81,6 +81,7 @@ pub enum FeatureDefinition { LargeDripstone(Box), HugeFungus(Box), SculkPatch(Box), + EndSpike(Box), ProjectedPatchySquare(Box), SteppedColumnCluster(Box), FallenTree(Box), @@ -650,6 +651,11 @@ impl FeatureDefinition { ) .map(|f| Self::SteppedColumnCluster(Box::new(f))) } + "minecraft:end_spike" => super::end_spike::EndSpikeFeature::decode( + json, + blocks.ok_or(DecodeError::Field("end spike bindings"))?, + ) + .map(|f| Self::EndSpike(Box::new(f))), "minecraft:sculk_patch" => super::sculk::SculkPatchFeature::decode( json, blocks.ok_or(DecodeError::Field("sculk patch bindings"))?, @@ -1018,6 +1024,7 @@ impl FeatureDefinition { Self::LargeDripstone(feature) => feature.place(world, random, origin), Self::HugeFungus(feature) => feature.place(world, random, origin), Self::SculkPatch(feature) => feature.place(world, random, origin), + Self::EndSpike(feature) => feature.place(world, random, origin), Self::ProjectedPatchySquare(feature) => feature.place(world, random, origin), Self::SteppedColumnCluster(feature) => feature.place(world, random, origin), Self::RootSystem(feature) => { diff --git a/crates/horizon-world/src/worldgen/placement/context.rs b/crates/horizon-world/src/worldgen/placement/context.rs index ad443be25..d00bec6c4 100644 --- a/crates/horizon-world/src/worldgen/placement/context.rs +++ b/crates/horizon-world/src/worldgen/placement/context.rs @@ -69,6 +69,16 @@ pub trait PlacementContext { ) -> Result { Err(PlacementQueryError::Unavailable) } + /// Add an End crystal entity (structure spawn) at an entity position. + fn spawn_end_crystal( + &mut self, + _position: [f64; 3], + _yaw: f32, + _beam_target: Option<[i32; 3]>, + _invulnerable: bool, + ) -> Result<(), PlacementQueryError> { + Ok(()) + } /// WorldGenLevel.getSeed: the world seed for seed-derived feature noise. fn world_seed(&mut self) -> Result { Err(PlacementQueryError::Unavailable)