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:
@@ -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)
|
||||
|
||||
Reference in New Issue
Block a user