WIP: blocks parity work, paused while the harness tooling is sped up

Uncommitted changes the agent had in progress when it was stopped; may
not build or pass its harnesses yet.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
Ludovic Marie
2026-10-11 14:26:46 +02:00
parent 6391ef0444
commit 45cb5850a9
7 changed files with 228 additions and 30 deletions
@@ -705,7 +705,7 @@ impl Game<'_> {
}
false
}
fn golem_shearable(&self, index: usize) -> bool {
pub(super) fn golem_shearable(&self, index: usize) -> bool {
self.mobs[index].extra.legs.as_deref().is_some_and(|a| {
self.res
.items
+118 -20
View File
@@ -217,11 +217,19 @@ pub(super) fn body_in_head(s: Species) -> bool {
|| matches!(s, Species::Wolf | Species::HappyGhast | Species::SulfurCube)
|| horizon_client::mobs::nautilus::is_nautilus(s)
}
/// Mobs whose saddle slot Horizon keeps in `extra.legs` (the copper
/// golem's antenna, `EQUIPMENT_SLOT_ANTENNA`).
fn saddle_in_legs(s: Species) -> bool {
s == Species::CopperGolem
}
/// What a mob holds in a slot.
pub(super) fn mob_slot_item(m: &Mob, slot: Slot) -> Option<Arc<str>> {
let x = &m.extra;
let body = body_in_head(m.species());
let antenna = saddle_in_legs(m.species());
match slot {
Slot::Saddle if antenna => x.legs.clone(),
Slot::Legs if antenna => None,
Slot::MainHand => x.main_hand.clone(),
Slot::OffHand => x.off_hand.clone(),
Slot::Feet => x.feet.clone(),
@@ -293,8 +301,10 @@ fn equip_sound(m: &Mob, slot: Slot, default: Option<String>) -> Option<String> {
}
pub(super) fn mob_set_slot(m: &mut Mob, slot: Slot, stack: ItemStack) {
let item: Arc<str> = stack.item.clone();
let antenna = saddle_in_legs(m.species());
let x = &mut m.extra;
match slot {
Slot::Saddle if antenna => x.legs = Some(item),
Slot::MainHand => x.main_hand = Some(item),
Slot::OffHand => x.off_hand = Some(item),
Slot::Feet => x.feet = Some(item),
@@ -1238,29 +1248,15 @@ impl Game<'_> {
}
return Ok((self.hurt_and_break(stack, 1), CLICK));
}
if self.res.facts.is_air(state) {
// BaseFireBlock.canBePlacedAt: a fire that survives, or a portal.
let below = self.dispenser_block_name((target.0, target.1 - 1, target.2));
let fire_name = if matches!(&*below, "minecraft:soul_sand" | "minecraft:soul_soil") {
"minecraft:soul_fire"
} else {
"minecraft:fire"
};
let fire = self.res.assets.registry.default_state(fire_name);
if let Some(fire) = fire
&& self.with_level(|b, level, ticks| b.can_survive(level, ticks, target_pos, fire))
{
self.level_set([target.0, target.1, target.2], fire)?;
} else if !self.try_light_portal([target.0, target.1, target.2])? {
// Nothing to light; vanilla still counts it as a success.
}
} else if self.prop(state, "lit").as_deref() == Some("false")
&& (name.contains("campfire") || name.contains("candle"))
&& self.prop(state, "waterlogged").as_deref() != Some("true")
{
if self.with_level(|b, level, ticks| b.fire_can_be_placed_at(level, ticks, target_pos, facing)) {
let fire = self.with_level(|b, level, ticks| b.fire_state_for(level, ticks, target_pos));
self.level_set([target.0, target.1, target.2], fire)?;
self.post_block_game_event("minecraft:block_place", [target.0, target.1, target.2], None, None);
} else if self.can_light(state, &name) {
if let Some(lit) = self.with_props(state, &[("lit", "true")]) {
self.level_set([target.0, target.1, target.2], lit)?;
}
self.post_block_game_event("minecraft:block_change", [target.0, target.1, target.2], None, None);
} else if &*name == "minecraft:tnt" {
if self.ui.rules.bool("tnt_explodes") {
self.spawn_primed_tnt(target_pos, false);
@@ -1276,6 +1272,14 @@ impl Game<'_> {
}
Ok((Some(stack), event))
}
/// `CampfireBlock.canLight || CandleBlock.canLight || CandleCakeBlock.canLight`.
fn can_light(&self, state: BlockStateId, name: &str) -> bool {
let lit = self.prop(state, "lit");
let waterlogged = self.prop(state, "waterlogged");
let dry_unlit = lit.as_deref() == Some("false") && waterlogged.as_deref() == Some("false");
((self.in_block_tag("minecraft:campfires", name) || self.in_block_tag("minecraft:candles", name)) && dry_unlit)
|| (self.in_block_tag("minecraft:candle_cakes", name) && lit.as_deref() == Some("false"))
}
fn dispense_bone_meal(
&mut self,
pos: Pos,
@@ -1536,6 +1540,13 @@ impl Game<'_> {
self.with_props(state, &[("charges", &(charge + 1).to_string())])
{
self.level_set([target.0, target.1, target.2], next)?;
// RespawnAnchorBlock.charge: Context.of(null, newState).
self.post_block_game_event(
"minecraft:block_change",
[target.0, target.1, target.2],
None,
Some(next),
);
}
self.audio.play(
"minecraft:block.respawn_anchor.charge",
@@ -1657,6 +1668,10 @@ impl Game<'_> {
fn shear_entity(&mut self, target: Pos) -> Result<bool> {
let shears = ItemStack::new("minecraft:shears", 1);
for t in self.targets_at(target) {
// Entity.shearOffAllLeashConnections comes first, for any entity.
if self.shear_off_leashes(t) {
return Ok(true);
}
let Target::Mob(i) = t else { continue };
let m = &self.mobs[i];
if !m.alive() {
@@ -1665,6 +1680,29 @@ impl Game<'_> {
let at = m.position;
let sound_at = Some([at.x, at.y, at.z]);
match m.species() {
Species::CopperGolem if self.golem_shearable(i) => {
// CopperGolem.shear: the antenna (the saddle slot) drops 1.5 up.
self.audio
.play("minecraft:entity.copper_golem.shear", sound_at, 1.0, 1.0);
if let Some(antenna) = self.mobs[i].extra.legs.take() {
self.spawn_at_location(at, 1.5, ItemStack::new(&antenna, 1));
}
}
Species::SulfurCube if sulfur_cube::has_body(m) => {
// SulfurCube.shear: the swallowed block comes out at the
// passenger attachment, and nothing is swallowed for 5 s.
let height = f64::from(m.height());
let id = m.id;
if let Some(body) = self.mobs[i].extra.head.take() {
self.spawn_at_location(at, height, ItemStack::new(&body, 1));
}
// setItemSlot(BODY, EMPTY): an unequip.
let ctx = self.who_context(Some(horizon_client::mobs::Who::Mob(id)), None);
self.post_game_event("minecraft:unequip", [at.x, at.y, at.z], ctx);
self.mobs[i].extra.ints[3] = sulfur_cube::PICKUP_TIMER;
self.audio
.play("minecraft:entity.sulfur_cube.eject", sound_at, 1.0, 1.0);
}
Species::Sheep if !m.extra.sheared && !m.is_baby() => {
let color = horizon_client::mobs::render::DYE_NAMES[m.extra.color as usize & 15];
self.audio
@@ -1756,6 +1794,66 @@ impl Game<'_> {
}
Ok(false)
}
/// `Entity.shearOffAllLeashConnections(null)`: the entity's own lead and
/// every lead held by it (within a 32 block box around its centre) drop;
/// a shear game event at the entity and a snip at its block follow.
fn shear_off_leashes(&mut self, t: Target) -> bool {
use horizon_client::mobs::{Who, leash::Holder};
let (holder, centre, own) = match t {
Target::Mob(i) => {
let m = &self.mobs[i];
let b = m.bounds();
(Holder::Mob(m.id), (b.min + b.max) * 0.5, Some(i))
}
Target::Player => {
let Some(v) = self.player_view() else { return false };
(Holder::Player, (v.bounds.min + v.bounds.max) * 0.5, None)
}
Target::Stand(_) => return false,
};
let area = Aabb::new(centre - Vec3::new(16.0, 16.0, 16.0), centre + Vec3::new(16.0, 16.0, 16.0));
let mut leashed: Vec<(u32, usize)> = self
.mobs
.iter()
.enumerate()
.filter(|(_, m)| !m.removed && m.extra.leash == Some(holder) && overlaps(m.bounds(), area))
.map(|(j, m)| (m.id, j))
.collect();
leashed.sort_unstable();
let own_leashed = own.is_some_and(|i| self.mobs[i].extra.leash.is_some());
if leashed.is_empty() && !own_leashed {
return false;
}
// Leashable.dropLeash: a lead item at the leashed entity's feet.
let mut drop = |game: &mut Self, j: usize| {
if game.mobs[j].extra.leash.take().is_some() {
let at = game.mobs[j].position;
game.spawn_at_location(at, 0.0, ItemStack::new("minecraft:lead", 1));
}
};
if let Some(i) = own.filter(|_| own_leashed) {
drop(self, i);
}
for (_, j) in leashed {
drop(self, j);
}
let (at, who) = match t {
Target::Mob(i) => {
let m = &self.mobs[i];
(m.position, Who::Mob(m.id))
}
_ => (
self.player.as_ref().map_or(Vec3::ZERO, |p| p.position),
Who::Player,
),
};
let ctx = self.who_context(Some(who), None);
self.post_game_event("minecraft:shear", [at.x, at.y, at.z], ctx);
let block = [at.x.floor() + 0.5, at.y.floor() + 0.5, at.z.floor() + 0.5];
self.audio
.play("minecraft:item.shears.snip", Some(block), 1.0, 1.0);
true
}
/// The brush behaviour: the first armadillo in front that `brushOffScute`s.
fn dispense_brush(&mut self, pos: Pos, facing: Direction, stack: ItemStack) -> Dispensed {
let target = offset(pos, facing);
+3 -6
View File
@@ -66,13 +66,10 @@ impl Game<'_> {
})
.collect()
}
/// `Entity.spawnAtLocation(level, Items.LEAD)`: the item entity draws its
/// motion from its own random, not the level's.
fn drop_lead_item(&mut self, at: [f64; 3]) {
let r = &mut self.world.random;
let v = [
f64::from(r.next_float()) * 0.2 - 0.1,
0.2,
f64::from(r.next_float()) * 0.2 - 0.1,
];
let v = super::dispenser::new_item_motion();
self.spawn_item(ItemStack::new("minecraft:lead", 1), at, v, 10);
}
/// `Leashable.dropLeash` / `removeLeash`: the lead falls as an item.
+13 -2
View File
@@ -452,9 +452,20 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
// ---- misc helpers ----
/// `BaseFireBlock.onPlace` (portal ignition is not modelled).
/// `BaseFireBlock.onPlace`: a fire inside an empty obsidian frame (in the
/// overworld or the nether) lights it, otherwise one that cannot survive
/// goes out.
fn base_fire_on_place(&mut self, pos: BlockPos, state: BlockStateId, same: bool) {
if !same && !self.can_survive(state, pos) {
if same {
return;
}
if matches!(self.level.dimension(), super::Dimension::Overworld | super::Dimension::Nether)
&& let Some(shape) = self.find_empty_portal_shape(pos, true)
{
self.create_portal_blocks(&shape);
return;
}
if !self.can_survive(state, pos) {
self.remove_block(pos, false);
}
}
+20
View File
@@ -549,6 +549,26 @@ impl Behaviours {
) -> bool {
self.sim(level, ticks).player_destroy(pos, creative)
}
/// `BaseFireBlock.getState(level, pos)`: soul fire on its base blocks,
/// otherwise fire shaped by its neighbours.
pub fn fire_state_for<L: LevelAccess + ?Sized>(
&self,
level: &mut L,
ticks: &mut Ticks,
pos: BlockPos,
) -> BlockStateId {
self.sim(level, ticks).fire_state_for(pos)
}
/// `BaseFireBlock.canBePlacedAt(level, pos, forwardDirection)`.
pub fn fire_can_be_placed_at<L: LevelAccess + ?Sized>(
&self,
level: &mut L,
ticks: &mut Ticks,
pos: BlockPos,
forward: horizon_core::geometry::Direction,
) -> bool {
self.sim(level, ticks).fire_can_be_placed_at(pos, forward)
}
/// `BlockState.canSurvive(level, pos)`.
pub fn can_survive<L: LevelAccess + ?Sized>(
&self,
+53 -1
View File
@@ -1,7 +1,7 @@
//! `PortalShape`: the obsidian frame search used by nether portal blocks.
use super::{LevelAccess, Sim, update::rel};
use crate::registry::BlockStateId;
use horizon_core::{geometry::Direction, position::BlockPos};
use horizon_core::{geometry::Direction, position::BlockPos, random::RandomSource};
const MIN_WIDTH: i32 = 2;
const MAX_WIDTH: i32 = 21;
@@ -126,4 +126,56 @@ impl<L: LevelAccess + ?Sized> Sim<'_, L> {
};
shape
}
/// `PortalShape.findEmptyPortalShape`: a valid frame holding no portal
/// block yet, on the preferred axis first.
pub fn find_empty_portal_shape(&self, pos: BlockPos, x_axis: bool) -> Option<PortalShape> {
[x_axis, !x_axis]
.into_iter()
.map(|axis| self.find_portal_shape(pos, axis))
.find(|shape| shape.is_valid() && shape.portal_blocks == 0)
}
/// `PortalShape.createPortalBlocks`: fill the frame (flags 18).
pub fn create_portal_blocks(&mut self, shape: &PortalShape) {
let b = self.b;
let base = b.default_of(b.named.nether_portal);
let state = b
.table
.with_text(base, b.props.axis, if shape.x_axis { "x" } else { "z" })
.unwrap_or(base);
for h in 0..shape.height {
for w in 0..shape.width {
let at = step(step(shape.bottom_left, Direction::Up, h), shape.right, w);
self.set_block(at, state, 18);
}
}
}
/// `BaseFireBlock.canBePlacedAt(level, pos, forwardDirection)`: air where
/// fire would survive, or the inside of an empty portal frame (vertical
/// directions pick the frame axis with the level random).
pub fn fire_can_be_placed_at(&mut self, pos: BlockPos, forward: Direction) -> bool {
if !self.b.is_air(self.state(pos)) {
return false;
}
if self.can_survive(self.fire_state_for(pos), pos) {
return true;
}
// isPortal
if !matches!(self.level.dimension(), super::Dimension::Overworld | super::Dimension::Nether) {
return false;
}
for face in Direction::ALL {
if self.portal_frame(self.state(rel(pos, face))) {
// getCounterClockWise().getAxis(): north/south turn to X.
let x_axis = match forward {
Direction::North | Direction::South => true,
Direction::West | Direction::East => false,
Direction::Up | Direction::Down => {
self.random().next_int_bound(2).unwrap_or(0) == 0
}
};
return self.find_empty_portal_shape(pos, x_axis).is_some();
}
}
false
}
}
@@ -134,6 +134,24 @@ public final class VanillaDispenserOracle {
throw new IllegalStateException("no slots in " + be);
}
/**
* The chunk source bone meal reaches for: saplings, grass and moss place
* their features with `getChunkSource().getGenerator()`, which none of
* them reads beyond passing it along.
*/
static final class Chunks extends net.minecraft.server.level.ServerChunkCache {
static net.minecraft.world.level.chunk.ChunkGenerator generator;
private Chunks() {
super(null, null, null, null, null, null, 0, 0, false, null);
}
@Override
public net.minecraft.world.level.chunk.ChunkGenerator getGenerator() {
return generator;
}
}
static Method dispenseFrom(Class<?> type) throws Exception {
for (Class<?> c = type; c != null; c = c.getSuperclass()) {
try {
@@ -191,6 +209,8 @@ public final class VanillaDispenserOracle {
w.entities = new ArrayList<>();
w.registries = ParityData.access;
w.server.loot.delegate = ParityData.loot;
if (Chunks.generator == null) Chunks.generator = VanillaBlockUpdateOracle.make(net.minecraft.world.level.levelgen.FlatLevelSource.class);
VanillaBlockUpdateOracle.set(ServerLevel.class, w, "chunkSource", VanillaBlockUpdateOracle.make(Chunks.class));
VanillaBlockUpdateOracle.set(Level.class, w, "damageSources", new net.minecraft.world.damagesource.DamageSources(ParityData.access));
if (f.has("rules")) {
for (var rule : f.getAsJsonObject("rules").entrySet()) {