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) <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-07 23:45:55 +02:00
parent a819c54e66
commit dfda7acef2
4 changed files with 222 additions and 0 deletions
+1
View File
@@ -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;
@@ -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<E>(error: PlacementQueryError) -> FeatureExecutionError<E> {
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<EndSpike> {
let key = LegacyRandom::new(seed).next_long() & 65535;
let mut random = LegacyRandom::new(key);
let mut sizes: Vec<i32> = (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<EndSpike>,
crystal_invulnerable: bool,
beam_target: Option<[i32; 3]>,
obsidian: BlockStateId,
air: BlockStateId,
iron_bars: BlockStateId,
bedrock: BlockStateId,
fire: BlockStateId,
blocks: Arc<TreeBlocks>,
}
impl EndSpikeFeature {
pub(crate) fn decode(json: &str, bindings: &FeatureBlockBindings<'_>) -> Result<Self, DecodeError> {
let object: Object = serde_json::from_str(json)?;
if kind(&object)? != "minecraft:end_spike" {
return Err(DecodeError::Field("end spike type"));
}
let raw: Vec<Object> = serde_json::from_str(required(&object, "spikes")?.get())?;
let int = |o: &Object, name: &str| -> Result<i32, DecodeError> {
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::<bool>(v.get()))
.transpose()?
.unwrap_or(false),
})
})
.collect::<Result<_, DecodeError>>()?;
let beam_target = optional(&object, "crystal_beam_target")
.map(|raw| -> Result<[i32; 3], DecodeError> {
let v: Vec<Box<serde_json::value::RawValue>> = 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::<bool>(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<W: FeatureWorld + PlacementContext, R: RandomSource>(
&self,
world: &mut W,
random: &mut R,
origin: [i32; 3],
) -> TreeResult<bool, W::Error> {
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<E>(&self, north: bool, south: bool, west: bool, east: bool) -> TreeResult<BlockStateId, E> {
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<W: FeatureWorld + PlacementContext, R: RandomSource>(
&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(())
}
}
@@ -81,6 +81,7 @@ pub enum FeatureDefinition {
LargeDripstone(Box<super::dripstone::LargeDripstoneFeature>),
HugeFungus(Box<super::fungus::HugeFungusFeature>),
SculkPatch(Box<super::sculk::SculkPatchFeature>),
EndSpike(Box<super::end_spike::EndSpikeFeature>),
ProjectedPatchySquare(Box<super::projected::ProjectedPatchySquareFeature>),
SteppedColumnCluster(Box<super::projected::SteppedColumnClusterFeature>),
FallenTree(Box<super::tree::FallenTreeFeature>),
@@ -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) => {
@@ -69,6 +69,16 @@ pub trait PlacementContext {
) -> Result<bool, PlacementQueryError> {
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<i64, PlacementQueryError> {
Err(PlacementQueryError::Unavailable)